poe-code 3.0.183 → 3.0.184

package/dist/index.js

@@ -777,11 +777,11 @@ var init_parse = __esm({
 function mergeLayers(layers) {
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path82) {
+function mergeObjectLayers(layers, path84) {
   const data = {};
   const sources = {};
   for (const key of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key, path82);
+    const resolved = resolveKey(layers, key, path84);
     if (resolved === void 0) {
       continue;
     }
@@ -799,7 +799,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key, path82) {
+function resolveKey(layers, key, path84) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -829,9 +829,9 @@ function resolveKey(layers, key, path82) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path82, key);
+  const fullPath = buildPath(path84, key);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path82, key]);
+    const merged = mergeObjectLayers(objectLayers, [...path84, key]);
     return {
       value: merged.data,
       sources: {
@@ -856,8 +856,8 @@ function isWinningCandidate(key, value) {
   }
   return true;
 }
-function buildPath(path82, key) {
-  return [...path82, key].join(".");
+function buildPath(path84, key) {
+  return [...path84, key].join(".");
 }
 function isPlainObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
@@ -1535,16 +1535,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path82) {
-  const ext = getExtension(path82);
+function detectFormat2(path84) {
+  const ext = getExtension(path84);
   return extensionMap[ext];
 }
-function getExtension(path82) {
-  const lastDot = path82.lastIndexOf(".");
+function getExtension(path84) {
+  const lastDot = path84.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path82.slice(lastDot).toLowerCase();
+  return path84.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -1880,8 +1880,8 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
-    const stat23 = await context.fs.stat(targetPath);
-    const currentMode = typeof stat23.mode === "number" ? stat23.mode & 511 : null;
+    const stat24 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat24.mode === "number" ? stat24.mode & 511 : null;
     if (currentMode === mutation.mode) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
@@ -2713,50 +2713,50 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path82, encoding) {
+    async readFile(path84, encoding) {
       if (encoding) {
-        return base.readFile(path82, encoding);
+        return base.readFile(path84, encoding);
       }
-      return base.readFile(path82);
+      return base.readFile(path84);
     },
-    async writeFile(path82, data, options) {
-      const previousContent = await tryReadText(base, path82);
+    async writeFile(path84, data, options) {
+      const previousContent = await tryReadText(base, path84);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path82,
+        path: path84,
         nextContent,
         previousContent
       });
     },
-    async symlink(target, path82) {
-      recorder.record({ type: "symlink", target, path: path82 });
+    async symlink(target, path84) {
+      recorder.record({ type: "symlink", target, path: path84 });
     },
-    async readlink(path82) {
-      return base.readlink(path82);
+    async readlink(path84) {
+      return base.readlink(path84);
     },
-    async mkdir(path82, options) {
-      recorder.record({ type: "mkdir", path: path82, options });
+    async mkdir(path84, options) {
+      recorder.record({ type: "mkdir", path: path84, options });
     },
-    async stat(path82) {
-      return base.stat(path82);
+    async stat(path84) {
+      return base.stat(path84);
     },
-    async lstat(path82) {
-      return base.lstat(path82);
+    async lstat(path84) {
+      return base.lstat(path84);
     },
     async rename(from, to) {
       recorder.record({ type: "rename", from, to });
     },
-    async unlink(path82) {
-      recorder.record({ type: "unlink", path: path82 });
+    async unlink(path84) {
+      recorder.record({ type: "unlink", path: path84 });
     },
-    async readdir(path82) {
-      return base.readdir(path82);
+    async readdir(path84) {
+      return base.readdir(path84);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path82, options) => {
-      recorder.record({ type: "rm", path: path82, options });
+    proxy.rm = async (path84, options) => {
+      recorder.record({ type: "rm", path: path84, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -2858,8 +2858,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path82, change) {
-  const command = `cat > ${path82}`;
+function renderWriteCommand(path84, change) {
+  const command = `cat > ${path84}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -3021,9 +3021,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path82) {
+async function tryReadText(base, path84) {
   try {
-    return await base.readFile(path82, "utf8");
+    return await base.readFile(path84, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -9823,9 +9823,10 @@ function statsToLines(stats, width) {
   }
   const mutedStyle = getToneStyle("muted");
   const totalTokens = stats.tokensIn + stats.tokensOut;
+  const iterationsLabel = stats.iterationsLabel ?? "Iteration";
   const lines = [
     createKeyValueLine("Status", formatStatus(stats.status), width, getStatusStyle(stats.status)),
-    createKeyValueLine("Iteration", formatNumber(stats.iterations), width),
+    createKeyValueLine(iterationsLabel, formatNumber(stats.iterations), width),
     createKeyValueLine("Elapsed", formatElapsed(stats.elapsedMs), width),
     createBlankLine(),
     createKeyValueLine("Tokens In", formatNumber(stats.tokensIn), width),
@@ -11936,8 +11937,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path82) {
-  if (!isAbsolute(path82)) {
+function assertAbsolutePath(path84) {
+  if (!isAbsolute(path84)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -12812,21 +12813,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 path82;
+        let path84;
         if (typeof item.content === "string") {
-          path82 = item.content;
+          path84 = item.content;
         } else {
           try {
-            path82 = JSON.stringify(item.content);
+            path84 = JSON.stringify(item.content);
           } catch {
-            path82 = String(item.content);
+            path84 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path82
+          path: path84
         };
       }
     }
@@ -12949,10 +12950,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 path82 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path84 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path82 };
+        yield { event: "tool_complete", id: item.id, kind, path: path84 };
       }
     }
   }
@@ -13636,7 +13637,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path82 = readString(event.path);
+  const path84 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -13651,8 +13652,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path82) {
-    toolCall.path = path82;
+  if (path84) {
+    toolCall.path = path84;
   }
 }
 var sessionCapture;
@@ -22016,8 +22017,35 @@ var init_stage = __esm({
 
 // packages/agent-kit/src/lock.ts
 import * as fsPromises4 from "node:fs/promises";
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+function createAbortError4() {
+  const error2 = new Error("The operation was aborted.");
+  error2.name = "AbortError";
+  return error2;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw createAbortError4();
+  }
+}
+function sleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  if (signal.aborted) {
+    return Promise.reject(createAbortError4());
+  }
+  return new Promise((resolve2, reject) => {
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError4());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function backoff(attempt, minTimeout, maxTimeout) {
   const delay2 = Math.min(maxTimeout, minTimeout * Math.pow(2, attempt));
@@ -22028,16 +22056,16 @@ function hasErrorCode(error2, code) {
 }
 function createDefaultFs() {
   return {
-    mkdir: async (path82, options) => {
-      await fsPromises4.mkdir(path82, options);
+    mkdir: async (path84, options) => {
+      await fsPromises4.mkdir(path84, options);
     },
     rmdir: fsPromises4.rmdir,
-    stat: async (path82) => {
-      const stat23 = await fsPromises4.stat(path82);
+    stat: async (path84) => {
+      const stat24 = await fsPromises4.stat(path84);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     }
   };
@@ -22059,6 +22087,7 @@ async function lockWorkflow(docPath, options = {}) {
   const staleMs = options.staleMs ?? 3e4;
   const lockPath = `${docPath}.lock`;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
+    throwIfAborted(options.signal);
     try {
       await fs17.mkdir(lockPath);
       let released = false;
@@ -22073,21 +22102,21 @@ async function lockWorkflow(docPath, options = {}) {
       if (!hasErrorCode(error2, "EEXIST")) {
         throw error2;
       }
-      let stat23;
+      let stat24;
       try {
-        stat23 = await fs17.stat(lockPath);
+        stat24 = await fs17.stat(lockPath);
       } catch (statError) {
         if (hasErrorCode(statError, "ENOENT")) {
           continue;
         }
         throw statError;
       }
-      if (Date.now() - stat23.mtimeMs > staleMs) {
+      if (Date.now() - stat24.mtimeMs > staleMs) {
         await removeLockDirectory(fs17, lockPath);
         continue;
       }
       if (attempt < retries) {
-        await sleep(backoff(attempt, minTimeout, maxTimeout));
+        await sleep(backoff(attempt, minTimeout, maxTimeout), options.signal);
       }
     }
   }
@@ -22115,7 +22144,7 @@ function toAbortError2(reason) {
   }
   return new Error(reason === void 0 ? "This operation was aborted." : String(reason));
 }
-function throwIfAborted(signal) {
+function throwIfAborted2(signal) {
   if (!signal?.aborted) {
     return;
   }
@@ -22248,7 +22277,7 @@ async function runDocumentWorkflow(options) {
   let pendingError;
   let currentWorkflow = initialWorkflow;
   try {
-    throwIfAborted(options.signal);
+    throwIfAborted2(options.signal);
     if (initialWorkflow.setup) {
       await runWorkflowHook(initialWorkflow.setup, {
         cwd: options.cwd,
@@ -22264,12 +22293,12 @@ async function runDocumentWorkflow(options) {
     }
     let shouldStop = false;
     for (let iteration = 0; iteration < initialWorkflow.maxIterations; iteration += 1) {
-      throwIfAborted(options.signal);
+      throwIfAborted2(options.signal);
       currentWorkflow = iteration === 0 ? initialWorkflow : await readWorkflow();
       await options.onIterationStart?.(iteration);
       let iterationResult = "completed";
       for (const stage of currentWorkflow.stages) {
-        throwIfAborted(options.signal);
+        throwIfAborted2(options.signal);
         try {
           const stageResult = await runWorkflowStage(stage, {
             cwd: options.cwd,
@@ -23536,11 +23565,11 @@ function createDefaultFs2() {
     writeFile: fsPromises5.writeFile,
     readdir: fsPromises5.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises5.stat(filePath);
+      const stat24 = await fsPromises5.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -25971,11 +26000,11 @@ function createDefaultFs3() {
     writeFile: fsPromises6.writeFile,
     readdir: fsPromises6.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises6.stat(filePath);
+      const stat24 = await fsPromises6.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, mkdirOptions) => {
@@ -26099,8 +26128,8 @@ var init_run = __esm({
       },
       unlink: (filePath) => fsPromises6.unlink(filePath),
       stat: async (filePath) => {
-        const stat23 = await fsPromises6.stat(filePath);
-        return { mode: stat23.mode };
+        const stat24 = await fsPromises6.stat(filePath);
+        return { mode: stat24.mode };
       },
       readdir: (filePath) => fsPromises6.readdir(filePath)
     };
@@ -26964,14 +26993,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path82 = input.slice(slashIndex);
-  if (container.length === 0 || path82.length === 0) {
+  const path84 = input.slice(slashIndex);
+  if (container.length === 0 || path84.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path82
+    path: path84
   };
 }
 function splitOnce(input, separator) {
@@ -28795,25 +28824,25 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path82, encoding) => {
+    readFile: ((path84, encoding) => {
       if (encoding) {
-        return fs3.readFile(path82, encoding);
+        return fs3.readFile(path84, encoding);
       }
-      return fs3.readFile(path82);
+      return fs3.readFile(path84);
     }),
-    symlink: (target, path82) => fs3.symlink(target, path82),
-    readlink: (path82) => fs3.readlink(path82, { encoding: "utf8" }),
-    writeFile: (path82, data, opts) => fs3.writeFile(path82, data, opts),
-    mkdir: (path82, opts) => fs3.mkdir(path82, opts).then(() => {
+    symlink: (target, path84) => fs3.symlink(target, path84),
+    readlink: (path84) => fs3.readlink(path84, { encoding: "utf8" }),
+    writeFile: (path84, data, opts) => fs3.writeFile(path84, data, opts),
+    mkdir: (path84, opts) => fs3.mkdir(path84, opts).then(() => {
     }),
-    stat: (path82) => fs3.stat(path82),
-    lstat: (path82) => fs3.lstat(path82),
+    stat: (path84) => fs3.stat(path84),
+    lstat: (path84) => fs3.lstat(path84),
     rename: (oldPath, newPath) => fs3.rename(oldPath, newPath),
-    rm: (path82, opts) => fs3.rm(path82, opts),
-    unlink: (path82) => fs3.unlink(path82),
-    readdir: (path82) => fs3.readdir(path82),
+    rm: (path84, opts) => fs3.rm(path84, opts),
+    unlink: (path84) => fs3.unlink(path84),
+    readdir: (path84) => fs3.readdir(path84),
     copyFile: (src, dest) => fs3.copyFile(src, dest),
-    chmod: (path82, mode) => fs3.chmod(path82, mode)
+    chmod: (path84, mode) => fs3.chmod(path84, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -29180,9 +29209,9 @@ function assertNotAborted4(signal) {
   if (!signal?.aborted) {
     return;
   }
-  throw createAbortError4();
+  throw createAbortError5();
 }
-function createAbortError4() {
+function createAbortError5() {
   const error2 = new Error("Pipeline run cancelled");
   error2.name = "AbortError";
   return error2;
@@ -29195,7 +29224,7 @@ var init_utils2 = __esm({
 
 // packages/pipeline/src/config/loader.ts
 import path34 from "node:path";
-import { parse as parse6, stringify } from "yaml";
+import { parse as parse6 } from "yaml";
 function asStepMode(value) {
   if (value === void 0 || value === null) {
     return "yolo";
@@ -29213,13 +29242,6 @@ function parseYamlDocument(filePath, content) {
     throw new Error(`Invalid pipeline step config YAML in "${filePath}": ${message2}`);
   }
 }
-function parseStepConfigSource(filePath, content) {
-  const document = parseYamlDocument(filePath, content);
-  return {
-    config: parseStepConfigData(filePath, document),
-    extendsBase: isRecord11(document) && document.extends === true
-  };
-}
 function parseStepConfigData(filePath, document) {
   if (document === null || document === void 0) {
     return { steps: {} };
@@ -29261,102 +29283,72 @@ function parseStepConfigData(filePath, document) {
   }
   return result;
 }
-function encodeShallowStepsConfig(config) {
-  const data = {};
-  if (Object.keys(config.steps).length > 0) {
-    data.steps = Object.fromEntries(
-      Object.entries(config.steps).map(([stepName, definition]) => [
-        stepName,
-        JSON.stringify(definition)
-      ])
-    );
-  }
-  if (config.setup !== void 0) {
-    data.setup = JSON.stringify(config.setup);
-  }
-  if (config.teardown !== void 0) {
-    data.teardown = JSON.stringify(config.teardown);
+function mergeStepDefinition(base, override, context) {
+  const prompt = override.prompt ?? base?.prompt;
+  if (typeof prompt !== "string" || prompt.length === 0) {
+    throw new Error(`Missing prompt for ${context}.`);
   }
-  return data;
+  const agent2 = override.agent ?? base?.agent;
+  const model = override.model ?? base?.model;
+  return {
+    mode: override.mode ?? base?.mode ?? "yolo",
+    prompt,
+    ...agent2 ? { agent: agent2 } : {},
+    ...model ? { model } : {}
+  };
 }
-function decodeShallowStepsConfig(filePath, document) {
-  const decoded = {};
-  if (document.steps !== void 0) {
-    if (!isRecord11(document.steps)) {
-      throw new Error(`Invalid pipeline step config in "${filePath}": "steps" must be an object.`);
-    }
-    decoded.steps = Object.fromEntries(
-      Object.entries(document.steps).map(([stepName, definition]) => [
-        stepName,
-        decodeEncodedDefinition(filePath, definition, `step "${stepName}"`)
-      ])
-    );
+function applyStepOverrides(config, stepOverrides) {
+  if (!stepOverrides || Object.keys(stepOverrides).length === 0) {
+    return config;
   }
-  if (document.setup !== void 0) {
-    decoded.setup = decodeEncodedDefinition(filePath, document.setup, "setup");
+  const steps = { ...config.steps };
+  for (const [stepName, override] of Object.entries(stepOverrides)) {
+    steps[stepName] = mergeStepDefinition(steps[stepName], override, `plan step "${stepName}"`);
   }
-  if (document.teardown !== void 0) {
-    decoded.teardown = decodeEncodedDefinition(filePath, document.teardown, "teardown");
-  }
-  return decoded;
+  return {
+    ...config,
+    steps
+  };
 }
-function decodeEncodedDefinition(filePath, value, context) {
-  if (typeof value !== "string") {
-    throw new Error(`Invalid ${context} in "${filePath}": expected an object.`);
-  }
-  let decoded;
+async function directoryExists(fs17, targetPath) {
   try {
-    decoded = JSON.parse(value);
+    return (await fs17.stat(targetPath)).isDirectory();
   } catch (error2) {
-    const message2 = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`Invalid ${context} in "${filePath}": ${message2}`);
-  }
-  if (!isRecord11(decoded)) {
-    throw new Error(`Invalid ${context} in "${filePath}": expected an object.`);
+    if (isNotFound2(error2)) {
+      return false;
+    }
+    throw error2;
   }
-  return decoded;
 }
-async function loadResolvedSteps(options) {
-  const globalDir = path34.join(options.homeDir, ".poe-code", "pipeline");
-  const globalPath = path34.join(globalDir, "steps.yaml");
-  const projectPath = path34.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
-  const [globalContent, projectContent] = await Promise.all([
-    readOptionalFile2(options.fs, globalPath),
-    readOptionalFile2(options.fs, projectPath)
-  ]);
-  const globalSource = globalContent == null ? void 0 : parseStepConfigSource(globalPath, globalContent);
-  if (projectContent == null) {
-    return globalSource?.config ?? { steps: {} };
+async function resolveStepsDirectory(options) {
+  const projectDir = path34.join(options.cwd, ".poe-code", "pipeline", "steps");
+  if (await directoryExists(options.fs, projectDir)) {
+    return projectDir;
   }
-  const projectSource = parseStepConfigSource(projectPath, projectContent);
-  if (projectSource.extendsBase) {
-    const resolved2 = await resolve(
-      [
-        { source: "document", filePath: projectPath, content: projectContent },
-        { source: "base", path: globalDir }
-      ],
-      { fs: options.fs }
-    );
-    return parseStepConfigData(projectPath, resolved2.data);
+  const globalDir = path34.join(options.homeDir, ".poe-code", "pipeline", "steps");
+  if (await directoryExists(options.fs, globalDir)) {
+    return globalDir;
   }
-  if (globalSource == null) {
-    return projectSource.config;
-  }
-  const resolved = await resolve(
-    [
-      {
-        source: "document",
-        filePath: projectPath,
-        content: stringify(encodeShallowStepsConfig(projectSource.config))
-      },
-      {
-        source: "global",
-        data: encodeShallowStepsConfig(globalSource.config)
-      }
-    ],
-    { fs: options.fs }
+  return null;
+}
+async function loadResolvedSteps(options) {
+  const name = options.name?.trim() || "default";
+  const stepsDir = await resolveStepsDirectory(options);
+  if (!stepsDir) {
+    if (name !== "default") {
+      throw new Error(`Unknown pipeline step config "${name}": no pipeline steps directory found.`);
+    }
+    return applyStepOverrides({ steps: {} }, options.stepOverrides);
+  }
+  const filePath = path34.join(stepsDir, `${name}.yaml`);
+  const content = await readOptionalFile2(options.fs, filePath);
+  if (content == null) {
+    throw new Error(`Unknown pipeline step config "${name}" in "${stepsDir}".`);
+  }
+  return applyStepOverrides(
+    parseStepConfigData(filePath, parseYamlDocument(filePath, content)),
+    options.stepOverrides
   );
-  return parseStepConfigData(projectPath, decodeShallowStepsConfig(projectPath, resolved.data));
 }
 var init_loader = __esm({
   "packages/pipeline/src/config/loader.ts"() {
@@ -29420,23 +29412,60 @@ function parseTaskStatus(value, availableSteps, taskId) {
   }
   return statusMap;
 }
-function asStepMode2(value) {
-  if (value === "edit" || value === "read") return value;
-  return "yolo";
+function parseStepMode(value, label) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value === "yolo" || value === "edit" || value === "read") {
+    return value;
+  }
+  throw new Error(`Invalid plan YAML: "${label}.mode" must be "yolo", "edit", or "read".`);
 }
-function parseStepDef(value, label) {
+function parseOptionalAgentFields(value, label) {
+  const result = {};
+  if (value.agent !== void 0) {
+    if (typeof value.agent !== "string" || value.agent.length === 0) {
+      throw new Error(`Invalid plan YAML: "${label}.agent" must be a non-empty string.`);
+    }
+    result.agent = value.agent;
+  }
+  if (value.model !== void 0) {
+    if (typeof value.model !== "string" || value.model.length === 0) {
+      throw new Error(`Invalid plan YAML: "${label}.model" must be a non-empty string.`);
+    }
+    result.model = value.model;
+  }
+  return result;
+}
+function parseStepOverride(value, label) {
   if (!isRecord11(value)) {
     throw new Error(`Invalid plan YAML: "${label}" must be an object.`);
   }
-  const prompt = value.prompt;
-  if (typeof prompt !== "string" || prompt.length === 0) {
+  const result = {
+    ...parseOptionalAgentFields(value, label)
+  };
+  const mode = parseStepMode(value.mode, label);
+  if (mode !== void 0) {
+    result.mode = mode;
+  }
+  if (value.prompt !== void 0) {
+    if (typeof value.prompt !== "string" || value.prompt.length === 0) {
+      throw new Error(`Invalid plan YAML: "${label}.prompt" must be a non-empty string.`);
+    }
+    result.prompt = value.prompt;
+  }
+  return result;
+}
+function parseStepDef(value, label) {
+  const override = parseStepOverride(value, label);
+  if (override.prompt === void 0) {
     throw new Error(`Invalid plan YAML: "${label}" is missing a prompt.`);
   }
   return {
-    mode: asStepMode2(value.mode),
-    prompt,
-    ...typeof value.agent === "string" && value.agent.length > 0 ? { agent: value.agent } : {},
-    ...typeof value.model === "string" && value.model.length > 0 ? { model: value.model } : {}
+    mode: override.mode ?? "yolo",
+    prompt: override.prompt,
+    ...override.agent ? { agent: override.agent } : {},
+    ...override.model ? { model: override.model } : {}
   };
 }
 function parseMcpConfig2(value) {
@@ -29480,6 +29509,23 @@ function parsePlan(planContent, options = {}) {
   if (!isRecord11(document)) {
     throw new Error("Invalid plan YAML: expected a top-level object.");
   }
+  let extendsName = "default";
+  if (document.extends !== void 0) {
+    if (typeof document.extends !== "string" || document.extends.trim().length === 0) {
+      throw new Error('Invalid plan YAML: "extends" must be a non-empty string.');
+    }
+    extendsName = document.extends.trim();
+  }
+  let stepOverrides;
+  if (document.steps !== void 0) {
+    if (!isRecord11(document.steps)) {
+      throw new Error('Invalid plan YAML: "steps" must be an object.');
+    }
+    stepOverrides = {};
+    for (const [stepName, value] of Object.entries(document.steps)) {
+      stepOverrides[stepName] = parseStepOverride(value, `steps.${stepName}`);
+    }
+  }
   const tasksValue = document.tasks;
   if (!Array.isArray(tasksValue)) {
     throw new Error('Invalid plan YAML: expected "tasks" to be an array.');
@@ -29519,6 +29565,8 @@ function parsePlan(planContent, options = {}) {
     }
   }
   return {
+    extends: extendsName,
+    ...stepOverrides !== void 0 ? { stepOverrides } : {},
     tasks,
     ...vars !== void 0 ? { vars } : {},
     ...setup !== void 0 ? { setup } : {},
@@ -29543,11 +29591,11 @@ function createDefaultFs4() {
     readFile: fsPromises7.readFile,
     readdir: fsPromises7.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises7.stat(filePath);
+      const stat24 = await fsPromises7.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     }
   };
@@ -29574,8 +29622,8 @@ function countCompletedTasks(planPath, content) {
 async function ensurePlanExists(fs17, cwd, planPath) {
   const absolutePath = path35.isAbsolute(planPath) ? planPath : path35.resolve(cwd, planPath);
   try {
-    const stat23 = await fs17.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const stat24 = await fs17.stat(absolutePath);
+    if (!stat24.isFile()) {
       throw new Error(`Plan not found at "${planPath}".`);
     }
   } catch (error2) {
@@ -29601,8 +29649,8 @@ async function scanPlansDir(fs17, plansDir, displayPrefix) {
       continue;
     }
     const absolutePath = path35.join(plansDir, entry);
-    const stat23 = await fs17.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const stat24 = await fs17.stat(absolutePath);
+    if (!stat24.isFile()) {
       continue;
     }
     const displayPath2 = path35.join(displayPrefix, entry);
@@ -29875,6 +29923,23 @@ var init_writer2 = __esm({
   }
 });
 
+// packages/pipeline/src/vars/interpolate.ts
+function interpolatePipelineVars(template, values, context = "template") {
+  return template.replace(PLACEHOLDER_PATTERN, (_match, key) => {
+    if (!Object.prototype.hasOwnProperty.call(values, key)) {
+      throw new Error(`Missing pipeline variable "${key}" in ${context}.`);
+    }
+    return values[key];
+  });
+}
+var PLACEHOLDER_PATTERN;
+var init_interpolate = __esm({
+  "packages/pipeline/src/vars/interpolate.ts"() {
+    "use strict";
+    PLACEHOLDER_PATTERN = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+  }
+});
+
 // packages/pipeline/src/run/runner.ts
 import path36 from "node:path";
 function selectFromTask(task) {
@@ -29897,12 +29962,8 @@ function selectNextExecution(plan, taskId) {
   }
   return { kind: "completed" };
 }
-function interpolate(template, values) {
-  let output = template;
-  for (const [key, value] of Object.entries(values)) {
-    output = output.split(`{{${key}}}`).join(value);
-  }
-  return output;
+function describeExecutionContext(selection) {
+  return selection.stepName ? `task "${selection.task.id}" step "${selection.stepName}"` : `task "${selection.task.id}"`;
 }
 async function resolveFileIncludes(template, cwd, readFile34) {
   const matches2 = [...template.matchAll(FILE_INCLUDE_PATTERN)];
@@ -29918,31 +29979,128 @@ async function resolveFileIncludes(template, cwd, readFile34) {
   return result;
 }
 function buildExecutionPrompt(input) {
+  const context = describeExecutionContext(input.selection);
+  const resolvedTaskPrompt = interpolatePipelineVars(
+    input.selection.task.prompt,
+    input.vars ?? {},
+    context
+  );
   if (!input.selection.stepName) {
-    return input.vars && Object.keys(input.vars).length > 0 ? interpolate(input.selection.task.prompt, input.vars) : input.selection.task.prompt;
+    return resolvedTaskPrompt;
   }
   const step = input.steps[input.selection.stepName];
   if (!step) {
     throw new Error(`Missing step definition for "${input.selection.stepName}".`);
   }
-  return interpolate(step.prompt, {
-    ...input.vars ?? {},
-    id: input.selection.task.id,
-    title: input.selection.task.title,
-    prompt: input.selection.task.prompt,
-    plan_path: input.planPath
-  });
+  return interpolatePipelineVars(
+    step.prompt,
+    {
+      ...input.vars ?? {},
+      id: input.selection.task.id,
+      title: input.selection.task.title,
+      prompt: resolvedTaskPrompt,
+      plan_path: input.planPath
+    },
+    context
+  );
 }
 var FILE_INCLUDE_PATTERN;
 var init_runner2 = __esm({
   "packages/pipeline/src/run/runner.ts"() {
     "use strict";
+    init_interpolate();
     FILE_INCLUDE_PATTERN = /\{\{file\s+['"]([^'"]+)['"]\s*\}\}/g;
   }
 });
 
-// packages/pipeline/src/run/pipeline.ts
+// packages/pipeline/src/vars/resolve.ts
 import path37 from "node:path";
+function looksLikeDocPath(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  if (trimmed.includes("\n")) return false;
+  if (trimmed.includes("{{")) return false;
+  if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+    return true;
+  }
+  if (trimmed.includes("/")) return true;
+  if (trimmed.endsWith(".md") || trimmed.endsWith(".markdown") || trimmed.endsWith(".txt")) {
+    return true;
+  }
+  return false;
+}
+async function resolveDocVarFromPath(options) {
+  const trimmed = options.value.trim();
+  const absolutePath = path37.isAbsolute(trimmed) ? trimmed : path37.join(options.cwd, trimmed);
+  try {
+    return await options.readFile(absolutePath, "utf8");
+  } catch (error2) {
+    throw new Error(
+      `Failed to read doc var "${options.key}" from "${trimmed}" (resolved to ${absolutePath}).`,
+      { cause: error2 }
+    );
+  }
+}
+async function resolvePipelineVars(vars, cwd, readFile34) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(vars)) {
+    if (key.endsWith("_doc") && looksLikeDocPath(value)) {
+      const docContent = await resolveDocVarFromPath({ key, value, cwd, readFile: readFile34 });
+      resolved[key] = await resolveFileIncludes(docContent, cwd, readFile34);
+      continue;
+    }
+    resolved[key] = await resolveFileIncludes(value, cwd, readFile34);
+  }
+  return resolved;
+}
+var init_resolve4 = __esm({
+  "packages/pipeline/src/vars/resolve.ts"() {
+    "use strict";
+    init_runner2();
+  }
+});
+
+// packages/pipeline/src/vars/validate.ts
+function validatePhasePrompt(phase, definition, vars) {
+  if (!definition) {
+    return;
+  }
+  interpolatePipelineVars(definition.prompt, vars, phase);
+}
+function validateResolvedPromptVars(input) {
+  const vars = input.vars ?? {};
+  validatePhasePrompt("setup", input.setup, vars);
+  for (const task of input.plan.tasks) {
+    if (typeof task.status === "string") {
+      buildExecutionPrompt({
+        selection: { kind: "run", task },
+        steps: input.steps,
+        planPath: input.planPath,
+        vars
+      });
+      continue;
+    }
+    for (const stepName of Object.keys(task.status)) {
+      buildExecutionPrompt({
+        selection: { kind: "run", task, stepName },
+        steps: input.steps,
+        planPath: input.planPath,
+        vars
+      });
+    }
+  }
+  validatePhasePrompt("teardown", input.teardown, vars);
+}
+var init_validate = __esm({
+  "packages/pipeline/src/vars/validate.ts"() {
+    "use strict";
+    init_runner2();
+    init_interpolate();
+  }
+});
+
+// packages/pipeline/src/run/pipeline.ts
+import path38 from "node:path";
 import * as fsPromises8 from "node:fs/promises";
 function createDefaultFs5() {
   return {
@@ -29950,11 +30108,11 @@ function createDefaultFs5() {
     writeFile: fsPromises8.writeFile,
     readdir: fsPromises8.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises8.stat(filePath);
+      const stat24 = await fsPromises8.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -29964,15 +30122,54 @@ function createDefaultFs5() {
     rename: fsPromises8.rename
   };
 }
+function isTaskDone(status) {
+  if (typeof status === "string") {
+    return status === "done";
+  }
+  return Object.values(status).every((stepStatus) => stepStatus === "done");
+}
+function completesTaskOnSuccess(task, stepName) {
+  if (!stepName || typeof task.status === "string") {
+    return true;
+  }
+  return Object.entries(task.status).every(
+    ([currentStepName, currentStatus]) => currentStepName === stepName || currentStatus === "done"
+  );
+}
 function isAbortError(error2) {
   return error2 instanceof Error && error2.name === "AbortError";
 }
-async function resolveVars(vars, cwd, readFile34) {
-  const resolved = {};
-  for (const [key, value] of Object.entries(vars)) {
-    resolved[key] = await resolveFileIncludes(value, cwd, readFile34);
+function formatLockWaitMessage(planPath) {
+  return `Another pipeline run is holding the lock for ${planPath}. Waiting...`;
+}
+function formatLockAcquiredMessage(planPath) {
+  return `Lock acquired for ${planPath}. Continuing.`;
+}
+async function acquirePipelineLock(options) {
+  let waitingReported = false;
+  const timerId = global.setTimeout(() => {
+    waitingReported = true;
+    options.onLockStatusChange?.({
+      state: "waiting",
+      message: formatLockWaitMessage(options.planPath)
+    });
+  }, 2e3);
+  try {
+    const release = await lockWorkflow(options.absolutePlanPath, {
+      fs: options.fs,
+      retries: Number.POSITIVE_INFINITY,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (waitingReported) {
+      options.onLockStatusChange?.({
+        state: "acquired",
+        message: formatLockAcquiredMessage(options.planPath)
+      });
+    }
+    return release;
+  } finally {
+    global.clearTimeout(timerId);
   }
-  return resolved;
 }
 function resolveMode2(stepName, steps) {
   if (!stepName) {
@@ -29985,9 +30182,9 @@ function resolveMode2(stepName, steps) {
   return step.mode;
 }
 async function archivePlan(fs17, absolutePlanPath) {
-  const dir = path37.dirname(absolutePlanPath);
-  const archiveDir = path37.join(dir, "archive");
-  const archivePath = path37.join(archiveDir, path37.basename(absolutePlanPath));
+  const dir = path38.dirname(absolutePlanPath);
+  const archiveDir = path38.join(dir, "archive");
+  const archivePath = path38.join(archiveDir, path38.basename(absolutePlanPath));
   await fs17.mkdir(archiveDir, { recursive: true });
   await fs17.rename(absolutePlanPath, archivePath);
 }
@@ -30024,11 +30221,7 @@ async function runPipeline(options) {
       metrics
     };
   }
-  const absolutePlanPath = resolveAbsolutePlanPath(
-    planPath,
-    options.cwd,
-    options.homeDir
-  );
+  const absolutePlanPath = resolveAbsolutePlanPath(planPath, options.cwd, options.homeDir);
   const runLogDir = options.logDir ?? resolveRunLogDir({
     planPath: absolutePlanPath,
     runner: "pipeline",
@@ -30038,10 +30231,7 @@ async function runPipeline(options) {
     const content = await fs17.readFile(absolutePlanPath, "utf8");
     const plan = parsePlan(content);
     const total = plan.tasks.length;
-    const done = plan.tasks.filter((t) => {
-      if (typeof t.status === "string") return t.status === "done";
-      return Object.values(t.status).every((s) => s === "done");
-    }).length;
+    const done = plan.tasks.filter((t) => isTaskDone(t.status)).length;
     const failed = plan.tasks.filter((t) => {
       if (typeof t.status === "string") return t.status === "failed";
       return Object.values(t.status).some((s) => s === "failed");
@@ -30061,6 +30251,20 @@ async function runPipeline(options) {
   let lastGoodPlan;
   let lastGoodStepsConfig;
   const pipelineStartTime = Date.now();
+  async function readResolvedPlanFromContent(content) {
+    const draftPlan = parsePlan(content);
+    const stepsConfig = await loadResolvedSteps({
+      cwd: options.cwd,
+      homeDir: options.homeDir,
+      fs: fs17,
+      name: draftPlan.extends,
+      stepOverrides: draftPlan.stepOverrides
+    });
+    return {
+      plan: parsePlan(content, { availableSteps: stepsConfig.steps }),
+      stepsConfig
+    };
+  }
   async function runPhase(phaseDef, phase, totalTasks, vars, mcp) {
     const phaseProgress = {
       taskId: phase,
@@ -30073,7 +30277,7 @@ async function runPipeline(options) {
     const startTime = Date.now();
     let result;
     try {
-      const rawPrompt = Object.keys(vars).length > 0 ? interpolate(phaseDef.prompt, vars) : phaseDef.prompt;
+      const rawPrompt = interpolatePipelineVars(phaseDef.prompt, vars, phase);
       const phasePrompt = await resolveFileIncludes(rawPrompt, options.cwd, fs17.readFile.bind(fs17));
       result = await runAgent({
         agent: phaseDef.agent ?? options.agent,
@@ -30108,19 +30312,35 @@ async function runPipeline(options) {
     });
     return { success: success2, cancelled: false };
   }
-  const initialStepsConfig = await loadResolvedSteps({
-    cwd: options.cwd,
-    homeDir: options.homeDir,
-    fs: fs17
-  });
   const initialContent = await fs17.readFile(absolutePlanPath, "utf8");
-  const initialPlan = parsePlan(initialContent, { availableSteps: initialStepsConfig.steps });
+  const {
+    plan: initialPlan,
+    stepsConfig: initialStepsConfig
+  } = await readResolvedPlanFromContent(initialContent);
   const resolvedSetup = initialPlan.setup === null ? void 0 : initialPlan.setup ?? initialStepsConfig.setup;
-  const resolvedTeardown = initialPlan.teardown === null ? void 0 : initialPlan.teardown ?? initialStepsConfig.teardown;
+  const initialResolvedTeardown = initialPlan.teardown === null ? void 0 : initialPlan.teardown ?? initialStepsConfig.teardown;
   const initialTotalTasks = initialPlan.tasks.length;
-  const initialVars = await resolveVars(initialPlan.vars ?? {}, options.cwd, fs17.readFile.bind(fs17));
+  const initialVars = await resolvePipelineVars(
+    initialPlan.vars ?? {},
+    options.cwd,
+    fs17.readFile.bind(fs17)
+  );
+  validateResolvedPromptVars({
+    plan: initialPlan,
+    steps: initialStepsConfig.steps,
+    planPath,
+    vars: initialVars,
+    ...resolvedSetup ? { setup: resolvedSetup } : {},
+    ...initialResolvedTeardown ? { teardown: initialResolvedTeardown } : {}
+  });
   if (resolvedSetup) {
-    const { success: success2, cancelled } = await runPhase(resolvedSetup, "setup", initialTotalTasks, initialVars, initialPlan.mcp);
+    const { success: success2, cancelled } = await runPhase(
+      resolvedSetup,
+      "setup",
+      initialTotalTasks,
+      initialVars,
+      initialPlan.mcp
+    );
     if (cancelled || !success2) {
       return {
         stopReason: cancelled ? "cancelled" : "failed",
@@ -30133,18 +30353,19 @@ async function runPipeline(options) {
   }
   while (runsCompleted < maxRuns) {
     assertNotAborted4(options.signal);
-    const release = await lockWorkflow(absolutePlanPath, { fs: fs17 });
+    const release = await acquirePipelineLock({
+      absolutePlanPath,
+      planPath,
+      fs: fs17,
+      ...options.signal ? { signal: options.signal } : {},
+      onLockStatusChange: options.onLockStatusChange
+    });
     try {
       let stepsConfig;
       let plan;
       try {
-        stepsConfig = await loadResolvedSteps({
-          cwd: options.cwd,
-          homeDir: options.homeDir,
-          fs: fs17
-        });
         const content = await fs17.readFile(absolutePlanPath, "utf8");
-        plan = parsePlan(content, { availableSteps: stepsConfig.steps });
+        ({ plan, stepsConfig } = await readResolvedPlanFromContent(content));
         lastGoodPlan = plan;
         lastGoodStepsConfig = stepsConfig;
       } catch (reloadError) {
@@ -30158,13 +30379,31 @@ async function runPipeline(options) {
         stepsConfig = lastGoodStepsConfig;
       }
       const totalTasks = plan.tasks.length;
-      const planVars = await resolveVars(plan.vars ?? {}, options.cwd, fs17.readFile.bind(fs17));
+      const planVars = await resolvePipelineVars(
+        plan.vars ?? {},
+        options.cwd,
+        fs17.readFile.bind(fs17)
+      );
+      const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? stepsConfig.teardown;
+      validateResolvedPromptVars({
+        plan,
+        steps: stepsConfig.steps,
+        planPath,
+        vars: planVars,
+        ...resolvedTeardown ? { teardown: resolvedTeardown } : {}
+      });
       const selection = selectNextExecution(plan, options.task);
       if (selection.kind === "completed") {
         if (runsCompleted > 0) {
           await archivePlan(fs17, absolutePlanPath);
           if (resolvedTeardown) {
-            const { success: success3, cancelled } = await runPhase(resolvedTeardown, "teardown", initialTotalTasks, planVars, plan.mcp);
+            const { success: success3, cancelled } = await runPhase(
+              resolvedTeardown,
+              "teardown",
+              initialTotalTasks,
+              planVars,
+              plan.mcp
+            );
             if (cancelled || !success3) {
               return {
                 stopReason: cancelled ? "cancelled" : "failed",
@@ -30250,8 +30489,11 @@ async function runPipeline(options) {
         metrics.totalCachedTokens += result.usage.cachedTokens ?? 0;
       }
       metrics.stepsCompleted += 1;
+      const taskCompleted = success2 && completesTaskOnSuccess(selection.task, selection.stepName);
       if (success2) {
-        metrics.tasksCompleted += 1;
+        if (taskCompleted) {
+          metrics.tasksCompleted += 1;
+        }
       } else {
         metrics.tasksFailed += 1;
       }
@@ -30278,6 +30520,7 @@ async function runPipeline(options) {
         ...taskProgress,
         durationMs: taskDurationMs,
         success: success2,
+        taskCompleted,
         ...result.usage ? { usage: result.usage } : {}
       });
       if (!success2) {
@@ -30312,6 +30555,9 @@ var init_pipeline = __esm({
     init_parser2();
     init_writer2();
     init_runner2();
+    init_interpolate();
+    init_resolve4();
+    init_validate();
     init_utils2();
   }
 });
@@ -30326,6 +30572,9 @@ var init_src18 = __esm({
     init_writer2();
     init_runner2();
     init_pipeline();
+    init_interpolate();
+    init_resolve4();
+    init_validate();
   }
 });
 
@@ -30339,7 +30588,7 @@ var init_types4 = __esm({
 // packages/experiment-loop/src/frontmatter/frontmatter.ts
 import matter2 from "gray-matter";
 import { dirname } from "node:path";
-import { stringify as stringify2 } from "yaml";
+import { stringify } from "yaml";
 function parseExperimentFrontmatter(content) {
   const parsed = matter2(content);
   return {
@@ -30638,7 +30887,7 @@ var init_git = __esm({
 });
 
 // packages/experiment-loop/src/config/loader.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import { readFile as readFile9 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { parse as parse8 } from "yaml";
@@ -30709,7 +30958,7 @@ async function loadInstructions() {
   return readBundledFile("default-instructions.md");
 }
 async function loadRunConfig(options) {
-  const projectPath = path38.join(options.cwd, ".poe-code", "experiments", "run.yaml");
+  const projectPath = path39.join(options.cwd, ".poe-code", "experiments", "run.yaml");
   const projectContent = await readOptionalFile3(options.fs, projectPath);
   if (projectContent == null) {
     return readDefaultRunConfig();
@@ -30718,8 +30967,8 @@ async function loadRunConfig(options) {
   if (projectDocument === null || projectDocument === void 0) {
     return readDefaultRunConfig();
   }
-  const bundledConfigDir = path38.resolve(fileURLToPath6(new URL(".", import.meta.url)));
-  const globalConfigDir = path38.resolve(path38.join(options.homeDir, ".poe-code", "experiments"));
+  const bundledConfigDir = path39.resolve(fileURLToPath6(new URL(".", import.meta.url)));
+  const globalConfigDir = path39.resolve(path39.join(options.homeDir, ".poe-code", "experiments"));
   const resolved = await resolve(
     [
       { source: "document", filePath: projectPath, content: projectContent },
@@ -30742,15 +30991,15 @@ var init_loader2 = __esm({
 });
 
 // packages/experiment-loop/src/discovery/discovery.ts
-import path39 from "node:path";
+import path40 from "node:path";
 import * as fsPromises9 from "node:fs/promises";
 function createDefaultFs6() {
   return {
     readdir: fsPromises9.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises9.stat(filePath);
+      const stat24 = await fsPromises9.stat(filePath);
       return {
-        isFile: () => stat23.isFile()
+        isFile: () => stat24.isFile()
       };
     }
   };
@@ -30776,12 +31025,12 @@ async function scanDir(fs17, absoluteDir, displayDir) {
     if (!isMarkdownFile(entry)) {
       continue;
     }
-    const absolutePath = path39.join(absoluteDir, entry);
-    const stat23 = await fs17.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const absolutePath = path40.join(absoluteDir, entry);
+    const stat24 = await fs17.stat(absolutePath);
+    if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path39.join(displayDir, entry);
+    const displayPath2 = path40.join(displayDir, entry);
     docs.push({
       path: displayPath2,
       displayPath: displayPath2
@@ -30790,18 +31039,18 @@ async function scanDir(fs17, absoluteDir, displayDir) {
   return docs;
 }
 function toDisplayPath(options) {
-  const localDir = path39.join(options.cwd, ".poe-code", "experiments");
-  const globalDir = path39.join(options.homeDir, ".poe-code", "experiments");
-  if (options.absolutePath.startsWith(`${localDir}${path39.sep}`)) {
-    return path39.join(
+  const localDir = path40.join(options.cwd, ".poe-code", "experiments");
+  const globalDir = path40.join(options.homeDir, ".poe-code", "experiments");
+  if (options.absolutePath.startsWith(`${localDir}${path40.sep}`)) {
+    return path40.join(
       ".poe-code/experiments",
-      path39.relative(localDir, options.absolutePath)
+      path40.relative(localDir, options.absolutePath)
     );
   }
-  if (options.absolutePath.startsWith(`${globalDir}${path39.sep}`)) {
-    return path39.join(
+  if (options.absolutePath.startsWith(`${globalDir}${path40.sep}`)) {
+    return path40.join(
       "~/.poe-code/experiments",
-      path39.relative(globalDir, options.absolutePath)
+      path40.relative(globalDir, options.absolutePath)
     );
   }
   return options.absolutePath;
@@ -30834,8 +31083,8 @@ async function discoverExperimentDocs(options) {
   const customDir = options.planDirectory?.trim();
   const docs = customDir ? await scanCustomDir(fs17, customDir, options.cwd, options.homeDir) : await scanDefaultDirs(fs17, options.cwd, options.homeDir);
   return docs.sort((left, right) => {
-    const leftName = path39.basename(left.displayPath).toLowerCase();
-    const rightName = path39.basename(right.displayPath).toLowerCase();
+    const leftName = path40.basename(left.displayPath).toLowerCase();
+    const rightName = path40.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -30849,18 +31098,18 @@ var init_discovery2 = __esm({
 // packages/experiment-loop/src/run/loop.ts
 import { exec as execCallback } from "node:child_process";
 import * as fsPromises10 from "node:fs/promises";
-import path40 from "node:path";
+import path41 from "node:path";
 function createDefaultFs7() {
   return {
     readFile: fsPromises10.readFile,
     writeFile: (filePath, content) => fsPromises10.writeFile(filePath, content, "utf8"),
     readdir: fsPromises10.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises10.stat(filePath);
+      const stat24 = await fsPromises10.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -30896,9 +31145,9 @@ function createDefaultExec() {
   });
 }
 function resolveJournalPath(docPath) {
-  return path40.join(
-    path40.dirname(docPath),
-    `${path40.basename(docPath, path40.extname(docPath))}.journal.jsonl`
+  return path41.join(
+    path41.dirname(docPath),
+    `${path41.basename(docPath, path41.extname(docPath))}.journal.jsonl`
   );
 }
 function normalizeMetrics(metric) {
@@ -30939,9 +31188,9 @@ function assertNotAborted5(signal) {
   if (!signal?.aborted) {
     return;
   }
-  throw createAbortError5();
+  throw createAbortError6();
 }
-function createAbortError5() {
+function createAbortError6() {
   const error2 = new Error("Experiment loop cancelled");
   error2.name = "AbortError";
   return error2;
@@ -30949,7 +31198,7 @@ function createAbortError5() {
 function isAbortError2(error2) {
   return error2 instanceof Error && error2.name === "AbortError";
 }
-function interpolate2(template, values) {
+function interpolate(template, values) {
   let output = template;
   for (const [key, value] of Object.entries(values)) {
     output = output.split(`{{${key}}}`).join(value);
@@ -30980,8 +31229,8 @@ function buildPrompt(options) {
     doc_path: options.docPath,
     doc_name: options.docName
   };
-  const context = interpolate2(options.runConfig.prompt, vars).trim();
-  const instructions = interpolate2(options.instructions, vars).trim();
+  const context = interpolate(options.runConfig.prompt, vars).trim();
+  const instructions = interpolate(options.instructions, vars).trim();
   return `${context}
 
 ${instructions}`;
@@ -31032,8 +31281,8 @@ async function runExperimentLoop(options) {
       [
         { source: "cli", data: { agent: options.agent } },
         { source: "document", filePath: absoluteDocPath, content: rawContent },
-        { source: "base", path: path40.join(options.cwd, ".poe-code/experiments/bases") },
-        { source: "base", path: path40.join(options.homeDir, ".poe-code/experiments/bases") },
+        { source: "base", path: path41.join(options.cwd, ".poe-code/experiments/bases") },
+        { source: "base", path: path41.join(options.homeDir, ".poe-code/experiments/bases") },
         { source: "defaults", data: { agent: "claude-code" } }
       ],
       { fs: fs17 }
@@ -31113,7 +31362,7 @@ async function runExperimentLoop(options) {
         experimentIndex,
         baseline,
         docPath: options.docPath,
-        docName: path40.basename(absoluteDocPath, path40.extname(absoluteDocPath))
+        docName: path41.basename(absoluteDocPath, path41.extname(absoluteDocPath))
       });
       const currentSpecifier = agents[(experimentIndex - 1) % agents.length];
       const model = currentSpecifier.model;
@@ -31209,7 +31458,7 @@ var init_src19 = __esm({
 });
 
 // packages/ralph/src/frontmatter/frontmatter.ts
-import { parse as parse9, stringify as stringify3 } from "yaml";
+import { parse as parse9, stringify as stringify2 } from "yaml";
 function parseFrontmatter2(content) {
   if (!content.startsWith(`${FENCE}
 `)) {
@@ -31248,7 +31497,7 @@ function writeFrontmatter(data, body) {
       iteration: data.status.iteration
     }
   };
-  const yaml = stringify3(serialized).trimEnd();
+  const yaml = stringify2(serialized).trimEnd();
   return `${FENCE}
 ${yaml}
 ${FENCE}
@@ -31346,17 +31595,17 @@ var init_frontmatter3 = __esm({
 });
 
 // packages/ralph/src/discovery/discovery.ts
-import path41 from "node:path";
+import path42 from "node:path";
 import * as fsPromises11 from "node:fs/promises";
 function createDefaultFs8() {
   return {
     readdir: fsPromises11.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises11.stat(filePath);
+      const stat24 = await fsPromises11.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     }
   };
@@ -31382,12 +31631,12 @@ async function scanDir2(fs17, absoluteDir, displayDir) {
     if (!isMarkdownFile2(entry)) {
       continue;
     }
-    const absolutePath = path41.join(absoluteDir, entry);
-    const stat23 = await fs17.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const absolutePath = path42.join(absoluteDir, entry);
+    const stat24 = await fs17.stat(absolutePath);
+    if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path41.join(displayDir, entry);
+    const displayPath2 = path42.join(displayDir, entry);
     docs.push({
       path: displayPath2,
       displayPath: displayPath2
@@ -31396,18 +31645,18 @@ async function scanDir2(fs17, absoluteDir, displayDir) {
   return docs;
 }
 function toDisplayPath2(options) {
-  const localDir = path41.join(options.cwd, ".poe-code", "ralph", "plans");
-  const globalDir = path41.join(options.homeDir, ".poe-code", "ralph", "plans");
-  if (options.absolutePath.startsWith(`${localDir}${path41.sep}`)) {
-    return path41.join(
+  const localDir = path42.join(options.cwd, ".poe-code", "ralph", "plans");
+  const globalDir = path42.join(options.homeDir, ".poe-code", "ralph", "plans");
+  if (options.absolutePath.startsWith(`${localDir}${path42.sep}`)) {
+    return path42.join(
       ".poe-code/ralph/plans",
-      path41.relative(localDir, options.absolutePath)
+      path42.relative(localDir, options.absolutePath)
     );
   }
-  if (options.absolutePath.startsWith(`${globalDir}${path41.sep}`)) {
-    return path41.join(
+  if (options.absolutePath.startsWith(`${globalDir}${path42.sep}`)) {
+    return path42.join(
       "~/.poe-code/ralph/plans",
-      path41.relative(globalDir, options.absolutePath)
+      path42.relative(globalDir, options.absolutePath)
     );
   }
   return options.absolutePath;
@@ -31440,8 +31689,8 @@ async function discoverDocs(options) {
   const customDir = options.planDirectory?.trim();
   const docs = customDir ? await scanCustomDir2(fs17, customDir, options.cwd, options.homeDir) : await scanDefaultDirs2(fs17, options.cwd, options.homeDir);
   return docs.sort((left, right) => {
-    const leftName = path41.basename(left.displayPath).toLowerCase();
-    const rightName = path41.basename(right.displayPath).toLowerCase();
+    const leftName = path42.basename(left.displayPath).toLowerCase();
+    const rightName = path42.basename(right.displayPath).toLowerCase();
     return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
   });
 }
@@ -31465,7 +31714,7 @@ var init_variables = __esm({
 });
 
 // packages/ralph/src/run/ralph.ts
-import path42 from "node:path";
+import path43 from "node:path";
 import * as fsPromises12 from "node:fs/promises";
 async function runRalph(options) {
   const fs17 = options.fs ?? createDefaultFs9();
@@ -31669,11 +31918,11 @@ async function resolveDocumentConfigFromContent(options, fs17, absoluteDocPath,
       },
       {
         source: "base",
-        path: path42.join(options.cwd, ".poe-code/ralph/bases")
+        path: path43.join(options.cwd, ".poe-code/ralph/bases")
       },
       {
         source: "base",
-        path: path42.join(options.homeDir, ".poe-code/ralph/bases")
+        path: path43.join(options.homeDir, ".poe-code/ralph/bases")
       },
       {
         source: "defaults",
@@ -31724,11 +31973,11 @@ function createDefaultFs9() {
     writeFile: (filePath, content) => fsPromises12.writeFile(filePath, content, "utf8"),
     readdir: fsPromises12.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises12.stat(filePath);
+      const stat24 = await fsPromises12.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -31806,9 +32055,9 @@ async function updateFrontmatter2(fs17, absoluteDocPath, state, iteration) {
   await fs17.writeFile(absoluteDocPath, content);
 }
 async function archivePlan2(fs17, absoluteDocPath) {
-  const dir = path42.dirname(absoluteDocPath);
-  const archiveDir = path42.join(dir, "archive");
-  const archivePath = path42.join(archiveDir, path42.basename(absoluteDocPath));
+  const dir = path43.dirname(absoluteDocPath);
+  const archiveDir = path43.join(dir, "archive");
+  const archivePath = path43.join(archiveDir, path43.basename(absoluteDocPath));
   await fs17.mkdir(archiveDir, { recursive: true });
   await fs17.rename(absoluteDocPath, archivePath);
 }
@@ -31843,7 +32092,7 @@ var init_src20 = __esm({
 });
 
 // packages/plan-browser/src/format.ts
-import path43 from "node:path";
+import path44 from "node:path";
 import { parseDocument as parseDocument5 } from "yaml";
 function isPipelineTaskDone(task) {
   if (typeof task.status === "string") {
@@ -32014,9 +32263,9 @@ function formatPipelinePlanMarkdown(options) {
   return lines.join("\n").trimEnd();
 }
 function resolveExperimentJournalPath(absolutePath) {
-  return path43.join(
-    path43.dirname(absolutePath),
-    `${path43.basename(absolutePath, path43.extname(absolutePath))}.journal.jsonl`
+  return path44.join(
+    path44.dirname(absolutePath),
+    `${path44.basename(absolutePath, path44.extname(absolutePath))}.journal.jsonl`
   );
 }
 async function readExperimentState(fs17, absolutePath) {
@@ -32046,7 +32295,7 @@ function resolveFormatFromPath(filePath) {
 }
 async function readPlanMetadata(options) {
   const content = await options.fs.readFile(options.absolutePath, "utf8");
-  const fallbackName = path43.basename(options.path);
+  const fallbackName = path44.basename(options.path);
   if (options.kind === "pipeline") {
     return {
       title: fallbackName,
@@ -32107,7 +32356,7 @@ var init_format = __esm({
 });
 
 // packages/plan-browser/src/discovery.ts
-import path44 from "node:path";
+import path45 from "node:path";
 import * as fsPromises13 from "node:fs/promises";
 function createDefaultFs10() {
   return {
@@ -32115,11 +32364,11 @@ function createDefaultFs10() {
     writeFile: fsPromises13.writeFile,
     readdir: fsPromises13.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises13.stat(filePath);
+      const stat24 = await fsPromises13.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (directoryPath, mkdirOptions) => {
@@ -32134,9 +32383,9 @@ function isNotFound5(error2) {
 }
 function resolveAbsoluteDirectory3(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path44.join(homeDir, dir.slice(2));
+    return path45.join(homeDir, dir.slice(2));
   }
-  return path44.isAbsolute(dir) ? dir : path44.resolve(cwd, dir);
+  return path45.isAbsolute(dir) ? dir : path45.resolve(cwd, dir);
 }
 function isMarkdownFile3(name) {
   return name.toLowerCase().endsWith(".md");
@@ -32213,12 +32462,12 @@ async function discoverSharedPlans(options) {
     if (!isMarkdownFile3(name)) {
       continue;
     }
-    const absolutePath = path44.join(absoluteDir, name);
-    const stat23 = await options.fs.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const absolutePath = path45.join(absoluteDir, name);
+    const stat24 = await options.fs.stat(absolutePath);
+    if (!stat24.isFile()) {
       continue;
     }
-    const displayPath2 = path44.join(displayDir, name);
+    const displayPath2 = path45.join(displayDir, name);
     const content = await options.fs.readFile(absolutePath, "utf8");
     const kind = classifyPlanKind(content, displayPath2);
     if (options.kind && kind !== options.kind) {
@@ -32239,7 +32488,7 @@ async function discoverSharedPlans(options) {
       format: metadata.format,
       title: metadata.title,
       detail: metadata.detail,
-      updatedAt: stat23.mtimeMs
+      updatedAt: stat24.mtimeMs
     });
   }
   return plans;
@@ -32263,7 +32512,7 @@ var init_discovery4 = __esm({
 });
 
 // packages/plan-browser/src/actions.ts
-import path45 from "node:path";
+import path46 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";
@@ -32275,8 +32524,8 @@ function editPlan2(absolutePath, options = {}) {
   spawnSync3(editor, [absolutePath], { stdio: "inherit" });
 }
 async function archivePlan3(entry, fs17) {
-  const archiveDir = path45.join(path45.dirname(entry.absolutePath), "archive");
-  const archivedPath = path45.join(archiveDir, path45.basename(entry.absolutePath));
+  const archiveDir = path46.join(path46.dirname(entry.absolutePath), "archive");
+  const archivedPath = path46.join(archiveDir, path46.basename(entry.absolutePath));
   await fs17.mkdir(archiveDir, { recursive: true });
   await fs17.rename(entry.absolutePath, archivedPath);
   return archivedPath;
@@ -32291,7 +32540,7 @@ var init_actions = __esm({
 });
 
 // packages/plan-browser/src/browser.ts
-import path46 from "node:path";
+import path47 from "node:path";
 async function runPlanBrowser(options) {
   const renderPlanPreview = async (entry) => {
     const markdown = await loadPlanPreviewMarkdown(entry, options.fs);
@@ -32320,7 +32569,7 @@ async function runPlanBrowser(options) {
     const selectedPath = await select2({
       message: "Select a plan",
       options: plans.map((plan) => ({
-        label: text.selectLabel(path46.basename(plan.path), plan.detail),
+        label: text.selectLabel(path47.basename(plan.path), plan.detail),
         hint: plan.typeLabel,
         value: plan.absolutePath
       }))
@@ -32356,7 +32605,7 @@ async function runPlanBrowser(options) {
     if (action === "archive") {
       try {
         const confirmed = options.assumeYes || await confirmOrCancel({
-          message: `Archive ${path46.basename(selectedPlan.path)}?`,
+          message: `Archive ${path47.basename(selectedPlan.path)}?`,
           initialValue: true
         });
         if (confirmed) {
@@ -32371,7 +32620,7 @@ async function runPlanBrowser(options) {
     }
     try {
       const confirmed = options.assumeYes || await confirmOrCancel({
-        message: `Permanently delete ${path46.basename(selectedPlan.path)}?`,
+        message: `Permanently delete ${path47.basename(selectedPlan.path)}?`,
         initialValue: true
       });
       if (confirmed) {
@@ -32516,7 +32765,7 @@ var init_scan = __esm({
 
 // packages/markdown-reader/src/core/document.ts
 import nodeFs2 from "node:fs/promises";
-import path47 from "node:path";
+import path48 from "node:path";
 import { parseDocument as parseDocument6 } from "yaml";
 async function loadMarkdownDocument(file, dependencies = {}) {
   const resolvedFile = resolveMarkdownPath(file, dependencies.cwd);
@@ -32531,7 +32780,7 @@ async function loadMarkdownDocument(file, dependencies = {}) {
   };
 }
 function resolveMarkdownPath(file, cwd = process.cwd()) {
-  return path47.isAbsolute(file) ? file : path47.resolve(cwd, file);
+  return path48.isAbsolute(file) ? file : path48.resolve(cwd, file);
 }
 function sliceMarkdownBytes(source, start, end) {
   return Buffer.from(source, "utf8").subarray(start, end).toString("utf8");
@@ -32678,7 +32927,7 @@ function resolveSection(sections, id) {
     `no section matching "${id}" (try 'read-markdown' to see the table of contents)`
   );
 }
-var init_resolve4 = __esm({
+var init_resolve5 = __esm({
   "packages/markdown-reader/src/core/resolve.ts"() {
     "use strict";
     init_src13();
@@ -32707,7 +32956,7 @@ var init_read_section = __esm({
   "packages/markdown-reader/src/core/read-section.ts"() {
     "use strict";
     init_document();
-    init_resolve4();
+    init_resolve5();
     readSection = createReadSection();
   }
 });
@@ -33624,13 +33873,13 @@ function isPlainObject3(value) {
 }
 function createFs() {
   return {
-    readFile: async (path82, encoding = "utf8") => readFile13(path82, { encoding }),
-    writeFile: async (path82, contents) => {
-      await writeFile9(path82, contents);
+    readFile: async (path84, encoding = "utf8") => readFile13(path84, { encoding }),
+    writeFile: async (path84, contents) => {
+      await writeFile9(path84, contents);
     },
-    exists: async (path82) => {
+    exists: async (path84) => {
       try {
-        await access(path82);
+        await access(path84);
         return true;
       } catch {
         return false;
@@ -33675,11 +33924,11 @@ function applySchemaCasing(schema, casing) {
     ...required === void 0 ? {} : { required }
   };
 }
-function collectParamSummaries(schema, casing, path82 = [], inheritedOptional = false) {
+function collectParamSummaries(schema, casing, path84 = [], inheritedOptional = false) {
   const summaries = [];
   for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
     const childSchema = unwrapOptional2(rawChildSchema);
-    const nextPath = [...path82, formatSegment(key, casing)];
+    const nextPath = [...path84, formatSegment(key, casing)];
     const optional = inheritedOptional || isOptional(rawChildSchema);
     if (childSchema.kind === "object") {
       summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
@@ -33708,17 +33957,17 @@ 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(path82) {
-  return path82.map((segment) => formatSegment(segment, "snake")).join("__");
+function formatToolName(path84) {
+  return path84.map((segment) => formatSegment(segment, "snake")).join("__");
 }
 function enumerateTools(root, casing, allowlist) {
   const tools = [];
-  function visit(node, path82) {
+  function visit(node, path84) {
     if (node.kind === "command") {
       if (!node.scope.includes("mcp")) {
         return;
       }
-      const name = formatToolName([...path82, node.name]);
+      const name = formatToolName([...path84, node.name]);
       const params = filterSchemaForScope(node.params, "mcp");
       if (!matchesAllowlist(name, allowlist)) {
         return;
@@ -33734,7 +33983,7 @@ function enumerateTools(root, casing, allowlist) {
       });
       return;
     }
-    const nextPath = [...path82, node.name];
+    const nextPath = [...path84, node.name];
     for (const child of node.children) {
       visit(child, nextPath);
     }
@@ -33993,7 +34242,7 @@ var init_SKILL_plan = __esm({
 });
 
 // src/cli/commands/plan.ts
-import path48 from "node:path";
+import path49 from "node:path";
 import { stringify as stringifyYaml2 } from "yaml";
 function buildPlanPrompt(options) {
   const trimmedQuestion = options.question.trim();
@@ -34145,7 +34394,7 @@ async function discoverPlans(container, kind) {
 async function resolveSelectedPlan(options) {
   const providedPath = options.providedPath?.trim();
   if (providedPath) {
-    const resolvedAbsolute = providedPath.startsWith("~/") ? path48.join(options.container.env.homeDir, providedPath.slice(2)) : path48.isAbsolute(providedPath) ? providedPath : path48.resolve(options.container.env.cwd, providedPath);
+    const resolvedAbsolute = providedPath.startsWith("~/") ? path49.join(options.container.env.homeDir, providedPath.slice(2)) : path49.isAbsolute(providedPath) ? providedPath : path49.resolve(options.container.env.cwd, providedPath);
     const matched2 = options.plans.find(
       (plan) => plan.path === providedPath || plan.absolutePath === providedPath || plan.absolutePath === resolvedAbsolute
     );
@@ -34163,7 +34412,7 @@ async function resolveSelectedPlan(options) {
   const selected = await select2({
     message: options.promptMessage,
     options: options.plans.map((plan) => ({
-      label: text.selectLabel(path48.basename(plan.path), plan.detail),
+      label: text.selectLabel(path49.basename(plan.path), plan.detail),
       hint: plan.typeLabel,
       value: plan.absolutePath
     }))
@@ -34201,7 +34450,7 @@ async function renderPlanList(container, options) {
           kind: plan.kind,
           type: plan.typeLabel,
           runner: plan.runner,
-          name: path48.basename(plan.path),
+          name: path49.basename(plan.path),
           path: plan.path,
           detail: plan.detail,
           updated: formatDate(plan.updatedAt)
@@ -34226,7 +34475,7 @@ async function renderPlanList(container, options) {
       rows: plans.map((plan) => ({
         kind: plan.kind,
         type: plan.typeLabel,
-        name: path48.basename(plan.path),
+        name: path49.basename(plan.path),
         detail: plan.detail,
         updated: formatDate(plan.updatedAt)
       }))
@@ -34260,7 +34509,7 @@ async function executePlanAction(options) {
   }
   if (!flags.assumeYes) {
     const confirmed = await confirmOrCancel({
-      message: options.action === "archive" ? `Archive ${path48.basename(plan.path)}?` : `Permanently delete ${path48.basename(plan.path)}?`,
+      message: options.action === "archive" ? `Archive ${path49.basename(plan.path)}?` : `Permanently delete ${path49.basename(plan.path)}?`,
       initialValue: true
     });
     if (!confirmed) {
@@ -34610,7 +34859,7 @@ var init_plan = __esm({
 });
 
 // src/cli/commands/pipeline-init.ts
-import path49 from "node:path";
+import path50 from "node:path";
 function buildPipelineInitPrompt(options) {
   const trimmedQuestion = options.question?.trim() ?? "";
   const sourceTitle = extractTitle2(options.sourceDocPath, options.sourceDocContent);
@@ -34623,7 +34872,9 @@ function buildPipelineInitPrompt(options) {
     "",
     "---",
     "",
-    `Plan directory: ${options.planDirectory}`,
+    "Edit the source document in place by prepending valid YAML frontmatter.",
+    "Do not create a new file.",
+    `The final result must remain at: ${options.sourceDocPath}`,
     "",
     "User request:",
     userRequest,
@@ -34650,7 +34901,7 @@ async function discoverPipelineInitSources(options) {
   const sourceFiles = await discoverMarkdownFiles(options.container.fs, sourceAbsoluteDirectory);
   const sources = [];
   for (const file of sourceFiles) {
-    const sourceName = path49.basename(file.relativePath, path49.extname(file.relativePath));
+    const sourceName = path50.basename(file.relativePath, path50.extname(file.relativePath));
     if (existingPlanNames.has(`plan-${sourceName}`)) {
       continue;
     }
@@ -34700,12 +34951,12 @@ async function discoverExistingPipelinePlanNames(fs17, absoluteDirectory) {
     if (!lower.endsWith(".md") && !lower.endsWith(".yaml")) {
       continue;
     }
-    const absolutePath = path49.join(absoluteDirectory, entry);
-    const stat23 = await fs17.stat(absolutePath);
-    if (!stat23.isFile()) {
+    const absolutePath = path50.join(absoluteDirectory, entry);
+    const stat24 = await fs17.stat(absolutePath);
+    if (!stat24.isFile()) {
       continue;
     }
-    planNames.add(path49.basename(entry, path49.extname(entry)));
+    planNames.add(path50.basename(entry, path50.extname(entry)));
   }
   return planNames;
 }
@@ -34721,17 +34972,17 @@ async function discoverMarkdownFiles(fs17, absoluteDirectory, parentRelativePath
   }
   const markdownFiles = [];
   for (const entry of [...entries].sort((left, right) => left.localeCompare(right))) {
-    const absolutePath = path49.join(absoluteDirectory, entry);
-    const relativePath = parentRelativePath.length > 0 ? path49.join(parentRelativePath, entry) : entry;
-    const stat23 = await fs17.stat(absolutePath);
-    if (stat23.isDirectory()) {
+    const absolutePath = path50.join(absoluteDirectory, entry);
+    const relativePath = parentRelativePath.length > 0 ? path50.join(parentRelativePath, entry) : entry;
+    const stat24 = await fs17.stat(absolutePath);
+    if (stat24.isDirectory()) {
       if (entry === "archive") {
         continue;
       }
       markdownFiles.push(...await discoverMarkdownFiles(fs17, absolutePath, relativePath));
       continue;
     }
-    if (!stat23.isFile() || !entry.toLowerCase().endsWith(".md")) {
+    if (!stat24.isFile() || !entry.toLowerCase().endsWith(".md")) {
       continue;
     }
     markdownFiles.push({
@@ -34752,7 +35003,7 @@ function extractTitle2(filePath, content) {
       return title;
     }
   }
-  return path49.basename(filePath, path49.extname(filePath));
+  return path50.basename(filePath, path50.extname(filePath));
 }
 function createMarkdownFence(content) {
   return "`".repeat(Math.max(3, longestBacktickRun(content) + 1));
@@ -34794,33 +35045,150 @@ var init_pipeline_init = __esm({
 var SKILL_plan_default2;
 var init_SKILL_plan2 = __esm({
   "src/templates/pipeline/SKILL_plan.md"() {
-    SKILL_plan_default2 = '---\nname: poe-code-pipeline-plan\ndescription: \'Generate a Pipeline plan markdown file with YAML frontmatter from a user request. Triggers on: create a pipeline plan, write plan for, plan this feature, pipeline plan.\'\n---\n\n## If The Request Is Empty\n\nAsk the user for a one-sentence description of what they want to build.\n\n## Goal\n\nWrite a markdown pipeline plan with YAML frontmatter. Before writing, determine where to place it:\n\n1. Write the plan to `docs/plans/plan-<name>.md` by default.\n2. Find the `steps.yaml` file. Check these locations in order and use the first one found:\n   a. `<project-root>/.poe-code/pipeline/steps.yaml` (project-level)\n   b. `~/.poe-code/pipeline/steps.yaml` (user-global)\n   If found, read it to determine available steps and note any `setup`/`teardown` hooks defined there. If not found in either location, use stepless tasks.\n3. Decide what belongs in the markdown body. If the user already has a Markdown design/context doc (for example in `docs/plans/`), use that content as the plan body when it makes sense. If they want to keep the source doc separate, link it via `vars` so it is available in every prompt without repeating the path.\n\n## Rules\n\n- Each task must be self-contained. Put all context needed to execute the task inside that task\'s `prompt`.\n- Do not create tasks that depend on hidden state from previous tasks.\n- Use short kebab-case ids.\n- Keep titles concise and descriptive.\n- The available steps come from the `steps.yaml` file you found (project or global). Use the current step names instead of inventing hardcoded ones.\n- If no step configuration is present, use stepless tasks with scalar `status: open`.\n- If step configuration is present, start every configured step status at `open`.\n- `setup` and `teardown` defined in `steps.yaml` are inherited automatically.\n- To disable an inherited hook for a specific plan, set `setup: false` or `teardown: false`.\n- To override an inherited hook, define the full block with an `prompt` field.\n- If the user keeps an existing Markdown plan document as a separate file, add a `vars` block with a `plan_doc` key pointing to the file path. The pipeline runtime reads the file and makes its contents available as a named placeholder in every prompt.\n- `vars` values are plain strings. Use the `file` include syntax inside a value to load a file at runtime (path relative to project root): write `var_name: "` followed by the file include tag and a closing `"`.\n- Each var name becomes a double-curly-brace placeholder usable in any task, step, setup, or teardown prompt.\n- The markdown body is for context, notes, acceptance criteria, or the design doc. Keep executable pipeline config in the YAML frontmatter.\n- Do not rely on the body alone for runtime context. Each task prompt must still include everything it needs directly or via `vars` placeholders.\n- Start the frontmatter with canonical metadata: `$schema: https://poe-platform.github.io/poe-code/schemas/plans/pipeline.schema.json`, `kind: pipeline`, and `version: 1`.\n\n## Output Format\n\n```markdown\n---\n$schema: https://poe-platform.github.io/poe-code/schemas/plans/pipeline.schema.json\nkind: pipeline\nversion: 1\n\n# vars: optional. Define named values available as double-curly-brace placeholders in every prompt.\n# Each value is a plain string. To load a file at runtime, write the value using the\n# file include syntax: double-curly-brace file followed by a quoted path.\n# Omit this block if there are no shared values to inject.\n#\n# vars:\n#   plan_doc: "(file include for docs/plans/my-feature.md)"  # loaded at runtime\n#   env: production                                           # literal string\n\n# setup/teardown are inherited from steps.yaml automatically.\n# Include them only to disable or override:\n#\n# setup: false              # disable the inherited setup hook\n# teardown: false           # disable the inherited teardown hook\n# setup:                    # override with a different prompt\n#   prompt: Custom setup\n#   mode: yolo\n\ntasks:\n  - id: auth-hardening\n    title: Harden auth flow\n    prompt: |\n      Improve auth validation and session handling.\n      # If vars defines plan_doc, reference it here using the double-curly-brace placeholder syntax.\n    # scalar when no steps.yaml steps are defined:\n    status: open\n    # stepped when steps.yaml defines steps:\n    # status:\n    #   implement: open\n    #   test: open\n    #   commit: open\n---\n\n# Context\n\nPaste the design doc, notes, acceptance criteria, or implementation details here.\nThis body is for human-readable context and future tooling.\nAny context needed at runtime must still appear in each task prompt or via vars placeholders.\n```\n\n## After Writing\n\nRun `poe-code pipeline validate <path>` to check the plan is valid before running it.\n\n## Notes\n\n- Match the uncommented step names and order from whichever `steps.yaml` file you find.\n- If `poe-code` is not available as a global command, use `npx poe-code` instead.\n';
+    SKILL_plan_default2 = '---\nname: poe-code-pipeline-plan\ndescription: \'Generate a Pipeline plan markdown file with YAML frontmatter from a user request. Triggers on: create a pipeline plan, write plan for, plan this feature, pipeline plan.\'\n---\n\n## If The Request Is Empty\n\nAsk the user for a one-sentence description of what they want to build.\n\n## Goal\n\nWrite a markdown pipeline plan with YAML frontmatter. Before writing, determine where to place it:\n\n1. Write the plan to `docs/plans/plan-<name>.md` by default.\n2. Find named step configs in `.poe-code/pipeline/steps/`.\n   a. Check `<project-root>/.poe-code/pipeline/steps/` first.\n   b. If that directory does not exist, check `~/.poe-code/pipeline/steps/`.\n   c. Read the available `*.yaml` files there (for example `default.yaml`, `fast.yaml`). Use `default` when the user does not ask for a different config. If no directory exists, use stepless tasks.\n3. Decide what belongs in the markdown body. If the user already has a Markdown design/context doc (for example in `docs/plans/`), use that content as the plan body when it makes sense. If they want to keep the source doc separate, link it via `vars` so it is available in every prompt without repeating the path.\n\n## Rules\n\n- Each task must be self-contained. Put all context needed to execute the task inside that task\'s `prompt`.\n- Do not create tasks that depend on hidden state from previous tasks.\n- Use short kebab-case ids.\n- Keep titles concise and descriptive.\n- The available steps come from the named step config you found in `.poe-code/pipeline/steps/`. Use the current step names instead of inventing hardcoded ones.\n- Always write `extends: <name>` in the frontmatter. Use `default` unless you discovered or intentionally chose another named config.\n- If no step configuration directory is present, use stepless tasks with scalar `status: open`.\n- If step configuration is present, start every configured step status at `open`.\n- `setup` and `teardown` from the extended step config are inherited automatically.\n- To disable an inherited hook for a specific plan, set `setup: false` or `teardown: false`.\n- To override an inherited hook, define the full block with a `prompt` field.\n- Use the plan-level `steps:` block only for per-plan step overrides. Override only the fields you need; unset fields inherit from the extended config.\n- If the user keeps an existing Markdown plan document as a separate file, add a `vars` block with a `plan_doc` key pointing to the file path. The pipeline runtime reads the file and makes its contents available as a named placeholder in every prompt.\n- `vars` values are plain strings. Use the `file` include syntax inside a value to load a file at runtime (path relative to project root): write `var_name: "` followed by the file include tag and a closing `"`.\n- Each var name becomes a double-curly-brace placeholder usable in any task, step, setup, or teardown prompt.\n- The markdown body is for context, notes, acceptance criteria, or the design doc. Keep executable pipeline config in the YAML frontmatter.\n- Do not rely on the body alone for runtime context. Each task prompt must still include everything it needs directly or via `vars` placeholders.\n- Start the frontmatter with canonical metadata: `$schema: https://poe-platform.github.io/poe-code/schemas/plans/pipeline.schema.json`, `kind: pipeline`, and `version: 1`.\n\n## Output Format\n\n```markdown\n---\n$schema: https://poe-platform.github.io/poe-code/schemas/plans/pipeline.schema.json\nkind: pipeline\nversion: 1\nextends: default\n\n# vars: optional. Define named values available as double-curly-brace placeholders in every prompt.\n# Each value is a plain string. To load a file at runtime, write the value using the\n# file include syntax: double-curly-brace file followed by a quoted path.\n# Omit this block if there are no shared values to inject.\n#\n# vars:\n#   plan_doc: "(file include for docs/plans/my-feature.md)"  # loaded at runtime\n#   env: production                                            # literal string\n\n# Optional per-plan step overrides. Unset fields inherit from the extended config.\n# Omit this block when the base config already fits.\n#\n# steps:\n#   implement:\n#     prompt: |\n#       Focus on the risky auth paths first.\n#   test:\n#     mode: read\n\n# setup/teardown are inherited from the extended step config automatically.\n# Include them only to disable or override:\n#\n# setup: false              # disable the inherited setup hook\n# teardown: false           # disable the inherited teardown hook\n# setup:                    # override with a different prompt\n#   prompt: Custom setup\n#   mode: yolo\n\ntasks:\n  - id: auth-hardening\n    title: Harden auth flow\n    prompt: |\n      Improve auth validation and session handling.\n      # If vars defines plan_doc, reference it here using the double-curly-brace placeholder syntax.\n    # scalar when no step config is available:\n    status: open\n    # stepped when the extended config defines steps:\n    # status:\n    #   implement: open\n    #   test: open\n    #   commit: open\n---\n\n# Context\n\nPaste the design doc, notes, acceptance criteria, or implementation details here.\nThis body is for human-readable context and future tooling.\nAny context needed at runtime must still appear in each task prompt or via vars placeholders.\n```\n\n## After Writing\n\nRun `poe-code pipeline validate <path>` to check the plan is valid before running it.\n\n## Notes\n\n- Match the uncommented step names and order from the named step config you choose.\n- If `poe-code` is not available as a global command, use `npx poe-code` instead.\n';
   }
 });
 
 // src/sdk/pipeline.ts
 import * as fsPromises14 from "node:fs/promises";
+import path51 from "node:path";
 function isAbortError4(error2) {
   return error2 instanceof Error && error2.name === "AbortError";
 }
+function createDefaultFs11() {
+  return {
+    readFile: fsPromises14.readFile,
+    writeFile: fsPromises14.writeFile,
+    readdir: fsPromises14.readdir,
+    stat: async (filePath) => {
+      const stat24 = await fsPromises14.stat(filePath);
+      return {
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
+      };
+    },
+    mkdir: async (filePath, options) => {
+      await fsPromises14.mkdir(filePath, options);
+    },
+    rmdir: fsPromises14.rmdir,
+    rename: fsPromises14.rename
+  };
+}
+function createEmptyMetrics() {
+  return {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCachedTokens: 0,
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    stepsCompleted: 0
+  };
+}
+function needsPipelineInit(planContent) {
+  try {
+    return parsePlan(planContent).tasks.length === 0;
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    if (message2 === "Invalid plan YAML: expected a top-level object." || message2 === 'Invalid plan YAML: expected "tasks" to be an array.') {
+      return true;
+    }
+    throw error2;
+  }
+}
+function withPipelineTimeoutRetries(runAgent) {
+  return async (input) => {
+    for (let attempt = 1; attempt <= PIPELINE_ACTIVITY_TIMEOUT_RETRY_COUNT; attempt += 1) {
+      try {
+        return await runAgent(input);
+      } catch (error2) {
+        if (!isActivityTimeoutError(error2) || attempt === PIPELINE_ACTIVITY_TIMEOUT_RETRY_COUNT) {
+          throw error2;
+        }
+      }
+    }
+    throw new Error("Unreachable");
+  };
+}
 async function runPipeline2(options) {
-  const runAgent = options.runAgent ?? (async (input) => {
+  const fs17 = options.fs ?? createDefaultFs11();
+  const runAgent = withPipelineTimeoutRetries(options.runAgent ?? (async (input) => {
     return await spawn7.autonomous(input.agent, {
       prompt: input.prompt,
       cwd: input.cwd,
       logDir: input.logDir,
       model: input.model,
       mode: input.mode,
+      maxTimeoutRetries: 1,
       ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
       ...input.signal ? { signal: input.signal } : {}
     });
+  }));
+  const planPath = await resolvePlanPath({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    plan: options.plan,
+    planDirectory: options.planDirectory,
+    assumeYes: options.assumeYes,
+    fs: fs17,
+    selectPlan: options.selectPlan,
+    promptForPath: options.promptForPath
   });
+  if (!planPath) {
+    return {
+      stopReason: "cancelled",
+      planPath: "",
+      runsCompleted: 0,
+      totalDurationMs: 0,
+      metrics: createEmptyMetrics()
+    };
+  }
+  const absolutePlanPath = resolveAbsolutePlanPath(planPath, options.cwd, options.homeDir);
+  const planContent = await fs17.readFile(absolutePlanPath, "utf8");
+  if (needsPipelineInit(planContent)) {
+    const initResult = await runPipelineInit({
+      agent: options.agent,
+      ...options.model ? { model: options.model } : {},
+      cwd: options.cwd,
+      homeDir: options.homeDir,
+      fs: fs17,
+      sources: [
+        {
+          absolutePath: absolutePlanPath,
+          relativePath: planPath,
+          title: path51.basename(planPath, path51.extname(planPath))
+        }
+      ],
+      assumeYes: options.assumeYes ?? false,
+      runAgent,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (initResult.stopReason === "cancelled") {
+      return {
+        stopReason: "cancelled",
+        planPath,
+        runsCompleted: 0,
+        totalDurationMs: 0,
+        metrics: createEmptyMetrics()
+      };
+    }
+    if (initResult.stopReason === "failed") {
+      throw new Error(`Pipeline init failed for "${planPath}".`);
+    }
+    const initializedPlanContent = await fs17.readFile(absolutePlanPath, "utf8");
+    if (needsPipelineInit(initializedPlanContent)) {
+      throw new Error(`Pipeline init did not produce runnable tasks for "${planPath}".`);
+    }
+  }
   return runPipeline({
     ...options,
+    fs: fs17,
+    plan: planPath,
     runAgent
   });
 }
 async function runPipelineInit(options) {
+  const fs17 = options.fs ?? createDefaultFs11();
   const runAgent = options.runAgent ?? (async (input) => {
     return await spawn7.autonomous(input.agent, {
       prompt: input.prompt,
@@ -34836,11 +35204,6 @@ async function runPipelineInit(options) {
       sourcesProcessed: 0
     };
   }
-  const planDirectory = resolvePlanDirectory2({
-    cwd: options.cwd,
-    homeDir: options.homeDir,
-    planDirectory: options.planDirectory ?? ".poe-code/pipeline/plans"
-  });
   let sourcesProcessed = 0;
   const totalSources = options.sources.length;
   for (const [sourceIndex, source] of options.sources.entries()) {
@@ -34853,7 +35216,7 @@ async function runPipelineInit(options) {
     const displayIndex = sourceIndex + 1;
     try {
       options.onSourceStart?.(source, displayIndex, totalSources);
-      const sourceDocContent = await fsPromises14.readFile(source.absolutePath, "utf8");
+      const sourceDocContent = await fs17.readFile(source.absolutePath, "utf8");
       if (options.signal?.aborted) {
         return {
           stopReason: "cancelled",
@@ -34862,7 +35225,6 @@ async function runPipelineInit(options) {
       }
       const prompt = buildPipelineInitPrompt({
         question: options.question,
-        planDirectory,
         sourceDocPath: source.relativePath,
         sourceDocContent,
         skillContent: SKILL_plan_default2
@@ -34903,19 +35265,22 @@ async function runPipelineInit(options) {
     sourcesProcessed
   };
 }
+var PIPELINE_ACTIVITY_TIMEOUT_RETRY_COUNT;
 var init_pipeline2 = __esm({
   async "src/sdk/pipeline.ts"() {
     "use strict";
+    init_src8();
     init_src18();
     await init_pipeline_init();
     init_SKILL_plan2();
     await init_spawn3();
     init_src18();
+    PIPELINE_ACTIVITY_TIMEOUT_RETRY_COUNT = 3;
   }
 });
 
 // packages/process-launcher/src/state/state-store.ts
-import path50 from "node:path";
+import path52 from "node:path";
 import * as nodeFs3 from "node:fs/promises";
 function isNotFoundError2(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
@@ -34931,9 +35296,9 @@ async function removeDirectory2(fs17, directoryPath) {
     throw error2;
   }
   for (const entry of entries) {
-    const entryPath = path50.join(directoryPath, entry);
-    const stat23 = await fs17.stat(entryPath);
-    if (stat23.isFile()) {
+    const entryPath = path52.join(directoryPath, entry);
+    const stat24 = await fs17.stat(entryPath);
+    if (stat24.isFile()) {
       await fs17.rm(entryPath, { force: true });
       continue;
     }
@@ -34948,7 +35313,7 @@ async function removeDirectory2(fs17, directoryPath) {
 }
 function createStateStore(stateDir, fs17 = nodeFs3) {
   async function read(id) {
-    const statePath = path50.join(stateDir, id, "state.json");
+    const statePath = path52.join(stateDir, id, "state.json");
     try {
       const content = await fs17.readFile(statePath, "utf8");
       return JSON.parse(content);
@@ -34960,9 +35325,9 @@ function createStateStore(stateDir, fs17 = nodeFs3) {
     }
   }
   async function write2(id, state) {
-    const processDir = path50.join(stateDir, id);
+    const processDir = path52.join(stateDir, id);
     await fs17.mkdir(processDir, { recursive: true });
-    await fs17.writeFile(path50.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
+    await fs17.writeFile(path52.join(processDir, "state.json"), `${JSON.stringify(state, null, 2)}
 `);
   }
   async function list() {
@@ -34977,10 +35342,10 @@ function createStateStore(stateDir, fs17 = nodeFs3) {
     }
     const states = [];
     for (const entry of [...entries].sort()) {
-      const entryPath = path50.join(stateDir, entry);
+      const entryPath = path52.join(stateDir, entry);
       try {
-        const stat23 = await fs17.stat(entryPath);
-        if (stat23.isFile()) {
+        const stat24 = await fs17.stat(entryPath);
+        if (stat24.isFile()) {
           continue;
         }
       } catch (error2) {
@@ -34997,7 +35362,7 @@ function createStateStore(stateDir, fs17 = nodeFs3) {
     return states;
   }
   async function remove2(id) {
-    await removeDirectory2(fs17, path50.join(stateDir, id));
+    await removeDirectory2(fs17, path52.join(stateDir, id));
   }
   return { read, write: write2, list, remove: remove2 };
 }
@@ -35008,16 +35373,16 @@ var init_state_store = __esm({
 });
 
 // packages/process-launcher/src/logs/log-writer.ts
-import path51 from "node:path";
+import path53 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 path51.join(logDir, `${stream}.log`);
+  return path53.join(logDir, `${stream}.log`);
 }
 function getRotatedLogPath(logDir, stream, index) {
-  return path51.join(logDir, `${stream}.${index}.log`);
+  return path53.join(logDir, `${stream}.${index}.log`);
 }
 async function isFile(fs17, filePath) {
   try {
@@ -35064,7 +35429,7 @@ async function removeAllStreamLogs(fs17, logDir, stream) {
       if (getRotatedLogIndex(fileName, stream) === null) {
         continue;
       }
-      await fs17.rm(path51.join(logDir, fileName), { force: true });
+      await fs17.rm(path53.join(logDir, fileName), { force: true });
     }
   } catch (error2) {
     if (isNotFoundError3(error2)) {
@@ -35324,7 +35689,7 @@ var init_engine = __esm({
 });
 
 // packages/process-runner/src/docker/args.ts
-import path52 from "node:path";
+import path54 from "node:path";
 function buildDockerRunArgs(input) {
   const args = [input.engine];
   if (input.engine === "docker" && input.context) {
@@ -35351,7 +35716,7 @@ function buildDockerRunArgs(input) {
     args.push("-e", `${key}=${value}`);
   }
   for (const mount of input.mounts) {
-    const volume = `${path52.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
+    const volume = `${path54.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
     args.push("-v", volume);
   }
   for (const port of input.ports) {
@@ -35608,13 +35973,13 @@ var init_src24 = __esm({
 import { spawnSync } from "node:child_process";
 import * as nodeFs5 from "node:fs/promises";
 import os5 from "node:os";
-import path53 from "node:path";
+import path55 from "node:path";
 function createSupervisor(options) {
   const { spec: spec10 } = options;
   const runner = resolveRunner(options);
   const stateStore = createStateStore(options.stateDir, options.fs);
   const logWriter = createLogWriter(
-    path53.join(options.stateDir, spec10.id, "logs"),
+    path55.join(options.stateDir, spec10.id, "logs"),
     spec10.logRetainCount ?? 5,
     options.fs
   );
@@ -35982,8 +36347,8 @@ async function resolveProcessWorkspace(cwd, stateDir) {
   };
 }
 function resolveWorkspaceHomeDir(stateDir) {
-  if (path53.basename(stateDir) === "launch" && path53.basename(path53.dirname(stateDir)) === ".poe-code") {
-    return path53.dirname(path53.dirname(stateDir));
+  if (path55.basename(stateDir) === "launch" && path55.basename(path55.dirname(stateDir)) === ".poe-code") {
+    return path55.dirname(path55.dirname(stateDir));
   }
   return os5.homedir();
 }
@@ -36035,7 +36400,7 @@ var init_supervisor = __esm({
 });
 
 // packages/process-launcher/src/launcher.ts
-import path54 from "node:path";
+import path56 from "node:path";
 import * as nodeFs6 from "node:fs/promises";
 async function startManagedProcess(options) {
   const fs17 = options.fs ?? defaultFs2();
@@ -36384,10 +36749,10 @@ async function listIds(fs17, baseDir) {
     const entries = await fs17.readdir(baseDir);
     const ids = [];
     for (const entry of entries) {
-      const entryPath = path54.join(baseDir, entry);
+      const entryPath = path56.join(baseDir, entry);
       try {
-        const stat23 = await fs17.stat(entryPath);
-        if (!stat23.isFile()) {
+        const stat24 = await fs17.stat(entryPath);
+        if (!stat24.isFile()) {
           ids.push(entry);
         }
       } catch (error2) {
@@ -36434,24 +36799,24 @@ async function readJsonFile(fs17, filePath) {
   }
 }
 async function writeJsonFile(fs17, filePath, value) {
-  await fs17.mkdir(path54.dirname(filePath), { recursive: true });
+  await fs17.mkdir(path56.dirname(filePath), { recursive: true });
   await fs17.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function resolveProcessDir(baseDir, id) {
-  return path54.join(baseDir, id);
+  return path56.join(baseDir, id);
 }
 function resolveSpecPath(baseDir, id) {
-  return path54.join(resolveProcessDir(baseDir, id), "spec.json");
+  return path56.join(resolveProcessDir(baseDir, id), "spec.json");
 }
 function resolveStatePath(baseDir, id) {
-  return path54.join(resolveProcessDir(baseDir, id), "state.json");
+  return path56.join(resolveProcessDir(baseDir, id), "state.json");
 }
 function resolveMetaPath(baseDir, id) {
-  return path54.join(resolveProcessDir(baseDir, id), "meta.json");
+  return path56.join(resolveProcessDir(baseDir, id), "meta.json");
 }
 function resolveLogDir2(baseDir, id) {
-  return path54.join(resolveProcessDir(baseDir, id), "logs");
+  return path56.join(resolveProcessDir(baseDir, id), "logs");
 }
 function isNotFoundError4(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
@@ -36532,8 +36897,8 @@ var init_ralph2 = __esm({
 
 // src/sdk/experiment.ts
 import * as fsPromises15 from "node:fs/promises";
-import path55 from "node:path";
-function createDefaultFs11() {
+import path57 from "node:path";
+function createDefaultFs12() {
   return {
     readFile: fsPromises15.readFile,
     writeFile: async (filePath, content) => {
@@ -36541,11 +36906,11 @@ function createDefaultFs11() {
     },
     readdir: fsPromises15.readdir,
     stat: async (filePath) => {
-      const stat23 = await fsPromises15.stat(filePath);
+      const stat24 = await fsPromises15.stat(filePath);
       return {
-        isFile: () => stat23.isFile(),
-        isDirectory: () => stat23.isDirectory(),
-        mtimeMs: stat23.mtimeMs
+        isFile: () => stat24.isFile(),
+        isDirectory: () => stat24.isDirectory(),
+        mtimeMs: stat24.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -36560,9 +36925,9 @@ function createDefaultFs11() {
   };
 }
 function resolveJournalPath2(docPath) {
-  return path55.join(
-    path55.dirname(docPath),
-    `${path55.basename(docPath, path55.extname(docPath))}.journal.jsonl`
+  return path57.join(
+    path57.dirname(docPath),
+    `${path57.basename(docPath, path57.extname(docPath))}.journal.jsonl`
   );
 }
 async function runExperiment(options) {
@@ -36580,13 +36945,13 @@ async function runExperiment(options) {
   });
 }
 async function readExperimentJournal(options) {
-  const fs17 = options.fs ?? createDefaultFs11();
+  const fs17 = options.fs ?? createDefaultFs12();
   const absoluteDocPath = resolveWorkflowPath(options.docPath, options.cwd, options.homeDir);
   const journal = new ExperimentJournal(resolveJournalPath2(absoluteDocPath), fs17);
   return await journal.readAll();
 }
 async function appendExperimentJournalEntry(options) {
-  const fs17 = options.fs ?? createDefaultFs11();
+  const fs17 = options.fs ?? createDefaultFs12();
   const absoluteDocPath = resolveWorkflowPath(options.docPath, options.cwd, options.homeDir);
   const journal = new ExperimentJournal(resolveJournalPath2(absoluteDocPath), fs17);
   await journal.init();
@@ -36769,7 +37134,7 @@ var init_frontmatter4 = __esm({
 });
 
 // packages/github-workflows/src/discover.ts
-import { readdir as readdir15, readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir16, readFile as readFile16 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 async function discoverAutomations(builtInDir, ...projectDirs) {
   const directories = [builtInDir, ...projectDirs];
@@ -36802,7 +37167,7 @@ async function loadAutomation(name, dirs) {
 }
 async function listMarkdownFiles(dir) {
   try {
-    const entries = await readdir15(dir);
+    const entries = await readdir16(dir);
     return entries.filter((entry) => entry.endsWith(".md")).sort((left, right) => left.localeCompare(right));
   } catch (error2) {
     if (isMissingPathError(error2)) {
@@ -37122,9 +37487,9 @@ var init_setup_agent = __esm({
 });
 
 // packages/github-workflows/src/variables.ts
-import path56 from "node:path";
+import path58 from "node:path";
 import { readFile as readFile17 } from "node:fs/promises";
-import { isMap as isMap3, parseDocument as parseDocument7, stringify as stringify4 } from "yaml";
+import { isMap as isMap3, parseDocument as parseDocument7, stringify as stringify3 } from "yaml";
 function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -37236,15 +37601,15 @@ function formatVariableBlock(name, value) {
   return formatYamlBlock(name, value);
 }
 function formatYamlBlock(name, value) {
-  return stringify4({ [name]: value }).trimEnd();
+  return stringify3({ [name]: value }).trimEnd();
 }
 function formatCommentedBlock(name, value) {
   return formatVariableBlock(name, value).split("\n").map((line) => `# ${line}`).join("\n");
 }
 async function loadVariableSources(builtInDir, projectDir) {
-  const builtInPath = path56.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInPath = path58.join(builtInDir, VARIABLES_FILE_NAME);
   const builtInVariables = parseVariables(builtInPath, await readFile17(builtInPath, "utf8"));
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path56.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path58.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: {} };
@@ -37256,13 +37621,13 @@ async function loadVariableSources(builtInDir, projectDir) {
   return { builtInVariables, extendsBuiltIns, projectVariables };
 }
 async function loadVariables(builtInDir, projectDir) {
-  const builtInPath = path56.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInPath = path58.join(builtInDir, VARIABLES_FILE_NAME);
   const builtInContent = await readFile17(builtInPath, "utf8");
   const builtInVariables = parseVariables(builtInPath, builtInContent);
   if (projectDir === void 0) {
     return filterDisabledVariables(builtInVariables);
   }
-  const projectVariablesPath = path56.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = path58.join(projectDir, VARIABLES_FILE_NAME);
   const projectVariablesContent = await readOptionalVariablesContent(projectVariablesPath);
   if (projectVariablesContent === void 0) {
     return filterDisabledVariables(builtInVariables);
@@ -37295,7 +37660,7 @@ async function loadVariableStatuses(builtInDir, projectDir) {
       (key) => !extendsBuiltIns || !Object.prototype.hasOwnProperty.call(builtInVariables, key)
     )
   ];
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path56.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path58.join(projectDir, VARIABLES_FILE_NAME);
   return orderedNames.map((name) => {
     if (!Object.prototype.hasOwnProperty.call(projectVariables, name)) {
       return {
@@ -37356,8 +37721,8 @@ var init_variables2 = __esm({
 });
 
 // packages/github-workflows/src/commands.ts
-import { access as access2, mkdir as mkdir15, readFile as readFile18, unlink as unlink5, writeFile as writeFile11 } from "node:fs/promises";
-import path57 from "node:path";
+import { access as access2, mkdir as mkdir16, readFile as readFile18, unlink as unlink5, writeFile as writeFile12 } from "node:fs/promises";
+import path59 from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 import Mustache3 from "mustache";
 function formatLabel(name) {
@@ -37380,7 +37745,7 @@ async function loadNamedAutomation(name, cwd) {
 }
 async function readBuiltInPromptFile(name) {
   try {
-    return await readFile18(path57.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
+    return await readFile18(path59.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
   } catch (error2) {
     if (isMissingPathError2(error2)) {
       throw new UserError(`Automation "${name}" was not found.`);
@@ -37389,11 +37754,11 @@ async function readBuiltInPromptFile(name) {
   }
 }
 async function readBuiltInWorkflowTemplate(name, variant, automationName = name, promptPath) {
-  const templatePath = path57.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
+  const templatePath = path59.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
   try {
     const content = await readFile18(templatePath, "utf8");
     const header = promptPath !== void 0 ? `# Auto-generated by: poe-code github-workflows install ${name}
-# Edit ${path57.relative(process.cwd(), promptPath)} to customize the prompt.
+# Edit ${path59.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);
@@ -37422,7 +37787,7 @@ function projectPromptDirs(cwd) {
   return [projectWorkflowDir(cwd)];
 }
 function projectWorkflowDir(cwd) {
-  return path57.join(cwd, ".github", "workflows");
+  return path59.join(cwd, ".github", "workflows");
 }
 function projectGitHubWorkflowsDir(cwd) {
   return projectWorkflowDir(cwd);
@@ -37441,7 +37806,7 @@ async function resolveBuiltInPromptsDir() {
   return builtInPromptsDirCandidates[0];
 }
 async function resolveBuiltInAssetsDir() {
-  return path57.dirname(await resolveBuiltInPromptsDir());
+  return path59.dirname(await resolveBuiltInPromptsDir());
 }
 function resolveCwd(cwd) {
   return cwd ?? process.cwd();
@@ -37595,17 +37960,17 @@ 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 ? path57.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
+  const promptPath = isEject ? path59.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
   const [workflowTemplate, rawPrompt] = await Promise.all([
     readBuiltInWorkflowTemplate(name, variant, localAutomationName, promptPath),
     readBuiltInPromptFile(name)
   ]);
-  const workflowPath = path57.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
-  await mkdir15(path57.dirname(workflowPath), { recursive: true });
-  await writeFile11(workflowPath, workflowTemplate, "utf8");
+  const workflowPath = path59.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
+  await mkdir16(path59.dirname(workflowPath), { recursive: true });
+  await writeFile12(workflowPath, workflowTemplate, "utf8");
   if (promptPath !== void 0) {
-    await mkdir15(path57.dirname(promptPath), { recursive: true });
-    await writeFile11(promptPath, addPromptHeader(rawPrompt, name), "utf8");
+    await mkdir16(path59.dirname(promptPath), { recursive: true });
+    await writeFile12(promptPath, addPromptHeader(rawPrompt, name), "utf8");
   }
   return {
     name,
@@ -37617,15 +37982,15 @@ async function installAutomation(name, cwd, isEject) {
 }
 async function ensureProjectSupportFiles(cwd, builtInVariables) {
   const projectDir = projectGitHubWorkflowsDir(cwd);
-  const variablesPath = path57.join(projectDir, "variables.yaml");
-  const readmePath = path57.join(projectDir, "README.md");
-  await mkdir15(projectDir, { recursive: true });
-  await writeFile11(
+  const variablesPath = path59.join(projectDir, "variables.yaml");
+  const readmePath = path59.join(projectDir, "README.md");
+  await mkdir16(projectDir, { recursive: true });
+  await writeFile12(
     variablesPath,
     generateProjectVariablesFile(builtInVariables, await readOptionalFile4(variablesPath)),
     "utf8"
   );
-  await writeFile11(readmePath, renderProjectReadme(), "utf8");
+  await writeFile12(readmePath, renderProjectReadme(), "utf8");
   return { readmePath, variablesPath };
 }
 async function readOptionalFile4(filePath) {
@@ -37900,7 +38265,7 @@ var init_commands2 = __esm({
       scope: ["cli"],
       handler: async ({ params }) => {
         const name = params.name;
-        const workflowPath = path57.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
+        const workflowPath = path59.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
         try {
           await unlink5(workflowPath);
         } catch (error2) {
@@ -38003,7 +38368,7 @@ var init_commands2 = __esm({
         return (await loadVariableStatuses(await resolveBuiltInAssetsDir(), projectGitHubWorkflowsDir(cwd))).map(
           (status) => ({
             ...status,
-            source: status.source === "built-in" ? status.source : path57.relative(cwd, status.source)
+            source: status.source === "built-in" ? status.source : path59.relative(cwd, status.source)
           })
         );
       },
@@ -38181,7 +38546,7 @@ var init_execution_context = __esm({
 });
 
 // src/sdk/launch.ts
-import path58 from "node:path";
+import path60 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 async function startLaunch(options) {
   const homeDir = resolveHomeDir(options.homeDir);
@@ -38287,7 +38652,7 @@ async function runLaunchDaemon(options) {
   });
 }
 function resolveLaunchBaseDir(homeDir) {
-  return path58.join(homeDir, ".poe-code", "launch");
+  return path60.join(homeDir, ".poe-code", "launch");
 }
 function resolveHomeDir(homeDir) {
   if (homeDir) {
@@ -38303,7 +38668,7 @@ function normalizeLaunchSpec(spec10, baseDir) {
   if (locator.scheme !== "local") {
     return spec10;
   }
-  const cwd = path58.isAbsolute(locator.path) ? locator.path : path58.resolve(baseDir, locator.path);
+  const cwd = path60.isAbsolute(locator.path) ? locator.path : path60.resolve(baseDir, locator.path);
   return {
     ...spec10,
     cwd
@@ -39280,15 +39645,15 @@ var init_renderer3 = __esm({
 });
 
 // packages/cmdkit/src/cli.ts
-import { access as access3, readFile as readFile19, writeFile as writeFile12 } from "node:fs/promises";
-import path60 from "node:path";
+import { access as access3, readFile as readFile19, writeFile as writeFile13 } from "node:fs/promises";
+import path62 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 "cmdkit";
   }
-  const parsed = path60.parse(entrypoint);
+  const parsed = path62.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "cmdkit";
 }
 function normalizeRoots2(roots, argv) {
@@ -39345,11 +39710,11 @@ function formatSegment2(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords2(segment).join(separator);
 }
-function toOptionFlag(path82, casing) {
-  return `--${path82.map((segment) => formatSegment2(segment, casing)).join(".")}`;
+function toOptionFlag(path84, casing) {
+  return `--${path84.map((segment) => formatSegment2(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path82, casing) {
-  return path82.map((segment) => {
+function toOptionAttribute(path84, casing) {
+  return path84.map((segment) => {
     const formatted = formatSegment2(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -39360,13 +39725,13 @@ function toOptionAttribute(path82, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath3(path82) {
-  return path82.join(".");
+function toDisplayPath3(path84) {
+  return path84.join(".");
 }
-function collectFields(schema, casing, path82 = [], inheritedOptional = false) {
+function collectFields(schema, casing, path84 = [], inheritedOptional = false) {
   const fields = [];
   for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path82, key];
+    const nextPath = [...path84, key];
     const optional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional3(rawChildSchema);
     if (childSchema.kind === "object") {
@@ -39389,9 +39754,9 @@ function collectFields(schema, casing, path82 = [], inheritedOptional = false) {
   }
   return fields;
 }
-function toCommanderOptionAttribute(path82, casing) {
-  const optionAttribute = toOptionAttribute(path82, casing);
-  const optionFlag = toOptionFlag(path82, casing);
+function toCommanderOptionAttribute(path84, casing) {
+  const optionAttribute = toOptionAttribute(path84, casing);
+  const optionFlag = toOptionFlag(path84, casing);
   if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
     return optionAttribute;
   }
@@ -39850,10 +40215,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, path82, value) {
+function setNestedValue(target, path84, value) {
   let cursor = target;
-  for (let index = 0; index < path82.length - 1; index += 1) {
-    const segment = path82[index] ?? "";
+  for (let index = 0; index < path84.length - 1; index += 1) {
+    const segment = path84[index] ?? "";
     const existing = cursor[segment];
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -39863,7 +40228,7 @@ function setNestedValue(target, path82, value) {
     cursor[segment] = next;
     cursor = next;
   }
-  const leaf = path82[path82.length - 1];
+  const leaf = path84[path84.length - 1];
   if (leaf !== void 0) {
     cursor[leaf] = value;
   }
@@ -39954,13 +40319,13 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs2() {
   return {
-    readFile: async (path82, encoding = "utf8") => readFile19(path82, { encoding }),
-    writeFile: async (path82, contents) => {
-      await writeFile12(path82, contents);
+    readFile: async (path84, encoding = "utf8") => readFile19(path84, { encoding }),
+    writeFile: async (path84, contents) => {
+      await writeFile13(path84, contents);
     },
-    exists: async (path82) => {
+    exists: async (path84) => {
       try {
-        await access3(path82);
+        await access3(path84);
         return true;
       } catch {
         return false;
@@ -39981,9 +40346,9 @@ function isPlainObject4(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path82) {
+function hasNestedField(fields, path84) {
   return fields.some(
-    (field) => path82.length < field.path.length && path82.every((segment, index) => field.path[index] === segment)
+    (field) => path84.length < field.path.length && path84.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -40070,9 +40435,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path82) {
+  function visitObject(current, path84) {
     for (const [key, value] of Object.entries(current)) {
-      const nextPath = [...path82, key];
+      const nextPath = [...path84, key];
       const displayPath2 = toDisplayPath3(nextPath);
       const field = fieldByPath.get(displayPath2);
       if (field !== void 0) {
@@ -40270,8 +40635,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path60.parse(commandPath);
-  return path60.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path62.parse(commandPath);
+  return path62.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector) {
   if (isNumericFixtureSelector(selector)) {
@@ -40990,7 +41355,7 @@ var init_agent2 = __esm({
 });
 
 // src/cli/commands/spawn.ts
-import path61 from "node:path";
+import path63 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));
@@ -41271,7 +41636,7 @@ async function resolvePromptInput(input, fs17, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("prompt @<path> requires a file path after '@'");
   }
-  const filePath = path61.isAbsolute(rawPath) ? rawPath : path61.join(baseDir, rawPath);
+  const filePath = path63.isAbsolute(rawPath) ? rawPath : path63.join(baseDir, rawPath);
   try {
     const contents = await fs17.readFile(filePath, "utf8");
     return contents.trim();
@@ -41292,7 +41657,7 @@ async function resolveMcpSpawnInput(input, fs17, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("--mcp-servers @<path> requires a file path after '@'");
   }
-  const filePath = path61.isAbsolute(rawPath) ? rawPath : path61.join(baseDir, rawPath);
+  const filePath = path63.isAbsolute(rawPath) ? rawPath : path63.join(baseDir, rawPath);
   try {
     return await fs17.readFile(filePath, "utf8");
   } catch (error2) {
@@ -42132,9 +42497,9 @@ var init_command_not_found = __esm({
 
 // src/cli/commands/utils-symlink-ops.ts
 import { dirname as dirname4 } from "node:path";
-async function tryLstat(fs17, path82) {
+async function tryLstat(fs17, path84) {
   try {
-    return await fs17.lstat(path82);
+    return await fs17.lstat(path84);
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -42185,13 +42550,13 @@ async function applySymlinkOps(fs17, ops, opts) {
   }
   return { conflicts };
 }
-async function isSymlinkPointingTo(fs17, path82, expectedTarget) {
+async function isSymlinkPointingTo(fs17, path84, expectedTarget) {
   try {
-    const stats = await fs17.lstat(path82);
+    const stats = await fs17.lstat(path84);
     if (!stats.isSymbolicLink()) {
       return false;
     }
-    return await fs17.readlink(path82) === expectedTarget;
+    return await fs17.readlink(path84) === expectedTarget;
   } catch (error2) {
     if (isNotFound(error2)) {
       return false;
@@ -42668,7 +43033,7 @@ var init_media_download = __esm({
 });
 
 // src/cli/commands/generate.ts
-import path62 from "node:path";
+import path64 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>",
@@ -42941,11 +43306,11 @@ function getDefaultMimeType(type) {
   return defaults[type];
 }
 function resolveOutputPath(filename, cwd) {
-  if (path62.isAbsolute(filename)) {
+  if (path64.isAbsolute(filename)) {
     return { path: filename, label: filename };
   }
   return {
-    path: path62.join(cwd, filename),
+    path: path64.join(cwd, filename),
     label: `./${filename}`
   };
 }
@@ -43546,10 +43911,10 @@ var init_shapes = __esm({
 });
 
 // packages/agent-mcp-config/src/apply.ts
-import path63 from "node:path";
+import path65 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml3 } from "yaml";
 function getConfigDirectory(configPath) {
-  return path63.dirname(configPath);
+  return path65.dirname(configPath);
 }
 function isConfigObject6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -43569,9 +43934,9 @@ function expandHomePath(configPath, homeDir) {
     return homeDir;
   }
   if (configPath.startsWith("~/")) {
-    return path63.join(homeDir, configPath.slice(2));
+    return path65.join(homeDir, configPath.slice(2));
   }
-  return path63.join(homeDir, configPath.slice(1));
+  return path65.join(homeDir, configPath.slice(1));
 }
 function parseYamlDocument2(content) {
   if (content.trim() === "") {
@@ -43604,7 +43969,7 @@ async function writeYamlConfig(configPath, document, options) {
     return;
   }
   const absolutePath = expandHomePath(configPath, options.homeDir);
-  const configDir = path63.dirname(absolutePath);
+  const configDir = path65.dirname(absolutePath);
   await options.fs.mkdir(configDir, { recursive: true });
   await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
     encoding: "utf8"
@@ -44875,8 +45240,8 @@ var init_dashboard_loop_shared = __esm({
 });
 
 // src/cli/commands/pipeline.ts
-import path64 from "node:path";
-import { readFile as readFile20, stat as stat17 } from "node:fs/promises";
+import path66 from "node:path";
+import { readFile as readFile20, stat as stat18 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 async function resolvePipelineCommandConfig(container) {
   const configDoc = await readMergedDocument(
@@ -44924,18 +45289,19 @@ function resolveMaxRuns(value) {
   return parsed;
 }
 function resolvePipelineInitSourcePath(container, sourcePath) {
-  const absolutePath = sourcePath.startsWith("~/") ? path64.join(container.env.homeDir, sourcePath.slice(2)) : path64.isAbsolute(sourcePath) ? sourcePath : path64.resolve(container.env.cwd, sourcePath);
+  const absolutePath = sourcePath.startsWith("~/") ? path66.join(container.env.homeDir, sourcePath.slice(2)) : path66.isAbsolute(sourcePath) ? sourcePath : path66.resolve(container.env.cwd, sourcePath);
   return {
     absolutePath,
     relativePath: sourcePath,
-    title: path64.basename(sourcePath, path64.extname(sourcePath))
+    title: path66.basename(sourcePath, path66.extname(sourcePath))
   };
 }
 function formatRunSummary(result) {
   const metrics = result.metrics;
   return [
     `Runs: ${result.runsCompleted}`,
-    `tasksCompleted: ${metrics.tasksCompleted}, tasksFailed: ${metrics.tasksFailed}, stepsCompleted: ${metrics.stepsCompleted}`,
+    `Tasks: ${metrics.tasksCompleted} completed, ${metrics.tasksFailed} failed`,
+    `Steps: ${metrics.stepsCompleted} completed`,
     `Total tokens: ${metrics.totalInputTokens} input, ${metrics.totalOutputTokens} output, ${metrics.totalCachedTokens} cached`,
     `Duration: ${formatDashboardDuration(result.totalDurationMs)}`
   ].join("\n   ");
@@ -44976,6 +45342,14 @@ function formatTaskCompleteMessage(progress) {
   if (progress.phase) {
     return `${progress.taskTitle} ${status} in ${duration}${usage}`;
   }
+  if (progress.stepName) {
+    if (progress.success && !progress.taskCompleted) {
+      return `Task ${progress.taskId} (${progress.stepName}) step done in ${duration}${usage}`;
+    }
+    if (!progress.success) {
+      return `Task ${progress.taskId} (${progress.stepName}) failed in ${duration}${usage}`;
+    }
+  }
   return `Task ${progress.taskId} ${status} in ${duration}${usage}`;
 }
 function formatDashboardCurrentAction(progress) {
@@ -45059,68 +45433,63 @@ async function streamAcpEventsToDashboard(options) {
 }
 function createPipelineDashboardRunAgent(options) {
   return async (input) => {
-    for (let attempt = 1; attempt <= 3; attempt += 1) {
-      const toolBuffer = createDashboardLineBuffer((line) => {
-        options.appendOutput("tool", `[${options.activeStage()}] ${line}`);
-      });
-      const errorBuffer = createDashboardLineBuffer((line) => {
-        options.appendOutput("error", `[${options.activeStage()}] ${line}`);
-      });
-      let sawStdout = false;
-      let sawStderr = false;
-      try {
-        const { events, result } = spawn7(input.agent, {
-          prompt: input.prompt,
-          cwd: input.cwd,
-          logDir: input.logDir,
-          model: input.model,
-          mode: input.mode,
-          ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
-          ...input.signal ? { signal: input.signal } : {},
-          tee: {
-            stdout: {
-              write(chunk) {
-                sawStdout = true;
-                toolBuffer.push(chunk);
-              }
-            },
-            stderr: {
-              write(chunk) {
-                sawStderr = true;
-                errorBuffer.push(chunk);
-              }
+    const toolBuffer = createDashboardLineBuffer((line) => {
+      options.appendOutput("tool", `[${options.activeStage()}] ${line}`);
+    });
+    const errorBuffer = createDashboardLineBuffer((line) => {
+      options.appendOutput("error", `[${options.activeStage()}] ${line}`);
+    });
+    let sawStdout = false;
+    let sawStderr = false;
+    try {
+      const { events, result } = spawn7(input.agent, {
+        prompt: input.prompt,
+        cwd: input.cwd,
+        logDir: input.logDir,
+        model: input.model,
+        mode: input.mode,
+        ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
+        ...input.signal ? { signal: input.signal } : {},
+        tee: {
+          stdout: {
+            write(chunk) {
+              sawStdout = true;
+              toolBuffer.push(chunk);
             }
           },
-          activityTimeoutMs: 10 * 60 * 1e3
-        });
-        const eventStream = streamAcpEventsToDashboard({
-          events,
-          onToolOutput(chunk) {
-            toolBuffer.push(chunk);
-          },
-          onErrorOutput(chunk) {
-            errorBuffer.push(chunk);
+          stderr: {
+            write(chunk) {
+              sawStderr = true;
+              errorBuffer.push(chunk);
+            }
           }
-        });
-        const [spawnResult, sawEvents] = await Promise.all([result, eventStream]);
-        if (!sawEvents && !sawStdout && spawnResult.stdout.length > 0) {
-          toolBuffer.push(spawnResult.stdout);
-        }
-        if (!sawStderr && spawnResult.stderr.length > 0) {
-          errorBuffer.push(spawnResult.stderr);
-        }
-        toolBuffer.flush();
-        errorBuffer.flush();
-        return spawnResult;
-      } catch (error2) {
-        toolBuffer.flush();
-        errorBuffer.flush();
-        if (!isActivityTimeoutError(error2) || attempt === 3) {
-          throw error2;
+        },
+        activityTimeoutMs: 10 * 60 * 1e3
+      });
+      const eventStream = streamAcpEventsToDashboard({
+        events,
+        onToolOutput(chunk) {
+          toolBuffer.push(chunk);
+        },
+        onErrorOutput(chunk) {
+          errorBuffer.push(chunk);
         }
+      });
+      const [spawnResult, sawEvents] = await Promise.all([result, eventStream]);
+      if (!sawEvents && !sawStdout && spawnResult.stdout.length > 0) {
+        toolBuffer.push(spawnResult.stdout);
+      }
+      if (!sawStderr && spawnResult.stderr.length > 0) {
+        errorBuffer.push(spawnResult.stderr);
       }
+      toolBuffer.flush();
+      errorBuffer.flush();
+      return spawnResult;
+    } catch (error2) {
+      toolBuffer.flush();
+      errorBuffer.flush();
+      throw error2;
     }
-    throw new Error("Unreachable");
   };
 }
 function dashboardStatusForResult(result) {
@@ -45145,15 +45514,18 @@ async function runPipelineWithDashboard(options) {
   let currentAction;
   let currentStage = "pipeline";
   let status = "running";
+  let waitingForLock = false;
   const syncStats = () => {
-    dashboard.updateStats({
+    const stats = {
       status,
       iterations,
+      iterationsLabel: "Tasks",
       tokensIn,
       tokensOut,
       elapsedMs: Math.max(0, Date.now() - startedAt),
       ...currentAction ? { currentAction } : {}
-    });
+    };
+    dashboard.updateStats(stats);
   };
   const appendOutput = (kind, message2) => {
     dashboard.appendOutput({
@@ -45196,6 +45568,17 @@ async function runPipelineWithDashboard(options) {
       onPlanReloadError(error2) {
         appendOutput("error", `Plan reload failed, using last good state: ${error2.message}`);
       },
+      onLockStatusChange(lockStatus) {
+        appendOutput("status", lockStatus.message);
+        if (lockStatus.state === "waiting") {
+          waitingForLock = true;
+          currentAction = lockStatus.message;
+        } else if (waitingForLock) {
+          waitingForLock = false;
+          currentAction = void 0;
+        }
+        syncStats();
+      },
       onPlanResolved(summary) {
         appendOutput(
           "info",
@@ -45217,7 +45600,9 @@ async function runPipelineWithDashboard(options) {
         syncStats();
       },
       onTaskComplete(progress) {
-        iterations += 1;
+        if (progress.taskCompleted) {
+          iterations += 1;
+        }
         if (progress.usage) {
           tokensIn += progress.usage.inputTokens;
           tokensOut += progress.usage.outputTokens;
@@ -45243,13 +45628,18 @@ async function runPipelineWithDashboard(options) {
   }
 }
 function resolvePipelinePaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path64.join(homeDir, ".poe-code", "pipeline") : path64.join(cwd, ".poe-code", "pipeline");
+  const rootPath = scope === "global" ? path66.join(homeDir, ".poe-code", "pipeline") : path66.join(cwd, ".poe-code", "pipeline");
   const displayRoot = scope === "global" ? "~/.poe-code/pipeline" : ".poe-code/pipeline";
+  const stepsDirectoryPath = path66.join(rootPath, "steps");
   return {
-    plansPath: path64.join(rootPath, "plans"),
-    stepsPath: path64.join(rootPath, "steps.yaml"),
+    plansPath: path66.join(rootPath, "plans"),
+    stepsDirectoryPath,
+    defaultStepsPath: path66.join(stepsDirectoryPath, "default.yaml"),
+    legacyStepsPath: path66.join(rootPath, "steps.yaml"),
     displayPlansPath: `${displayRoot}/plans`,
-    displayStepsPath: `${displayRoot}/steps.yaml`
+    displayStepsDirectoryPath: `${displayRoot}/steps`,
+    displayDefaultStepsPath: `${displayRoot}/steps/default.yaml`,
+    displayLegacyStepsPath: `${displayRoot}/steps.yaml`
   };
 }
 async function loadPipelineTemplates() {
@@ -45258,16 +45648,16 @@ async function loadPipelineTemplates() {
   }
   const packageRoot = await findPackageRoot3(fileURLToPath9(import.meta.url));
   const templateRoots = [
-    path64.join(packageRoot, "src", "templates", "pipeline"),
-    path64.join(packageRoot, "dist", "templates", "pipeline")
+    path66.join(packageRoot, "src", "templates", "pipeline"),
+    path66.join(packageRoot, "dist", "templates", "pipeline")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk(templateRoot)) {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile20(path64.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile20(path64.join(templateRoot, "steps.yaml.mustache"), "utf8")
+      readFile20(path66.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile20(path66.join(templateRoot, "steps.yaml.mustache"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -45276,7 +45666,7 @@ async function loadPipelineTemplates() {
 }
 async function pathExistsOnDisk(targetPath) {
   try {
-    await stat17(targetPath);
+    await stat18(targetPath);
     return true;
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
@@ -45286,12 +45676,12 @@ async function pathExistsOnDisk(targetPath) {
   }
 }
 async function findPackageRoot3(entryFilePath) {
-  let currentPath = path64.dirname(entryFilePath);
+  let currentPath = path66.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk(path64.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk(path66.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path64.dirname(currentPath);
+    const parentPath = path66.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Pipeline templates.");
     }
@@ -45407,6 +45797,9 @@ function registerPipelineCommand(program, container) {
               `Plan reload failed, using last good state: ${error2.message}`
             );
           },
+          onLockStatusChange(lockStatus) {
+            resources.logger.info(lockStatus.message);
+          },
           onPlanResolved(summary2) {
             resources.logger.resolved(
               "Config",
@@ -45463,11 +45856,7 @@ function registerPipelineCommand(program, container) {
   });
   pipeline.command("init").description("Initialize pipeline plans from source Markdown docs.").argument("[question]", "Optional user question to forward to the plan generator").option("--agent <name>", "Agent to generate the plan with").option("--model <model>", "Model override passed to the agent").option("--source <path>", "Single source Markdown doc to convert").option("--sources <paths...>", "Multiple source Markdown docs to convert").action(async function(question) {
     const flags = resolveCommandFlags(program);
-    const resources = createExecutionResources(
-      container,
-      flags,
-      "pipeline:init"
-    );
+    const resources = createExecutionResources(container, flags, "pipeline:init");
     const options = this.opts();
     resources.logger.intro("pipeline init");
     try {
@@ -45499,7 +45888,6 @@ function registerPipelineCommand(program, container) {
         }
         agent2 = resolvePipelineAgent(selected);
       }
-      const commandConfig = await resolvePipelineCommandConfig(container);
       if (options.source && sourcePaths && sourcePaths.length > 0) {
         throw new ValidationError("Use either --source or --sources, not both.");
       }
@@ -45532,7 +45920,9 @@ function registerPipelineCommand(program, container) {
           return;
         }
         const selectedSourcePaths = Array.isArray(selected) ? new Set(selected) : /* @__PURE__ */ new Set();
-        sources = discoveredSources.filter((source) => selectedSourcePaths.has(source.relativePath));
+        sources = discoveredSources.filter(
+          (source) => selectedSourcePaths.has(source.relativePath)
+        );
         if (sources.length === 0) {
           return;
         }
@@ -45541,7 +45931,6 @@ function registerPipelineCommand(program, container) {
         agent: agent2,
         cwd: container.env.cwd,
         homeDir: container.env.homeDir,
-        ...commandConfig.planDirectory ? { planDirectory: commandConfig.planDirectory } : {},
         ...options.model ? { model: options.model } : {},
         ...resolvedQuestion ? { question: resolvedQuestion } : {},
         sources,
@@ -45581,35 +45970,46 @@ function registerPipelineCommand(program, container) {
         container.env.homeDir
       );
       const content = await container.fs.readFile(absolutePath, "utf8");
+      const draftPlan = parsePlan(content);
       const steps = await loadResolvedSteps({
         cwd: container.env.cwd,
         homeDir: container.env.homeDir,
-        fs: container.fs
+        fs: container.fs,
+        name: draftPlan.extends,
+        stepOverrides: draftPlan.stepOverrides
       });
-      const hasSteps = Object.keys(steps.steps).length > 0;
-      const plan = parsePlan(content, hasSteps ? { availableSteps: steps.steps } : {});
+      const plan = parsePlan(content, { availableSteps: steps.steps });
       const total = plan.tasks.length;
       const done = plan.tasks.filter((t) => {
         if (typeof t.status === "string") return t.status === "done";
         return Object.values(t.status).every((s) => s === "done");
       }).length;
+      const readFile34 = container.fs.readFile.bind(container.fs);
+      const resolvedVars = await resolvePipelineVars(
+        plan.vars ?? {},
+        container.env.cwd,
+        readFile34
+      );
+      const resolvedSetup = plan.setup === null ? void 0 : plan.setup ?? steps.setup;
+      const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? steps.teardown;
+      validateResolvedPromptVars({
+        plan,
+        steps: steps.steps,
+        planPath: file,
+        vars: resolvedVars,
+        setup: resolvedSetup,
+        teardown: resolvedTeardown
+      });
       resources.logger.resolved("Plan", file);
       resources.logger.resolved("Tasks", `${total} tasks (${done} done)`);
-      if (hasSteps) {
+      if (Object.keys(steps.steps).length > 0) {
         resources.logger.resolved("Steps", Object.keys(steps.steps).join(", "));
       }
       resources.logger.success("Plan is valid.");
       const opts = this.opts();
       if (opts.preview) {
-        const readFile34 = container.fs.readFile.bind(container.fs);
-        const resolvedVars = {};
-        for (const [key, value] of Object.entries(plan.vars ?? {})) {
-          resolvedVars[key] = await resolveFileIncludes(value, container.env.cwd, readFile34);
-        }
-        const resolvedSetup = plan.setup === null ? void 0 : plan.setup ?? steps.setup;
-        const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? steps.teardown;
         if (resolvedSetup) {
-          const raw = Object.keys(resolvedVars).length > 0 ? interpolate(resolvedSetup.prompt, resolvedVars) : resolvedSetup.prompt;
+          const raw = interpolatePipelineVars(resolvedSetup.prompt, resolvedVars, "setup");
           const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile34);
           resources.logger.resolved("setup", expanded);
         }
@@ -45643,7 +46043,7 @@ function registerPipelineCommand(program, container) {
           }
         }
         if (resolvedTeardown) {
-          const raw = Object.keys(resolvedVars).length > 0 ? interpolate(resolvedTeardown.prompt, resolvedVars) : resolvedTeardown.prompt;
+          const raw = interpolatePipelineVars(resolvedTeardown.prompt, resolvedVars, "teardown");
           const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile34);
           resources.logger.resolved("teardown", expanded);
         }
@@ -45662,7 +46062,7 @@ function registerPipelineCommand(program, container) {
     process.stdout.write(`${resolvedPath}
 `);
   });
-  pipeline.command("install").description("Install the Pipeline /plan skill and scaffold pipeline files.").option("--agent <name>", "Agent to install the Pipeline skill for").option("--local", "Install project-local skill and pipeline files").option("--global", "Install user-global skill and pipeline files").option("--force", "Overwrite an existing steps.yaml scaffold").action(async function() {
+  pipeline.command("install").description("Install the Pipeline /plan skill and scaffold pipeline files.").option("--agent <name>", "Agent to install the Pipeline skill for").option("--local", "Install project-local skill and pipeline files").option("--global", "Install user-global skill and pipeline files").option("--force", "Overwrite an existing default step config scaffold").action(async function() {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(container, flags, "pipeline:install");
     const options = this.opts();
@@ -45747,22 +46147,39 @@ function registerPipelineCommand(program, container) {
           resources.logger.info(`Create: ${pipelinePaths.displayPlansPath}`);
         }
       }
-      const stepsExists = await pathExists5(container.fs, pipelinePaths.stepsPath);
+      const legacyStepsExists = await pathExists5(container.fs, pipelinePaths.legacyStepsPath);
+      let stepsExists = await pathExists5(container.fs, pipelinePaths.defaultStepsPath);
+      if (legacyStepsExists && !stepsExists) {
+        if (flags.dryRun) {
+          resources.logger.dryRun(
+            `Would rename: ${pipelinePaths.displayLegacyStepsPath} -> ${pipelinePaths.displayDefaultStepsPath}`
+          );
+        } else {
+          await container.fs.mkdir(pipelinePaths.stepsDirectoryPath, {
+            recursive: true
+          });
+          await container.fs.rename(pipelinePaths.legacyStepsPath, pipelinePaths.defaultStepsPath);
+          resources.logger.info(
+            `Rename: ${pipelinePaths.displayLegacyStepsPath} -> ${pipelinePaths.displayDefaultStepsPath}`
+          );
+        }
+        stepsExists = true;
+      }
       if (stepsExists && !options.force) {
-        resources.logger.info(`Skip: ${pipelinePaths.displayStepsPath} (already exists)`);
+        resources.logger.info(`Skip: ${pipelinePaths.displayDefaultStepsPath} (already exists)`);
       } else if (flags.dryRun) {
         resources.logger.dryRun(
-          `Would ${stepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayStepsPath}`
+          `Would ${stepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayDefaultStepsPath}`
         );
       } else {
-        await container.fs.mkdir(path64.dirname(pipelinePaths.stepsPath), {
+        await container.fs.mkdir(path66.dirname(pipelinePaths.defaultStepsPath), {
           recursive: true
         });
-        await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
+        await container.fs.writeFile(pipelinePaths.defaultStepsPath, templates.steps, {
           encoding: "utf8"
         });
         resources.logger.info(
-          `${stepsExists ? "Overwrite" : "Create"}: ${pipelinePaths.displayStepsPath}`
+          `${stepsExists ? "Overwrite" : "Create"}: ${pipelinePaths.displayDefaultStepsPath}`
         );
       }
       resources.context.complete({
@@ -45798,7 +46215,7 @@ var init_pipeline3 = __esm({
 });
 
 // src/cli/commands/ralph.ts
-import path65 from "node:path";
+import path67 from "node:path";
 function formatRalphAgentSummary(agent2) {
   return Array.isArray(agent2) ? agent2.join(", ") : agent2;
 }
@@ -45979,9 +46396,9 @@ function normalizeConfiguredIterations(value) {
 }
 function resolveAbsoluteDocPath(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path65.join(container.env.homeDir, docPath.slice(2));
+    return path67.join(container.env.homeDir, docPath.slice(2));
   }
-  return path65.isAbsolute(docPath) ? docPath : path65.resolve(container.env.cwd, docPath);
+  return path67.isAbsolute(docPath) ? docPath : path67.resolve(container.env.cwd, docPath);
 }
 async function resolveRalphCommandConfig(container) {
   const configDoc = await readMergedDocument(
@@ -46360,11 +46777,11 @@ var init_ralph3 = __esm({
 });
 
 // src/cli/commands/experiment.ts
-import path66 from "node:path";
-import { readFile as readFile21, stat as stat18 } from "node:fs/promises";
+import path68 from "node:path";
+import { readFile as readFile21, stat as stat19 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path66.join(homeDir, ".poe-code", "experiments") : path66.join(cwd, ".poe-code", "experiments");
+  const rootPath = scope === "global" ? path68.join(homeDir, ".poe-code", "experiments") : path68.join(cwd, ".poe-code", "experiments");
   const displayRoot = scope === "global" ? "~/.poe-code/experiments" : ".poe-code/experiments";
   return {
     experimentsPath: rootPath,
@@ -46373,7 +46790,7 @@ function resolveExperimentPaths(scope, cwd, homeDir) {
 }
 async function pathExistsOnDisk2(targetPath) {
   try {
-    await stat18(targetPath);
+    await stat19(targetPath);
     return true;
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
@@ -46383,12 +46800,12 @@ async function pathExistsOnDisk2(targetPath) {
   }
 }
 async function findPackageRoot4(entryFilePath) {
-  let currentPath = path66.dirname(entryFilePath);
+  let currentPath = path68.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk2(path66.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk2(path68.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path66.dirname(currentPath);
+    const parentPath = path68.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Experiment templates.");
     }
@@ -46401,16 +46818,16 @@ async function loadExperimentTemplates() {
   }
   const packageRoot = await findPackageRoot4(fileURLToPath10(import.meta.url));
   const templateRoots = [
-    path66.join(packageRoot, "src", "templates", "experiment"),
-    path66.join(packageRoot, "dist", "templates", "experiment")
+    path68.join(packageRoot, "src", "templates", "experiment"),
+    path68.join(packageRoot, "dist", "templates", "experiment")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk2(templateRoot)) {
       continue;
     }
     const [skillPlan, runYaml] = await Promise.all([
-      readFile21(path66.join(templateRoot, "SKILL_experiment.md"), "utf8"),
-      readFile21(path66.join(templateRoot, "run.yaml.mustache"), "utf8")
+      readFile21(path68.join(templateRoot, "SKILL_experiment.md"), "utf8"),
+      readFile21(path68.join(templateRoot, "run.yaml.mustache"), "utf8")
     ]);
     experimentTemplatesCache = { skillPlan, runYaml };
     return experimentTemplatesCache;
@@ -47095,8 +47512,8 @@ function registerExperimentCommand(program, container) {
           resources.logger.info(`Create: ${experimentPaths.displayExperimentsPath}`);
         }
       }
-      const runYamlPath = path66.join(experimentPaths.experimentsPath, "run.yaml");
-      const runYamlDisplayPath = path66.join(experimentPaths.displayExperimentsPath, "run.yaml");
+      const runYamlPath = path68.join(experimentPaths.experimentsPath, "run.yaml");
+      const runYamlDisplayPath = path68.join(experimentPaths.displayExperimentsPath, "run.yaml");
       if (!await pathExists6(container.fs, runYamlPath)) {
         if (flags.dryRun) {
           resources.logger.dryRun(`Would create: ${runYamlDisplayPath}`);
@@ -47559,9 +47976,9 @@ var init_launch2 = __esm({
 });
 
 // packages/memory/src/paths.ts
-import path67 from "node:path";
+import path69 from "node:path";
 function resolveMemoryRoot(cwd) {
-  return path67.resolve(cwd, ".poe-code", "memory");
+  return path69.resolve(cwd, ".poe-code", "memory");
 }
 function assertSafeRelPath(input) {
   const trimmed = input.trim();
@@ -47569,10 +47986,10 @@ function assertSafeRelPath(input) {
     throw new MemoryPathError("Expected a non-empty relative path.");
   }
   const slashNormalized = trimmed.replaceAll("\\", "/");
-  if (path67.posix.isAbsolute(slashNormalized) || path67.win32.isAbsolute(slashNormalized)) {
+  if (path69.posix.isAbsolute(slashNormalized) || path69.win32.isAbsolute(slashNormalized)) {
     throw new MemoryPathError(`Expected a relative path, received absolute path "${input}".`);
   }
-  const normalized = path67.posix.normalize(slashNormalized);
+  const normalized = path69.posix.normalize(slashNormalized);
   if (normalized === "." || normalized.length === 0) {
     throw new MemoryPathError("Expected a relative path to a file or directory.");
   }
@@ -47602,11 +48019,11 @@ var init_paths2 = __esm({
 
 // packages/memory/src/init.ts
 import * as fs4 from "node:fs/promises";
-import path68 from "node:path";
+import path70 from "node:path";
 async function initMemory(root) {
-  await fs4.mkdir(path68.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
-  await writeFileIfMissing(path68.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
-  await writeFileIfMissing(path68.join(root, MEMORY_LOG_RELPATH), "");
+  await fs4.mkdir(path70.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
+  await writeFileIfMissing(path70.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
+  await writeFileIfMissing(path70.join(root, MEMORY_LOG_RELPATH), "");
 }
 async function writeFileIfMissing(filePath, content) {
   try {
@@ -47628,7 +48045,7 @@ var init_init = __esm({
 });
 
 // packages/memory/src/frontmatter.ts
-import { parse as parse11, stringify as stringify5 } from "yaml";
+import { parse as parse11, stringify as stringify4 } from "yaml";
 function parseFrontmatter4(markdown) {
   const content = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
   const openingLineBreak = readOpeningLineBreak5(content);
@@ -47790,10 +48207,10 @@ function parseSources(value) {
     if (!isRecord20(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path82 = readRequiredString(item.path, "sources[].path");
+    const path84 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path82, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path84, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString3(value, field) {
@@ -47837,7 +48254,7 @@ var init_frontmatter5 = __esm({
 
 // packages/memory/src/pages.ts
 import * as fs5 from "node:fs/promises";
-import path69 from "node:path";
+import path71 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)));
@@ -47845,8 +48262,8 @@ async function listPages(root) {
 }
 async function readPage(root, relPath) {
   const normalizedRelPath = assertMarkdownRelPath(relPath);
-  const absPath = path69.join(root, normalizedRelPath);
-  const [content, stat23] = await Promise.all([fs5.readFile(absPath, "utf8"), fs5.stat(absPath)]);
+  const absPath = path71.join(root, normalizedRelPath);
+  const [content, stat24] = await Promise.all([fs5.readFile(absPath, "utf8"), fs5.stat(absPath)]);
   try {
     const parsed = parseFrontmatter4(content);
     return {
@@ -47854,7 +48271,7 @@ async function readPage(root, relPath) {
       frontmatter: parsed.frontmatter,
       body: parsed.body,
       bytes: Buffer.byteLength(content),
-      mtimeMs: stat23.mtimeMs
+      mtimeMs: stat24.mtimeMs
     };
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
@@ -47864,7 +48281,7 @@ async function readPage(root, relPath) {
       frontmatter: {},
       body: content,
       bytes: Buffer.byteLength(content),
-      mtimeMs: stat23.mtimeMs
+      mtimeMs: stat24.mtimeMs
     };
   }
 }
@@ -47874,7 +48291,7 @@ async function collectMarkdownRelPaths(root, startRelPath = "") {
   return relPaths.sort((left, right) => left.localeCompare(right));
 }
 async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
-  const absPath = path69.join(root, currentRelPath);
+  const absPath = path71.join(root, currentRelPath);
   let entryNames;
   try {
     entryNames = await fs5.readdir(absPath);
@@ -47885,8 +48302,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 : path69.posix.join(currentRelPath, entryName);
-    const entryAbsPath = path69.join(root, entryRelPath);
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path71.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path71.join(root, entryRelPath);
     const entryStat = await fs5.stat(entryAbsPath);
     if (entryStat.isDirectory()) {
       if (entryName === MEMORY_CACHE_DIR_RELPATH) {
@@ -47916,7 +48333,7 @@ function assertMarkdownRelPath(relPath) {
   return normalizedRelPath;
 }
 function isMarkdownPath(relPath) {
-  return path69.posix.extname(relPath).toLowerCase() === ".md";
+  return path71.posix.extname(relPath).toLowerCase() === ".md";
 }
 function isMissing(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
@@ -47931,7 +48348,7 @@ var init_pages = __esm({
 
 // packages/memory/src/search.ts
 import * as fs6 from "node:fs/promises";
-import path70 from "node:path";
+import path72 from "node:path";
 async function searchMemory(root, query) {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) {
@@ -47940,7 +48357,7 @@ async function searchMemory(root, query) {
   const relPaths = await collectMarkdownRelPaths(root);
   const hits = [];
   for (const relPath of relPaths) {
-    const content = await fs6.readFile(path70.join(root, relPath), "utf8");
+    const content = await fs6.readFile(path72.join(root, relPath), "utf8");
     if (content.length === 0) {
       continue;
     }
@@ -47967,7 +48384,7 @@ var init_search = __esm({
 
 // packages/memory/src/status.ts
 import * as fs7 from "node:fs/promises";
-import path71 from "node:path";
+import path73 from "node:path";
 async function statusOf(root) {
   if (!await pathExists7(root)) {
     return {
@@ -47984,9 +48401,9 @@ async function statusOf(root) {
   let totalBytes = 0;
   let lastWriteAtMs = Number.NEGATIVE_INFINITY;
   for (const relPath of markdownRelPaths) {
-    const stat23 = await fs7.stat(path71.join(root, relPath));
-    totalBytes += stat23.size;
-    lastWriteAtMs = Math.max(lastWriteAtMs, stat23.mtimeMs);
+    const stat24 = await fs7.stat(path73.join(root, relPath));
+    totalBytes += stat24.size;
+    lastWriteAtMs = Math.max(lastWriteAtMs, stat24.mtimeMs);
   }
   return {
     pageCount: pageRelPaths.length,
@@ -48016,8 +48433,8 @@ var init_status = __esm({
 
 // packages/memory/src/lock.ts
 import * as fsPromises18 from "node:fs/promises";
-import path72 from "node:path";
-function createDefaultFs12() {
+import path74 from "node:path";
+function createDefaultFs13() {
   return {
     readFile: (filePath, encoding) => fsPromises18.readFile(filePath, encoding),
     unlink: fsPromises18.unlink,
@@ -48074,8 +48491,8 @@ async function readLockPid(fs17, lockPath) {
   }
 }
 async function withLock(root, run, options = {}) {
-  const fs17 = options.fs ?? createDefaultFs12();
-  const lockPath = path72.join(root, MEMORY_LOCK_RELPATH);
+  const fs17 = options.fs ?? createDefaultFs13();
+  const lockPath = path74.join(root, MEMORY_LOCK_RELPATH);
   const pid = options.pid ?? process.pid;
   const retries = options.retries ?? 20;
   const minTimeoutMs = options.minTimeoutMs ?? 25;
@@ -48127,7 +48544,7 @@ var init_confidence = __esm({
 // packages/memory/src/reconcile.ts
 import { createHash } from "node:crypto";
 import * as fs8 from "node:fs/promises";
-import path73 from "node:path";
+import path75 from "node:path";
 var init_reconcile = __esm({
   "packages/memory/src/reconcile.ts"() {
     "use strict";
@@ -48141,7 +48558,7 @@ var init_reconcile = __esm({
 
 // packages/memory/src/write.ts
 import * as fs9 from "node:fs/promises";
-import path74 from "node:path";
+import path76 from "node:path";
 async function clearMemory(root) {
   await withLock(root, async () => {
     await removeChildren(root);
@@ -48153,13 +48570,13 @@ async function removeChildren(directoryPath) {
     if (entryName === MEMORY_LOCK_RELPATH) {
       continue;
     }
-    const entryPath = path74.join(directoryPath, entryName);
-    const stat23 = await fs9.stat(entryPath);
-    if (stat23.isDirectory()) {
+    const entryPath = path76.join(directoryPath, entryName);
+    const stat24 = await fs9.stat(entryPath);
+    if (stat24.isDirectory()) {
       await removeDirectory3(entryPath);
       continue;
     }
-    if (stat23.isFile()) {
+    if (stat24.isFile()) {
       await fs9.unlink(entryPath);
     }
   }
@@ -48181,7 +48598,7 @@ var init_write2 = __esm({
 
 // packages/memory/src/edit.ts
 import * as fs10 from "node:fs/promises";
-import path75 from "node:path";
+import path77 from "node:path";
 var init_edit = __esm({
   "packages/memory/src/edit.ts"() {
     "use strict";
@@ -48192,7 +48609,7 @@ var init_edit = __esm({
 
 // packages/memory/src/audit.ts
 import * as fs11 from "node:fs/promises";
-import path76 from "node:path";
+import path78 from "node:path";
 var init_audit = __esm({
   "packages/memory/src/audit.ts"() {
     "use strict";
@@ -48205,7 +48622,7 @@ var init_audit = __esm({
 // packages/memory/src/cache.ts
 import { createHash as createHash2 } from "node:crypto";
 import * as fs12 from "node:fs/promises";
-import path77 from "node:path";
+import path79 from "node:path";
 var init_cache = __esm({
   "packages/memory/src/cache.ts"() {
     "use strict";
@@ -48312,7 +48729,7 @@ var init_src28 = __esm({
 
 // packages/memory/src/tokens.ts
 import * as fs13 from "node:fs/promises";
-import path78 from "node:path";
+import path80 from "node:path";
 async function computeTokenStats(root) {
   if (!await pathExists8(root)) {
     return {
@@ -48334,11 +48751,11 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path78.resolve(root, "..", "..");
+  const repoRoot = path80.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
-    const absPath = path78.isAbsolute(sourcePath) ? sourcePath : path78.resolve(repoRoot, sourcePath);
+    const absPath = path80.isAbsolute(sourcePath) ? sourcePath : path80.resolve(repoRoot, sourcePath);
     try {
       const content = await fs13.readFile(absPath, "utf8");
       sourceTokens += countTokens(content);
@@ -48383,7 +48800,7 @@ var init_tokens2 = __esm({
 
 // packages/memory/src/ingest.ts
 import * as fs14 from "node:fs/promises";
-import path79 from "node:path";
+import path81 from "node:path";
 var init_ingest = __esm({
   "packages/memory/src/ingest.ts"() {
     "use strict";
@@ -48418,7 +48835,7 @@ var init_install3 = __esm({
 
 // packages/memory/src/query.ts
 import * as fs15 from "node:fs/promises";
-import path80 from "node:path";
+import path82 from "node:path";
 var init_query = __esm({
   "packages/memory/src/query.ts"() {
     "use strict";
@@ -48474,7 +48891,7 @@ var init_src29 = __esm({
 });
 
 // src/cli/commands/memory.ts
-import path81 from "node:path";
+import path83 from "node:path";
 import * as fs16 from "node:fs/promises";
 function resolvePageRelPath(input) {
   const trimmed = input.trim();
@@ -48482,7 +48899,7 @@ function resolvePageRelPath(input) {
     throw new ValidationError("Missing page path.");
   }
   const normalized = trimmed.replaceAll("\\", "/");
-  const withExt = path81.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
+  const withExt = path83.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
   return withExt.startsWith("pages/") ? withExt : `pages/${withExt}`;
 }
 function displayPageRelPath(relPath) {
@@ -48520,8 +48937,8 @@ function registerMemoryCommand(program, container) {
     }
     await initMemory(root);
     resources.context.complete({
-      success: `Initialized memory at ${path81.relative(container.env.cwd, root)}`,
-      dry: `Would initialize memory at ${path81.relative(container.env.cwd, root)}`
+      success: `Initialized memory at ${path83.relative(container.env.cwd, root)}`,
+      dry: `Would initialize memory at ${path83.relative(container.env.cwd, root)}`
     });
     resources.context.finalize();
   });
@@ -48551,7 +48968,7 @@ function registerMemoryCommand(program, container) {
     resources.logger.intro("memory show");
     await assertInitialized(root);
     const relPath = resolvePageRelPath(pagePath);
-    const absPath = path81.join(root, relPath);
+    const absPath = path83.join(root, relPath);
     try {
       const content = await fs16.readFile(absPath, "utf8");
       process.stdout.write(content.endsWith("\n") ? content : `${content}
@@ -48649,7 +49066,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.183",
+      version: "3.0.184",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -48864,22 +49281,22 @@ function formatCommandHeader(cmd) {
   }
   return `Poe - ${parts.reverse().join(" ")}`;
 }
-function findCommandByPath(root, path82) {
+function findCommandByPath(root, path84) {
   let current = root;
-  for (const segment of path82) {
+  for (const segment of path84) {
     const next = current.commands.find(
       (command) => Reflect.get(command, "_hidden") !== true && command.name() === segment
     );
     if (!next) {
-      throw new Error(`Root help command is missing: ${path82.join(" ")}`);
+      throw new Error(`Root help command is missing: ${path84.join(" ")}`);
     }
     current = next;
   }
   return current;
 }
-function formatRootHelpCommandName(path82, command) {
+function formatRootHelpCommandName(path84, command) {
   const leaf = [command.name(), ...command.aliases()].join(", ");
-  return path82.length > 1 ? [...path82.slice(0, -1), leaf].join(" ") : leaf;
+  return path84.length > 1 ? [...path84.slice(0, -1), leaf].join(" ") : leaf;
 }
 function splitUsageParts(usage) {
   return usage.split(" ").map((part) => part.trim()).filter((part) => part.length > 0);
@@ -49546,7 +49963,7 @@ init_config3();
 init_constants();
 init_errors2();
 import os7 from "node:os";
-import path59 from "node:path";
+import path61 from "node:path";
 import fsPromises17 from "node:fs/promises";
 import { Command } from "commander";
 function parseMcpSpawnConfig(input) {
@@ -49618,10 +50035,10 @@ function resolveWorkingDirectory(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path59.isAbsolute(candidate)) {
+  if (path61.isAbsolute(candidate)) {
     return candidate;
   }
-  return path59.resolve(baseDir, candidate);
+  return path61.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(