poe-code 3.0.92 → 3.0.94

package/dist/index.js

@@ -988,16 +988,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path22) {
-  const ext = getExtension(path22);
+function detectFormat(path26) {
+  const ext = getExtension(path26);
   return extensionMap[ext];
 }
-function getExtension(path22) {
-  const lastDot = path22.lastIndexOf(".");
+function getExtension(path26) {
+  const lastDot = path26.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path22.slice(lastDot).toLowerCase();
+  return path26.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -1328,8 +1328,8 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
-    const stat4 = await context.fs.stat(targetPath);
-    const currentMode = typeof stat4.mode === "number" ? stat4.mode & 511 : null;
+    const stat8 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat8.mode === "number" ? stat8.mode & 511 : null;
     if (currentMode === mutation.mode) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
@@ -1740,38 +1740,38 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path22, encoding) {
+    async readFile(path26, encoding) {
       if (encoding) {
-        return base.readFile(path22, encoding);
+        return base.readFile(path26, encoding);
       }
-      return base.readFile(path22);
+      return base.readFile(path26);
     },
-    async writeFile(path22, data, options) {
-      const previousContent = await tryReadText(base, path22);
+    async writeFile(path26, data, options) {
+      const previousContent = await tryReadText(base, path26);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path22,
+        path: path26,
         nextContent,
         previousContent
       });
     },
-    async mkdir(path22, options) {
-      recorder.record({ type: "mkdir", path: path22, options });
+    async mkdir(path26, options) {
+      recorder.record({ type: "mkdir", path: path26, options });
     },
-    async stat(path22) {
-      return base.stat(path22);
+    async stat(path26) {
+      return base.stat(path26);
     },
-    async unlink(path22) {
-      recorder.record({ type: "unlink", path: path22 });
+    async unlink(path26) {
+      recorder.record({ type: "unlink", path: path26 });
     },
-    async readdir(path22) {
-      return base.readdir(path22);
+    async readdir(path26) {
+      return base.readdir(path26);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path22, options) => {
-      recorder.record({ type: "rm", path: path22, options });
+    proxy.rm = async (path26, options) => {
+      recorder.record({ type: "rm", path: path26, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -1861,8 +1861,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path22, change) {
-  const command = `cat > ${path22}`;
+function renderWriteCommand(path26, change) {
+  const command = `cat > ${path26}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -2024,9 +2024,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path22) {
+async function tryReadText(base, path26) {
   try {
-    return await base.readFile(path22, "utf8");
+    return await base.readFile(path26, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -3993,21 +3993,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 path22;
+        let path26;
         if (typeof item.content === "string") {
-          path22 = item.content;
+          path26 = item.content;
         } else {
           try {
-            path22 = JSON.stringify(item.content);
+            path26 = JSON.stringify(item.content);
           } catch {
-            path22 = String(item.content);
+            path26 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path22
+          path: path26
         };
       }
     }
@@ -4129,10 +4129,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 = isNonEmptyString2(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString2(item.server) ? item.server : "unknown"}.${isNonEmptyString2(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path22 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path26 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path22 };
+        yield { event: "tool_complete", id: item.id, kind, path: path26 };
       }
     }
   }
@@ -6045,21 +6045,21 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path22, encoding) => {
+    readFile: ((path26, encoding) => {
       if (encoding) {
-        return fs2.readFile(path22, encoding);
+        return fs2.readFile(path26, encoding);
       }
-      return fs2.readFile(path22);
+      return fs2.readFile(path26);
     }),
-    writeFile: (path22, data, opts) => fs2.writeFile(path22, data, opts),
-    mkdir: (path22, opts) => fs2.mkdir(path22, opts).then(() => {
+    writeFile: (path26, data, opts) => fs2.writeFile(path26, data, opts),
+    mkdir: (path26, opts) => fs2.mkdir(path26, opts).then(() => {
     }),
-    stat: (path22) => fs2.stat(path22),
-    rm: (path22, opts) => fs2.rm(path22, opts),
-    unlink: (path22) => fs2.unlink(path22),
-    readdir: (path22) => fs2.readdir(path22),
+    stat: (path26) => fs2.stat(path26),
+    rm: (path26, opts) => fs2.rm(path26, opts),
+    unlink: (path26) => fs2.unlink(path26),
+    readdir: (path26) => fs2.readdir(path26),
     copyFile: (src, dest) => fs2.copyFile(src, dest),
-    chmod: (path22, mode) => fs2.chmod(path22, mode)
+    chmod: (path26, mode) => fs2.chmod(path26, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -6763,8 +6763,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path22) {
-  if (!isAbsolute(path22)) {
+function assertAbsolutePath(path26) {
+  if (!isAbsolute(path26)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -14082,8 +14082,8 @@ var init_parseUtil = __esm({
     init_errors2();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path22, errorMaps, issueData } = params;
-      const fullPath = [...path22, ...issueData.path || []];
+      const { data, path: path26, errorMaps, issueData } = params;
+      const fullPath = [...path26, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -14363,11 +14363,11 @@ var init_types4 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path22, key) {
+      constructor(parent, value, path26, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path22;
+        this._path = path26;
         this._key = key;
       }
       get path() {
@@ -17871,10 +17871,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path22) {
-  if (!path22)
+function getElementAtPath(obj, path26) {
+  if (!path26)
     return obj;
-  return path22.reduce((acc, key) => acc?.[key], obj);
+  return path26.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -18186,11 +18186,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path22, issues) {
+function prefixIssues(path26, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path22);
+    iss.path.unshift(path26);
     return iss;
   });
 }
@@ -27244,7 +27244,7 @@ var require_code = __commonJS({
       else if (arg instanceof Name)
         code.push(arg);
       else
-        code.push(interpolate(arg));
+        code.push(interpolate2(arg));
     }
     exports.addCodeArg = addCodeArg;
     function optimize(expr) {
@@ -27283,7 +27283,7 @@ var require_code = __commonJS({
       return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
     }
     exports.strConcat = strConcat;
-    function interpolate(x) {
+    function interpolate2(x) {
       return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify2(Array.isArray(x) ? x.join(",") : x);
     }
     function stringify3(x) {
@@ -30351,8 +30351,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path22) {
-      let input = path22;
+    function removeDotSegments(path26) {
+      let input = path26;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -30551,8 +30551,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path22, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path22 && path22 !== "/" ? path22 : void 0;
+        const [path26, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path26 && path26 !== "/" ? path26 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -30704,24 +30704,24 @@ var require_fast_uri = __commonJS({
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize3(parse8(uri, options), options);
+        serialize3(parse10(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse8(serialize3(uri, options), options);
+        parse10(serialize3(uri, options), options);
       }
       return uri;
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse8(baseURI, schemelessOptions), parse8(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse10(baseURI, schemelessOptions), parse10(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize3(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse8(serialize3(base, options), options);
-        relative = parse8(serialize3(relative, options), options);
+        base = parse10(serialize3(base, options), options);
+        relative = parse10(serialize3(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -30773,13 +30773,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize3(normalizeComponentEncoding(parse8(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize3(normalizeComponentEncoding(parse10(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize3(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize3(normalizeComponentEncoding(parse8(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize3(normalizeComponentEncoding(parse10(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize3(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -30848,7 +30848,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse8(uri, opts) {
+    function parse10(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -30942,7 +30942,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize: serialize3,
-      parse: parse8
+      parse: parse10
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -35311,8 +35311,8 @@ function backoff(attempt, min, max) {
 }
 async function tryRemoveStale(lockPath, staleMs, fs3) {
   try {
-    const stat4 = await fs3.stat(lockPath);
-    if (Date.now() - stat4.mtimeMs > staleMs) {
+    const stat8 = await fs3.stat(lockPath);
+    if (Date.now() - stat8.mtimeMs > staleMs) {
       await fs3.rmdir(lockPath);
       return true;
     }
@@ -35586,13 +35586,13 @@ function getDirtyFiles(cwd) {
   for (const line of lines) {
     if (!line) continue;
     if (line.length < 4) continue;
-    let path22 = line.slice(3).trim();
+    let path26 = line.slice(3).trim();
     const renameArrow = " -> ";
-    const arrowIndex = path22.lastIndexOf(renameArrow);
+    const arrowIndex = path26.lastIndexOf(renameArrow);
     if (arrowIndex >= 0) {
-      path22 = path22.slice(arrowIndex + renameArrow.length).trim();
+      path26 = path26.slice(arrowIndex + renameArrow.length).trim();
     }
-    if (path22) files.push(path22);
+    if (path26) files.push(path26);
   }
   return files;
 }
@@ -35873,17 +35873,17 @@ function serializePlan(prd) {
   return yaml.endsWith("\n") ? yaml : `${yaml}
 `;
 }
-function lockPlanFile(path22) {
-  return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
+function lockPlanFile(path26) {
+  return lockFile(path26, { retries: 20, minTimeout: 25, maxTimeout: 250 });
 }
-async function writePlan(path22, prd, options = {}) {
+async function writePlan(path26, prd, options = {}) {
   const fs3 = options.fs ?? fsPromises4;
   const lock = options.lock ?? lockPlanFile;
-  await fs3.mkdir(dirname3(path22), { recursive: true });
-  const release = await lock(path22);
+  await fs3.mkdir(dirname3(path26), { recursive: true });
+  const release = await lock(path26);
   try {
     const yaml = serializePlan(prd);
-    await fs3.writeFile(path22, yaml, { encoding: "utf8" });
+    await fs3.writeFile(path26, yaml, { encoding: "utf8" });
   } finally {
     await release();
   }
@@ -35996,8 +35996,8 @@ var init_selector = __esm({
 // packages/ralph/src/story/updater.ts
 import { dirname as dirname4 } from "node:path";
 import * as fsPromises5 from "node:fs/promises";
-function lockPlanFile2(path22) {
-  return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
+function lockPlanFile2(path26) {
+  return lockFile(path26, { retries: 20, minTimeout: 25, maxTimeout: 250 });
 }
 function assertStoryStatus(value) {
   if (value === "open") return;
@@ -36072,8 +36072,8 @@ var init_selector2 = __esm({
 // packages/ralph/src/requirement/updater.ts
 import { dirname as dirname5 } from "node:path";
 import * as fsPromises6 from "node:fs/promises";
-function lockPlanFile3(path22) {
-  return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
+function lockPlanFile3(path26) {
+  return lockFile(path26, { retries: 20, minTimeout: 25, maxTimeout: 250 });
 }
 function findRequirement(plan, requirementId) {
   const req = plan.requirements.find((r) => r.id === requirementId);
@@ -36136,9 +36136,9 @@ function appendSection(lines, title, items, options) {
   }
   lines.push("");
 }
-async function writeRunMeta(path22, metadata, options = {}) {
+async function writeRunMeta(path26, metadata, options = {}) {
   const fs3 = options.fs ?? fsPromises7;
-  await fs3.mkdir(dirname6(path22), { recursive: true });
+  await fs3.mkdir(dirname6(path26), { recursive: true });
   const lines = [];
   lines.push("# Ralph Run Summary", "");
   lines.push(`- Run ID: ${metadata.runId}`);
@@ -36167,7 +36167,7 @@ async function writeRunMeta(path22, metadata, options = {}) {
   const git = metadata.git ?? null;
   if (!git) {
     lines.push("");
-    await fs3.writeFile(path22, lines.join("\n"), { encoding: "utf8" });
+    await fs3.writeFile(path26, lines.join("\n"), { encoding: "utf8" });
     return;
   }
   lines.push("", "## Git");
@@ -36182,7 +36182,7 @@ async function writeRunMeta(path22, metadata, options = {}) {
     lines.push("");
   } else {
     lines.push("");
-    await fs3.writeFile(path22, lines.join("\n"), { encoding: "utf8" });
+    await fs3.writeFile(path26, lines.join("\n"), { encoding: "utf8" });
     return;
   }
   if (git.commits !== void 0 && git.commits !== null) {
@@ -36202,7 +36202,7 @@ async function writeRunMeta(path22, metadata, options = {}) {
   appendSection(lines, "### Uncommitted Changes", git.dirtyFiles, {
     emptyLabel: "(none)"
   });
-  await fs3.writeFile(path22, lines.join("\n"), { encoding: "utf8" });
+  await fs3.writeFile(path26, lines.join("\n"), { encoding: "utf8" });
 }
 var init_metadata = __esm({
   "packages/ralph/src/run/metadata.ts"() {
@@ -36290,9 +36290,9 @@ async function defaultStreamingSpawn(agentId, options) {
     exitCode: result.exitCode
   };
 }
-function absPath(cwd, path22) {
-  if (!path22) return resolvePath4(cwd);
-  return path22.startsWith("/") ? path22 : resolvePath4(cwd, path22);
+function absPath(cwd, path26) {
+  if (!path26) return resolvePath4(cwd);
+  return path26.startsWith("/") ? path26 : resolvePath4(cwd, path26);
 }
 function pad2(value) {
   return value < 10 ? `0${value}` : String(value);
@@ -36342,8 +36342,8 @@ async function appendToErrorsLog(fs3, errorsLogPath, message) {
   await fs3.mkdir(dirname7(errorsLogPath), { recursive: true });
   await fs3.writeFile(errorsLogPath, `${previous}${next}`, { encoding: "utf8" });
 }
-function lockPlanFile4(path22) {
-  return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
+function lockPlanFile4(path26) {
+  return lockFile(path26, { retries: 20, minTimeout: 25, maxTimeout: 250 });
 }
 function getCurrentBranch(cwd) {
   try {
@@ -36534,7 +36534,7 @@ async function buildLoop(options) {
       });
       worktreeBranch = entry.branch;
       const worktreePath = entry.path;
-      const symlinkFn = fs3.symlink ?? ((target, path22) => fsPromises8.symlink(target, path22));
+      const symlinkFn = fs3.symlink ?? ((target, path26) => fsPromises8.symlink(target, path26));
       const exec3 = worktreeDeps.exec;
       const dirsToLink = [".poe-code-ralph", ".agents/poe-code-ralph"];
       for (const dir of dirsToLink) {
@@ -37235,27 +37235,27 @@ function formatTimestamp3(date4) {
   const seconds = pad22(date4.getSeconds());
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
-function validateLogPath(path22) {
-  if (typeof path22 !== "string" || path22.trim().length === 0) {
+function validateLogPath(path26) {
+  if (typeof path26 !== "string" || path26.trim().length === 0) {
     throw new Error(
-      `Invalid activity log path: expected a non-empty string, got ${String(path22)}`
+      `Invalid activity log path: expected a non-empty string, got ${String(path26)}`
     );
   }
-  if (path22.includes("\0")) {
+  if (path26.includes("\0")) {
     throw new Error("Invalid activity log path: contains null byte");
   }
 }
-async function logActivity(path22, message, options = {}) {
-  validateLogPath(path22);
+async function logActivity(path26, message, options = {}) {
+  validateLogPath(path26);
   const fs3 = options.fs ?? fsPromises11;
-  const parent = dirname8(path22);
+  const parent = dirname8(path26);
   if (parent && parent !== ".") {
     await fs3.mkdir(parent, { recursive: true });
   }
   const entry = `[${formatTimestamp3(/* @__PURE__ */ new Date())}] ${message}
 `;
   try {
-    await fs3.appendFile(path22, entry, { encoding: "utf8" });
+    await fs3.appendFile(path26, entry, { encoding: "utf8" });
   } catch (error2) {
     const detail = error2 instanceof Error ? error2.message : `Unknown error: ${String(error2)}`;
     throw new Error(`Failed to append activity log entry: ${detail}`, { cause: error2 });
@@ -38583,13 +38583,1137 @@ var init_models = __esm({
   }
 });
 
+// packages/pipeline/src/utils.ts
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNotFound2(error2) {
+  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT";
+}
+async function readOptionalFile(fs3, filePath) {
+  try {
+    return await fs3.readFile(filePath, "utf8");
+  } catch (error2) {
+    if (isNotFound2(error2)) {
+      return null;
+    }
+    throw error2;
+  }
+}
+function assertNotAborted(signal) {
+  if (!signal?.aborted) {
+    return;
+  }
+  throw createAbortError();
+}
+function createAbortError() {
+  const error2 = new Error("Pipeline run cancelled");
+  error2.name = "AbortError";
+  return error2;
+}
+var init_utils3 = __esm({
+  "packages/pipeline/src/utils.ts"() {
+    "use strict";
+  }
+});
+
+// packages/pipeline/src/config/loader.ts
+import path22 from "node:path";
+import { parse as parse8 } from "yaml";
+function asStepMode(value) {
+  if (value === void 0 || value === null) {
+    return "yolo";
+  }
+  if (value === "yolo" || value === "edit" || value === "read") {
+    return value;
+  }
+  throw new Error(`Invalid step mode "${String(value)}". Expected "yolo", "edit", or "read".`);
+}
+function parseYamlDocument(filePath, content) {
+  try {
+    return parse8(content);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Invalid pipeline step config YAML in "${filePath}": ${message}`);
+  }
+}
+function parseStepConfigDocument(filePath, content) {
+  const document = parseYamlDocument(filePath, content);
+  if (!isRecord6(document)) {
+    throw new Error(`Invalid pipeline step config in "${filePath}": expected a top-level object.`);
+  }
+  const stepsValue = document.steps;
+  if (stepsValue === void 0 || stepsValue === null) {
+    return {};
+  }
+  if (!isRecord6(stepsValue)) {
+    throw new Error(`Invalid pipeline step config in "${filePath}": "steps" must be an object.`);
+  }
+  const steps = {};
+  for (const [stepName, value] of Object.entries(stepsValue)) {
+    if (!isRecord6(value)) {
+      throw new Error(`Invalid step "${stepName}" in "${filePath}": expected an object.`);
+    }
+    const instruction = value.instruction;
+    if (typeof instruction !== "string" || instruction.length === 0) {
+      throw new Error(`Missing instruction for step "${stepName}" in "${filePath}".`);
+    }
+    const step = {
+      mode: asStepMode(value.mode),
+      instruction
+    };
+    steps[stepName] = step;
+  }
+  return steps;
+}
+function parseConfigDocument2(filePath, content) {
+  const document = parseYamlDocument(filePath, content);
+  if (document === null || document === void 0) {
+    return {};
+  }
+  if (!isRecord6(document)) {
+    throw new Error(`Invalid pipeline config in "${filePath}": expected a top-level object.`);
+  }
+  const planPath = document.planPath;
+  if (planPath !== void 0 && typeof planPath !== "string") {
+    throw new Error(`Invalid planPath in "${filePath}": expected a string.`);
+  }
+  return {
+    ...typeof planPath === "string" && planPath.trim().length > 0 ? { planPath: planPath.trim() } : {}
+  };
+}
+async function loadConfigFile(fs3, filePath) {
+  const content = await readOptionalFile(fs3, filePath);
+  if (content == null) {
+    return {};
+  }
+  return parseConfigDocument2(filePath, content);
+}
+async function loadStepsFile(fs3, filePath) {
+  const content = await readOptionalFile(fs3, filePath);
+  if (content == null) {
+    return {};
+  }
+  return parseStepConfigDocument(filePath, content);
+}
+async function loadPipelineConfig(options) {
+  const globalPath = path22.join(options.homeDir, ".poe-code", "pipeline", "config.yaml");
+  const projectPath = path22.join(options.cwd, ".poe-code", "pipeline", "config.yaml");
+  const [globalConfig2, projectConfig] = await Promise.all([
+    loadConfigFile(options.fs, globalPath),
+    loadConfigFile(options.fs, projectPath)
+  ]);
+  return {
+    ...globalConfig2,
+    ...projectConfig
+  };
+}
+async function loadResolvedSteps(options) {
+  const globalPath = path22.join(options.homeDir, ".poe-code", "pipeline", "steps.yaml");
+  const projectPath = path22.join(options.cwd, ".poe-code", "pipeline", "steps.yaml");
+  const [globalSteps, projectSteps] = await Promise.all([
+    loadStepsFile(options.fs, globalPath),
+    loadStepsFile(options.fs, projectPath)
+  ]);
+  return {
+    ...globalSteps,
+    ...projectSteps
+  };
+}
+var init_loader2 = __esm({
+  "packages/pipeline/src/config/loader.ts"() {
+    "use strict";
+    init_utils3();
+  }
+});
+
+// packages/pipeline/src/plan/parser.ts
+import { parse as parse9 } from "yaml";
+function asRequiredString2(value, field) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new Error(`Missing ${field}`);
+}
+function normalizeStatus2(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`Invalid ${field}: expected "open", "done", or "failed".`);
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "open" || normalized === "done" || normalized === "failed") {
+    return normalized;
+  }
+  throw new Error(`Invalid ${field} "${value}". Expected "open", "done", or "failed".`);
+}
+function parseTaskStatus(value, availableSteps, taskId) {
+  if (typeof value === "string") {
+    return normalizeStatus2(value, "task status");
+  }
+  if (!isRecord6(value)) {
+    throw new Error(`Invalid status for task "${taskId}": expected a string or step-status map.`);
+  }
+  const statusMap = {};
+  for (const [stepName, stepStatus] of Object.entries(value)) {
+    if (availableSteps && !(stepName in availableSteps)) {
+      throw new Error(`Unknown step "${stepName}" referenced by task "${taskId}".`);
+    }
+    statusMap[stepName] = normalizeStatus2(stepStatus, `step status for "${stepName}"`);
+  }
+  return statusMap;
+}
+function parsePlan2(yamlContent, options = {}) {
+  let document;
+  try {
+    document = parse9(yamlContent);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Invalid plan YAML: ${message}`);
+  }
+  if (!isRecord6(document)) {
+    throw new Error("Invalid plan YAML: expected a top-level object.");
+  }
+  const tasksValue = document.tasks;
+  if (!Array.isArray(tasksValue)) {
+    throw new Error('Invalid plan YAML: expected "tasks" to be an array.');
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const tasks = tasksValue.map((value, index) => {
+    if (!isRecord6(value)) {
+      throw new Error(`Invalid tasks[${index}]: expected an object.`);
+    }
+    const id = asRequiredString2(value.id, `tasks[${index}].id`);
+    if (ids.has(id)) {
+      throw new Error(`Duplicate task id "${id}".`);
+    }
+    ids.add(id);
+    return {
+      id,
+      title: asRequiredString2(value.title, `tasks[${index}].title`),
+      prompt: asRequiredString2(value.prompt, `tasks[${index}].prompt`),
+      status: parseTaskStatus(value.status, options.availableSteps, id)
+    };
+  });
+  return { tasks };
+}
+var init_parser2 = __esm({
+  "packages/pipeline/src/plan/parser.ts"() {
+    "use strict";
+    init_utils3();
+  }
+});
+
+// packages/pipeline/src/plan/discovery.ts
+import path23 from "node:path";
+import * as fsPromises13 from "node:fs/promises";
+function createDefaultFs() {
+  return {
+    readFile: fsPromises13.readFile,
+    readdir: fsPromises13.readdir,
+    stat: async (filePath) => {
+      const stat8 = await fsPromises13.stat(filePath);
+      return {
+        isFile: () => stat8.isFile(),
+        isDirectory: () => stat8.isDirectory(),
+        mtimeMs: stat8.mtimeMs
+      };
+    }
+  };
+}
+function isPlanCandidateFile2(name) {
+  const lower = name.toLowerCase();
+  return lower.startsWith("plan") && (lower.endsWith(".yaml") || lower.endsWith(".yml"));
+}
+function countCompletedTasks(planPath, content) {
+  const plan = parsePlan2(content);
+  const total = plan.tasks.length;
+  const done = plan.tasks.filter((task) => {
+    if (typeof task.status === "string") {
+      return task.status === "done";
+    }
+    return Object.values(task.status).every((status) => status === "done");
+  }).length;
+  return {
+    path: planPath,
+    done,
+    total
+  };
+}
+async function ensurePlanExists(fs3, cwd, planPath) {
+  const absolutePath = path23.isAbsolute(planPath) ? planPath : path23.resolve(cwd, planPath);
+  try {
+    const stat8 = await fs3.stat(absolutePath);
+    if (!stat8.isFile()) {
+      throw new Error(`Plan not found at "${planPath}".`);
+    }
+  } catch (error2) {
+    if (isNotFound2(error2)) {
+      throw new Error(`Plan not found at "${planPath}".`);
+    }
+    throw error2;
+  }
+}
+async function listPlanCandidates2(fs3, cwd) {
+  const plansDir = path23.join(cwd, ".poe-code", "pipeline", "plans");
+  let entries;
+  try {
+    entries = await fs3.readdir(plansDir);
+  } catch (error2) {
+    if (isNotFound2(error2)) {
+      return [];
+    }
+    throw error2;
+  }
+  const candidates = [];
+  for (const entry of entries) {
+    if (!isPlanCandidateFile2(entry)) {
+      continue;
+    }
+    const absolutePath = path23.join(plansDir, entry);
+    const stat8 = await fs3.stat(absolutePath);
+    if (!stat8.isFile()) {
+      continue;
+    }
+    const relativePath = path23.relative(cwd, absolutePath);
+    const content = await fs3.readFile(absolutePath, "utf8");
+    candidates.push(countCompletedTasks(relativePath, content));
+  }
+  candidates.sort((left, right) => left.path.localeCompare(right.path));
+  return candidates;
+}
+async function resolvePlanPath2(options) {
+  const fs3 = options.fs ?? createDefaultFs();
+  const explicitPlan = options.plan?.trim();
+  if (explicitPlan) {
+    await ensurePlanExists(fs3, options.cwd, explicitPlan);
+    return explicitPlan;
+  }
+  const config2 = await loadPipelineConfig({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    fs: fs3
+  });
+  if (config2.planPath) {
+    await ensurePlanExists(fs3, options.cwd, config2.planPath);
+    return config2.planPath;
+  }
+  const candidates = await listPlanCandidates2(fs3, options.cwd);
+  if (candidates.length >= 1) {
+    if (options.assumeYes) {
+      return candidates[0].path;
+    }
+    if (!options.selectPlan) {
+      return null;
+    }
+    return options.selectPlan({
+      message: "Select a pipeline plan to run",
+      options: candidates.map((candidate) => ({
+        label: `${candidate.path} (${candidate.done}/${candidate.total})`,
+        value: candidate.path
+      }))
+    });
+  }
+  if (options.assumeYes) {
+    throw new Error(
+      "No plan found under .poe-code/pipeline/plans/. Provide --plan <path> to an existing plan file."
+    );
+  }
+  if (!options.promptForPath) {
+    return null;
+  }
+  return options.promptForPath({
+    message: "Enter the pipeline plan path",
+    placeholder: ".poe-code/pipeline/plans/plan.yaml"
+  });
+}
+var init_discovery = __esm({
+  "packages/pipeline/src/plan/discovery.ts"() {
+    "use strict";
+    init_loader2();
+    init_parser2();
+    init_utils3();
+  }
+});
+
+// packages/pipeline/src/plan/writer.ts
+import { parseDocument, isMap, isSeq } from "yaml";
+function getTasksNode(document) {
+  const tasksNode = document.get("tasks", true);
+  if (!tasksNode || !isSeq(tasksNode)) {
+    throw new Error('Invalid plan YAML: expected "tasks" to be a sequence.');
+  }
+  return tasksNode;
+}
+function getTaskNode(tasksNode, taskId) {
+  for (const item of tasksNode.items) {
+    if (!isMap(item)) {
+      continue;
+    }
+    if (item.get("id") === taskId) {
+      return item;
+    }
+  }
+  throw new Error(`Task "${taskId}" not found in plan.`);
+}
+async function readPlanFile(fs3, planPath) {
+  return fs3.readFile(planPath, "utf8");
+}
+async function writeTaskStatus(options) {
+  const content = await readPlanFile(options.fs, options.planPath);
+  const document = parseDocument(content);
+  const tasksNode = getTasksNode(document);
+  const taskNode = getTaskNode(tasksNode, options.taskId);
+  if (options.stepName) {
+    const statusNode = taskNode.get("status", true);
+    if (!statusNode || !isMap(statusNode)) {
+      throw new Error(`Task "${options.taskId}" does not use step statuses.`);
+    }
+    statusNode.set(options.stepName, options.status);
+  } else {
+    taskNode.set("status", options.status);
+  }
+  await options.fs.writeFile(options.planPath, document.toString(), {
+    encoding: "utf8"
+  });
+}
+var init_writer2 = __esm({
+  "packages/pipeline/src/plan/writer.ts"() {
+    "use strict";
+  }
+});
+
+// packages/pipeline/src/run/runner.ts
+function getFailedStepName(status) {
+  return Object.entries(status).find(([, value]) => value === "failed")?.[0];
+}
+function getOpenStepName(status) {
+  return Object.entries(status).find(([, value]) => value === "open")?.[0];
+}
+function selectFromTask(task) {
+  if (typeof task.status === "string") {
+    if (task.status === "done") {
+      return { kind: "completed" };
+    }
+    if (task.status === "failed") {
+      return { kind: "blocked", task };
+    }
+    return { kind: "run", task };
+  }
+  const failedStepName = getFailedStepName(task.status);
+  if (failedStepName) {
+    return { kind: "blocked", task, stepName: failedStepName };
+  }
+  const openStepName = getOpenStepName(task.status);
+  if (openStepName) {
+    return { kind: "run", task, stepName: openStepName };
+  }
+  return { kind: "completed" };
+}
+function selectNextExecution(plan, taskId) {
+  const tasks = taskId ? plan.tasks.filter((task) => task.id === taskId) : plan.tasks;
+  if (taskId && tasks.length === 0) {
+    throw new Error(`Task "${taskId}" was not found in the plan.`);
+  }
+  for (const task of tasks) {
+    const selection = selectFromTask(task);
+    if (selection.kind !== "completed") {
+      return selection;
+    }
+  }
+  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 buildExecutionPrompt(input) {
+  if (!input.selection.stepName) {
+    return input.selection.task.prompt;
+  }
+  const step = input.steps[input.selection.stepName];
+  if (!step) {
+    throw new Error(`Missing step definition for "${input.selection.stepName}".`);
+  }
+  return interpolate(step.instruction, {
+    id: input.selection.task.id,
+    title: input.selection.task.title,
+    prompt: input.selection.task.prompt,
+    plan_path: input.planPath
+  });
+}
+var init_runner = __esm({
+  "packages/pipeline/src/run/runner.ts"() {
+    "use strict";
+  }
+});
+
+// packages/pipeline/src/lock/lock.ts
+import * as fsPromises14 from "node:fs/promises";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoff2(attempt, min, max) {
+  const delay = Math.min(max, min * Math.pow(2, attempt));
+  return delay + Math.random() * delay * 0.1;
+}
+function createDefaultFs2() {
+  return {
+    mkdir: async (filePath) => {
+      await fsPromises14.mkdir(filePath);
+    },
+    rmdir: fsPromises14.rmdir,
+    stat: async (filePath) => {
+      const stat8 = await fsPromises14.stat(filePath);
+      return {
+        isFile: () => stat8.isFile(),
+        isDirectory: () => stat8.isDirectory(),
+        mtimeMs: stat8.mtimeMs
+      };
+    }
+  };
+}
+async function lockFile2(filePath, options = {}) {
+  const fs3 = options.fs ?? createDefaultFs2();
+  const retries = options.retries ?? 20;
+  const minTimeout = options.minTimeout ?? 25;
+  const maxTimeout = options.maxTimeout ?? 250;
+  const staleMs = options.staleMs ?? 3e4;
+  const lockPath = `${filePath}.lock`;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      await fs3.mkdir(lockPath);
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        try {
+          await fs3.rmdir(lockPath);
+        } catch (error2) {
+          if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "ENOENT") {
+            throw error2;
+          }
+        }
+      };
+    } catch (error2) {
+      if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "EEXIST") {
+        throw error2;
+      }
+      const stat8 = await fs3.stat(lockPath);
+      if (Date.now() - stat8.mtimeMs > staleMs) {
+        await fs3.rmdir(lockPath);
+        continue;
+      }
+      if (attempt < retries) {
+        await sleep2(backoff2(attempt, minTimeout, maxTimeout));
+      }
+    }
+  }
+  throw new Error(`Failed to acquire lock on "${filePath}".`);
+}
+var init_lock2 = __esm({
+  "packages/pipeline/src/lock/lock.ts"() {
+    "use strict";
+  }
+});
+
+// packages/pipeline/src/run/pipeline.ts
+import path24 from "node:path";
+import * as fsPromises15 from "node:fs/promises";
+function createDefaultFs3() {
+  return {
+    readFile: fsPromises15.readFile,
+    writeFile: fsPromises15.writeFile,
+    readdir: fsPromises15.readdir,
+    stat: async (filePath) => {
+      const stat8 = await fsPromises15.stat(filePath);
+      return {
+        isFile: () => stat8.isFile(),
+        isDirectory: () => stat8.isDirectory(),
+        mtimeMs: stat8.mtimeMs
+      };
+    },
+    mkdir: async (filePath, options) => {
+      await fsPromises15.mkdir(filePath, options);
+    },
+    rmdir: fsPromises15.rmdir
+  };
+}
+function isAbortError(error2) {
+  return error2 instanceof Error && error2.name === "AbortError";
+}
+function resolveMode(stepName, steps) {
+  if (!stepName) {
+    return "yolo";
+  }
+  const step = steps[stepName];
+  if (!step) {
+    throw new Error(`Missing step definition for "${stepName}".`);
+  }
+  return step.mode;
+}
+async function runPipeline(options) {
+  const fs3 = options.fs ?? createDefaultFs3();
+  const runAgent = options.runAgent;
+  if (!runAgent) {
+    throw new Error("runPipeline requires a runAgent implementation.");
+  }
+  const planPath = await resolvePlanPath2({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    plan: options.plan,
+    assumeYes: options.assumeYes,
+    fs: fs3,
+    selectPlan: options.selectPlan,
+    promptForPath: options.promptForPath
+  });
+  if (!planPath) {
+    return {
+      stopReason: "cancelled",
+      planPath: "",
+      runsCompleted: 0,
+      totalDurationMs: 0
+    };
+  }
+  const absolutePlanPath = path24.isAbsolute(planPath) ? planPath : path24.resolve(options.cwd, planPath);
+  if (options.onPlanResolved) {
+    const content = await fs3.readFile(absolutePlanPath, "utf8");
+    const plan = parsePlan2(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 failed = plan.tasks.filter((t) => {
+      if (typeof t.status === "string") return t.status === "failed";
+      return Object.values(t.status).some((s) => s === "failed");
+    }).length;
+    options.onPlanResolved({
+      planPath,
+      done,
+      failed,
+      open: total - done - failed,
+      total
+    });
+  }
+  const maxRuns = options.maxRuns ?? Number.POSITIVE_INFINITY;
+  let runsCompleted = 0;
+  const pipelineStartTime = Date.now();
+  while (runsCompleted < maxRuns) {
+    assertNotAborted(options.signal);
+    const release = await lockFile2(absolutePlanPath, { fs: fs3 });
+    try {
+      const steps = await loadResolvedSteps({
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+        fs: fs3
+      });
+      const content = await fs3.readFile(absolutePlanPath, "utf8");
+      const plan = parsePlan2(content, { availableSteps: steps });
+      const totalTasks = plan.tasks.length;
+      const selection = selectNextExecution(plan, options.task);
+      if (selection.kind === "completed") {
+        return {
+          stopReason: runsCompleted === 0 ? "nothing_to_run" : "completed",
+          planPath,
+          runsCompleted,
+          totalDurationMs: Date.now() - pipelineStartTime
+        };
+      }
+      if (selection.kind === "blocked") {
+        return {
+          stopReason: "failed",
+          planPath,
+          runsCompleted,
+          totalDurationMs: Date.now() - pipelineStartTime,
+          lastTaskId: selection.task.id,
+          ...selection.stepName ? { lastStepName: selection.stepName } : {}
+        };
+      }
+      const taskProgress = {
+        taskId: selection.task.id,
+        taskTitle: selection.task.title,
+        ...selection.stepName ? { stepName: selection.stepName } : {},
+        index: runsCompleted + 1,
+        total: totalTasks
+      };
+      options.onTaskStart?.(taskProgress);
+      const prompt = buildExecutionPrompt({
+        selection,
+        steps,
+        planPath
+      });
+      const mode = resolveMode(selection.stepName, steps);
+      const taskStartTime = Date.now();
+      let result;
+      try {
+        result = await runAgent({
+          agent: options.agent,
+          prompt,
+          mode,
+          cwd: options.cwd,
+          ...options.model ? { model: options.model } : {},
+          ...options.signal ? { signal: options.signal } : {}
+        });
+      } catch (error2) {
+        if (isAbortError(error2)) {
+          return {
+            stopReason: "cancelled",
+            planPath,
+            runsCompleted,
+            totalDurationMs: Date.now() - pipelineStartTime,
+            lastTaskId: selection.task.id,
+            ...selection.stepName ? { lastStepName: selection.stepName } : {}
+          };
+        }
+        throw error2;
+      }
+      const taskDurationMs = Date.now() - taskStartTime;
+      const success2 = result.exitCode === 0;
+      await writeTaskStatus({
+        fs: fs3,
+        planPath: absolutePlanPath,
+        taskId: selection.task.id,
+        ...selection.stepName ? { stepName: selection.stepName } : {},
+        status: success2 ? "done" : "failed"
+      });
+      runsCompleted += 1;
+      options.onTaskComplete?.({
+        ...taskProgress,
+        durationMs: taskDurationMs,
+        success: success2
+      });
+      if (!success2) {
+        return {
+          stopReason: "failed",
+          planPath,
+          runsCompleted,
+          totalDurationMs: Date.now() - pipelineStartTime,
+          lastTaskId: selection.task.id,
+          ...selection.stepName ? { lastStepName: selection.stepName } : {}
+        };
+      }
+    } finally {
+      await release();
+    }
+  }
+  return {
+    stopReason: "max_runs",
+    planPath,
+    runsCompleted,
+    totalDurationMs: Date.now() - pipelineStartTime
+  };
+}
+var init_pipeline2 = __esm({
+  "packages/pipeline/src/run/pipeline.ts"() {
+    "use strict";
+    init_loader2();
+    init_lock2();
+    init_discovery();
+    init_parser2();
+    init_writer2();
+    init_runner();
+    init_utils3();
+  }
+});
+
+// packages/pipeline/src/index.ts
+var init_src14 = __esm({
+  "packages/pipeline/src/index.ts"() {
+    "use strict";
+    init_loader2();
+    init_discovery();
+    init_parser2();
+    init_writer2();
+    init_runner();
+    init_pipeline2();
+  }
+});
+
+// src/sdk/pipeline.ts
+async function runPipeline2(options) {
+  return runPipeline({
+    ...options,
+    runAgent: async (input) => {
+      const { events, result } = spawn5(input.agent, {
+        prompt: input.prompt,
+        cwd: input.cwd,
+        model: input.model,
+        mode: input.mode
+      });
+      await renderAcpStream(events);
+      return result;
+    }
+  });
+}
+var init_pipeline3 = __esm({
+  async "src/sdk/pipeline.ts"() {
+    "use strict";
+    init_src14();
+    init_src5();
+    await init_spawn3();
+  }
+});
+
+// src/cli/commands/pipeline.ts
+import path25 from "node:path";
+import { readFile as readFile6, stat as stat7 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function formatDuration2(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+function resolvePipelineAgent(value) {
+  if (!value || value.trim().length === 0) {
+    return DEFAULT_PIPELINE_AGENT;
+  }
+  const resolved = resolveAgentId(value.trim());
+  if (!resolved) {
+    throw new ValidationError(`Unsupported agent: ${value}`);
+  }
+  return resolved;
+}
+function resolveMaxRuns(value) {
+  if (value == null) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new ValidationError(
+      `Invalid max-runs "${value}". Expected a positive integer.`
+    );
+  }
+  return parsed;
+}
+function resolvePipelinePaths(scope, cwd, homeDir) {
+  const rootPath = scope === "global" ? path25.join(homeDir, ".poe-code", "pipeline") : path25.join(cwd, ".poe-code", "pipeline");
+  const displayRoot = scope === "global" ? "~/.poe-code/pipeline" : ".poe-code/pipeline";
+  return {
+    plansPath: path25.join(rootPath, "plans"),
+    stepsPath: path25.join(rootPath, "steps.yaml"),
+    displayPlansPath: `${displayRoot}/plans`,
+    displayStepsPath: `${displayRoot}/steps.yaml`
+  };
+}
+async function loadPipelineTemplates() {
+  if (pipelineTemplatesCache) {
+    return pipelineTemplatesCache;
+  }
+  const packageRoot = await findPackageRoot(fileURLToPath3(import.meta.url));
+  const templateRoots = [
+    path25.join(packageRoot, "src", "templates", "pipeline"),
+    path25.join(packageRoot, "dist", "templates", "pipeline")
+  ];
+  for (const templateRoot of templateRoots) {
+    if (!await pathExistsOnDisk(templateRoot)) {
+      continue;
+    }
+    const [skillPlan, steps] = await Promise.all([
+      readFile6(path25.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile6(path25.join(templateRoot, "steps.yaml.hbs"), "utf8")
+    ]);
+    pipelineTemplatesCache = { skillPlan, steps };
+    return pipelineTemplatesCache;
+  }
+  throw new Error("Pipeline templates not found.");
+}
+async function pathExistsOnDisk(targetPath) {
+  try {
+    await stat7(targetPath);
+    return true;
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+async function findPackageRoot(entryFilePath) {
+  let currentPath = path25.dirname(entryFilePath);
+  while (true) {
+    if (await pathExistsOnDisk(path25.join(currentPath, "package.json"))) {
+      return currentPath;
+    }
+    const parentPath = path25.dirname(currentPath);
+    if (parentPath === currentPath) {
+      throw new Error("Unable to locate package root for Pipeline templates.");
+    }
+    currentPath = parentPath;
+  }
+}
+async function pathExists4(fs3, targetPath) {
+  try {
+    await fs3.stat(targetPath);
+    return true;
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
+      return false;
+    }
+    throw error2;
+  }
+}
+function registerPipelineCommand(program, container) {
+  const pipeline = program.command("pipeline").description("Run a fixed-step task pipeline plan.");
+  pipeline.command("run").description("Run the selected pipeline plan until completion, failure, cancellation, or cap.").option("--agent <name>", "Agent to run each pipeline step with").option("--model <model>", "Model override passed to the agent").option("--task <id>", "Run only the specified task").option("--plan <path>", "Path to the pipeline plan file").option("--max-runs <n>", "Maximum number of agent executions to perform").action(async function() {
+    const flags = resolveCommandFlags(program);
+    const resources = createExecutionResources(
+      container,
+      flags,
+      "pipeline:run"
+    );
+    const options = this.opts();
+    resources.logger.intro("pipeline run");
+    try {
+      let agent;
+      if (options.agent) {
+        agent = resolvePipelineAgent(options.agent);
+      } else if (flags.assumeYes) {
+        agent = DEFAULT_PIPELINE_AGENT;
+      } else {
+        const selected = await select2({
+          message: "Select agent to run pipeline steps with:",
+          options: supportedAgents2.map((value) => ({
+            value,
+            label: value
+          }))
+        });
+        if (isCancel2(selected)) {
+          cancel2("Pipeline run cancelled.");
+          return;
+        }
+        agent = resolvePipelineAgent(selected);
+      }
+      const result = await runPipeline2({
+        agent,
+        cwd: container.env.cwd,
+        homeDir: container.env.homeDir,
+        ...options.model ? { model: options.model } : {},
+        ...options.task ? { task: options.task } : {},
+        ...options.plan ? { plan: options.plan } : {},
+        ...resolveMaxRuns(options.maxRuns) != null ? { maxRuns: resolveMaxRuns(options.maxRuns) } : {},
+        assumeYes: flags.assumeYes,
+        onPlanResolved(summary2) {
+          const configLines = [`Agent: ${agent}`];
+          if (options.model) configLines.push(`Model: ${options.model}`);
+          configLines.push(`Plan: ${summary2.planPath}`);
+          resources.logger.resolved("Config", configLines.join("\n   "));
+          const parts = [`${summary2.done}/${summary2.total} done`];
+          if (summary2.failed) parts.push(`${summary2.failed} failed`);
+          if (summary2.open) parts.push(`${summary2.open} open`);
+          resources.logger.resolved("Tasks", parts.join(", "));
+        },
+        selectPlan: async (input) => {
+          const selected = await select2(input);
+          if (isCancel2(selected)) {
+            cancel2("Pipeline run cancelled.");
+            return null;
+          }
+          return typeof selected === "string" ? selected : null;
+        },
+        promptForPath: async (input) => {
+          const value = await text3(input);
+          if (isCancel2(value)) {
+            cancel2("Pipeline run cancelled.");
+            return null;
+          }
+          return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+        },
+        onTaskStart(progress) {
+          const step = progress.stepName ? ` (${progress.stepName})` : "";
+          resources.logger.info(
+            `Task ${progress.index}/${progress.total}: ${progress.taskId}${step}`
+          );
+        },
+        onTaskComplete(progress) {
+          const duration3 = formatDuration2(progress.durationMs);
+          const status = progress.success ? "done" : "failed";
+          resources.logger.info(
+            `Task ${progress.taskId} ${status} in ${duration3}`
+          );
+        }
+      });
+      const summary = [
+        `Tasks: ${result.runsCompleted}/${result.runsCompleted + (result.stopReason === "completed" || result.stopReason === "nothing_to_run" ? 0 : 1)}`,
+        `Duration: ${formatDuration2(result.totalDurationMs)}`
+      ].join("\n   ");
+      if (result.stopReason === "failed") {
+        process.exitCode = 1;
+        resources.logger.error(
+          `Pipeline blocked at ${result.lastTaskId}${result.lastStepName ? ` (${result.lastStepName})` : ""}.`
+        );
+        resources.logger.resolved("Run summary", summary);
+        return;
+      }
+      if (result.stopReason === "cancelled") {
+        process.exitCode = 130;
+        resources.logger.warn("Pipeline run cancelled.");
+        resources.logger.resolved("Run summary", summary);
+        return;
+      }
+      if (result.stopReason === "nothing_to_run") {
+        resources.logger.info("Nothing to run.");
+        return;
+      }
+      if (result.stopReason === "max_runs") {
+        resources.logger.info(
+          `Reached max runs (${result.runsCompleted}).`
+        );
+        resources.logger.resolved("Run summary", summary);
+        return;
+      }
+      resources.logger.resolved("Run summary", summary);
+      resources.logger.success("Pipeline run finished.");
+    } finally {
+      resources.context.finalize();
+    }
+  });
+  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() {
+    const flags = resolveCommandFlags(program);
+    const resources = createExecutionResources(
+      container,
+      flags,
+      "pipeline:install"
+    );
+    const options = this.opts();
+    if (options.local && options.global) {
+      throw new ValidationError("Use either --local or --global, not both.");
+    }
+    try {
+      let agent = options.agent;
+      if (!agent) {
+        if (flags.assumeYes) {
+          agent = DEFAULT_PIPELINE_AGENT;
+        } else {
+          const selected = await select2({
+            message: "Select agent to install the Pipeline skill for:",
+            options: supportedAgents2.map((value) => ({
+              value,
+              label: value
+            }))
+          });
+          if (isCancel2(selected)) {
+            cancel2("Pipeline install cancelled.");
+            return;
+          }
+          agent = selected;
+        }
+      }
+      const support = resolveAgentSupport2(agent);
+      if (support.status !== "supported" || !support.id) {
+        throw new ValidationError(`Unsupported agent: ${agent}`);
+      }
+      let scope;
+      if (options.local) {
+        scope = "local";
+      } else if (options.global) {
+        scope = "global";
+      } else if (flags.assumeYes) {
+        scope = DEFAULT_PIPELINE_SCOPE;
+      } else {
+        const selected = await select2({
+          message: "Select install scope:",
+          options: [
+            { value: "local", label: "Local" },
+            { value: "global", label: "Global" }
+          ]
+        });
+        if (isCancel2(selected)) {
+          cancel2("Pipeline install cancelled.");
+          return;
+        }
+        scope = selected;
+      }
+      resources.logger.intro(`pipeline install (${support.id}, ${scope})`);
+      const templates = await loadPipelineTemplates();
+      const skillResult = await installSkill(
+        support.id,
+        {
+          name: "poe-code-pipeline-plan",
+          content: templates.skillPlan
+        },
+        {
+          fs: container.fs,
+          cwd: container.env.cwd,
+          homeDir: container.env.homeDir,
+          scope,
+          dryRun: flags.dryRun
+        }
+      );
+      if (flags.dryRun) {
+        resources.logger.dryRun(`Would create: ${skillResult.displayPath}`);
+      } else {
+        resources.logger.info(`Create: ${skillResult.displayPath}`);
+      }
+      const pipelinePaths = resolvePipelinePaths(
+        scope,
+        container.env.cwd,
+        container.env.homeDir
+      );
+      if (!await pathExists4(container.fs, pipelinePaths.plansPath)) {
+        if (flags.dryRun) {
+          resources.logger.dryRun(`Would create: ${pipelinePaths.displayPlansPath}`);
+        } else {
+          await container.fs.mkdir(pipelinePaths.plansPath, { recursive: true });
+          resources.logger.info(`Create: ${pipelinePaths.displayPlansPath}`);
+        }
+      }
+      const stepsExists = await pathExists4(container.fs, pipelinePaths.stepsPath);
+      if (stepsExists && !options.force) {
+        resources.logger.info(
+          `Skip: ${pipelinePaths.displayStepsPath} (already exists)`
+        );
+      } else if (flags.dryRun) {
+        resources.logger.dryRun(
+          `Would ${stepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayStepsPath}`
+        );
+      } else {
+        await container.fs.mkdir(path25.dirname(pipelinePaths.stepsPath), {
+          recursive: true
+        });
+        await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
+          encoding: "utf8"
+        });
+        resources.logger.info(
+          `${stepsExists ? "Overwrite" : "Create"}: ${pipelinePaths.displayStepsPath}`
+        );
+      }
+      resources.context.complete({
+        success: `Installed Pipeline skill for ${support.id} and scaffolded ${scope} pipeline files`,
+        dry: `Would install Pipeline skill for ${support.id} and scaffold ${scope} pipeline files`
+      });
+    } finally {
+      resources.context.finalize();
+    }
+  });
+}
+var DEFAULT_PIPELINE_AGENT, DEFAULT_PIPELINE_SCOPE, pipelineTemplatesCache;
+var init_pipeline4 = __esm({
+  async "src/cli/commands/pipeline.ts"() {
+    "use strict";
+    init_src4();
+    init_src3();
+    init_src11();
+    init_errors();
+    init_shared();
+    await init_pipeline3();
+    DEFAULT_PIPELINE_AGENT = "claude-code";
+    DEFAULT_PIPELINE_SCOPE = "local";
+    pipelineTemplatesCache = null;
+  }
+});
+
 // package.json
 var package_default;
 var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.92",
+      version: "3.0.94",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -38793,6 +39917,16 @@ function formatHelpText(input) {
       args: "[agent]",
       description: "Remove agent skills configuration"
     },
+    {
+      name: "pipeline install",
+      args: "[agent]",
+      description: "Install pipeline skill into agent configuration"
+    },
+    {
+      name: "pipeline run",
+      args: "",
+      description: "Run a fixed-step task pipeline plan"
+    },
     {
       name: "usage",
       args: "",
@@ -38953,6 +40087,7 @@ function bootstrapProgram(container) {
   registerRalphCommand(program, container);
   registerUsageCommand(program, container);
   registerModelsCommand(program, container);
+  registerPipelineCommand(program, container);
   program.allowExcessArguments().action(function() {
     const args = this.args;
     if (args.length > 0) {
@@ -39008,6 +40143,7 @@ var init_program = __esm({
     init_ralph();
     init_usage();
     init_models();
+    await init_pipeline4();
     init_package();
     init_command_not_found();
     init_execution_context();