poe-code 3.0.193 → 3.0.195

package/dist/index.js

@@ -785,11 +785,11 @@ var init_parse = __esm({
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path93) {
+function mergeObjectLayers(layers, path94) {
   const data = {};
   const sources = {};
   for (const key2 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key2, path93);
+    const resolved = resolveKey(layers, key2, path94);
     if (resolved === void 0) {
       continue;
     }
@@ -807,7 +807,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key2, path93) {
+function resolveKey(layers, key2, path94) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -837,9 +837,9 @@ function resolveKey(layers, key2, path93) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path93, key2);
+  const fullPath = buildPath(path94, key2);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path93, key2]);
+    const merged = mergeObjectLayers(objectLayers, [...path94, key2]);
     return {
       value: merged.data,
       sources: {
@@ -864,8 +864,8 @@ function isWinningCandidate(key2, value) {
   }
   return true;
 }
-function buildPath(path93, key2) {
-  return [...path93, key2].join(".");
+function buildPath(path94, key2) {
+  return [...path94, key2].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1543,16 +1543,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path93) {
-  const ext = getExtension(path93);
+function detectFormat2(path94) {
+  const ext = getExtension(path94);
   return extensionMap[ext];
 }
-function getExtension(path93) {
-  const lastDot = path93.lastIndexOf(".");
+function getExtension(path94) {
+  const lastDot = path94.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path93.slice(lastDot).toLowerCase();
+  return path94.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -2764,50 +2764,50 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path93, encoding) {
+    async readFile(path94, encoding) {
       if (encoding) {
-        return base.readFile(path93, encoding);
+        return base.readFile(path94, encoding);
       }
-      return base.readFile(path93);
+      return base.readFile(path94);
     },
-    async writeFile(path93, data, options) {
-      const previousContent = await tryReadText(base, path93);
+    async writeFile(path94, data, options) {
+      const previousContent = await tryReadText(base, path94);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path93,
+        path: path94,
         nextContent,
         previousContent
       });
     },
-    async symlink(target, path93) {
-      recorder.record({ type: "symlink", target, path: path93 });
+    async symlink(target, path94) {
+      recorder.record({ type: "symlink", target, path: path94 });
     },
-    async readlink(path93) {
-      return base.readlink(path93);
+    async readlink(path94) {
+      return base.readlink(path94);
     },
-    async mkdir(path93, options) {
-      recorder.record({ type: "mkdir", path: path93, options });
+    async mkdir(path94, options) {
+      recorder.record({ type: "mkdir", path: path94, options });
     },
-    async stat(path93) {
-      return base.stat(path93);
+    async stat(path94) {
+      return base.stat(path94);
     },
-    async lstat(path93) {
-      return base.lstat(path93);
+    async lstat(path94) {
+      return base.lstat(path94);
     },
     async rename(from, to) {
       recorder.record({ type: "rename", from, to });
     },
-    async unlink(path93) {
-      recorder.record({ type: "unlink", path: path93 });
+    async unlink(path94) {
+      recorder.record({ type: "unlink", path: path94 });
     },
-    async readdir(path93) {
-      return base.readdir(path93);
+    async readdir(path94) {
+      return base.readdir(path94);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path93, options) => {
-      recorder.record({ type: "rm", path: path93, options });
+    proxy.rm = async (path94, options) => {
+      recorder.record({ type: "rm", path: path94, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -2909,8 +2909,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path93, change) {
-  const command = `cat > ${path93}`;
+function renderWriteCommand(path94, change) {
+  const command = `cat > ${path94}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -3072,9 +3072,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path93) {
+async function tryReadText(base, path94) {
   try {
-    return await base.readFile(path93, "utf8");
+    return await base.readFile(path94, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -11892,8 +11892,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path93) {
-  if (!isAbsolute(path93)) {
+function assertAbsolutePath(path94) {
+  if (!isAbsolute(path94)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -12768,21 +12768,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path93;
+        let path94;
         if (typeof item.content === "string") {
-          path93 = item.content;
+          path94 = item.content;
         } else {
           try {
-            path93 = JSON.stringify(item.content);
+            path94 = JSON.stringify(item.content);
           } catch {
-            path93 = String(item.content);
+            path94 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path93
+          path: path94
         };
       }
     }
@@ -12905,10 +12905,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path93 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path94 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path93 };
+        yield { event: "tool_complete", id: item.id, kind, path: path94 };
       }
     }
   }
@@ -13592,7 +13592,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString2(event.id);
   const kind = readString2(event.kind);
-  const path93 = readString2(event.path);
+  const path94 = readString2(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -13607,8 +13607,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path93) {
-    toolCall.path = path93;
+  if (path94) {
+    toolCall.path = path94;
   }
 }
 var sessionCapture;
@@ -24144,22 +24144,83 @@ function backoff(attempt, minTimeout, maxTimeout) {
 function hasErrorCode(error2, code) {
   return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
 }
+function hasAnyErrorCode(error2, codes) {
+  return codes.some((code) => hasErrorCode(error2, code));
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return !hasErrorCode(error2, "ESRCH");
+  }
+}
 function createDefaultFs() {
   return {
-    open: (path93, flags) => fsPromises5.open(path93, flags),
+    open: (path94, flags) => fsPromises5.open(path94, flags),
+    readFile: (path94, encoding) => fsPromises5.readFile(path94, encoding),
     stat: fsPromises5.stat,
     unlink: fsPromises5.unlink
   };
 }
-async function removeLockFile(fs19, lockPath) {
+async function removeLockFile(fs19, lockPath, signal) {
+  for (let attempt = 0; attempt <= 4; attempt += 1) {
+    throwIfAborted(signal);
+    try {
+      await fs19.unlink(lockPath);
+      return;
+    } catch (error2) {
+      if (hasErrorCode(error2, "ENOENT")) {
+        return;
+      }
+      if (!hasAnyErrorCode(error2, ["EPERM", "EBUSY"]) || attempt === 4) {
+        throw error2;
+      }
+    }
+    await sleep(25 * 2 ** attempt, signal);
+  }
+}
+function parseLockMetadata(content) {
   try {
-    await fs19.unlink(lockPath);
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !("host" in parsed) || !("pid" in parsed)) {
+      return void 0;
+    }
+    const { host, pid } = parsed;
+    if (typeof host === "string" && typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0) {
+      return {
+        host,
+        pid
+      };
+    }
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+  return void 0;
+}
+async function readLockMetadata(fs19, lockPath) {
+  if (!fs19.readFile) {
+    return void 0;
+  }
+  try {
+    return parseLockMetadata(await fs19.readFile(lockPath, "utf8"));
   } catch (error2) {
-    if (!hasErrorCode(error2, "ENOENT")) {
-      throw error2;
+    if (hasErrorCode(error2, "ENOENT")) {
+      return null;
     }
+    return void 0;
   }
 }
+async function shouldReclaimLock(options) {
+  const metadata = await readLockMetadata(options.fs, options.lockPath);
+  if (metadata === null) {
+    return "missing";
+  }
+  if (metadata?.host === os2.hostname()) {
+    return !options.isPidRunning(metadata.pid);
+  }
+  return Date.now() - options.stat.mtimeMs > options.staleMs;
+}
 async function writeLockMetadata(handle) {
   try {
     await handle.writeFile(
@@ -24180,7 +24241,8 @@ async function acquireFileLock(filePath, options = {}) {
   const retries = options.retries ?? 20;
   const minTimeout = options.minTimeout ?? 25;
   const maxTimeout = options.maxTimeout ?? 250;
-  const staleMs = options.staleMs ?? 3e4;
+  const staleMs = options.staleMs ?? 1e3;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning;
   const lockPath = `${filePath}.lock`;
   let attempt = 0;
   while (attempt <= retries) {
@@ -24194,7 +24256,7 @@ async function acquireFileLock(filePath, options = {}) {
           return;
         }
         released = true;
-        await removeLockFile(fs19, lockPath);
+        await removeLockFile(fs19, lockPath, options.signal);
       };
     } catch (error2) {
       if (!hasErrorCode(error2, "EEXIST")) {
@@ -24210,8 +24272,18 @@ async function acquireFileLock(filePath, options = {}) {
       }
       throw statError;
     }
-    if (Date.now() - stat24.mtimeMs > staleMs) {
-      await removeLockFile(fs19, lockPath);
+    const reclaimLock = await shouldReclaimLock({
+      fs: fs19,
+      isPidRunning: pidIsRunning,
+      lockPath,
+      staleMs,
+      stat: stat24
+    });
+    if (reclaimLock === "missing") {
+      continue;
+    }
+    if (reclaimLock) {
+      await removeLockFile(fs19, lockPath, options.signal);
       continue;
     }
     if (attempt >= retries) {
@@ -26290,8 +26362,69 @@ var init_src14 = __esm({
   }
 });
 
-// packages/toolcraft/src/index.ts
+// packages/toolcraft/src/package-metadata.ts
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import path24 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+function pathFromInput(from) {
+  if (from instanceof URL) {
+    return fileURLToPath2(from);
+  }
+  if (from.startsWith("file:")) {
+    return fileURLToPath2(from);
+  }
+  return path24.resolve(from);
+}
+function getSearchDirectory(from) {
+  const resolved = pathFromInput(from);
+  try {
+    return statSync(resolved).isDirectory() ? resolved : path24.dirname(resolved);
+  } catch {
+    return path24.dirname(resolved);
+  }
+}
+function readPackageMetadata(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+  const metadata = { path: packageJsonPath };
+  if (typeof parsed.name === "string") {
+    metadata.name = parsed.name;
+  }
+  if (typeof parsed.version === "string") {
+    metadata.version = parsed.version;
+  }
+  return metadata;
+}
+function findPackageMetadata(from) {
+  let current = getSearchDirectory(from);
+  while (true) {
+    const packageJsonPath = path24.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      return readPackageMetadata(packageJsonPath);
+    }
+    const parent = path24.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function findEntrypointPackageMetadata(entrypoint) {
+  if (entrypoint === void 0 || entrypoint.length === 0) {
+    return void 0;
+  }
+  if (!path24.isAbsolute(entrypoint) && !entrypoint.startsWith("file:")) {
+    return void 0;
+  }
+  return findPackageMetadata(entrypoint);
+}
+var init_package_metadata = __esm({
+  "packages/toolcraft/src/package-metadata.ts"() {
+    "use strict";
+  }
+});
+
+// packages/toolcraft/src/index.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function cloneScope(scope) {
   return scope === void 0 ? void 0 : [...scope];
 }
@@ -26373,7 +26506,7 @@ function validateRenameMap(rename8) {
 function parseStackPath(candidate) {
   if (candidate.startsWith("file://")) {
     try {
-      return fileURLToPath2(candidate);
+      return fileURLToPath3(candidate);
     } catch {
       return void 0;
     }
@@ -26731,6 +26864,7 @@ var init_src15 = __esm({
     init_config3();
     init_user_error();
     init_src14();
+    init_package_metadata();
     commandConfigSymbol = /* @__PURE__ */ Symbol("toolcraft.command.config");
     groupConfigSymbol = /* @__PURE__ */ Symbol("toolcraft.group.config");
     commandSourcePathSymbol = /* @__PURE__ */ Symbol("toolcraft.command.sourcePath");
@@ -26819,7 +26953,7 @@ var init_builder_group = __esm({
 
 // packages/agent-skill-config/src/configs.ts
 import os3 from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 function resolveAgentSupport(input, registry = agentSkillConfigs) {
   const resolvedId = resolveAgentId(input);
   if (!resolvedId) {
@@ -26859,9 +26993,9 @@ var init_configs2 = __esm({
 });
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile3, stat as stat3 } from "node:fs/promises";
-import path25 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import path26 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function pathExists2(target) {
   try {
     await stat3(target);
@@ -26874,12 +27008,12 @@ async function pathExists2(target) {
   }
 }
 async function findPackageRoot(entryFilePath) {
-  let current = path25.dirname(entryFilePath);
+  let current = path26.dirname(entryFilePath);
   while (true) {
-    if (await pathExists2(path25.join(current, "package.json"))) {
+    if (await pathExists2(path26.join(current, "package.json"))) {
       return current;
     }
-    const parent = path25.dirname(current);
+    const parent = path26.dirname(current);
     if (parent === current) {
       throw new Error("Unable to locate package root for agent-skill-config templates.");
     }
@@ -26887,11 +27021,11 @@ async function findPackageRoot(entryFilePath) {
   }
 }
 async function resolveTemplatePath(templateId) {
-  const packageRoot = await findPackageRoot(fileURLToPath3(import.meta.url));
+  const packageRoot = await findPackageRoot(fileURLToPath4(import.meta.url));
   const candidates = [
-    path25.join(packageRoot, "src", "templates", templateId),
-    path25.join(packageRoot, "dist", "templates", templateId),
-    path25.join(packageRoot, "dist", "templates", "skill", templateId)
+    path26.join(packageRoot, "src", "templates", templateId),
+    path26.join(packageRoot, "dist", "templates", templateId),
+    path26.join(packageRoot, "dist", "templates", "skill", templateId)
   ];
   for (const candidate of candidates) {
     if (await pathExists2(candidate)) {
@@ -26912,7 +27046,7 @@ async function loadTemplate(templateId) {
     return cached2;
   }
   const resolved = await resolveTemplatePath(templateId);
-  const content = await readFile3(resolved, "utf8");
+  const content = await readFile4(resolved, "utf8");
   cache.set(templateId, content);
   return content;
 }
@@ -27059,9 +27193,9 @@ var init_src16 = __esm({
 });
 
 // packages/superintendent/src/commands/install.ts
-import path26 from "node:path";
-import { readFile as readFile4, stat as stat4, mkdir as mkdir4, writeFile as writeFile2, unlink as unlink3, readdir as readdir3, chmod as chmod2 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import path27 from "node:path";
+import { readFile as readFile5, stat as stat4, mkdir as mkdir4, writeFile as writeFile2, unlink as unlink3, readdir as readdir3, chmod as chmod2 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 async function resolvePlanDirectory(cwd, homeDir, env) {
   const configPath = resolveConfigPath(homeDir);
   const projectConfigPath = resolveProjectConfigPath(cwd);
@@ -27070,9 +27204,9 @@ async function resolvePlanDirectory(cwd, homeDir, env) {
 }
 function resolveAbsoluteDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path26.join(homeDir, dir.slice(2));
+    return path27.join(homeDir, dir.slice(2));
   }
-  return path26.isAbsolute(dir) ? dir : path26.resolve(cwd, dir);
+  return path27.isAbsolute(dir) ? dir : path27.resolve(cwd, dir);
 }
 async function pathExists3(targetPath) {
   try {
@@ -27089,17 +27223,17 @@ async function loadSkillTemplate() {
   if (skillTemplateCache) {
     return skillTemplateCache;
   }
-  const packageRoot = await findPackageRoot2(fileURLToPath4(import.meta.url));
+  const packageRoot = await findPackageRoot2(fileURLToPath5(import.meta.url));
   const templateRoots = [
-    path26.join(packageRoot, "src", "templates"),
-    path26.join(packageRoot, "dist", "templates")
+    path27.join(packageRoot, "src", "templates"),
+    path27.join(packageRoot, "dist", "templates")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExists3(templateRoot)) {
       continue;
     }
-    skillTemplateCache = await readFile4(
-      path26.join(templateRoot, "SKILL_superintendent.md"),
+    skillTemplateCache = await readFile5(
+      path27.join(templateRoot, "SKILL_superintendent.md"),
       "utf8"
     );
     return skillTemplateCache;
@@ -27107,12 +27241,12 @@ async function loadSkillTemplate() {
   throw new Error("Unable to locate Superintendent skill template.");
 }
 async function findPackageRoot2(entryFilePath) {
-  let currentPath = path26.dirname(entryFilePath);
+  let currentPath = path27.dirname(entryFilePath);
   while (true) {
-    if (await pathExists3(path26.join(currentPath, "package.json"))) {
+    if (await pathExists3(path27.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path26.dirname(currentPath);
+    const parentPath = path27.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Superintendent templates.");
     }
@@ -27128,7 +27262,7 @@ var init_install = __esm({
     init_src16();
     init_src13();
     fs2 = {
-      readFile: (p, encoding) => readFile4(p, encoding),
+      readFile: (p, encoding) => readFile5(p, encoding),
       writeFile: (p, content) => writeFile2(p, content),
       mkdir: (p, options) => mkdir4(p, options).then(() => void 0),
       unlink: (p) => unlink3(p),
@@ -27423,13 +27557,13 @@ var init_complete = __esm({
 });
 
 // packages/superintendent/src/commands/plan-path.ts
-import path27 from "node:path";
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir5, unlink as unlink4, stat as stat5, readdir as readdir4 } from "node:fs/promises";
+import path28 from "node:path";
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir5, unlink as unlink4, stat as stat5, readdir as readdir4 } from "node:fs/promises";
 function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path27.join(homeDir, dir.slice(2));
+    return path28.join(homeDir, dir.slice(2));
   }
-  return path27.isAbsolute(dir) ? dir : path27.resolve(cwd, dir);
+  return path28.isAbsolute(dir) ? dir : path28.resolve(cwd, dir);
 }
 var fs3, planPathCommand;
 var init_plan_path = __esm({
@@ -27438,7 +27572,7 @@ var init_plan_path = __esm({
     init_src15();
     init_src5();
     fs3 = {
-      readFile: (p, encoding) => readFile5(p, encoding),
+      readFile: (p, encoding) => readFile6(p, encoding),
       writeFile: (p, content) => writeFile3(p, content),
       mkdir: (p, options) => mkdir5(p, options).then(() => void 0),
       unlink: (p) => unlink4(p),
@@ -27512,7 +27646,7 @@ var init_config_scope = __esm({
 });
 
 // packages/superintendent/src/commands/run.ts
-import path28 from "node:path";
+import path29 from "node:path";
 import * as fsPromises7 from "node:fs/promises";
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 function createRunMcpCommand(runners) {
@@ -27905,7 +28039,7 @@ async function runSuperintendentCommand(options) {
         session.pauseRequested = true;
       }
       editPlan(session.dashboard, session.latestLogFile, env, options.openInEditor);
-      appendEvent("info", `Log opened: ${path28.basename(session.latestLogFile)}`);
+      appendEvent("info", `Log opened: ${path29.basename(session.latestLogFile)}`);
       syncStats();
     }
   };
@@ -28054,13 +28188,13 @@ async function listPlanDirectoryDocs(fs19, planDirectory, cwd, homeDir) {
     }
     throw error2;
   }
-  return entries.filter((entry) => entry.toLowerCase().endsWith(".md")).map((entry) => path28.join(absoluteDir, entry)).sort((left, right) => left.localeCompare(right));
+  return entries.filter((entry) => entry.toLowerCase().endsWith(".md")).map((entry) => path29.join(absoluteDir, entry)).sort((left, right) => left.localeCompare(right));
 }
 function resolveAbsolutePlanDirectory(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path28.join(homeDir, dir.slice(2));
+    return path29.join(homeDir, dir.slice(2));
   }
-  return path28.isAbsolute(dir) ? dir : path28.resolve(cwd, dir);
+  return path29.isAbsolute(dir) ? dir : path29.resolve(cwd, dir);
 }
 function normalizeAgentSelection(value) {
   if (typeof value !== "string") {
@@ -28296,7 +28430,7 @@ function resolveEditor(env) {
   const parts = raw.split(/\s+/);
   const command = parts[0] ?? "vi";
   const args = parts.slice(1);
-  const binary = path28.basename(command);
+  const binary = path29.basename(command);
   const mode = GUI_EDITOR_BINARIES.has(binary) ? "gui" : "tty";
   return { command, args, mode };
 }
@@ -28323,11 +28457,11 @@ function stripStopReason(result) {
   };
 }
 function displayPath(filePath, cwd, homeDir) {
-  if (filePath.startsWith(`${cwd}${path28.sep}`)) {
-    return path28.relative(cwd, filePath);
+  if (filePath.startsWith(`${cwd}${path29.sep}`)) {
+    return path29.relative(cwd, filePath);
   }
-  if (filePath.startsWith(`${homeDir}${path28.sep}`)) {
-    return `~/${path28.relative(homeDir, filePath)}`;
+  if (filePath.startsWith(`${homeDir}${path29.sep}`)) {
+    return `~/${path29.relative(homeDir, filePath)}`;
   }
   return filePath;
 }
@@ -28731,7 +28865,7 @@ var init_src17 = __esm({
 });
 
 // src/services/config.ts
-import path29 from "node:path";
+import path30 from "node:path";
 async function deleteConfig(options) {
   const { fs: fs19, filePath } = options;
   try {
@@ -28834,7 +28968,7 @@ async function migrateLegacyCredentialsIfNeeded(fs19, filePath) {
   await migrateLegacyCredentialsFile(fs19, filePath);
 }
 async function migrateLegacyCredentialsFile(fs19, configPath) {
-  const legacyPath = path29.join(path29.dirname(configPath), "credentials.json");
+  const legacyPath = path30.join(path30.dirname(configPath), "credentials.json");
   const raw = await readFileIfExists(fs19, legacyPath);
   if (raw === null) {
     return;
@@ -28903,9 +29037,9 @@ async function recoverInvalidConfig(fs19, filePath, content) {
   await fs19.writeFile(filePath, EMPTY_DOCUMENT3, { encoding: "utf8" });
 }
 function createInvalidBackupPath2(filePath) {
-  const directory = path29.dirname(filePath);
-  const baseName = path29.basename(filePath);
-  return path29.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
+  const directory = path30.dirname(filePath);
+  const baseName = path30.basename(filePath);
+  return path30.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
 function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -29062,7 +29196,7 @@ var init_errors2 = __esm({
 });
 
 // src/cli/commands/shared.ts
-import path30 from "node:path";
+import path31 from "node:path";
 function buildActiveProvider(id, baseUrl, credential) {
   return { id, baseUrl, credential, extraEnv: {} };
 }
@@ -29197,7 +29331,7 @@ function buildResumeCommand(canonicalService, threadId, cwd) {
   if (!binaryName) {
     return void 0;
   }
-  const resumeCwd = path30.resolve(cwd);
+  const resumeCwd = path31.resolve(cwd);
   const args = spawnConfig.resumeCommand(threadId, resumeCwd);
   const agentCommand = [binaryName, ...args.map(shlexQuote)].join(" ");
   const needsCdPrefix = !args.includes(resumeCwd);
@@ -29397,14 +29531,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path93 = input.slice(slashIndex);
-  if (container.length === 0 || path93.length === 0) {
+  const path94 = input.slice(slashIndex);
+  if (container.length === 0 || path94.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path93
+    path: path94
   };
 }
 function splitOnce(input, separator) {
@@ -29465,9 +29599,9 @@ var init_parse3 = __esm({
 });
 
 // packages/workspace-resolver/src/github/clone.ts
-import path31 from "node:path";
+import path32 from "node:path";
 function buildCachePath(homeDir, locator) {
-  return path31.join(
+  return path32.join(
     homeDir,
     ".poe-code",
     "workspaces",
@@ -29482,7 +29616,7 @@ async function cloneOrUpdate(locator, options) {
   const cacheDir = buildCachePath(options.homeDir, locator);
   const exists = await pathExists4(options.fs, cacheDir);
   if (!exists) {
-    await options.fs.mkdir(path31.dirname(cacheDir), { recursive: true });
+    await options.fs.mkdir(path32.dirname(cacheDir), { recursive: true });
     await assertExecSuccess(
       await options.exec("git", ["clone", "--depth", "1", buildCloneUrl(locator), cacheDir]),
       "git clone failed"
@@ -29528,9 +29662,9 @@ var init_clone = __esm({
 });
 
 // packages/workspace-resolver/src/github/isolation.ts
-import path32 from "node:path";
+import path33 from "node:path";
 async function createWritableCheckout(locator, sourceCwd, options) {
-  const cwd = path32.join(
+  const cwd = path33.join(
     options.homeDir,
     ".poe-code",
     "workspaces",
@@ -29539,7 +29673,7 @@ async function createWritableCheckout(locator, sourceCwd, options) {
     createCheckoutId()
   );
   const revision = locator.ref ?? "HEAD";
-  await options.fs.mkdir(path32.dirname(cwd), { recursive: true });
+  await options.fs.mkdir(path33.dirname(cwd), { recursive: true });
   await assertExecSuccess2(
     await options.exec("git", ["worktree", "add", "--detach", cwd, revision], {
       cwd: sourceCwd
@@ -29579,12 +29713,12 @@ var init_isolation = __esm({
 });
 
 // packages/workspace-resolver/src/resolve.ts
-import path33 from "node:path";
+import path34 from "node:path";
 async function resolveWorkspace(input, options) {
   const locator = parseLocator(input);
   if (locator.scheme === "local") {
     return {
-      cwd: path33.isAbsolute(locator.path) ? locator.path : path33.resolve(options.baseDir, locator.path),
+      cwd: path34.isAbsolute(locator.path) ? locator.path : path34.resolve(options.baseDir, locator.path),
       locator
     };
   }
@@ -29597,7 +29731,7 @@ async function resolveWorkspace(input, options) {
   try {
     writable = mode === "read" ? void 0 : await createWritableCheckout(locator, cacheDir, options);
     const workspaceRoot = writable?.cwd ?? cacheDir;
-    const cwd = locator.subdir ? path33.join(workspaceRoot, locator.subdir) : workspaceRoot;
+    const cwd = locator.subdir ? path34.join(workspaceRoot, locator.subdir) : workspaceRoot;
     await assertPathExists(options.fs, cwd, locator);
     return {
       cwd,
@@ -29810,7 +29944,7 @@ var init_spawn_core = __esm({
 });
 
 // src/cli/environment.ts
-import path34 from "node:path";
+import path35 from "node:path";
 function createCliEnvironment(init) {
   const platform = init.platform ?? process.platform;
   const variables = init.variables ?? process.env;
@@ -29818,7 +29952,7 @@ function createCliEnvironment(init) {
   const projectConfigPath = resolveProjectConfigPath(init.cwd);
   const logDir = resolveLogDir(init.homeDir);
   const { poeApiBaseUrl, poeBaseUrl } = resolvePoeBaseUrls(variables);
-  const resolveHomePath = (...segments) => path34.join(init.homeDir, ...segments);
+  const resolveHomePath = (...segments) => path35.join(init.homeDir, ...segments);
   const getVariable = (name) => variables[name];
   return {
     cwd: init.cwd,
@@ -29835,7 +29969,7 @@ function createCliEnvironment(init) {
   };
 }
 function resolveLogDir(homeDir) {
-  return path34.join(homeDir, ".poe-code", "logs");
+  return path35.join(homeDir, ".poe-code", "logs");
 }
 function resolvePoeBaseUrls(variables) {
   const raw = variables.POE_BASE_URL;
@@ -30583,7 +30717,7 @@ var init_logger2 = __esm({
 });
 
 // src/cli/error-logger.ts
-import path35 from "node:path";
+import path36 from "node:path";
 var DEFAULT_MAX_SIZE, DEFAULT_MAX_BACKUPS, ErrorLogger;
 var init_error_logger = __esm({
   "src/cli/error-logger.ts"() {
@@ -30600,7 +30734,7 @@ var init_error_logger = __esm({
       fileLoggingAvailable;
       constructor(options) {
         this.fs = options.fs;
-        this.logFilePath = path35.join(options.logDir, "errors.log");
+        this.logFilePath = path36.join(options.logDir, "errors.log");
         this.logToStderr = options.logToStderr ?? true;
         this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
         this.maxBackups = options.maxBackups ?? DEFAULT_MAX_BACKUPS;
@@ -30721,7 +30855,7 @@ ${entry.stack}`);
         return `${this.logFilePath}.${index}`;
       }
       ensureLogDirectory() {
-        const directory = path35.dirname(this.logFilePath);
+        const directory = path36.dirname(this.logFilePath);
         try {
           if (!this.fs.existsSync(directory)) {
             this.fs.mkdirSync(directory, { recursive: true });
@@ -30739,9 +30873,9 @@ ${entry.stack}`);
 });
 
 // src/providers/index.ts
-import path36 from "node:path";
+import path37 from "node:path";
 import { readdir as readdir6 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath5, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath6, pathToFileURL } from "node:url";
 function isProviderModule(filename) {
   if (filename.endsWith(".d.ts") || filename.endsWith(".d.ts.map")) {
     return false;
@@ -30766,7 +30900,7 @@ async function loadProviders() {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!isProviderModule(entry.name)) continue;
-    const moduleUrl = pathToFileURL(path36.join(currentDir, entry.name)).href;
+    const moduleUrl = pathToFileURL(path37.join(currentDir, entry.name)).href;
     const moduleExports = await import(moduleUrl);
     if (!moduleExports.provider) {
       throw new Error(`Provider module "${entry.name}" must export "provider".`);
@@ -30782,8 +30916,8 @@ var moduleDir, currentDir, defaultProviders;
 var init_providers = __esm({
   async "src/providers/index.ts"() {
     "use strict";
-    moduleDir = path36.dirname(fileURLToPath5(import.meta.url));
-    currentDir = path36.basename(moduleDir) === "providers" ? moduleDir : path36.join(moduleDir, "providers");
+    moduleDir = path37.dirname(fileURLToPath6(import.meta.url));
+    currentDir = path37.basename(moduleDir) === "providers" ? moduleDir : path37.join(moduleDir, "providers");
     defaultProviders = await loadProviders();
   }
 });
@@ -31360,25 +31494,25 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path93, encoding) => {
+    readFile: ((path94, encoding) => {
       if (encoding) {
-        return fs4.readFile(path93, encoding);
+        return fs4.readFile(path94, encoding);
       }
-      return fs4.readFile(path93);
+      return fs4.readFile(path94);
     }),
-    symlink: (target, path93) => fs4.symlink(target, path93),
-    readlink: (path93) => fs4.readlink(path93, { encoding: "utf8" }),
-    writeFile: (path93, data, opts) => fs4.writeFile(path93, data, opts),
-    mkdir: (path93, opts) => fs4.mkdir(path93, opts).then(() => {
+    symlink: (target, path94) => fs4.symlink(target, path94),
+    readlink: (path94) => fs4.readlink(path94, { encoding: "utf8" }),
+    writeFile: (path94, data, opts) => fs4.writeFile(path94, data, opts),
+    mkdir: (path94, opts) => fs4.mkdir(path94, opts).then(() => {
     }),
-    stat: (path93) => fs4.stat(path93),
-    lstat: (path93) => fs4.lstat(path93),
+    stat: (path94) => fs4.stat(path94),
+    lstat: (path94) => fs4.lstat(path94),
     rename: (oldPath, newPath) => fs4.rename(oldPath, newPath),
-    rm: (path93, opts) => fs4.rm(path93, opts),
-    unlink: (path93) => fs4.unlink(path93),
-    readdir: (path93) => fs4.readdir(path93),
+    rm: (path94, opts) => fs4.rm(path94, opts),
+    unlink: (path94) => fs4.unlink(path94),
+    readdir: (path94) => fs4.readdir(path94),
     copyFile: (src, dest) => fs4.copyFile(src, dest),
-    chmod: (path93, mode) => fs4.chmod(path93, mode)
+    chmod: (path94, mode) => fs4.chmod(path94, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -31764,7 +31898,7 @@ var init_utils2 = __esm({
 });
 
 // packages/pipeline/src/config/loader.ts
-import path37 from "node:path";
+import path38 from "node:path";
 import { parse as parse6 } from "yaml";
 function asStepMode(value) {
   if (value === void 0 || value === null) {
@@ -31872,22 +32006,22 @@ async function directoryExists(fs19, targetPath) {
   }
 }
 async function resolveStepsFile(options) {
-  const projectFile = path37.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
+  const projectFile = path38.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
   if (await fileExists2(options.fs, projectFile)) {
     return projectFile;
   }
-  const globalFile = path37.join(options.homeDir, ".poe-code", "pipeline", "steps.yaml");
+  const globalFile = path38.join(options.homeDir, ".poe-code", "pipeline", "steps.yaml");
   if (await fileExists2(options.fs, globalFile)) {
     return globalFile;
   }
   return null;
 }
 async function resolveStepsDirectory(options) {
-  const projectDir = path37.join(options.cwd, ".poe-code", "pipeline", "steps");
+  const projectDir = path38.join(options.cwd, ".poe-code", "pipeline", "steps");
   if (await directoryExists(options.fs, projectDir)) {
     return projectDir;
   }
-  const globalDir = path37.join(options.homeDir, ".poe-code", "pipeline", "steps");
+  const globalDir = path38.join(options.homeDir, ".poe-code", "pipeline", "steps");
   if (await directoryExists(options.fs, globalDir)) {
     return globalDir;
   }
@@ -31911,9 +32045,9 @@ function parseConfigData(filePath, document) {
   return config;
 }
 async function loadPipelineConfig(options) {
-  const globalDir = path37.join(options.homeDir, ".poe-code", "pipeline");
-  const globalPath = path37.join(globalDir, "config.yaml");
-  const projectPath = path37.join(options.cwd, ".poe-code", "pipeline", "config.yaml");
+  const globalDir = path38.join(options.homeDir, ".poe-code", "pipeline");
+  const globalPath = path38.join(globalDir, "config.yaml");
+  const projectPath = path38.join(options.cwd, ".poe-code", "pipeline", "config.yaml");
   const [globalContent, projectContent] = await Promise.all([
     readOptionalFile2(options.fs, globalPath),
     readOptionalFile2(options.fs, projectPath)
@@ -31950,7 +32084,7 @@ async function loadResolvedSteps(options) {
     }
     return applyStepOverrides({ steps: {} }, options.stepOverrides);
   }
-  const filePath = path37.join(stepsDir, `${name}.yaml`);
+  const filePath = path38.join(stepsDir, `${name}.yaml`);
   const content = await readOptionalFile2(options.fs, filePath);
   if (content == null) {
     throw new Error(`Unknown pipeline step config "${name}" in "${stepsDir}".`);
@@ -32194,7 +32328,7 @@ var init_parser2 = __esm({
 });
 
 // packages/pipeline/src/plan/discovery.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import * as fsPromises8 from "node:fs/promises";
 import { parse as parseYaml3 } from "yaml";
 function createDefaultFs4() {
@@ -32239,7 +32373,7 @@ function countCompletedTasks(planPath, content) {
   };
 }
 async function ensurePlanExists(fs19, cwd, planPath) {
-  const absolutePath = path38.isAbsolute(planPath) ? planPath : path38.resolve(cwd, planPath);
+  const absolutePath = path39.isAbsolute(planPath) ? planPath : path39.resolve(cwd, planPath);
   try {
     const stat24 = await fs19.stat(absolutePath);
     if (!stat24.isFile()) {
@@ -32267,12 +32401,12 @@ async function scanPlansDir(fs19, plansDir, displayPrefix) {
     if (!isMarkdownFile(entry)) {
       continue;
     }
-    const absolutePath = path38.join(plansDir, entry);
+    const absolutePath = path39.join(plansDir, entry);
     const stat24 = await fs19.stat(absolutePath);
     if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path38.join(displayPrefix, entry);
+    const displayPath2 = path39.join(displayPrefix, entry);
     const content = await fs19.readFile(absolutePath, "utf8");
     if (!isPipelinePlan(content)) {
       continue;
@@ -32293,9 +32427,9 @@ async function scanCustomPlanDir(fs19, planDirectory, cwd, homeDir) {
 }
 function resolveAbsoluteDirectory3(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path38.join(homeDir, dir.slice(2));
+    return path39.join(homeDir, dir.slice(2));
   }
-  return path38.isAbsolute(dir) ? dir : path38.resolve(cwd, dir);
+  return path39.isAbsolute(dir) ? dir : path39.resolve(cwd, dir);
 }
 function describeDiscoveryDirectory(planDirectory) {
   const configured = planDirectory?.trim();
@@ -32307,9 +32441,9 @@ function resolvePlanDirectory2(options) {
 }
 function resolveAbsolutePlanPath(planPath, cwd, homeDir) {
   if (planPath.startsWith("~/")) {
-    return path38.join(homeDir, planPath.slice(2));
+    return path39.join(homeDir, planPath.slice(2));
   }
-  return path38.isAbsolute(planPath) ? planPath : path38.resolve(cwd, planPath);
+  return path39.isAbsolute(planPath) ? planPath : path39.resolve(cwd, planPath);
 }
 async function resolvePlanPath(options) {
   const fs19 = options.fs ?? createDefaultFs4();
@@ -32371,7 +32505,7 @@ async function resolvePlanPaths(options) {
   }
   const selectedPath = await options.promptForPath({
     message: "Enter the pipeline plan path",
-    placeholder: path38.join(describeDiscoveryDirectory(options.planDirectory), "plan.md")
+    placeholder: path39.join(describeDiscoveryDirectory(options.planDirectory), "plan.md")
   });
   return selectedPath ? [selectedPath] : null;
 }
@@ -32563,7 +32697,7 @@ var init_interpolate = __esm({
 });
 
 // packages/pipeline/src/run/runner.ts
-import path39 from "node:path";
+import path40 from "node:path";
 function selectFromTask(task) {
   if (typeof task.status === "string") {
     return task.status === "done" ? { kind: "completed" } : { kind: "run", task };
@@ -32587,15 +32721,15 @@ function selectNextExecution(plan, taskId) {
 function describeExecutionContext(selection) {
   return selection.stepName ? `task "${selection.task.id}" step "${selection.stepName}"` : `task "${selection.task.id}"`;
 }
-async function resolveFileIncludes(template, cwd, readFile37) {
+async function resolveFileIncludes(template, cwd, readFile38) {
   const matches2 = [...template.matchAll(FILE_INCLUDE_PATTERN)];
   if (matches2.length === 0) {
     return template;
   }
   let result = template;
   for (const match of matches2) {
-    const absolutePath = path39.resolve(cwd, match[1]);
-    const content = await readFile37(absolutePath, "utf8");
+    const absolutePath = path40.resolve(cwd, match[1]);
+    const content = await readFile38(absolutePath, "utf8");
     result = result.replace(match[0], content);
   }
   return result;
@@ -32636,7 +32770,7 @@ var init_runner2 = __esm({
 });
 
 // packages/pipeline/src/vars/resolve.ts
-import path40 from "node:path";
+import path41 from "node:path";
 function looksLikeDocPath(value) {
   const trimmed = value.trim();
   if (trimmed.length === 0) return false;
@@ -32653,7 +32787,7 @@ function looksLikeDocPath(value) {
 }
 async function resolveDocVarFromPath(options) {
   const trimmed = options.value.trim();
-  const absolutePath = path40.isAbsolute(trimmed) ? trimmed : path40.join(options.cwd, trimmed);
+  const absolutePath = path41.isAbsolute(trimmed) ? trimmed : path41.join(options.cwd, trimmed);
   try {
     return await options.readFile(absolutePath, "utf8");
   } catch (error2) {
@@ -32663,15 +32797,15 @@ async function resolveDocVarFromPath(options) {
     );
   }
 }
-async function resolvePipelineVars(vars, cwd, readFile37) {
+async function resolvePipelineVars(vars, cwd, readFile38) {
   const resolved = {};
   for (const [key2, value] of Object.entries(vars)) {
     if (key2.endsWith("_doc") && looksLikeDocPath(value)) {
-      const docContent = await resolveDocVarFromPath({ key: key2, value, cwd, readFile: readFile37 });
-      resolved[key2] = await resolveFileIncludes(docContent, cwd, readFile37);
+      const docContent = await resolveDocVarFromPath({ key: key2, value, cwd, readFile: readFile38 });
+      resolved[key2] = await resolveFileIncludes(docContent, cwd, readFile38);
       continue;
     }
-    resolved[key2] = await resolveFileIncludes(value, cwd, readFile37);
+    resolved[key2] = await resolveFileIncludes(value, cwd, readFile38);
   }
   return resolved;
 }
@@ -32722,7 +32856,7 @@ var init_validate = __esm({
 });
 
 // packages/pipeline/src/run/pipeline.ts
-import path41 from "node:path";
+import path42 from "node:path";
 import * as fsPromises9 from "node:fs/promises";
 function createDefaultFs5() {
   const fs19 = {
@@ -32807,9 +32941,9 @@ function resolveMode2(stepName, steps) {
   return step.mode;
 }
 async function archivePlan(fs19, absolutePlanPath) {
-  const dir = path41.dirname(absolutePlanPath);
-  const archiveDir = path41.join(dir, "archive");
-  const archivePath = path41.join(archiveDir, path41.basename(absolutePlanPath));
+  const dir = path42.dirname(absolutePlanPath);
+  const archiveDir = path42.join(dir, "archive");
+  const archivePath = path42.join(archiveDir, path42.basename(absolutePlanPath));
   await fs19.mkdir(archiveDir, { recursive: true });
   await fs19.rename(absolutePlanPath, archivePath);
 }
@@ -33512,9 +33646,9 @@ var init_git = __esm({
 });
 
 // packages/experiment-loop/src/config/loader.ts
-import path42 from "node:path";
-import { readFile as readFile10 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import path43 from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { parse as parse8 } from "yaml";
 function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -33557,8 +33691,8 @@ function parseRunConfigDocument(filePath, content) {
   return parseRunConfigData(filePath, parseRunConfigYaml(filePath, content));
 }
 async function readBundledFile(name) {
-  const filePath = fileURLToPath6(new URL(`./${name}`, import.meta.url));
-  return readFile10(filePath, "utf8");
+  const filePath = fileURLToPath7(new URL(`./${name}`, import.meta.url));
+  return readFile11(filePath, "utf8");
 }
 async function readDefaultRunConfig() {
   const content = await readBundledFile("default-run.yaml");
@@ -33569,7 +33703,7 @@ async function readDefaultRunConfig() {
   return config;
 }
 function createRunConfigResolveFs(fs19) {
-  const bundledRunPath = fileURLToPath6(new URL("./run.yaml", import.meta.url));
+  const bundledRunPath = fileURLToPath7(new URL("./run.yaml", import.meta.url));
   return {
     async readFile(filePath, encoding) {
       if (filePath === bundledRunPath) {
@@ -33583,7 +33717,7 @@ async function loadInstructions() {
   return readBundledFile("default-instructions.md");
 }
 async function loadRunConfig(options) {
-  const projectPath = path42.join(options.cwd, ".poe-code", "experiments", "run.yaml");
+  const projectPath = path43.join(options.cwd, ".poe-code", "experiments", "run.yaml");
   const projectContent = await readOptionalFile3(options.fs, projectPath);
   if (projectContent == null) {
     return readDefaultRunConfig();
@@ -33592,8 +33726,8 @@ async function loadRunConfig(options) {
   if (projectDocument === null || projectDocument === void 0) {
     return readDefaultRunConfig();
   }
-  const bundledConfigDir = path42.resolve(fileURLToPath6(new URL(".", import.meta.url)));
-  const globalConfigDir = path42.resolve(path42.join(options.homeDir, ".poe-code", "experiments"));
+  const bundledConfigDir = path43.resolve(fileURLToPath7(new URL(".", import.meta.url)));
+  const globalConfigDir = path43.resolve(path43.join(options.homeDir, ".poe-code", "experiments"));
   const resolved = await resolve(
     [
       { source: "document", filePath: projectPath, content: projectContent },
@@ -33616,7 +33750,7 @@ var init_loader2 = __esm({
 });
 
 // packages/experiment-loop/src/discovery/discovery.ts
-import path43 from "node:path";
+import path44 from "node:path";
 import * as fsPromises10 from "node:fs/promises";
 function createDefaultFs6() {
   return {
@@ -33650,12 +33784,12 @@ async function scanDir(fs19, absoluteDir, displayDir) {
     if (!isMarkdownFile2(entry)) {
       continue;
     }
-    const absolutePath = path43.join(absoluteDir, entry);
+    const absolutePath = path44.join(absoluteDir, entry);
     const stat24 = await fs19.stat(absolutePath);
     if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path43.join(displayDir, entry);
+    const displayPath2 = path44.join(displayDir, entry);
     docs.push({
       path: displayPath2,
       displayPath: displayPath2
@@ -33664,18 +33798,18 @@ async function scanDir(fs19, absoluteDir, displayDir) {
   return docs;
 }
 function toDisplayPath(options) {
-  const localDir = path43.join(options.cwd, ".poe-code", "experiments");
-  const globalDir = path43.join(options.homeDir, ".poe-code", "experiments");
-  if (options.absolutePath.startsWith(`${localDir}${path43.sep}`)) {
-    return path43.join(
+  const localDir = path44.join(options.cwd, ".poe-code", "experiments");
+  const globalDir = path44.join(options.homeDir, ".poe-code", "experiments");
+  if (options.absolutePath.startsWith(`${localDir}${path44.sep}`)) {
+    return path44.join(
       ".poe-code/experiments",
-      path43.relative(localDir, options.absolutePath)
+      path44.relative(localDir, options.absolutePath)
     );
   }
-  if (options.absolutePath.startsWith(`${globalDir}${path43.sep}`)) {
-    return path43.join(
+  if (options.absolutePath.startsWith(`${globalDir}${path44.sep}`)) {
+    return path44.join(
       "~/.poe-code/experiments",
-      path43.relative(globalDir, options.absolutePath)
+      path44.relative(globalDir, options.absolutePath)
     );
   }
   return options.absolutePath;
@@ -33708,8 +33842,8 @@ async function discoverExperimentDocs(options) {
   const customDir = options.planDirectory?.trim();
   const docs = customDir ? await scanCustomDir(fs19, customDir, options.cwd, options.homeDir) : await scanDefaultDirs(fs19, options.cwd, options.homeDir);
   return docs.sort((left, right) => {
-    const leftName = path43.basename(left.displayPath).toLowerCase();
-    const rightName = path43.basename(right.displayPath).toLowerCase();
+    const leftName = path44.basename(left.displayPath).toLowerCase();
+    const rightName = path44.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -33723,7 +33857,7 @@ var init_discovery2 = __esm({
 // packages/experiment-loop/src/run/loop.ts
 import { exec as execCallback } from "node:child_process";
 import * as fsPromises11 from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 function createDefaultFs7() {
   const fs19 = {
     readFile: fsPromises11.readFile,
@@ -33775,9 +33909,9 @@ function createDefaultExec() {
   });
 }
 function resolveJournalPath(docPath) {
-  return path44.join(
-    path44.dirname(docPath),
-    `${path44.basename(docPath, path44.extname(docPath))}.journal.jsonl`
+  return path45.join(
+    path45.dirname(docPath),
+    `${path45.basename(docPath, path45.extname(docPath))}.journal.jsonl`
   );
 }
 function normalizeMetrics(metric) {
@@ -33911,8 +34045,8 @@ async function runExperimentLoop(options) {
       [
         { source: "cli", data: { agent: options.agent } },
         { source: "document", filePath: absoluteDocPath, content: rawContent },
-        { source: "base", path: path44.join(options.cwd, ".poe-code/experiments/bases") },
-        { source: "base", path: path44.join(options.homeDir, ".poe-code/experiments/bases") },
+        { source: "base", path: path45.join(options.cwd, ".poe-code/experiments/bases") },
+        { source: "base", path: path45.join(options.homeDir, ".poe-code/experiments/bases") },
         { source: "defaults", data: { agent: "claude-code" } }
       ],
       { fs: fs19 }
@@ -33994,7 +34128,7 @@ async function runExperimentLoop(options) {
         experimentIndex,
         baseline,
         docPath: options.docPath,
-        docName: path44.basename(absoluteDocPath, path44.extname(absoluteDocPath))
+        docName: path45.basename(absoluteDocPath, path45.extname(absoluteDocPath))
       });
       const currentSpecifier = agents[(experimentIndex - 1) % agents.length];
       const model = currentSpecifier.model;
@@ -34227,7 +34361,7 @@ var init_frontmatter3 = __esm({
 });
 
 // packages/ralph/src/discovery/discovery.ts
-import path45 from "node:path";
+import path46 from "node:path";
 import * as fsPromises12 from "node:fs/promises";
 function createDefaultFs8() {
   return {
@@ -34263,12 +34397,12 @@ async function scanDir2(fs19, absoluteDir, displayDir) {
     if (!isMarkdownFile3(entry)) {
       continue;
     }
-    const absolutePath = path45.join(absoluteDir, entry);
+    const absolutePath = path46.join(absoluteDir, entry);
     const stat24 = await fs19.stat(absolutePath);
     if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path45.join(displayDir, entry);
+    const displayPath2 = path46.join(displayDir, entry);
     docs.push({
       path: displayPath2,
       displayPath: displayPath2
@@ -34277,18 +34411,18 @@ async function scanDir2(fs19, absoluteDir, displayDir) {
   return docs;
 }
 function toDisplayPath2(options) {
-  const localDir = path45.join(options.cwd, ".poe-code", "ralph", "plans");
-  const globalDir = path45.join(options.homeDir, ".poe-code", "ralph", "plans");
-  if (options.absolutePath.startsWith(`${localDir}${path45.sep}`)) {
-    return path45.join(
+  const localDir = path46.join(options.cwd, ".poe-code", "ralph", "plans");
+  const globalDir = path46.join(options.homeDir, ".poe-code", "ralph", "plans");
+  if (options.absolutePath.startsWith(`${localDir}${path46.sep}`)) {
+    return path46.join(
       ".poe-code/ralph/plans",
-      path45.relative(localDir, options.absolutePath)
+      path46.relative(localDir, options.absolutePath)
     );
   }
-  if (options.absolutePath.startsWith(`${globalDir}${path45.sep}`)) {
-    return path45.join(
+  if (options.absolutePath.startsWith(`${globalDir}${path46.sep}`)) {
+    return path46.join(
       "~/.poe-code/ralph/plans",
-      path45.relative(globalDir, options.absolutePath)
+      path46.relative(globalDir, options.absolutePath)
     );
   }
   return options.absolutePath;
@@ -34321,8 +34455,8 @@ async function discoverDocs(options) {
   const customDir = options.planDirectory?.trim();
   const docs = customDir ? await scanCustomDir2(fs19, customDir, options.cwd, options.homeDir) : await scanDefaultDirs2(fs19, options.cwd, options.homeDir);
   return docs.sort((left, right) => {
-    const leftName = path45.basename(left.displayPath).toLowerCase();
-    const rightName = path45.basename(right.displayPath).toLowerCase();
+    const leftName = path46.basename(left.displayPath).toLowerCase();
+    const rightName = path46.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -34346,7 +34480,7 @@ var init_variables = __esm({
 });
 
 // packages/ralph/src/run/ralph.ts
-import path46 from "node:path";
+import path47 from "node:path";
 import * as fsPromises13 from "node:fs/promises";
 async function runRalph(options) {
   const fs19 = options.fs ?? createDefaultFs9();
@@ -34550,11 +34684,11 @@ async function resolveDocumentConfigFromContent(options, fs19, absoluteDocPath,
       },
       {
         source: "base",
-        path: path46.join(options.cwd, ".poe-code/ralph/bases")
+        path: path47.join(options.cwd, ".poe-code/ralph/bases")
       },
       {
         source: "base",
-        path: path46.join(options.homeDir, ".poe-code/ralph/bases")
+        path: path47.join(options.homeDir, ".poe-code/ralph/bases")
       },
       {
         source: "defaults",
@@ -34694,9 +34828,9 @@ async function updateFrontmatter2(fs19, absoluteDocPath, state, iteration) {
   await fs19.writeFile(absoluteDocPath, content);
 }
 async function archivePlan2(fs19, absoluteDocPath) {
-  const dir = path46.dirname(absoluteDocPath);
-  const archiveDir = path46.join(dir, "archive");
-  const archivePath = path46.join(archiveDir, path46.basename(absoluteDocPath));
+  const dir = path47.dirname(absoluteDocPath);
+  const archiveDir = path47.join(dir, "archive");
+  const archivePath = path47.join(archiveDir, path47.basename(absoluteDocPath));
   await fs19.mkdir(archiveDir, { recursive: true });
   await fs19.rename(absoluteDocPath, archivePath);
 }
@@ -34731,7 +34865,7 @@ var init_src23 = __esm({
 });
 
 // packages/plan-browser/src/format.ts
-import path47 from "node:path";
+import path48 from "node:path";
 import { parseDocument as parseDocument5 } from "yaml";
 function isPipelineTaskDone(task) {
   if (typeof task.status === "string") {
@@ -34902,9 +35036,9 @@ function formatPipelinePlanMarkdown(options) {
   return lines.join("\n").trimEnd();
 }
 function resolveExperimentJournalPath(absolutePath) {
-  return path47.join(
-    path47.dirname(absolutePath),
-    `${path47.basename(absolutePath, path47.extname(absolutePath))}.journal.jsonl`
+  return path48.join(
+    path48.dirname(absolutePath),
+    `${path48.basename(absolutePath, path48.extname(absolutePath))}.journal.jsonl`
   );
 }
 async function readExperimentState(fs19, absolutePath) {
@@ -34934,7 +35068,7 @@ function resolveFormatFromPath(filePath) {
 }
 async function readPlanMetadata(options) {
   const content = await options.fs.readFile(options.absolutePath, "utf8");
-  const fallbackName = path47.basename(options.path);
+  const fallbackName = path48.basename(options.path);
   if (options.kind === "pipeline") {
     return {
       title: fallbackName,
@@ -34995,7 +35129,7 @@ var init_format = __esm({
 });
 
 // packages/plan-browser/src/discovery.ts
-import path48 from "node:path";
+import path49 from "node:path";
 import * as fsPromises14 from "node:fs/promises";
 function createDefaultFs10() {
   return {
@@ -35022,9 +35156,9 @@ function isNotFound5(error2) {
 }
 function resolveAbsoluteDirectory4(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path48.join(homeDir, dir.slice(2));
+    return path49.join(homeDir, dir.slice(2));
   }
-  return path48.isAbsolute(dir) ? dir : path48.resolve(cwd, dir);
+  return path49.isAbsolute(dir) ? dir : path49.resolve(cwd, dir);
 }
 function isMarkdownFile4(name) {
   return name.toLowerCase().endsWith(".md");
@@ -35101,12 +35235,12 @@ async function discoverSharedPlans(options) {
     if (!isMarkdownFile4(name)) {
       continue;
     }
-    const absolutePath = path48.join(absoluteDir, name);
+    const absolutePath = path49.join(absoluteDir, name);
     const stat24 = await options.fs.stat(absolutePath);
     if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path48.join(displayDir, name);
+    const displayPath2 = path49.join(displayDir, name);
     const content = await options.fs.readFile(absolutePath, "utf8");
     const kind = classifyPlanKind(content, displayPath2);
     if (options.kind && kind !== options.kind) {
@@ -35151,7 +35285,7 @@ var init_discovery4 = __esm({
 });
 
 // packages/plan-browser/src/actions.ts
-import path49 from "node:path";
+import path50 from "node:path";
 import { spawnSync as nodeSpawnSync2 } from "node:child_process";
 function resolveEditor2(env = process.env) {
   const editor = env.EDITOR?.trim() || env.VISUAL?.trim() || "vi";
@@ -35163,8 +35297,8 @@ function editPlan2(absolutePath, options = {}) {
   spawnSync3(editor, [absolutePath], { stdio: "inherit" });
 }
 async function archivePlan3(entry, fs19) {
-  const archiveDir = path49.join(path49.dirname(entry.absolutePath), "archive");
-  const archivedPath = path49.join(archiveDir, path49.basename(entry.absolutePath));
+  const archiveDir = path50.join(path50.dirname(entry.absolutePath), "archive");
+  const archivedPath = path50.join(archiveDir, path50.basename(entry.absolutePath));
   await fs19.mkdir(archiveDir, { recursive: true });
   await fs19.rename(entry.absolutePath, archivedPath);
   return archivedPath;
@@ -35179,7 +35313,7 @@ var init_actions = __esm({
 });
 
 // packages/plan-browser/src/browser.ts
-import path50 from "node:path";
+import path51 from "node:path";
 async function runPlanBrowser(options) {
   const renderPlanPreview = async (entry) => {
     const markdown = await loadPlanPreviewMarkdown(entry, options.fs);
@@ -35208,7 +35342,7 @@ async function runPlanBrowser(options) {
     const selectedPath = await select2({
       message: "Select a plan",
       options: plans.map((plan) => ({
-        label: text.selectLabel(path50.basename(plan.path), plan.detail),
+        label: text.selectLabel(path51.basename(plan.path), plan.detail),
         hint: plan.typeLabel,
         value: plan.absolutePath
       }))
@@ -35244,7 +35378,7 @@ async function runPlanBrowser(options) {
     if (action === "archive") {
       try {
         const confirmed = options.assumeYes || await confirmOrCancel({
-          message: `Archive ${path50.basename(selectedPlan.path)}?`,
+          message: `Archive ${path51.basename(selectedPlan.path)}?`,
           initialValue: true
         });
         if (confirmed) {
@@ -35259,7 +35393,7 @@ async function runPlanBrowser(options) {
     }
     try {
       const confirmed = options.assumeYes || await confirmOrCancel({
-        message: `Permanently delete ${path50.basename(selectedPlan.path)}?`,
+        message: `Permanently delete ${path51.basename(selectedPlan.path)}?`,
         initialValue: true
       });
       if (confirmed) {
@@ -35404,7 +35538,7 @@ var init_scan = __esm({
 
 // packages/markdown-reader/src/core/document.ts
 import nodeFs2 from "node:fs/promises";
-import path51 from "node:path";
+import path52 from "node:path";
 import { parseDocument as parseDocument6 } from "yaml";
 async function loadMarkdownDocument(file, dependencies = {}) {
   const resolvedFile = resolveMarkdownPath(file, dependencies.cwd);
@@ -35419,7 +35553,7 @@ async function loadMarkdownDocument(file, dependencies = {}) {
   };
 }
 function resolveMarkdownPath(file, cwd = process.cwd()) {
-  return path51.isAbsolute(file) ? file : path51.resolve(cwd, file);
+  return path52.isAbsolute(file) ? file : path52.resolve(cwd, file);
 }
 function sliceMarkdownBytes(source, start, end) {
   return Buffer.from(source, "utf8").subarray(start, end).toString("utf8");
@@ -36594,7 +36728,7 @@ var init_state = __esm({
 });
 
 // packages/task-list/src/backends/utils.ts
-import path52 from "node:path";
+import path53 from "node:path";
 function hasErrorCode2(error2, code) {
   return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
 }
@@ -36626,7 +36760,7 @@ async function statIfExists(fs19, filePath) {
 async function writeAtomically(fs19, filePath, content) {
   const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
   tmpFileCounter += 1;
-  await fs19.mkdir(path52.dirname(filePath), { recursive: true });
+  await fs19.mkdir(path53.dirname(filePath), { recursive: true });
   try {
     await fs19.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
     await fs19.rename(tempPath, filePath);
@@ -36650,7 +36784,7 @@ var init_utils3 = __esm({
 });
 
 // packages/task-list/src/backends/markdown-dir.ts
-import path53 from "node:path";
+import path54 from "node:path";
 import { parseDocument as parseDocument7, stringify as stringify3 } from "yaml";
 function validateListName(name) {
   if (name.length === 0 || name === ARCHIVE_DIRECTORY_NAME || name.startsWith(".") || name.includes("/") || name.includes("\\") || name.includes("..")) {
@@ -36669,16 +36803,16 @@ function parseQualifiedId(qualifiedId) {
   };
 }
 function listPath(rootPath, list) {
-  return path53.join(rootPath, list);
+  return path54.join(rootPath, list);
 }
 function archiveDirectoryPath(rootPath, list) {
-  return path53.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
+  return path54.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
 }
 function activeTaskPath(rootPath, list, id) {
-  return path53.join(listPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+  return path54.join(listPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
 }
 function archivedTaskPath(rootPath, list, id) {
-  return path53.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+  return path54.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
 }
 function isMarkdownFile5(entryName) {
   return entryName.endsWith(MARKDOWN_EXTENSION);
@@ -36910,7 +37044,7 @@ function createTasksView(deps, list) {
       if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile5(entryName)) {
         continue;
       }
-      const entryPath = path53.join(directoryPath, entryName);
+      const entryPath = path54.join(directoryPath, entryName);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (!entryStat?.isFile()) {
         continue;
@@ -37065,7 +37199,7 @@ async function markdownDirBackend(deps) {
       if (entryName === ARCHIVE_DIRECTORY_NAME || isHiddenEntry(entryName) || isLockFile(entryName)) {
         continue;
       }
-      const entryPath = path53.join(deps.path, entryName);
+      const entryPath = path54.join(deps.path, entryName);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (entryStat?.isDirectory()) {
         result.push(entryName);
@@ -38072,7 +38206,7 @@ var init_gate = __esm({
 });
 
 // packages/toolcraft/src/human-in-loop/runner.ts
-import { access, readFile as readFile14, writeFile as writeFile10 } from "node:fs/promises";
+import { access, readFile as readFile15, writeFile as writeFile10 } from "node:fs/promises";
 async function runApproval(approvalId, runtimeOptions, root) {
   const { tasks } = await ensureApprovalList(runtimeOptions);
   const task = await tasks.get(approvalId);
@@ -38192,13 +38326,13 @@ function createHandlerContext(command, params) {
 }
 function createFs() {
   return {
-    readFile: async (path93, encoding = "utf8") => readFile14(path93, { encoding }),
-    writeFile: async (path93, contents) => {
-      await writeFile10(path93, contents);
+    readFile: async (path94, encoding = "utf8") => readFile15(path94, { encoding }),
+    writeFile: async (path94, contents) => {
+      await writeFile10(path94, contents);
     },
-    exists: async (path93) => {
+    exists: async (path94) => {
       try {
-        await access(path93);
+        await access(path94);
         return true;
       } catch {
         return false;
@@ -38804,9 +38938,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path93 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path94 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path93);
+  nextActivePaths.add(path94);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -38817,13 +38951,13 @@ function hasSelfReferencingRef(schema, root, path93 = "#", activePaths = /* @__P
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path93}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path94}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path93}/additionalProperties`,
+    `${path94}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -38832,7 +38966,7 @@ function hasSelfReferencingRef(schema, root, path93 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path93}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path94}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -38842,19 +38976,19 @@ function hasSelfReferencingRef(schema, root, path93 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path93}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path94}/$defs/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path93}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path94}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path93}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path94}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -38870,14 +39004,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path93 = getLocalRefPath(ref);
-  if (path93 === void 0) {
+  const path94 = getLocalRefPath(ref);
+  if (path94 === void 0) {
     return void 0;
   }
-  if (path93 === "#") {
+  if (path94 === "#") {
     return root;
   }
-  const segments = path93.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path94.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -38971,9 +39105,9 @@ var init_json_schema_converter = __esm({
 });
 
 // packages/toolcraft/src/mcp-proxy.ts
-import { existsSync } from "node:fs";
-import { mkdir as mkdir13, readFile as readFile15, rename as rename7, unlink as unlink11, writeFile as writeFile11 } from "node:fs/promises";
-import path54 from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir13, readFile as readFile16, rename as rename7, unlink as unlink11, writeFile as writeFile11 } from "node:fs/promises";
+import path55 from "node:path";
 function getInternalGroupConfig2(group) {
   const symbol = Object.getOwnPropertySymbols(group).find(
     (candidate) => candidate.description === GROUP_CONFIG_SYMBOL_DESCRIPTION
@@ -39115,7 +39249,7 @@ async function ensureConnected(connection) {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await readFile15(cachePath, "utf8");
+    const raw = await readFile16(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || !Array.isArray(parsed.tools) || parsed.upstream === void 0 || typeof parsed.upstream.name !== "string" || typeof parsed.upstream.version !== "string") {
       return void 0;
@@ -39136,7 +39270,7 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache2) {
-  const directory = path54.dirname(cachePath);
+  const directory = path55.dirname(cachePath);
   const tempPath = `${cachePath}.tmp`;
   await mkdir13(directory, { recursive: true });
   await writeFile11(tempPath, `${JSON.stringify(cache2, null, 2)}
@@ -39279,14 +39413,14 @@ function collectProxyGroups(root) {
 }
 function resolveCachePath(name, projectRoot) {
   if (projectRoot !== void 0) {
-    return path54.join(projectRoot, ".toolcraft", "mcp", `${name}.json`);
+    return path55.join(projectRoot, ".toolcraft", "mcp", `${name}.json`);
   }
   let current = process.cwd();
   while (true) {
-    if (existsSync(path54.join(current, "package.json"))) {
-      return path54.join(current, ".toolcraft", "mcp", `${name}.json`);
+    if (existsSync2(path55.join(current, "package.json"))) {
+      return path55.join(current, ".toolcraft", "mcp", `${name}.json`);
     }
-    const parent = path54.dirname(current);
+    const parent = path55.dirname(current);
     if (parent === current) {
       throw new Error(
         `Could not find package.json above "${process.cwd()}" while resolving MCP cache path.`
@@ -39404,7 +39538,7 @@ var init_schema_scope = __esm({
 });
 
 // packages/toolcraft/src/mcp.ts
-import { access as access2, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
+import { access as access2, readFile as readFile17, writeFile as writeFile12 } from "node:fs/promises";
 function normalizeRoots(roots) {
   if (!Array.isArray(roots)) {
     return roots;
@@ -39472,13 +39606,13 @@ function isPlainObject4(value) {
 }
 function createFs2() {
   return {
-    readFile: async (path93, encoding = "utf8") => readFile16(path93, { encoding }),
-    writeFile: async (path93, contents) => {
-      await writeFile12(path93, contents);
+    readFile: async (path94, encoding = "utf8") => readFile17(path94, { encoding }),
+    writeFile: async (path94, contents) => {
+      await writeFile12(path94, contents);
     },
-    exists: async (path93) => {
+    exists: async (path94) => {
       try {
-        await access2(path93);
+        await access2(path94);
         return true;
       } catch {
         return false;
@@ -39523,11 +39657,11 @@ function applySchemaCasing(schema, casing) {
     ...required === void 0 ? {} : { required }
   };
 }
-function collectParamSummaries(schema, casing, path93 = [], inheritedOptional = false) {
+function collectParamSummaries(schema, casing, path94 = [], inheritedOptional = false) {
   const summaries = [];
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
     const childSchema = unwrapOptional2(rawChildSchema);
-    const nextPath = [...path93, formatSegment(key2, casing)];
+    const nextPath = [...path94, formatSegment(key2, casing)];
     const optional = inheritedOptional || isOptional(rawChildSchema);
     if (childSchema.kind === "object") {
       summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
@@ -39556,8 +39690,8 @@ function matchesAllowlist(toolName, allowlist) {
   const candidates = segments.map((_segment, index) => segments.slice(0, index + 1).join("__"));
   return candidates.some((candidate) => allowlist.includes(candidate));
 }
-function formatToolName(path93) {
-  return path93.map((segment) => formatSegment(segment, "snake")).join("__");
+function formatToolName(path94) {
+  return path94.map((segment) => formatSegment(segment, "snake")).join("__");
 }
 function enumerateTools(root, casing, allowlist) {
   const tools = [];
@@ -39759,7 +39893,8 @@ function createResolvedMCPServer(root, options) {
   };
   validateServices(services);
   const tools = enumerateTools(root, casing, options.tools);
-  const server = createServer({ name: options.name, version: options.version });
+  const version = resolveMCPVersion(options.version);
+  const server = createServer({ name: options.name, version });
   for (const tool of tools) {
     server.tool(
       tool.name,
@@ -39809,6 +39944,13 @@ function createResolvedMCPServer(root, options) {
     }
   };
 }
+function resolveMCPVersion(version) {
+  const resolvedVersion = version ?? findEntrypointPackageMetadata(process.argv[1])?.version;
+  if (resolvedVersion === void 0) {
+    throw new Error("MCP version is required when no package.json version can be inferred from the entrypoint.");
+  }
+  return resolvedVersion;
+}
 async function runMCP(roots, options) {
   const root = mergeApprovalsGroup(normalizeRoots(roots));
   await resolveMcpProxies(root);
@@ -39826,6 +39968,7 @@ var init_mcp2 = __esm({
     init_human_in_loop();
     init_mcp_proxy();
     init_number_schema();
+    init_package_metadata();
     init_schema_scope();
     RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
   }
@@ -39901,7 +40044,7 @@ var init_SKILL_plan = __esm({
 });
 
 // src/cli/commands/plan.ts
-import path55 from "node:path";
+import path56 from "node:path";
 import { stringify as stringifyYaml2 } from "yaml";
 function buildPlanPrompt(options) {
   const trimmedQuestion = options.question.trim();
@@ -40053,7 +40196,7 @@ async function discoverPlans(container, kind) {
 async function resolveSelectedPlan(options) {
   const providedPath = options.providedPath?.trim();
   if (providedPath) {
-    const resolvedAbsolute = providedPath.startsWith("~/") ? path55.join(options.container.env.homeDir, providedPath.slice(2)) : path55.isAbsolute(providedPath) ? providedPath : path55.resolve(options.container.env.cwd, providedPath);
+    const resolvedAbsolute = providedPath.startsWith("~/") ? path56.join(options.container.env.homeDir, providedPath.slice(2)) : path56.isAbsolute(providedPath) ? providedPath : path56.resolve(options.container.env.cwd, providedPath);
     const matched2 = options.plans.find(
       (plan) => plan.path === providedPath || plan.absolutePath === providedPath || plan.absolutePath === resolvedAbsolute
     );
@@ -40071,7 +40214,7 @@ async function resolveSelectedPlan(options) {
   const selected = await select2({
     message: options.promptMessage,
     options: options.plans.map((plan) => ({
-      label: text.selectLabel(path55.basename(plan.path), plan.detail),
+      label: text.selectLabel(path56.basename(plan.path), plan.detail),
       hint: plan.typeLabel,
       value: plan.absolutePath
     }))
@@ -40109,7 +40252,7 @@ async function renderPlanList(container, options) {
           kind: plan.kind,
           type: plan.typeLabel,
           runner: plan.runner,
-          name: path55.basename(plan.path),
+          name: path56.basename(plan.path),
           path: plan.path,
           detail: plan.detail,
           updated: formatDate(plan.updatedAt)
@@ -40134,7 +40277,7 @@ async function renderPlanList(container, options) {
       rows: plans.map((plan) => ({
         kind: plan.kind,
         type: plan.typeLabel,
-        name: path55.basename(plan.path),
+        name: path56.basename(plan.path),
         detail: plan.detail,
         updated: formatDate(plan.updatedAt)
       }))
@@ -40168,7 +40311,7 @@ async function executePlanAction(options) {
   }
   if (!flags.assumeYes) {
     const confirmed = await confirmOrCancel({
-      message: options.action === "archive" ? `Archive ${path55.basename(plan.path)}?` : `Permanently delete ${path55.basename(plan.path)}?`,
+      message: options.action === "archive" ? `Archive ${path56.basename(plan.path)}?` : `Permanently delete ${path56.basename(plan.path)}?`,
       initialValue: true
     });
     if (!confirmed) {
@@ -40518,7 +40661,7 @@ var init_plan = __esm({
 });
 
 // src/cli/commands/pipeline-init.ts
-import path56 from "node:path";
+import path57 from "node:path";
 import { parse as parseYaml4 } from "yaml";
 function buildPipelineInitPrompt(options) {
   const trimmedQuestion = options.question?.trim() ?? "";
@@ -40605,8 +40748,8 @@ async function discoverMarkdownFiles(fs19, absoluteDirectory, parentRelativePath
   }
   const markdownFiles = [];
   for (const entry of [...entries].sort((left, right) => left.localeCompare(right))) {
-    const absolutePath = path56.join(absoluteDirectory, entry);
-    const relativePath = parentRelativePath.length > 0 ? path56.join(parentRelativePath, entry) : entry;
+    const absolutePath = path57.join(absoluteDirectory, entry);
+    const relativePath = parentRelativePath.length > 0 ? path57.join(parentRelativePath, entry) : entry;
     const stat24 = await fs19.stat(absolutePath);
     if (stat24.isDirectory()) {
       if (entry === "archive") {
@@ -40636,7 +40779,7 @@ function extractTitle2(filePath, content) {
       return title;
     }
   }
-  return path56.basename(filePath, path56.extname(filePath));
+  return path57.basename(filePath, path57.extname(filePath));
 }
 function createMarkdownFence(content) {
   return "`".repeat(Math.max(3, longestBacktickRun(content) + 1));
@@ -40681,7 +40824,7 @@ var init_SKILL_plan2 = __esm({
 
 // src/sdk/pipeline.ts
 import * as fsPromises16 from "node:fs/promises";
-import path57 from "node:path";
+import path58 from "node:path";
 import { parse as parseYaml5 } from "yaml";
 function isActivityTimeoutError2(error2) {
   return error2 instanceof Error && error2.name === "ActivityTimeoutError";
@@ -40727,7 +40870,7 @@ async function runPipeline2(options) {
     });
   });
   if (options.plan) {
-    const planAbsolutePath = path57.resolve(options.cwd, options.plan);
+    const planAbsolutePath = path58.resolve(options.cwd, options.plan);
     if (await planNeedsInit(planAbsolutePath)) {
       const sourceDocContent = await fsPromises16.readFile(planAbsolutePath, "utf8");
       const prompt = buildPipelineInitPrompt({
@@ -40845,7 +40988,7 @@ var init_pipeline2 = __esm({
 });
 
 // packages/process-launcher/src/state/state-store.ts
-import path58 from "node:path";
+import path59 from "node:path";
 import * as nodeFs3 from "node:fs/promises";
 function isNotFoundError2(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
@@ -40861,7 +41004,7 @@ async function removeDirectory2(fs19, directoryPath) {
     throw error2;
   }
   for (const entry of entries) {
-    const entryPath = path58.join(directoryPath, entry);
+    const entryPath = path59.join(directoryPath, entry);
     const stat24 = await fs19.stat(entryPath);
     if (stat24.isFile()) {
       await fs19.rm(entryPath, { force: true });
@@ -40878,7 +41021,7 @@ async function removeDirectory2(fs19, directoryPath) {
 }
 function createStateStore(stateDir, fs19 = nodeFs3) {
   async function read(id) {
-    const statePath = path58.join(stateDir, id, "state.json");
+    const statePath = path59.join(stateDir, id, "state.json");
     try {
       const content = await fs19.readFile(statePath, "utf8");
       return JSON.parse(content);
@@ -40890,9 +41033,9 @@ function createStateStore(stateDir, fs19 = nodeFs3) {
     }
   }
   async function write2(id, state) {
-    const processDir = path58.join(stateDir, id);
+    const processDir = path59.join(stateDir, id);
     await fs19.mkdir(processDir, { recursive: true });
-    await fs19.writeFile(path58.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
+    await fs19.writeFile(path59.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
 `);
   }
   async function list() {
@@ -40907,7 +41050,7 @@ function createStateStore(stateDir, fs19 = nodeFs3) {
     }
     const states = [];
     for (const entry of [...entries].sort()) {
-      const entryPath = path58.join(stateDir, entry);
+      const entryPath = path59.join(stateDir, entry);
       try {
         const stat24 = await fs19.stat(entryPath);
         if (stat24.isFile()) {
@@ -40927,7 +41070,7 @@ function createStateStore(stateDir, fs19 = nodeFs3) {
     return states;
   }
   async function remove2(id) {
-    await removeDirectory2(fs19, path58.join(stateDir, id));
+    await removeDirectory2(fs19, path59.join(stateDir, id));
   }
   return { read, write: write2, list, remove: remove2 };
 }
@@ -40938,16 +41081,16 @@ var init_state_store = __esm({
 });
 
 // packages/process-launcher/src/logs/log-writer.ts
-import path59 from "node:path";
+import path60 from "node:path";
 import * as nodeFs4 from "node:fs/promises";
 function isNotFoundError3(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
 function getCurrentLogPath(logDir, stream) {
-  return path59.join(logDir, `${stream}.log`);
+  return path60.join(logDir, `${stream}.log`);
 }
 function getRotatedLogPath(logDir, stream, index) {
-  return path59.join(logDir, `${stream}.${index}.log`);
+  return path60.join(logDir, `${stream}.${index}.log`);
 }
 async function isFile(fs19, filePath) {
   try {
@@ -40994,7 +41137,7 @@ async function removeAllStreamLogs(fs19, logDir, stream) {
       if (getRotatedLogIndex(fileName, stream) === null) {
         continue;
       }
-      await fs19.rm(path59.join(logDir, fileName), { force: true });
+      await fs19.rm(path60.join(logDir, fileName), { force: true });
     }
   } catch (error2) {
     if (isNotFoundError3(error2)) {
@@ -41254,7 +41397,7 @@ var init_engine = __esm({
 });
 
 // packages/process-runner/src/docker/args.ts
-import path60 from "node:path";
+import path61 from "node:path";
 function buildDockerRunArgs(input) {
   const args = [input.engine];
   if (input.engine === "docker" && input.context) {
@@ -41281,7 +41424,7 @@ function buildDockerRunArgs(input) {
     args.push("-e", `${key2}=${value}`);
   }
   for (const mount of input.mounts) {
-    const volume = `${path60.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    const volume = `${path61.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
     args.push("-v", volume);
   }
   for (const port of input.ports) {
@@ -41538,13 +41681,13 @@ var init_src29 = __esm({
 import { spawnSync } from "node:child_process";
 import * as nodeFs5 from "node:fs/promises";
 import os6 from "node:os";
-import path61 from "node:path";
+import path62 from "node:path";
 function createSupervisor(options) {
   const { spec: spec10 } = options;
   const runner = resolveRunner(options);
   const stateStore = createStateStore(options.stateDir, options.fs);
   const logWriter = createLogWriter(
-    path61.join(options.stateDir, spec10.id, "logs"),
+    path62.join(options.stateDir, spec10.id, "logs"),
     spec10.logRetainCount ?? 5,
     options.fs
   );
@@ -41912,8 +42055,8 @@ async function resolveProcessWorkspace(cwd, stateDir) {
   };
 }
 function resolveWorkspaceHomeDir(stateDir) {
-  if (path61.basename(stateDir) === "launch" && path61.basename(path61.dirname(stateDir)) === ".poe-code") {
-    return path61.dirname(path61.dirname(stateDir));
+  if (path62.basename(stateDir) === "launch" && path62.basename(path62.dirname(stateDir)) === ".poe-code") {
+    return path62.dirname(path62.dirname(stateDir));
   }
   return os6.homedir();
 }
@@ -41965,7 +42108,7 @@ var init_supervisor = __esm({
 });
 
 // packages/process-launcher/src/launcher.ts
-import path62 from "node:path";
+import path63 from "node:path";
 import * as nodeFs6 from "node:fs/promises";
 async function startManagedProcess(options) {
   const fs19 = options.fs ?? defaultFs2();
@@ -42314,7 +42457,7 @@ async function listIds(fs19, baseDir) {
     const entries = await fs19.readdir(baseDir);
     const ids = [];
     for (const entry of entries) {
-      const entryPath = path62.join(baseDir, entry);
+      const entryPath = path63.join(baseDir, entry);
       try {
         const stat24 = await fs19.stat(entryPath);
         if (!stat24.isFile()) {
@@ -42364,24 +42507,24 @@ async function readJsonFile(fs19, filePath) {
   }
 }
 async function writeJsonFile(fs19, filePath, value) {
-  await fs19.mkdir(path62.dirname(filePath), { recursive: true });
+  await fs19.mkdir(path63.dirname(filePath), { recursive: true });
   await fs19.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function resolveProcessDir(baseDir, id) {
-  return path62.join(baseDir, id);
+  return path63.join(baseDir, id);
 }
 function resolveSpecPath(baseDir, id) {
-  return path62.join(resolveProcessDir(baseDir, id), "spec.json");
+  return path63.join(resolveProcessDir(baseDir, id), "spec.json");
 }
 function resolveStatePath(baseDir, id) {
-  return path62.join(resolveProcessDir(baseDir, id), "state.json");
+  return path63.join(resolveProcessDir(baseDir, id), "state.json");
 }
 function resolveMetaPath(baseDir, id) {
-  return path62.join(resolveProcessDir(baseDir, id), "meta.json");
+  return path63.join(resolveProcessDir(baseDir, id), "meta.json");
 }
 function resolveLogDir2(baseDir, id) {
-  return path62.join(resolveProcessDir(baseDir, id), "logs");
+  return path63.join(resolveProcessDir(baseDir, id), "logs");
 }
 function isNotFoundError4(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
@@ -42462,7 +42605,7 @@ var init_ralph2 = __esm({
 
 // src/sdk/experiment.ts
 import * as fsPromises17 from "node:fs/promises";
-import path63 from "node:path";
+import path64 from "node:path";
 function createDefaultFs12() {
   return {
     readFile: fsPromises17.readFile,
@@ -42490,9 +42633,9 @@ function createDefaultFs12() {
   };
 }
 function resolveJournalPath2(docPath) {
-  return path63.join(
-    path63.dirname(docPath),
-    `${path63.basename(docPath, path63.extname(docPath))}.journal.jsonl`
+  return path64.join(
+    path64.dirname(docPath),
+    `${path64.basename(docPath, path64.extname(docPath))}.journal.jsonl`
   );
 }
 async function runExperiment(options) {
@@ -42699,7 +42842,7 @@ var init_frontmatter4 = __esm({
 });
 
 // packages/github-workflows/src/discover.ts
-import { readdir as readdir16, readFile as readFile19 } from "node:fs/promises";
+import { readdir as readdir16, readFile as readFile20 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 async function discoverAutomations(builtInDir, ...projectDirs) {
   const directories = [builtInDir, ...projectDirs];
@@ -42743,7 +42886,7 @@ async function listMarkdownFiles(dir) {
 }
 async function readAutomation(dir, fileName, baseName, baseDirs) {
   const filePath = join2(dir, fileName);
-  const content = await readFile19(filePath, "utf8");
+  const content = await readFile20(filePath, "utf8");
   const resolved = await resolve(
     [
       {
@@ -42764,7 +42907,7 @@ async function readAutomation(dir, fileName, baseName, baseDirs) {
       }
     ],
     {
-      fs: { readFile: readFile19 }
+      fs: { readFile: readFile20 }
     }
   );
   const name = stripPrefix(fileName.slice(0, -3));
@@ -43052,8 +43195,8 @@ var init_setup_agent = __esm({
 });
 
 // packages/github-workflows/src/variables.ts
-import path64 from "node:path";
-import { readFile as readFile20 } from "node:fs/promises";
+import path65 from "node:path";
+import { readFile as readFile21 } from "node:fs/promises";
 import { isMap as isMap3, parseDocument as parseDocument9, stringify as stringify4 } from "yaml";
 function isRecord20(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -43144,7 +43287,7 @@ function extractUserOverrideBlocks(filePath, content) {
 }
 async function readOptionalVariablesContent(filePath) {
   try {
-    return await readFile20(filePath, "utf8");
+    return await readFile21(filePath, "utf8");
   } catch (error2) {
     if (error2 instanceof Error && error2.code === "ENOENT") {
       return void 0;
@@ -43172,9 +43315,9 @@ function formatCommentedBlock(name, value) {
   return formatVariableBlock(name, value).split("\n").map((line) => `# ${line}`).join("\n");
 }
 async function loadVariableSources(builtInDir, projectDir) {
-  const builtInPath = path64.join(builtInDir, VARIABLES_FILE_NAME);
-  const builtInVariables = parseVariables(builtInPath, await readFile20(builtInPath, "utf8"));
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path64.join(projectDir, VARIABLES_FILE_NAME);
+  const builtInPath = path65.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInVariables = parseVariables(builtInPath, await readFile21(builtInPath, "utf8"));
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path65.join(projectDir, VARIABLES_FILE_NAME);
   const projectVariablesContent = projectVariablesPath === void 0 ? void 0 : await readOptionalVariablesContent(projectVariablesPath);
   if (projectVariablesPath === void 0 || projectVariablesContent === void 0) {
     return { builtInVariables, extendsBuiltIns: true, projectVariables: {} };
@@ -43186,13 +43329,13 @@ async function loadVariableSources(builtInDir, projectDir) {
   return { builtInVariables, extendsBuiltIns, projectVariables };
 }
 async function loadVariables(builtInDir, projectDir) {
-  const builtInPath = path64.join(builtInDir, VARIABLES_FILE_NAME);
-  const builtInContent = await readFile20(builtInPath, "utf8");
+  const builtInPath = path65.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInContent = await readFile21(builtInPath, "utf8");
   const builtInVariables = parseVariables(builtInPath, builtInContent);
   if (projectDir === void 0) {
     return filterDisabledVariables(builtInVariables);
   }
-  const projectVariablesPath = path64.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = path65.join(projectDir, VARIABLES_FILE_NAME);
   const projectVariablesContent = await readOptionalVariablesContent(projectVariablesPath);
   if (projectVariablesContent === void 0) {
     return filterDisabledVariables(builtInVariables);
@@ -43211,7 +43354,7 @@ async function loadVariables(builtInDir, projectDir) {
       }
     ],
     {
-      fs: { readFile: readFile20 },
+      fs: { readFile: readFile21 },
       autoExtend: true
     }
   );
@@ -43225,7 +43368,7 @@ async function loadVariableStatuses(builtInDir, projectDir) {
       (key2) => !extendsBuiltIns || !Object.prototype.hasOwnProperty.call(builtInVariables, key2)
     )
   ];
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path64.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path65.join(projectDir, VARIABLES_FILE_NAME);
   return orderedNames.map((name) => {
     if (!Object.prototype.hasOwnProperty.call(projectVariables, name)) {
       return {
@@ -43286,9 +43429,9 @@ var init_variables2 = __esm({
 });
 
 // packages/github-workflows/src/commands.ts
-import { access as access3, mkdir as mkdir16, readFile as readFile21, unlink as unlink12, writeFile as writeFile14 } from "node:fs/promises";
-import path65 from "node:path";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { access as access3, mkdir as mkdir16, readFile as readFile22, unlink as unlink12, writeFile as writeFile14 } from "node:fs/promises";
+import path66 from "node:path";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 import Mustache3 from "mustache";
 function formatLabel(name) {
   const capitalize2 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
@@ -43310,7 +43453,7 @@ async function loadNamedAutomation(name, cwd) {
 }
 async function readBuiltInPromptFile(name) {
   try {
-    return await readFile21(path65.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
+    return await readFile22(path66.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
   } catch (error2) {
     if (isMissingPathError2(error2)) {
       throw new UserError(`Automation "${name}" was not found.`);
@@ -43319,11 +43462,11 @@ async function readBuiltInPromptFile(name) {
   }
 }
 async function readBuiltInWorkflowTemplate(name, variant, automationName = name, promptPath) {
-  const templatePath = path65.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
+  const templatePath = path66.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
   try {
-    const content = await readFile21(templatePath, "utf8");
+    const content = await readFile22(templatePath, "utf8");
     const header = promptPath !== void 0 ? `# Auto-generated by: poe-code github-workflows install ${name}
-# Edit ${path65.relative(process.cwd(), promptPath)} to customize the prompt.
+# Edit ${path66.relative(process.cwd(), promptPath)} to customize the prompt.
 ` : `# Auto-generated by: poe-code github-workflows install ${name}
 `;
     const processedContent = content.replaceAll(` ${name}`, ` ${automationName}`).replaceAll("__UPSTREAM_REPO__", UPSTREAM_REPO);
@@ -43352,7 +43495,7 @@ function projectPromptDirs(cwd) {
   return [projectWorkflowDir(cwd)];
 }
 function projectWorkflowDir(cwd) {
-  return path65.join(cwd, ".github", "workflows");
+  return path66.join(cwd, ".github", "workflows");
 }
 function projectGitHubWorkflowsDir(cwd) {
   return projectWorkflowDir(cwd);
@@ -43371,7 +43514,7 @@ async function resolveBuiltInPromptsDir() {
   return builtInPromptsDirCandidates[0];
 }
 async function resolveBuiltInAssetsDir() {
-  return path65.dirname(await resolveBuiltInPromptsDir());
+  return path66.dirname(await resolveBuiltInPromptsDir());
 }
 function resolveCwd(cwd) {
   return cwd ?? process.cwd();
@@ -43525,16 +43668,16 @@ function addPromptHeader(content, name) {
 async function installAutomation(name, cwd, isEject) {
   const variant = isEject ? "ejected" : "caller";
   const localAutomationName = isEject ? `poe-code-${name}` : name;
-  const promptPath = isEject ? path65.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
+  const promptPath = isEject ? path66.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
   const [workflowTemplate, rawPrompt] = await Promise.all([
     readBuiltInWorkflowTemplate(name, variant, localAutomationName, promptPath),
     readBuiltInPromptFile(name)
   ]);
-  const workflowPath = path65.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
-  await mkdir16(path65.dirname(workflowPath), { recursive: true });
+  const workflowPath = path66.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
+  await mkdir16(path66.dirname(workflowPath), { recursive: true });
   await writeFile14(workflowPath, workflowTemplate, "utf8");
   if (promptPath !== void 0) {
-    await mkdir16(path65.dirname(promptPath), { recursive: true });
+    await mkdir16(path66.dirname(promptPath), { recursive: true });
     await writeFile14(promptPath, addPromptHeader(rawPrompt, name), "utf8");
   }
   return {
@@ -43547,8 +43690,8 @@ async function installAutomation(name, cwd, isEject) {
 }
 async function ensureProjectSupportFiles(cwd, builtInVariables) {
   const projectDir = projectGitHubWorkflowsDir(cwd);
-  const variablesPath = path65.join(projectDir, "variables.yaml");
-  const readmePath = path65.join(projectDir, "README.md");
+  const variablesPath = path66.join(projectDir, "variables.yaml");
+  const readmePath = path66.join(projectDir, "README.md");
   await mkdir16(projectDir, { recursive: true });
   await writeFile14(
     variablesPath,
@@ -43560,7 +43703,7 @@ async function ensureProjectSupportFiles(cwd, builtInVariables) {
 }
 async function readOptionalFile4(filePath) {
   try {
-    return await readFile21(filePath, "utf8");
+    return await readFile22(filePath, "utf8");
   } catch (error2) {
     if (isMissingPathError2(error2)) {
       return void 0;
@@ -43623,12 +43766,12 @@ var init_commands2 = __esm({
     init_variables2();
     UPSTREAM_REPO = "poe-platform/poe-code";
     builtInPromptsDirCandidates = [
-      fileURLToPath7(new URL("./prompts", import.meta.url)),
-      fileURLToPath7(new URL("../src/prompts", import.meta.url))
+      fileURLToPath8(new URL("./prompts", import.meta.url)),
+      fileURLToPath8(new URL("../src/prompts", import.meta.url))
     ];
     builtInWorkflowTemplatesDirCandidates = [
-      fileURLToPath7(new URL("./workflow-templates", import.meta.url)),
-      fileURLToPath7(new URL("../src/workflow-templates", import.meta.url))
+      fileURLToPath8(new URL("./workflow-templates", import.meta.url)),
+      fileURLToPath8(new URL("../src/workflow-templates", import.meta.url))
     ];
     Mustache3.escape = (value) => value;
     installableAutomations = [
@@ -43830,7 +43973,7 @@ var init_commands2 = __esm({
       scope: ["cli"],
       handler: async ({ params }) => {
         const name = params.name;
-        const workflowPath = path65.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
+        const workflowPath = path66.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
         try {
           await unlink12(workflowPath);
         } catch (error2) {
@@ -43933,7 +44076,7 @@ var init_commands2 = __esm({
         return (await loadVariableStatuses(await resolveBuiltInAssetsDir(), projectGitHubWorkflowsDir(cwd))).map(
           (status) => ({
             ...status,
-            source: status.source === "built-in" ? status.source : path65.relative(cwd, status.source)
+            source: status.source === "built-in" ? status.source : path66.relative(cwd, status.source)
           })
         );
       },
@@ -43988,7 +44131,7 @@ var init_src31 = __esm({
 
 // src/utils/execution-context.ts
 import { basename as basename2, dirname as dirname3 } from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
 function detectExecutionContext(input) {
   const { argv, env, moduleUrl } = input;
   if (isDevelopmentMode(argv, env)) {
@@ -44047,7 +44190,7 @@ function detectNpxVersion(env) {
   return "default";
 }
 function createDevelopmentContext(moduleUrl) {
-  const modulePath = fileURLToPath8(moduleUrl);
+  const modulePath = fileURLToPath9(moduleUrl);
   const srcIndex = modulePath.lastIndexOf("/src/");
   const projectRoot = srcIndex !== -1 ? modulePath.substring(0, srcIndex) : dirname3(dirname3(modulePath));
   return {
@@ -44111,7 +44254,7 @@ var init_execution_context = __esm({
 });
 
 // src/sdk/launch.ts
-import path66 from "node:path";
+import path67 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 async function startLaunch(options) {
   const homeDir = resolveHomeDir(options.homeDir);
@@ -44217,7 +44360,7 @@ async function runLaunchDaemon(options) {
   });
 }
 function resolveLaunchBaseDir(homeDir) {
-  return path66.join(homeDir, ".poe-code", "launch");
+  return path67.join(homeDir, ".poe-code", "launch");
 }
 function resolveHomeDir(homeDir) {
   if (homeDir) {
@@ -44233,7 +44376,7 @@ function normalizeLaunchSpec(spec10, baseDir) {
   if (locator.scheme !== "local") {
     return spec10;
   }
-  const cwd = path66.isAbsolute(locator.path) ? locator.path : path66.resolve(baseDir, locator.path);
+  const cwd = path67.isAbsolute(locator.path) ? locator.path : path67.resolve(baseDir, locator.path);
   return {
     ...spec10,
     cwd
@@ -45227,15 +45370,15 @@ var init_renderer3 = __esm({
 });
 
 // packages/toolcraft/src/cli.ts
-import { access as access4, readFile as readFile22, writeFile as writeFile15 } from "node:fs/promises";
-import path68 from "node:path";
+import { access as access4, readFile as readFile23, writeFile as writeFile15 } from "node:fs/promises";
+import path69 from "node:path";
 import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
 function inferProgramName(argv) {
   const entrypoint = argv[1];
   if (typeof entrypoint !== "string" || entrypoint.length === 0) {
     return "toolcraft";
   }
-  const parsed = path68.parse(entrypoint);
+  const parsed = path69.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "toolcraft";
 }
 function normalizeRoots2(roots, argv) {
@@ -45292,11 +45435,11 @@ function formatSegment2(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords2(segment).join(separator);
 }
-function toOptionFlag(path93, casing) {
-  return `--${path93.map((segment) => formatSegment2(segment, casing)).join(".")}`;
+function toOptionFlag(path94, casing) {
+  return `--${path94.map((segment) => formatSegment2(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path93, casing) {
-  return path93.map((segment) => {
+function toOptionAttribute(path94, casing) {
+  return path94.map((segment) => {
     const formatted = formatSegment2(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -45307,23 +45450,23 @@ function toOptionAttribute(path93, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath3(path93) {
-  return path93.join(".");
+function toDisplayPath3(path94) {
+  return path94.join(".");
 }
-function toUnionKindControlPath(path93) {
-  if (path93.length === 0) {
+function toUnionKindControlPath(path94) {
+  if (path94.length === 0) {
     return ["kind"];
   }
-  const head = path93.slice(0, -1);
-  const tail = path93[path93.length - 1] ?? "";
+  const head = path94.slice(0, -1);
+  const tail = path94[path94.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path93) {
-  if (path93.length === 0) {
+function toUnionKindDisplayPath(path94) {
+  if (path94.length === 0) {
     return "kind";
   }
-  const head = path93.slice(0, -1);
-  const tail = path93[path93.length - 1] ?? "";
+  const head = path94.slice(0, -1);
+  const tail = path94[path94.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -45339,19 +45482,19 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema]) => schema.kind !== "optional").map(([key2]) => formatSegment2(key2, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema, casing, path93 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path94 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path93, key2];
+    const nextPath = [...path94, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional3(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
     if (childSchema.kind === "object") {
-      const nested = collectFields(childSchema, casing, nextPath, runtimeOptional, variantContext);
+      const nested = collectFields(childSchema, casing, globalLongOptionFlags, nextPath, runtimeOptional, variantContext);
       collected.dynamicFields.push(...nested.dynamicFields);
       collected.fields.push(...nested.fields);
       collected.variants.push(...nested.variants);
@@ -45365,7 +45508,7 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
         path: [...nextPath, childSchema.discriminator],
         displayPath: toDisplayPath3([...nextPath, childSchema.discriminator]),
         optionAttribute: toOptionAttribute([...nextPath, childSchema.discriminator], casing),
-        commanderOptionAttribute: toCommanderOptionAttribute([...nextPath, childSchema.discriminator], casing),
+        commanderOptionAttribute: toCommanderOptionAttribute([...nextPath, childSchema.discriminator], casing, globalLongOptionFlags),
         optionFlag: toOptionFlag([...nextPath, childSchema.discriminator], casing),
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
@@ -45378,7 +45521,7 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
       collected.fields.push(controlField);
       const branches = [];
       for (const [branchId, branchSchema] of Object.entries(childSchema.branches)) {
-        const branch = collectFields(branchSchema, casing, nextPath, true, {
+        const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
           id: variantId,
           branchId
         });
@@ -45412,7 +45555,7 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
         path: controlPath,
         displayPath: controlDisplayPath,
         optionAttribute: toOptionAttribute(controlPath, casing),
-        commanderOptionAttribute: toCommanderOptionAttribute(controlPath, casing),
+        commanderOptionAttribute: toCommanderOptionAttribute(controlPath, casing, globalLongOptionFlags),
         optionFlag: toOptionFlag(controlPath, casing),
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
@@ -45427,7 +45570,7 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
       const branches = [];
       childSchema.branches.forEach((branchSchema, index) => {
         const branchId = branchIds[index] ?? "";
-        const branch = collectFields(branchSchema, casing, nextPath, true, {
+        const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
           id: variantId,
           branchId
         });
@@ -45494,7 +45637,7 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
       path: nextPath,
       displayPath: toDisplayPath3(nextPath),
       optionAttribute: toOptionAttribute(nextPath, casing),
-      commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing),
+      commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing, globalLongOptionFlags),
       optionFlag: toOptionFlag(nextPath, casing),
       shortFlag: childSchema.short,
       schema: childSchema,
@@ -45509,10 +45652,10 @@ function collectFields(schema, casing, path93 = [], inheritedOptional = false, v
   }
   return collected;
 }
-function toCommanderOptionAttribute(path93, casing) {
-  const optionAttribute = toOptionAttribute(path93, casing);
-  const optionFlag = toOptionFlag(path93, casing);
-  if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
+function toCommanderOptionAttribute(path94, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path94, casing);
+  const optionFlag = toOptionFlag(path94, casing);
+  if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
   return `param_${optionAttribute}`;
@@ -45542,8 +45685,8 @@ function assignPositionals(fields, positional) {
   });
   return fields;
 }
-function formatOptionFlags(field) {
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function formatOptionFlags(field, globalLongOptionFlags) {
+  const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
   if (collidesWithGlobalFlag) {
     if (field.shortFlag === void 0) {
       throw new UserError(
@@ -45661,9 +45804,9 @@ function parseArrayValue(value, schema, label) {
   }
   return splitArrayInput(value).map((item) => parseScalarValue(item, itemSchema, label));
 }
-function createOption(field) {
-  const flags = formatOptionFlags(field);
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function createOption(field, globalLongOptionFlags) {
+  const flags = formatOptionFlags(field, globalLongOptionFlags);
+  const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
   const commanderValue = (value) => value === null ? NULL_OPTION_VALUE : value;
   if (field.schema.kind === "boolean") {
     if (collidesWithGlobalFlag) {
@@ -45708,6 +45851,9 @@ function createOption(field) {
   );
   return [option];
 }
+function getGlobalLongOptionFlags(presetsEnabled) {
+  return new Set(presetsEnabled ? ["--preset", ...ALWAYS_GLOBAL_LONG_OPTION_FLAGS] : ALWAYS_GLOBAL_LONG_OPTION_FLAGS);
+}
 function createCommanderOption(flags, description, field) {
   const option = new Option(flags, description);
   if (field.commanderOptionAttribute !== field.optionAttribute) {
@@ -45801,14 +45947,14 @@ function describeSchemaType(schema) {
       throw new UserError("Unsupported CLI schema kind.");
   }
 }
-function formatHelpFieldFlags(field) {
+function formatHelpFieldFlags(field, globalLongOptionFlags) {
   if (field.positionalIndex !== void 0) {
     return formatPositionalToken(field);
   }
   if (field.schema.kind === "boolean") {
-    return `${formatOptionFlags(field)} [value]`;
+    return `${formatOptionFlags(field, globalLongOptionFlags)} [value]`;
   }
-  return `${formatOptionFlags(field)} <${describeSchemaType(field.schema)}>`;
+  return `${formatOptionFlags(field, globalLongOptionFlags)} <${describeSchemaType(field.schema)}>`;
 }
 function appendHelpMetadata(description, metadata) {
   if (metadata.length === 0) {
@@ -45950,18 +46096,31 @@ function formatSecretDescription(secret) {
   }
   return secret.optional === true ? "Optional secret" : "Required secret";
 }
-function formatCommandRows(group, scope) {
-  return getVisibleChildren(group, scope).map((child) => ({
-    name: child.aliases.length === 0 ? child.name : `${child.name} (${child.aliases.join(", ")})`,
-    description: child.description ?? ""
-  }));
+function formatCommandRowName(node, depth) {
+  const name = node.aliases.length === 0 ? node.name : `${node.name} (${node.aliases.join(", ")})`;
+  return `${"  ".repeat(depth)}${name}`;
 }
-function formatGlobalOptionRows(showVersion) {
-  const rows = [
-    {
+function formatCommandRows(group, scope, depth = 0) {
+  return getVisibleChildren(group, scope).flatMap((child) => {
+    const row = {
+      name: formatCommandRowName(child, depth),
+      description: child.description ?? ""
+    };
+    if (child.kind === "command") {
+      return [row];
+    }
+    return [row, ...formatCommandRows(child, scope, depth + 1)];
+  });
+}
+function formatGlobalOptionRows(showVersion, presetsEnabled) {
+  const rows = [];
+  if (presetsEnabled) {
+    rows.push({
       flags: "--preset <path>",
       description: "Load parameter defaults from a JSON file"
-    },
+    });
+  }
+  rows.push(
     {
       flags: "--yes",
       description: "Accept defaults, skip prompts"
@@ -45974,7 +46133,7 @@ function formatGlobalOptionRows(showVersion) {
       flags: "-h, --help",
       description: "Show help"
     }
-  ];
+  );
   if (showVersion) {
     rows.push({
       flags: "--version",
@@ -45993,7 +46152,7 @@ function buildUsageLine(breadcrumb, rootUsageName, suffix) {
   const subPath = breadcrumb.slice(1).join(" ");
   return subPath ? `${rootUsageName} ${subPath} ${suffix}` : `${rootUsageName} ${suffix}`;
 }
-function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
+function renderGroupHelp(group, breadcrumb, scope, showVersion, presetsEnabled, rootUsageName) {
   const sections = [];
   const commandRows = formatCommandRows(group, scope);
   if (commandRows.length > 0) {
@@ -46001,7 +46160,7 @@ function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
 ${formatCommandList(commandRows)}`);
   }
   sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(showVersion))}`);
+${formatOptionList(formatGlobalOptionRows(showVersion, presetsEnabled))}`);
   return renderHelpDocument({
     breadcrumb,
     usageLine: buildUsageLine(breadcrumb, rootUsageName, "[options] [command]"),
@@ -46010,12 +46169,13 @@ ${formatOptionList(formatGlobalOptionRows(showVersion))}`);
     sections
   });
 }
-function renderLeafHelp(command, breadcrumb, casing, rootUsageName) {
+function renderLeafHelp(command, breadcrumb, casing, presetsEnabled, rootUsageName) {
   const sections = [];
-  const collected = collectFields(command.params, casing);
+  const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled);
+  const collected = collectFields(command.params, casing, globalLongOptionFlags);
   const fields = assignPositionals(collected.fields, command.positional);
   const optionRows = fields.map((field) => ({
-    flags: formatHelpFieldFlags(field),
+    flags: formatHelpFieldFlags(field, globalLongOptionFlags),
     description: formatHelpFieldDescription(field)
   })).concat(collected.dynamicFields.flatMap((field) => formatDynamicHelpFields(field, casing)));
   if (optionRows.length > 0) {
@@ -46023,7 +46183,7 @@ function renderLeafHelp(command, breadcrumb, casing, rootUsageName) {
 ${formatOptionList(optionRows)}`);
   }
   sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(false))}`);
+${formatOptionList(formatGlobalOptionRows(false, presetsEnabled))}`);
   const secretRows = formatSecretRows(command.secrets);
   if (secretRows.length > 0) {
     sections.push(`${text.section("Secrets (via environment):")}
@@ -46062,25 +46222,32 @@ async function renderGeneratedHelp(root, argv, options) {
   const output = resolveHelpOutput(argv);
   const casing = options.casing ?? "kebab";
   await withOutputFormat2(output, async () => {
-    const rendered = target.node.kind === "group" ? renderGroupHelp(target.node, target.breadcrumb, "cli", options.version !== void 0, options.rootUsageName) : renderLeafHelp(target.node, target.breadcrumb, casing, options.rootUsageName);
+    const rendered = target.node.kind === "group" ? renderGroupHelp(
+      target.node,
+      target.breadcrumb,
+      "cli",
+      options.version !== void 0,
+      options.presets === true,
+      options.rootUsageName
+    ) : renderLeafHelp(target.node, target.breadcrumb, casing, options.presets === true, options.rootUsageName);
     process.stdout.write(rendered);
   });
 }
-function createNodeCommand(node, casing, execute2, pathSegments = []) {
+function createNodeCommand(node, casing, globalLongOptionFlags, execute2, presetsEnabled, pathSegments = []) {
   const nextPathSegments = [...pathSegments, node.name];
   if (node.kind === "command") {
     if (!node.scope.includes("cli")) {
       return null;
     }
     const command = new CommanderCommand(node.name);
-    const collected = collectFields(node.params, casing);
+    const collected = collectFields(node.params, casing, globalLongOptionFlags);
     const fields = assignPositionals(collected.fields, node.positional);
     if (node.description !== void 0) {
       command.description(node.description);
     }
     node.aliases.forEach((alias) => command.alias(alias));
     command.addHelpCommand(false);
-    addGlobalOptions(command);
+    addGlobalOptions(command, presetsEnabled);
     command.allowExcessArguments(true);
     if (collected.dynamicFields.length > 0) {
       command.allowUnknownOption(true);
@@ -46090,7 +46257,7 @@ function createNodeCommand(node, casing, execute2, pathSegments = []) {
         command.argument(formatPositionalToken(field));
         continue;
       }
-      for (const option of createOption(field)) {
+      for (const option of createOption(field, globalLongOptionFlags)) {
         command.addOption(option);
       }
     }
@@ -46104,6 +46271,7 @@ function createNodeCommand(node, casing, execute2, pathSegments = []) {
         dynamicFields: collected.dynamicFields,
         fields,
         positionalValues,
+        presetsEnabled,
         rawArgv: actionCommand.args,
         actionCommand,
         variants: collected.variants
@@ -46114,22 +46282,25 @@ function createNodeCommand(node, casing, execute2, pathSegments = []) {
   if (!isNodeVisibleInScope(node, "cli")) {
     return null;
   }
-  const visibleChildren = node.children.map((child) => createNodeCommand(child, casing, execute2, nextPathSegments)).filter((child) => child !== null);
+  const visibleChildren = node.children.map((child) => createNodeCommand(child, casing, globalLongOptionFlags, execute2, presetsEnabled, nextPathSegments)).filter((child) => child !== null);
   const group = new CommanderCommand(node.name);
   if (node.description !== void 0) {
     group.description(node.description);
   }
   node.aliases.forEach((alias) => group.alias(alias));
   group.addHelpCommand(false);
-  addGlobalOptions(group);
+  addGlobalOptions(group, presetsEnabled);
   for (const child of visibleChildren) {
     const isDefaultChild = node.default !== void 0 && node.default.scope.includes("cli") && (child.name() === node.default.name || child.aliases().includes(node.default.name));
     group.addCommand(child, isDefaultChild ? { isDefault: true } : void 0);
   }
   return group;
 }
-function addGlobalOptions(command) {
-  command.option("--preset <path>", "Load parameter defaults from a JSON file.").option("--yes", "Accept defaults and skip prompts.").option("--output <format>", "Output format.", (value) => {
+function addGlobalOptions(command, presetsEnabled) {
+  if (presetsEnabled) {
+    command.option("--preset <path>", "Load parameter defaults from a JSON file.");
+  }
+  command.option("--yes", "Accept defaults and skip prompts.").option("--output <format>", "Output format.", (value) => {
     if (value === "rich" || value === "md" || value === "json") {
       return value;
     }
@@ -46139,10 +46310,10 @@ function addGlobalOptions(command) {
     throw new InvalidArgumentError('Invalid value for "--output". Expected one of: rich, md, markdown, json.');
   }).option("--verbose", "Print stack traces for unexpected errors.");
 }
-function setNestedValue(target, path93, value) {
+function setNestedValue(target, path94, value) {
   let cursor = target;
-  for (let index = 0; index < path93.length - 1; index += 1) {
-    const segment = path93[index] ?? "";
+  for (let index = 0; index < path94.length - 1; index += 1) {
+    const segment = path94[index] ?? "";
     const existing = cursor[segment];
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -46152,7 +46323,7 @@ function setNestedValue(target, path93, value) {
     cursor[segment] = next;
     cursor = next;
   }
-  const leaf = path93[path93.length - 1];
+  const leaf = path94[path94.length - 1];
   if (leaf !== void 0) {
     cursor[leaf] = value;
   }
@@ -46249,13 +46420,13 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs3() {
   return {
-    readFile: async (path93, encoding = "utf8") => readFile22(path93, { encoding }),
-    writeFile: async (path93, contents) => {
-      await writeFile15(path93, contents);
+    readFile: async (path94, encoding = "utf8") => readFile23(path94, { encoding }),
+    writeFile: async (path94, contents) => {
+      await writeFile15(path94, contents);
     },
-    exists: async (path93) => {
+    exists: async (path94) => {
       try {
-        await access4(path93);
+        await access4(path94);
         return true;
       } catch {
         return false;
@@ -46276,9 +46447,9 @@ function isPlainObject5(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path93) {
+function hasNestedField(fields, path94) {
   return fields.some(
-    (field) => path93.length < field.path.length && path93.every((segment, index) => field.path[index] === segment)
+    (field) => path94.length < field.path.length && path94.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -46353,7 +46524,7 @@ function validatePresetFieldValue(value, field, presetPath) {
 async function loadPresetValues(fields, presetPath) {
   let rawPreset;
   try {
-    rawPreset = await readFile22(presetPath, {
+    rawPreset = await readFile23(presetPath, {
       encoding: "utf8"
     });
   } catch (error2) {
@@ -46374,9 +46545,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path93) {
+  function visitObject(current, path94) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path93, key2];
+      const nextPath = [...path94, key2];
       const displayPath2 = toDisplayPath3(nextPath);
       const field = fieldByPath.get(displayPath2);
       if (field !== void 0) {
@@ -46574,8 +46745,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path68.parse(commandPath);
-  return path68.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path69.parse(commandPath);
+  return path69.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector) {
   if (isNumericFixtureSelector(selector)) {
@@ -46602,7 +46773,7 @@ async function loadFixtureScenario(command, selector) {
   const fixturePath = resolveFixturePath(commandPath);
   let rawFixture;
   try {
-    rawFixture = await readFile22(fixturePath, {
+    rawFixture = await readFile23(fixturePath, {
       encoding: "utf8"
     });
   } catch {
@@ -46698,8 +46869,8 @@ function validateServices2(services) {
     }
   }
 }
-function getNestedValue(target, path93) {
-  return path93.reduce(
+function getNestedValue(target, path94) {
+  return path94.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -47165,7 +47336,7 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
       optionValues,
       state.rawArgv,
       state.casing,
-      resolvedFlags.preset,
+      state.presetsEnabled ? resolvedFlags.preset : void 0,
       shouldPrompt
     );
     const context = {
@@ -47233,6 +47404,7 @@ async function runCLI(roots, options = {}) {
   const casing = options.casing ?? "kebab";
   const services = options.services ?? {};
   const runtimeOptions = options.humanInLoop ?? {};
+  const version = options.version ?? findEntrypointPackageMetadata(process.argv[1])?.version;
   const servicesWithBuiltIns = {
     ...services,
     runtimeOptions,
@@ -47243,7 +47415,7 @@ async function runCLI(roots, options = {}) {
   };
   validateServices2(services);
   if (hasHelpFlag(process.argv)) {
-    await renderGeneratedHelp(root, process.argv, options);
+    await renderGeneratedHelp(root, process.argv, { ...options, version });
     return;
   }
   const program = new CommanderCommand();
@@ -47251,9 +47423,11 @@ async function runCLI(roots, options = {}) {
   program.exitOverride();
   program.showHelpAfterError();
   program.addHelpCommand(false);
-  addGlobalOptions(program);
-  if (options.version !== void 0) {
-    program.version(options.version, "--version");
+  const presetsEnabled = options.presets === true;
+  const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled);
+  addGlobalOptions(program, presetsEnabled);
+  if (version !== void 0) {
+    program.version(version, "--version");
   }
   let lastActionCommand;
   const execute2 = async (state) => {
@@ -47261,7 +47435,7 @@ async function runCLI(roots, options = {}) {
     await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeOptions);
   };
   for (const child of root.children) {
-    const command = createNodeCommand(child, casing, execute2);
+    const command = createNodeCommand(child, casing, globalLongOptionFlags, execute2, presetsEnabled);
     if (command === null) {
       continue;
     }
@@ -47281,7 +47455,7 @@ async function runCLI(roots, options = {}) {
     );
   }
 }
-var RESERVED_SERVICE_NAMES2, NULL_OPTION_VALUE, HELP_FLAGS, GLOBAL_LONG_OPTION_FLAGS, DESIGN_SYSTEM_OUTPUT_BY_MODE;
+var RESERVED_SERVICE_NAMES2, NULL_OPTION_VALUE, HELP_FLAGS, ALWAYS_GLOBAL_LONG_OPTION_FLAGS, DESIGN_SYSTEM_OUTPUT_BY_MODE;
 var init_cli = __esm({
   "packages/toolcraft/src/cli.ts"() {
     "use strict";
@@ -47291,11 +47465,12 @@ var init_cli = __esm({
     init_human_in_loop();
     init_mcp_proxy();
     init_number_schema();
+    init_package_metadata();
     init_renderer3();
     RESERVED_SERVICE_NAMES2 = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
     NULL_OPTION_VALUE = /* @__PURE__ */ Symbol("toolcraft.cli.null");
     HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-    GLOBAL_LONG_OPTION_FLAGS = /* @__PURE__ */ new Set(["--preset", "--yes", "--output", "--verbose"]);
+    ALWAYS_GLOBAL_LONG_OPTION_FLAGS = ["--yes", "--output", "--verbose"];
     DESIGN_SYSTEM_OUTPUT_BY_MODE = {
       rich: "terminal",
       md: "markdown",
@@ -47815,7 +47990,7 @@ var init_agent2 = __esm({
 });
 
 // src/cli/commands/spawn.ts
-import path69 from "node:path";
+import path70 from "node:path";
 import { Option as Option2 } from "commander";
 function registerSpawnCommand(program, container, options = {}) {
   const spawnServices = container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name));
@@ -48096,7 +48271,7 @@ async function resolvePromptInput(input, fs19, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("prompt @<path> requires a file path after '@'");
   }
-  const filePath = path69.isAbsolute(rawPath) ? rawPath : path69.join(baseDir, rawPath);
+  const filePath = path70.isAbsolute(rawPath) ? rawPath : path70.join(baseDir, rawPath);
   try {
     const contents = await fs19.readFile(filePath, "utf8");
     return contents.trim();
@@ -48117,7 +48292,7 @@ async function resolveMcpSpawnInput(input, fs19, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("--mcp-servers @<path> requires a file path after '@'");
   }
-  const filePath = path69.isAbsolute(rawPath) ? rawPath : path69.join(baseDir, rawPath);
+  const filePath = path70.isAbsolute(rawPath) ? rawPath : path70.join(baseDir, rawPath);
   try {
     return await fs19.readFile(filePath, "utf8");
   } catch (error2) {
@@ -49005,9 +49180,9 @@ var init_command_not_found = __esm({
 
 // src/cli/commands/utils-symlink-ops.ts
 import { dirname as dirname4 } from "node:path";
-async function tryLstat(fs19, path93) {
+async function tryLstat(fs19, path94) {
   try {
-    return await fs19.lstat(path93);
+    return await fs19.lstat(path94);
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -49058,13 +49233,13 @@ async function applySymlinkOps(fs19, ops, opts) {
   }
   return { conflicts };
 }
-async function isSymlinkPointingTo(fs19, path93, expectedTarget) {
+async function isSymlinkPointingTo(fs19, path94, expectedTarget) {
   try {
-    const stats = await fs19.lstat(path93);
+    const stats = await fs19.lstat(path94);
     if (!stats.isSymbolicLink()) {
       return false;
     }
-    return await fs19.readlink(path93) === expectedTarget;
+    return await fs19.readlink(path94) === expectedTarget;
   } catch (error2) {
     if (isNotFound(error2)) {
       return false;
@@ -49542,7 +49717,7 @@ var init_media_download = __esm({
 });
 
 // src/cli/commands/generate.ts
-import path70 from "node:path";
+import path71 from "node:path";
 function registerGenerateCommand(program, container) {
   const generate2 = program.command("generate").alias("g").description("Generate content via Poe API.").option("--model <model>", `Model identifier (default: ${DEFAULT_TEXT_MODEL})`).option(
     "--param <key=value>",
@@ -49815,11 +49990,11 @@ function getDefaultMimeType(type) {
   return defaults[type];
 }
 function resolveOutputPath(filename, cwd) {
-  if (path70.isAbsolute(filename)) {
+  if (path71.isAbsolute(filename)) {
     return { path: filename, label: filename };
   }
   return {
-    path: path70.join(cwd, filename),
+    path: path71.join(cwd, filename),
     label: `./${filename}`
   };
 }
@@ -50420,10 +50595,10 @@ var init_shapes = __esm({
 });
 
 // packages/agent-mcp-config/src/apply.ts
-import path71 from "node:path";
+import path72 from "node:path";
 import { parse as parseYaml6, stringify as stringifyYaml3 } from "yaml";
 function getConfigDirectory(configPath) {
-  return path71.dirname(configPath);
+  return path72.dirname(configPath);
 }
 function isConfigObject6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -50443,9 +50618,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path71.join(homeDir, configPath.slice(2));
+    return path72.join(homeDir, configPath.slice(2));
   }
-  return path71.join(homeDir, configPath.slice(1));
+  return path72.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument2(content) {
   if (content.trim() === "") {
@@ -50478,7 +50653,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path71.dirname(absolutePath);
+  const configDir = path72.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -51757,9 +51932,9 @@ var init_dashboard_loop_shared = __esm({
 });
 
 // src/cli/commands/pipeline.ts
-import path72 from "node:path";
-import { readFile as readFile23, stat as stat18 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
+import path73 from "node:path";
+import { readFile as readFile24, stat as stat18 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
 async function resolvePipelineCommandConfig(container) {
   const [configDoc, pipelineYamlConfig] = await Promise.all([
     readMergedDocument(
@@ -51816,11 +51991,11 @@ function resolveMaxRuns(value) {
   return parsed;
 }
 function resolvePipelineInitSourcePath(container, sourcePath) {
-  const absolutePath = sourcePath.startsWith("~/") ? path72.join(container.env.homeDir, sourcePath.slice(2)) : path72.isAbsolute(sourcePath) ? sourcePath : path72.resolve(container.env.cwd, sourcePath);
+  const absolutePath = sourcePath.startsWith("~/") ? path73.join(container.env.homeDir, sourcePath.slice(2)) : path73.isAbsolute(sourcePath) ? sourcePath : path73.resolve(container.env.cwd, sourcePath);
   return {
     absolutePath,
     relativePath: sourcePath,
-    title: path72.basename(sourcePath, path72.extname(sourcePath))
+    title: path73.basename(sourcePath, path73.extname(sourcePath))
   };
 }
 function isActivityTimeoutError3(error2) {
@@ -52162,12 +52337,12 @@ async function runPipelineWithDashboard(options) {
   }
 }
 function resolvePipelinePaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path72.join(homeDir, ".poe-code", "pipeline") : path72.join(cwd, ".poe-code", "pipeline");
+  const rootPath = scope === "global" ? path73.join(homeDir, ".poe-code", "pipeline") : path73.join(cwd, ".poe-code", "pipeline");
   const displayRoot = scope === "global" ? "~/.poe-code/pipeline" : ".poe-code/pipeline";
   return {
-    plansPath: path72.join(rootPath, "plans"),
-    stepsPath: path72.join(rootPath, "steps.yaml"),
-    legacyDefaultStepsPath: path72.join(rootPath, "steps", "default.yaml"),
+    plansPath: path73.join(rootPath, "plans"),
+    stepsPath: path73.join(rootPath, "steps.yaml"),
+    legacyDefaultStepsPath: path73.join(rootPath, "steps", "default.yaml"),
     displayPlansPath: `${displayRoot}/plans`,
     displayStepsPath: `${displayRoot}/steps.yaml`
   };
@@ -52176,18 +52351,18 @@ async function loadPipelineTemplates() {
   if (pipelineTemplatesCache) {
     return pipelineTemplatesCache;
   }
-  const packageRoot = await findPackageRoot3(fileURLToPath9(import.meta.url));
+  const packageRoot = await findPackageRoot3(fileURLToPath10(import.meta.url));
   const templateRoots = [
-    path72.join(packageRoot, "src", "templates", "pipeline"),
-    path72.join(packageRoot, "dist", "templates", "pipeline")
+    path73.join(packageRoot, "src", "templates", "pipeline"),
+    path73.join(packageRoot, "dist", "templates", "pipeline")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk(templateRoot)) {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile23(path72.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile23(path72.join(templateRoot, "steps.yaml.mustache"), "utf8")
+      readFile24(path73.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile24(path73.join(templateRoot, "steps.yaml.mustache"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -52206,12 +52381,12 @@ async function pathExistsOnDisk(targetPath) {
   }
 }
 async function findPackageRoot3(entryFilePath) {
-  let currentPath = path72.dirname(entryFilePath);
+  let currentPath = path73.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk(path72.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk(path73.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path72.dirname(currentPath);
+    const parentPath = path73.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Pipeline templates.");
     }
@@ -52499,11 +52674,11 @@ function registerPipelineCommand(program, container) {
         if (typeof t.status === "string") return t.status === "done";
         return Object.values(t.status).every((s) => s === "done");
       }).length;
-      const readFile37 = container.fs.readFile.bind(container.fs);
+      const readFile38 = container.fs.readFile.bind(container.fs);
       const resolvedVars = await resolvePipelineVars(
         plan.vars ?? {},
         container.env.cwd,
-        readFile37
+        readFile38
       );
       const resolvedSetup = plan.setup === null ? void 0 : plan.setup ?? steps.setup;
       const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? steps.teardown;
@@ -52525,7 +52700,7 @@ function registerPipelineCommand(program, container) {
       if (opts.preview) {
         if (resolvedSetup) {
           const raw = interpolatePipelineVars(resolvedSetup.prompt, resolvedVars, "setup");
-          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile37);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile38);
           resources.logger.resolved("setup", expanded);
         }
         for (const task of plan.tasks) {
@@ -52538,7 +52713,7 @@ function registerPipelineCommand(program, container) {
                 vars: resolvedVars
               }),
               container.env.cwd,
-              readFile37
+              readFile38
             );
             resources.logger.resolved(`task: ${task.id} \u2014 ${task.title}`, expanded);
           } else {
@@ -52551,7 +52726,7 @@ function registerPipelineCommand(program, container) {
                   vars: resolvedVars
                 }),
                 container.env.cwd,
-                readFile37
+                readFile38
               );
               resources.logger.resolved(`task: ${task.id} / ${stepName}`, expanded);
             }
@@ -52559,7 +52734,7 @@ function registerPipelineCommand(program, container) {
         }
         if (resolvedTeardown) {
           const raw = interpolatePipelineVars(resolvedTeardown.prompt, resolvedVars, "teardown");
-          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile37);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile38);
           resources.logger.resolved("teardown", expanded);
         }
       }
@@ -52676,7 +52851,7 @@ function registerPipelineCommand(program, container) {
           `Would ${stepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayStepsPath}`
         );
       } else {
-        await container.fs.mkdir(path72.dirname(pipelinePaths.stepsPath), {
+        await container.fs.mkdir(path73.dirname(pipelinePaths.stepsPath), {
           recursive: true
         });
         await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
@@ -52722,7 +52897,7 @@ var init_pipeline3 = __esm({
 });
 
 // src/cli/commands/ralph.ts
-import path73 from "node:path";
+import path74 from "node:path";
 function formatRalphAgentSummary(agent2) {
   return Array.isArray(agent2) ? agent2.join(", ") : agent2;
 }
@@ -52903,9 +53078,9 @@ function normalizeConfiguredIterations(value) {
 }
 function resolveAbsoluteDocPath(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path73.join(container.env.homeDir, docPath.slice(2));
+    return path74.join(container.env.homeDir, docPath.slice(2));
   }
-  return path73.isAbsolute(docPath) ? docPath : path73.resolve(container.env.cwd, docPath);
+  return path74.isAbsolute(docPath) ? docPath : path74.resolve(container.env.cwd, docPath);
 }
 async function resolveRalphCommandConfig(container) {
   const configDoc = await readMergedDocument(
@@ -53300,11 +53475,11 @@ var init_ralph3 = __esm({
 });
 
 // src/cli/commands/experiment.ts
-import path74 from "node:path";
-import { readFile as readFile24, stat as stat19 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
+import path75 from "node:path";
+import { readFile as readFile25, stat as stat19 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path74.join(homeDir, ".poe-code", "experiments") : path74.join(cwd, ".poe-code", "experiments");
+  const rootPath = scope === "global" ? path75.join(homeDir, ".poe-code", "experiments") : path75.join(cwd, ".poe-code", "experiments");
   const displayRoot = scope === "global" ? "~/.poe-code/experiments" : ".poe-code/experiments";
   return {
     experimentsPath: rootPath,
@@ -53323,12 +53498,12 @@ async function pathExistsOnDisk2(targetPath) {
   }
 }
 async function findPackageRoot4(entryFilePath) {
-  let currentPath = path74.dirname(entryFilePath);
+  let currentPath = path75.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk2(path74.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk2(path75.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path74.dirname(currentPath);
+    const parentPath = path75.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Experiment templates.");
     }
@@ -53339,18 +53514,18 @@ async function loadExperimentTemplates() {
   if (experimentTemplatesCache) {
     return experimentTemplatesCache;
   }
-  const packageRoot = await findPackageRoot4(fileURLToPath10(import.meta.url));
+  const packageRoot = await findPackageRoot4(fileURLToPath11(import.meta.url));
   const templateRoots = [
-    path74.join(packageRoot, "src", "templates", "experiment"),
-    path74.join(packageRoot, "dist", "templates", "experiment")
+    path75.join(packageRoot, "src", "templates", "experiment"),
+    path75.join(packageRoot, "dist", "templates", "experiment")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk2(templateRoot)) {
       continue;
     }
     const [skillPlan, runYaml] = await Promise.all([
-      readFile24(path74.join(templateRoot, "SKILL_experiment.md"), "utf8"),
-      readFile24(path74.join(templateRoot, "run.yaml.mustache"), "utf8")
+      readFile25(path75.join(templateRoot, "SKILL_experiment.md"), "utf8"),
+      readFile25(path75.join(templateRoot, "run.yaml.mustache"), "utf8")
     ]);
     experimentTemplatesCache = { skillPlan, runYaml };
     return experimentTemplatesCache;
@@ -54044,8 +54219,8 @@ function registerExperimentCommand(program, container) {
           resources.logger.info(`Create: ${experimentPaths.displayExperimentsPath}`);
         }
       }
-      const runYamlPath = path74.join(experimentPaths.experimentsPath, "run.yaml");
-      const runYamlDisplayPath = path74.join(experimentPaths.displayExperimentsPath, "run.yaml");
+      const runYamlPath = path75.join(experimentPaths.experimentsPath, "run.yaml");
+      const runYamlDisplayPath = path75.join(experimentPaths.displayExperimentsPath, "run.yaml");
       if (!await pathExists6(container.fs, runYamlPath)) {
         if (flags.dryRun) {
           resources.logger.dryRun(`Would create: ${runYamlDisplayPath}`);
@@ -54508,9 +54683,9 @@ var init_launch2 = __esm({
 });
 
 // packages/memory/src/paths.ts
-import path75 from "node:path";
+import path76 from "node:path";
 function resolveMemoryRoot(cwd) {
-  return path75.resolve(cwd, ".poe-code", "memory");
+  return path76.resolve(cwd, ".poe-code", "memory");
 }
 function assertSafeRelPath(input) {
   const trimmed = input.trim();
@@ -54518,10 +54693,10 @@ function assertSafeRelPath(input) {
     throw new MemoryPathError("Expected a non-empty relative path.");
   }
   const slashNormalized = trimmed.replaceAll("\\", "/");
-  if (path75.posix.isAbsolute(slashNormalized) || path75.win32.isAbsolute(slashNormalized)) {
+  if (path76.posix.isAbsolute(slashNormalized) || path76.win32.isAbsolute(slashNormalized)) {
     throw new MemoryPathError(`Expected a relative path, received absolute path "${input}".`);
   }
-  const normalized = path75.posix.normalize(slashNormalized);
+  const normalized = path76.posix.normalize(slashNormalized);
   if (normalized === "." || normalized.length === 0) {
     throw new MemoryPathError("Expected a relative path to a file or directory.");
   }
@@ -54550,7 +54725,7 @@ var init_paths2 = __esm({
 });
 
 // packages/memory/src/resolve-root.ts
-import path76 from "node:path";
+import path77 from "node:path";
 async function resolveConfiguredMemoryRoot(options) {
   const envOverride = options.env[MEMORY_ROOT_ENV_VAR]?.trim();
   if (envOverride && envOverride.length > 0) {
@@ -54567,7 +54742,7 @@ async function resolveConfiguredMemoryRoot(options) {
   return resolveMemoryRoot(options.cwd);
 }
 function resolveAgainstCwd(cwd, value) {
-  return path76.isAbsolute(value) ? value : path76.resolve(cwd, value);
+  return path77.isAbsolute(value) ? value : path77.resolve(cwd, value);
 }
 var MEMORY_ROOT_ENV_VAR;
 var init_resolve_root = __esm({
@@ -54581,11 +54756,11 @@ var init_resolve_root = __esm({
 
 // packages/memory/src/init.ts
 import * as fs5 from "node:fs/promises";
-import path77 from "node:path";
+import path78 from "node:path";
 async function initMemory(root) {
-  await fs5.mkdir(path77.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
-  await writeFileIfMissing(path77.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
-  await writeFileIfMissing(path77.join(root, MEMORY_LOG_RELPATH), "");
+  await fs5.mkdir(path78.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
+  await writeFileIfMissing(path78.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
+  await writeFileIfMissing(path78.join(root, MEMORY_LOG_RELPATH), "");
 }
 async function writeFileIfMissing(filePath, content) {
   try {
@@ -54784,10 +54959,10 @@ function parseSources(value) {
     if (!isRecord22(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path93 = readRequiredString(item.path, "sources[].path");
+    const path94 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path93, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path94, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString3(value, field) {
@@ -54831,7 +55006,7 @@ var init_frontmatter5 = __esm({
 
 // packages/memory/src/pages.ts
 import * as fs6 from "node:fs/promises";
-import path78 from "node:path";
+import path79 from "node:path";
 async function listPages(root) {
   const relPaths = await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH);
   const pages = await Promise.all(relPaths.map(async (relPath) => readPage(root, relPath)));
@@ -54839,7 +55014,7 @@ async function listPages(root) {
 }
 async function readPage(root, relPath) {
   const normalizedRelPath = assertMarkdownRelPath(relPath);
-  const absPath = path78.join(root, normalizedRelPath);
+  const absPath = path79.join(root, normalizedRelPath);
   const [content, stat24] = await Promise.all([fs6.readFile(absPath, "utf8"), fs6.stat(absPath)]);
   try {
     const parsed = parseFrontmatter4(content);
@@ -54868,7 +55043,7 @@ async function collectMarkdownRelPaths(root, startRelPath = "") {
   return relPaths.sort((left, right) => left.localeCompare(right));
 }
 async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
-  const absPath = path78.join(root, currentRelPath);
+  const absPath = path79.join(root, currentRelPath);
   let entryNames;
   try {
     entryNames = await fs6.readdir(absPath);
@@ -54879,8 +55054,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 : path78.posix.join(currentRelPath, entryName);
-    const entryAbsPath = path78.join(root, entryRelPath);
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path79.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path79.join(root, entryRelPath);
     const entryStat = await fs6.stat(entryAbsPath);
     if (entryStat.isDirectory()) {
       if (entryName === MEMORY_CACHE_DIR_RELPATH) {
@@ -54910,7 +55085,7 @@ function assertMarkdownRelPath(relPath) {
   return normalizedRelPath;
 }
 function isMarkdownPath(relPath) {
-  return path78.posix.extname(relPath).toLowerCase() === ".md";
+  return path79.posix.extname(relPath).toLowerCase() === ".md";
 }
 function isMissing(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
@@ -54925,7 +55100,7 @@ var init_pages = __esm({
 
 // packages/memory/src/search.ts
 import * as fs7 from "node:fs/promises";
-import path79 from "node:path";
+import path80 from "node:path";
 async function searchMemory(root, query) {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) {
@@ -54934,7 +55109,7 @@ async function searchMemory(root, query) {
   const relPaths = await collectMarkdownRelPaths(root);
   const hits = [];
   for (const relPath of relPaths) {
-    const content = await fs7.readFile(path79.join(root, relPath), "utf8");
+    const content = await fs7.readFile(path80.join(root, relPath), "utf8");
     if (content.length === 0) {
       continue;
     }
@@ -54961,7 +55136,7 @@ var init_search = __esm({
 
 // packages/memory/src/status.ts
 import * as fs8 from "node:fs/promises";
-import path80 from "node:path";
+import path81 from "node:path";
 async function statusOf(root) {
   if (!await pathExists7(root)) {
     return {
@@ -54978,7 +55153,7 @@ async function statusOf(root) {
   let totalBytes = 0;
   let lastWriteAtMs = Number.NEGATIVE_INFINITY;
   for (const relPath of markdownRelPaths) {
-    const stat24 = await fs8.stat(path80.join(root, relPath));
+    const stat24 = await fs8.stat(path81.join(root, relPath));
     totalBytes += stat24.size;
     lastWriteAtMs = Math.max(lastWriteAtMs, stat24.mtimeMs);
   }
@@ -55010,7 +55185,7 @@ var init_status = __esm({
 
 // packages/memory/src/lock.ts
 import * as fsPromises20 from "node:fs/promises";
-import path81 from "node:path";
+import path82 from "node:path";
 function createDefaultFs13() {
   return {
     readFile: (filePath, encoding) => fsPromises20.readFile(filePath, encoding),
@@ -55040,7 +55215,7 @@ function parsePid(input) {
   const pid = Number.parseInt(value, 10);
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
-function isPidRunning(pid) {
+function isPidRunning2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -55069,12 +55244,12 @@ async function readLockPid(fs19, lockPath) {
 }
 async function withLock(root, run, options = {}) {
   const fs19 = options.fs ?? createDefaultFs13();
-  const lockPath = path81.join(root, MEMORY_LOCK_RELPATH);
+  const lockPath = path82.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
   const minTimeoutMs = options.minTimeoutMs ?? 25;
   const maxTimeoutMs = options.maxTimeoutMs ?? 250;
-  const pidIsRunning = options.isPidRunning ?? isPidRunning;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning2;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
     try {
       await fs19.writeFile(lockPath, `${pid}
@@ -55292,13 +55467,13 @@ var init_confidence = __esm({
 // packages/memory/src/reconcile.ts
 import { createHash } from "node:crypto";
 import * as fs9 from "node:fs/promises";
-import path82 from "node:path";
+import path83 from "node:path";
 async function snapshot(root) {
   const pages = Object.fromEntries(
     await Promise.all(
       (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => [
         relPath,
-        hashContent(await fs9.readFile(path82.join(root, relPath), "utf8"))
+        hashContent(await fs9.readFile(path83.join(root, relPath), "utf8"))
       ])
     )
   );
@@ -55309,7 +55484,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 = path82.join(root, relPath);
+      const absPath = path83.join(root, relPath);
       const markdown = await fs9.readFile(absPath, "utf8");
       const parsed = parsePageMarkdown(relPath, markdown);
       const normalizedFrontmatter = withDenormalizedSources(parsed.frontmatter, parsed.body);
@@ -55331,7 +55506,7 @@ async function reconcile(root, before, _verb, detail) {
     })
   );
   await Promise.all(
-    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs9.writeFile(path82.join(root, page.relPath), page.nextMarkdown, "utf8"))
+    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs9.writeFile(path83.join(root, page.relPath), page.nextMarkdown, "utf8"))
   );
   const diff2 = diffSnapshots(before, await snapshot(root));
   await writeIndex(root);
@@ -55361,7 +55536,7 @@ async function appendLogEntries(root, diff2, detail, timestamp = (/* @__PURE__ *
   if (entries.length === 0) {
     return;
   }
-  const logPath = path82.join(root, MEMORY_LOG_RELPATH);
+  const logPath = path83.join(root, MEMORY_LOG_RELPATH);
   const existing = await fs9.readFile(logPath, "utf8");
   const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   await fs9.writeFile(logPath, `${existing}${separator}${entries.join("\n")}
@@ -55385,7 +55560,7 @@ async function writeIndex(root) {
       description: page.frontmatter.description ?? ""
     }))
   );
-  await fs9.writeFile(path82.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
+  await fs9.writeFile(path83.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
 }
 function parsePageMarkdown(relPath, markdown) {
   try {
@@ -55437,14 +55612,14 @@ var init_reconcile = __esm({
 
 // packages/memory/src/write.ts
 import * as fs10 from "node:fs/promises";
-import path83 from "node:path";
+import path84 from "node:path";
 async function writePage(root, relPath, body, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    await fs10.mkdir(path83.dirname(path83.join(root, pageRelPath)), { recursive: true });
+    await fs10.mkdir(path84.dirname(path84.join(root, pageRelPath)), { recursive: true });
     await fs10.writeFile(
-      path83.join(root, pageRelPath),
+      path84.join(root, pageRelPath),
       serializeFrontmatter(opts.frontmatter ?? {}, body),
       "utf8"
     );
@@ -55455,8 +55630,8 @@ async function appendToPage(root, relPath, content, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   return withLock(root, async () => {
     const before = await snapshot(root);
-    const pagePath = path83.join(root, pageRelPath);
-    await fs10.mkdir(path83.dirname(pagePath), { recursive: true });
+    const pagePath = path84.join(root, pageRelPath);
+    await fs10.mkdir(path84.dirname(pagePath), { recursive: true });
     const existing = await readMarkdownIfPresent(pagePath);
     const parsed = existing === void 0 ? { frontmatter: {}, body: "" } : parseFrontmatter4(existing);
     await fs10.writeFile(
@@ -55478,7 +55653,7 @@ async function removeChildren(directoryPath) {
     if (entryName === MEMORY_LOCK_RELPATH) {
       continue;
     }
-    const entryPath = path83.join(directoryPath, entryName);
+    const entryPath = path84.join(directoryPath, entryName);
     const stat24 = await fs10.stat(entryPath);
     if (stat24.isDirectory()) {
       await removeDirectory3(entryPath);
@@ -55495,7 +55670,7 @@ async function removeDirectory3(directoryPath) {
 }
 function assertPageRelPath(relPath) {
   const normalizedRelPath = assertSafeRelPath(relPath);
-  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path83.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
+  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path84.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
     throw new Error(`Expected a markdown page path under "${MEMORY_PAGES_DIR_RELPATH}/".`);
   }
   return normalizedRelPath;
@@ -55523,7 +55698,7 @@ var init_write2 = __esm({
 
 // packages/memory/src/edit.ts
 import * as fs11 from "node:fs/promises";
-import path84 from "node:path";
+import path85 from "node:path";
 var init_edit = __esm({
   "packages/memory/src/edit.ts"() {
     "use strict";
@@ -55534,7 +55709,7 @@ var init_edit = __esm({
 
 // packages/memory/src/audit.ts
 import * as fs12 from "node:fs/promises";
-import path85 from "node:path";
+import path86 from "node:path";
 async function auditClaims(root, repoRoot, options = {}) {
   const minInferredConfidence = options.minInferredConfidence ?? DEFAULT_MIN_INFERRED_CONFIDENCE;
   const rejectUntagged = options.rejectUntagged ?? DEFAULT_REJECT_UNTAGGED;
@@ -55586,10 +55761,10 @@ async function auditSourceRef(source, claimLineNumber, repoRoot, sourceCache) {
   if (isUrlLike(source.path)) {
     return void 0;
   }
-  if (path85.isAbsolute(source.path)) {
+  if (path86.isAbsolute(source.path)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but source paths must be repo-relative or URLs.`;
   }
-  const absPath = path85.resolve(repoRoot, source.path);
+  const absPath = path86.resolve(repoRoot, source.path);
   if (!isWithinRoot(repoRoot, absPath)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", which resolves outside the repo root.`;
   }
@@ -55655,8 +55830,8 @@ function isUrlLike(value) {
   return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
 }
 function isWithinRoot(root, absPath) {
-  const relative = path85.relative(root, absPath);
-  return relative === "" || !relative.startsWith("..") && !path85.isAbsolute(relative);
+  const relative = path86.relative(root, absPath);
+  return relative === "" || !relative.startsWith("..") && !path86.isAbsolute(relative);
 }
 var DEFAULT_MIN_INFERRED_CONFIDENCE, DEFAULT_REJECT_UNTAGGED, DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS;
 var init_audit = __esm({
@@ -55674,7 +55849,7 @@ var init_audit = __esm({
 // packages/memory/src/cache.ts
 import { createHash as createHash2 } from "node:crypto";
 import * as fs13 from "node:fs/promises";
-import path86 from "node:path";
+import path87 from "node:path";
 function computeIngestKey(input) {
   const hash = createHash2("sha256");
   hash.update(input.sourceBytes);
@@ -55687,7 +55862,7 @@ function computeIngestKey(input) {
   return hash.digest("hex");
 }
 async function readCacheEntry(root, key2) {
-  const cachePath = path86.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key2}.json`);
+  const cachePath = path87.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key2}.json`);
   let raw;
   try {
     raw = await fs13.readFile(cachePath, "utf8");
@@ -55706,9 +55881,9 @@ async function readCacheEntry(root, key2) {
   }
 }
 async function writeCacheEntry(root, entry) {
-  await fs13.mkdir(path86.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+  await fs13.mkdir(path87.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
   await fs13.writeFile(
-    path86.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
+    path87.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
     `${JSON.stringify(entry)}
 `,
     "utf8"
@@ -55824,9 +55999,9 @@ var init_tokenizer = __esm({
 });
 
 // packages/tokenfill/src/corpus.ts
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { dirname as dirname5, join as join5 } from "node:path";
-import { fileURLToPath as fileURLToPath11 } from "node:url";
+import { fileURLToPath as fileURLToPath12 } from "node:url";
 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));
 }
@@ -55835,14 +56010,14 @@ function loadBuiltInCorpusArticles() {
   if (corpusFileNames.length === 0) {
     throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
   }
-  return corpusFileNames.map((fileName) => readFileSync2(join5(corpusDirectoryPath, fileName), "utf8").trim());
+  return corpusFileNames.map((fileName) => readFileSync3(join5(corpusDirectoryPath, fileName), "utf8").trim());
 }
 var CORPUS_ARTICLE_SEPARATOR, corpusDirectoryPath, BUILT_IN_CORPUS_ARTICLES;
 var init_corpus = __esm({
   "packages/tokenfill/src/corpus.ts"() {
     "use strict";
     CORPUS_ARTICLE_SEPARATOR = "\n\n";
-    corpusDirectoryPath = join5(dirname5(fileURLToPath11(import.meta.url)), "corpus");
+    corpusDirectoryPath = join5(dirname5(fileURLToPath12(import.meta.url)), "corpus");
     BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
   }
 });
@@ -55870,7 +56045,7 @@ var init_src33 = __esm({
 
 // packages/memory/src/tokens.ts
 import * as fs14 from "node:fs/promises";
-import path87 from "node:path";
+import path88 from "node:path";
 async function computeTokenStats(root) {
   if (!await pathExists8(root)) {
     return {
@@ -55892,11 +56067,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path87.resolve(root, "..", "..");
+  const repoRoot = path88.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path87.isAbsolute(sourcePath) ? sourcePath : path87.resolve(repoRoot, sourcePath);
+    const absPath = path88.isAbsolute(sourcePath) ? sourcePath : path88.resolve(repoRoot, sourcePath);
     try {
       const content = await fs14.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -55941,7 +56116,7 @@ var init_tokens2 = __esm({
 
 // packages/memory/src/ingest.ts
 import * as fs15 from "node:fs/promises";
-import path88 from "node:path";
+import path89 from "node:path";
 function resolveRunners2(overrides) {
   return {
     computeIngestKey: overrides?.computeIngestKey ?? computeIngestKey,
@@ -55955,10 +56130,10 @@ function resolveRunners2(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners2(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs15.readFile(path88.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs15.readFile(path89.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs15,
-    filePath: path88.join(inferRepoRoot(root), "poe-code.json")
+    filePath: path89.join(inferRepoRoot(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key2 = resolved.computeIngestKey({
@@ -56048,7 +56223,7 @@ async function materializeSource(source) {
   throw new Error("URL ingest not implemented yet.");
 }
 function inferRepoRoot(root) {
-  return path88.resolve(root, "..", "..");
+  return path89.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs) {
   return await new Promise((resolve2, reject) => {
@@ -56100,7 +56275,7 @@ var init_install3 = __esm({
 
 // packages/memory/src/query.ts
 import * as fs16 from "node:fs/promises";
-import path89 from "node:path";
+import path90 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -56114,7 +56289,7 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs16,
-    filePath: path89.join(inferRepoRoot2(root), "poe-code.json")
+    filePath: path90.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);
@@ -56129,7 +56304,7 @@ async function queryMemory(root, options) {
 }
 async function selectQueryContext(root, question, budget) {
   const [indexText, pages] = await Promise.all([
-    fs16.readFile(path89.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs16.readFile(path90.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -56208,7 +56383,7 @@ function tokenize2(text4) {
   return text4.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path89.resolve(root, "..", "..");
+  return path90.resolve(root, "..", "..");
 }
 var init_query = __esm({
   "packages/memory/src/query.ts"() {
@@ -56223,7 +56398,7 @@ var init_query = __esm({
 
 // packages/memory/src/explain.ts
 import * as fs17 from "node:fs/promises";
-import path90 from "node:path";
+import path91 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -56246,7 +56421,7 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs17,
-    filePath: path90.join(inferRepoRoot3(root), "poe-code.json")
+    filePath: path91.join(inferRepoRoot3(root), "poe-code.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const response = await spawn3(agentId, { prompt });
@@ -56295,7 +56470,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path90.resolve(root, "..", "..");
+  return path91.resolve(root, "..", "..");
 }
 var init_explain = __esm({
   "packages/memory/src/explain.ts"() {
@@ -56317,9 +56492,9 @@ var init_explain_cli = __esm({
 });
 
 // packages/memory/src/handle.ts
-import path91 from "node:path";
+import path92 from "node:path";
 function openMemory(opts) {
-  if (!path91.isAbsolute(opts.root)) {
+  if (!path92.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;
@@ -56393,7 +56568,7 @@ var init_src34 = __esm({
 });
 
 // src/cli/commands/memory.ts
-import path92 from "node:path";
+import path93 from "node:path";
 import * as fs18 from "node:fs/promises";
 async function resolveRoot(container) {
   return resolveConfiguredMemoryRoot({
@@ -56410,7 +56585,7 @@ function resolvePageRelPath(input) {
     throw new ValidationError("Missing page path.");
   }
   const normalized = trimmed.replaceAll("\\", "/");
-  const withExt = path92.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
+  const withExt = path93.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
   return withExt.startsWith("pages/") ? withExt : `pages/${withExt}`;
 }
 function displayPageRelPath(relPath) {
@@ -56448,8 +56623,8 @@ function registerMemoryCommand(program, container) {
     }
     await initMemory(root);
     resources.context.complete({
-      success: `Initialized memory at ${path92.relative(container.env.cwd, root)}`,
-      dry: `Would initialize memory at ${path92.relative(container.env.cwd, root)}`
+      success: `Initialized memory at ${path93.relative(container.env.cwd, root)}`,
+      dry: `Would initialize memory at ${path93.relative(container.env.cwd, root)}`
     });
     resources.context.finalize();
   });
@@ -56481,7 +56656,7 @@ function registerMemoryCommand(program, container) {
     resources.logger.intro("memory show");
     await assertInitialized(mem);
     const relPath = resolvePageRelPath(pagePath);
-    const absPath = path92.join(mem.root, relPath);
+    const absPath = path93.join(mem.root, relPath);
     try {
       const content = await fs18.readFile(absPath, "utf8");
       process.stdout.write(content.endsWith("\n") ? content : `${content}
@@ -56663,7 +56838,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.193",
+      version: "3.0.195",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -56880,22 +57055,22 @@ function formatCommandHeader(cmd) {
   }
   return `Poe - ${parts.reverse().join(" ")}`;
 }
-function findCommandByPath(root, path93) {
+function findCommandByPath(root, path94) {
   let current = root;
-  for (const segment of path93) {
+  for (const segment of path94) {
     const next = current.commands.find(
       (command) => Reflect.get(command, "_hidden") !== true && command.name() === segment
     );
     if (!next) {
-      throw new Error(`Root help command is missing: ${path93.join(" ")}`);
+      throw new Error(`Root help command is missing: ${path94.join(" ")}`);
     }
     current = next;
   }
   return current;
 }
-function formatRootHelpCommandName(path93, command) {
+function formatRootHelpCommandName(path94, command) {
   const leaf = [command.name(), ...command.aliases()].join(", ");
-  return path93.length > 1 ? [...path93.slice(0, -1), leaf].join(" ") : leaf;
+  return path94.length > 1 ? [...path94.slice(0, -1), leaf].join(" ") : leaf;
 }
 function splitUsageParts(usage) {
   return usage.split(" ").map((part) => part.trim()).filter((part) => part.length > 0);
@@ -57606,7 +57781,7 @@ init_config4();
 init_constants();
 init_errors2();
 import os8 from "node:os";
-import path67 from "node:path";
+import path68 from "node:path";
 import fsPromises19 from "node:fs/promises";
 import { Command } from "commander";
 function parseMcpSpawnConfig(input) {
@@ -57678,10 +57853,10 @@ function resolveWorkingDirectory(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path67.isAbsolute(candidate)) {
+  if (path68.isAbsolute(candidate)) {
     return candidate;
   }
-  return path67.resolve(baseDir, candidate);
+  return path68.resolve(baseDir, candidate);
 }
 function configurePoeAgentRunOptions(command) {
   return command.option("-y, --yes", "Accept configured defaults without prompting").option("--model <model>", "Model identifier override").option("--prompt <text>", "Prompt text to send").option("-C, --cwd <path>", "Working directory for the agent").option("--stdin", "Read the prompt from stdin").option(