poe-code 3.0.155 → 3.0.156

package/dist/index.js

@@ -925,16 +925,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path43) {
-  const ext = getExtension(path43);
+function detectFormat(path48) {
+  const ext = getExtension(path48);
   return extensionMap[ext];
 }
-function getExtension(path43) {
-  const lastDot = path43.lastIndexOf(".");
+function getExtension(path48) {
+  const lastDot = path48.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path43.slice(lastDot).toLowerCase();
+  return path48.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -1265,8 +1265,8 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
-    const stat13 = await context.fs.stat(targetPath);
-    const currentMode = typeof stat13.mode === "number" ? stat13.mode & 511 : null;
+    const stat14 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat14.mode === "number" ? stat14.mode & 511 : null;
     if (currentMode === mutation.mode) {
       return {
         outcome: { changed: false, effect: "none", detail: "noop" },
@@ -1989,38 +1989,38 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path43, encoding) {
+    async readFile(path48, encoding) {
       if (encoding) {
-        return base.readFile(path43, encoding);
+        return base.readFile(path48, encoding);
       }
-      return base.readFile(path43);
+      return base.readFile(path48);
     },
-    async writeFile(path43, data, options) {
-      const previousContent = await tryReadText(base, path43);
+    async writeFile(path48, data, options) {
+      const previousContent = await tryReadText(base, path48);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path43,
+        path: path48,
         nextContent,
         previousContent
       });
     },
-    async mkdir(path43, options) {
-      recorder.record({ type: "mkdir", path: path43, options });
+    async mkdir(path48, options) {
+      recorder.record({ type: "mkdir", path: path48, options });
     },
-    async stat(path43) {
-      return base.stat(path43);
+    async stat(path48) {
+      return base.stat(path48);
     },
-    async unlink(path43) {
-      recorder.record({ type: "unlink", path: path43 });
+    async unlink(path48) {
+      recorder.record({ type: "unlink", path: path48 });
     },
-    async readdir(path43) {
-      return base.readdir(path43);
+    async readdir(path48) {
+      return base.readdir(path48);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path43, options) => {
-      recorder.record({ type: "rm", path: path43, options });
+    proxy.rm = async (path48, options) => {
+      recorder.record({ type: "rm", path: path48, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -2110,8 +2110,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path43, change) {
-  const command = `cat > ${path43}`;
+function renderWriteCommand(path48, change) {
+  const command = `cat > ${path48}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -2273,9 +2273,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path43) {
+async function tryReadText(base, path48) {
   try {
-    return await base.readFile(path43, "utf8");
+    return await base.readFile(path48, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -3404,6 +3404,9 @@ function resolveOutputFormat(env = process.env) {
   cached = VALID_FORMATS.has(raw) ? raw : "terminal";
   return cached;
 }
+function withOutputFormat(format, fn) {
+  return formatStorage.run(format, fn);
+}
 function resetOutputFormatCache() {
   cached = void 0;
 }
@@ -7752,6 +7755,14 @@ async function text3(opts) {
 async function confirm2(opts) {
   return clack.confirm(opts);
 }
+async function confirmOrCancel(opts) {
+  const result = await confirm2(opts);
+  if (Ct(result)) {
+    cancel("Operation cancelled.");
+    throw new PromptCancelledError();
+  }
+  return result === true;
+}
 async function password2(opts) {
   return clack.password(opts);
 }
@@ -7818,6 +7829,7 @@ async function withSpinner(options) {
     throw error2;
   }
 }
+var PromptCancelledError;
 var init_prompts = __esm({
   "packages/design-system/src/prompts/index.ts"() {
     "use strict";
@@ -7829,6 +7841,15 @@ var init_prompts = __esm({
     init_note();
     init_outro();
     init_spinner2();
+    PromptCancelledError = class extends Error {
+      constructor(message2 = "Operation cancelled.") {
+        super(message2);
+        this.name = "PromptCancelledError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+    };
   }
 });
 
@@ -8089,21 +8110,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 path43;
+        let path48;
         if (typeof item.content === "string") {
-          path43 = item.content;
+          path48 = item.content;
         } else {
           try {
-            path43 = JSON.stringify(item.content);
+            path48 = JSON.stringify(item.content);
           } catch {
-            path43 = String(item.content);
+            path48 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path43
+          path: path48
         };
       }
     }
@@ -8226,10 +8247,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 path43 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path48 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path43 };
+        yield { event: "tool_complete", id: item.id, kind, path: path48 };
       }
     }
   }
@@ -9241,8 +9262,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path43) {
-  if (!isAbsolute(path43)) {
+function assertAbsolutePath(path48) {
+  if (!isAbsolute(path48)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -10354,7 +10375,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path43 = readString(event.path);
+  const path48 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -10369,8 +10390,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path43) {
-    toolCall.path = path43;
+  if (path48) {
+    toolCall.path = path48;
   }
 }
 var sessionCapture;
@@ -10859,14 +10880,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path43 = input.slice(slashIndex);
-  if (container.length === 0 || path43.length === 0) {
+  const path48 = input.slice(slashIndex);
+  if (container.length === 0 || path48.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path43
+    path: path48
   };
 }
 function splitOnce(input, separator) {
@@ -12743,21 +12764,21 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path43, encoding) => {
+    readFile: ((path48, encoding) => {
       if (encoding) {
-        return fs2.readFile(path43, encoding);
+        return fs2.readFile(path48, encoding);
       }
-      return fs2.readFile(path43);
+      return fs2.readFile(path48);
     }),
-    writeFile: (path43, data, opts) => fs2.writeFile(path43, data, opts),
-    mkdir: (path43, opts) => fs2.mkdir(path43, opts).then(() => {
+    writeFile: (path48, data, opts) => fs2.writeFile(path48, data, opts),
+    mkdir: (path48, opts) => fs2.mkdir(path48, opts).then(() => {
     }),
-    stat: (path43) => fs2.stat(path43),
-    rm: (path43, opts) => fs2.rm(path43, opts),
-    unlink: (path43) => fs2.unlink(path43),
-    readdir: (path43) => fs2.readdir(path43),
+    stat: (path48) => fs2.stat(path48),
+    rm: (path48, opts) => fs2.rm(path48, opts),
+    unlink: (path48) => fs2.unlink(path48),
+    readdir: (path48) => fs2.readdir(path48),
     copyFile: (src, dest) => fs2.copyFile(src, dest),
-    chmod: (path43, mode) => fs2.chmod(path43, mode)
+    chmod: (path48, mode) => fs2.chmod(path48, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -13390,11 +13411,11 @@ function createDefaultFs() {
     readFile: fsPromises2.readFile,
     readdir: fsPromises2.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises2.stat(filePath);
+      const stat14 = await fsPromises2.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        isDirectory: () => stat13.isDirectory(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        isDirectory: () => stat14.isDirectory(),
+        mtimeMs: stat14.mtimeMs
       };
     }
   };
@@ -13421,8 +13442,8 @@ function countCompletedTasks(planPath, content) {
 async function ensurePlanExists(fs3, cwd, planPath) {
   const absolutePath = path15.isAbsolute(planPath) ? planPath : path15.resolve(cwd, planPath);
   try {
-    const stat13 = await fs3.stat(absolutePath);
-    if (!stat13.isFile()) {
+    const stat14 = await fs3.stat(absolutePath);
+    if (!stat14.isFile()) {
       throw new Error(`Plan not found at "${planPath}".`);
     }
   } catch (error2) {
@@ -13448,8 +13469,8 @@ async function scanPlansDir(fs3, plansDir, displayPrefix) {
       continue;
     }
     const absolutePath = path15.join(plansDir, entry);
-    const stat13 = await fs3.stat(absolutePath);
-    if (!stat13.isFile()) {
+    const stat14 = await fs3.stat(absolutePath);
+    if (!stat14.isFile()) {
       continue;
     }
     const displayPath = path15.join(displayPrefix, entry);
@@ -13491,8 +13512,8 @@ async function resolvePlanDirectory(options) {
   const fs3 = options.fs ?? createDefaultFs();
   const projectDir = path15.join(options.cwd, ".poe-code");
   try {
-    const stat13 = await fs3.stat(projectDir);
-    if (stat13.isDirectory()) {
+    const stat14 = await fs3.stat(projectDir);
+    if (stat14.isDirectory()) {
       return path15.join(options.cwd, ".poe-code", "pipeline", "plans");
     }
   } catch {
@@ -13707,11 +13728,11 @@ function createDefaultFs2() {
     },
     rmdir: fsPromises3.rmdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises3.stat(filePath);
+      const stat14 = await fsPromises3.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        isDirectory: () => stat13.isDirectory(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        isDirectory: () => stat14.isDirectory(),
+        mtimeMs: stat14.mtimeMs
       };
     }
   };
@@ -13744,8 +13765,8 @@ async function lockFile(filePath, options = {}) {
       if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "EEXIST") {
         throw error2;
       }
-      const stat13 = await fs3.stat(lockPath);
-      if (Date.now() - stat13.mtimeMs > staleMs) {
+      const stat14 = await fs3.stat(lockPath);
+      if (Date.now() - stat14.mtimeMs > staleMs) {
         await fs3.rmdir(lockPath);
         continue;
       }
@@ -13771,11 +13792,11 @@ function createDefaultFs3() {
     writeFile: fsPromises4.writeFile,
     readdir: fsPromises4.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises4.stat(filePath);
+      const stat14 = await fsPromises4.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        isDirectory: () => stat13.isDirectory(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        isDirectory: () => stat14.isDirectory(),
+        mtimeMs: stat14.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -14237,8 +14258,8 @@ async function removeDirectory2(fs3, directoryPath) {
   }
   for (const entry of entries) {
     const entryPath = path18.join(directoryPath, entry);
-    const stat13 = await fs3.stat(entryPath);
-    if (stat13.isFile()) {
+    const stat14 = await fs3.stat(entryPath);
+    if (stat14.isFile()) {
       await fs3.rm(entryPath, { force: true });
       continue;
     }
@@ -14284,8 +14305,8 @@ function createStateStore(stateDir, fs3 = nodeFs2) {
     for (const entry of [...entries].sort()) {
       const entryPath = path18.join(stateDir, entry);
       try {
-        const stat13 = await fs3.stat(entryPath);
-        if (stat13.isFile()) {
+        const stat14 = await fs3.stat(entryPath);
+        if (stat14.isFile()) {
           continue;
         }
       } catch (error2) {
@@ -15691,8 +15712,8 @@ async function listIds(fs3, baseDir) {
     for (const entry of entries) {
       const entryPath = path22.join(baseDir, entry);
       try {
-        const stat13 = await fs3.stat(entryPath);
-        if (!stat13.isFile()) {
+        const stat14 = await fs3.stat(entryPath);
+        if (!stat14.isFile()) {
           ids.push(entry);
         }
       } catch (error2) {
@@ -15945,10 +15966,10 @@ function createDefaultFs4() {
   return {
     readdir: fsPromises5.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises5.stat(filePath);
+      const stat14 = await fsPromises5.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        mtimeMs: stat14.mtimeMs
       };
     }
   };
@@ -15975,8 +15996,8 @@ async function scanDir(fs3, absoluteDir, displayDir) {
       continue;
     }
     const absolutePath = path23.join(absoluteDir, entry);
-    const stat13 = await fs3.stat(absolutePath);
-    if (!stat13.isFile()) {
+    const stat14 = await fs3.stat(absolutePath);
+    if (!stat14.isFile()) {
       continue;
     }
     const displayPath = path23.join(displayDir, entry);
@@ -16149,10 +16170,10 @@ function createDefaultFs5() {
     writeFile: (filePath, content) => fsPromises6.writeFile(filePath, content, "utf8"),
     readdir: fsPromises6.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises6.stat(filePath);
+      const stat14 = await fsPromises6.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        mtimeMs: stat14.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -16679,10 +16700,10 @@ function createDefaultFs6() {
     writeFile: (filePath, content) => fsPromises7.writeFile(filePath, content, "utf8"),
     readdir: fsPromises7.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises7.stat(filePath);
+      const stat14 = await fsPromises7.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        mtimeMs: stat14.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -17000,10 +17021,10 @@ function createDefaultFs7() {
     },
     readdir: fsPromises8.readdir,
     stat: async (filePath) => {
-      const stat13 = await fsPromises8.stat(filePath);
+      const stat14 = await fsPromises8.stat(filePath);
       return {
-        isFile: () => stat13.isFile(),
-        mtimeMs: stat13.mtimeMs
+        isFile: () => stat14.isFile(),
+        mtimeMs: stat14.mtimeMs
       };
     },
     mkdir: async (filePath, options) => {
@@ -23933,11 +23954,11 @@ function formatSegment(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords(segment).join(separator);
 }
-function toOptionFlag(path43, casing) {
-  return `--${path43.map((segment) => formatSegment(segment, casing)).join(".")}`;
+function toOptionFlag(path48, casing) {
+  return `--${path48.map((segment) => formatSegment(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path43, casing) {
-  return path43.map((segment) => {
+function toOptionAttribute(path48, casing) {
+  return path48.map((segment) => {
     const formatted = formatSegment(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -23948,13 +23969,13 @@ function toOptionAttribute(path43, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path43) {
-  return path43.join(".");
+function toDisplayPath(path48) {
+  return path48.join(".");
 }
-function collectFields(schema, casing, path43 = [], inheritedOptional = false) {
+function collectFields(schema, casing, path48 = [], inheritedOptional = false) {
   const fields = [];
   for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path43, key];
+    const nextPath = [...path48, key];
     const optional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional(rawChildSchema);
     if (childSchema.kind === "object") {
@@ -23977,9 +23998,9 @@ function collectFields(schema, casing, path43 = [], inheritedOptional = false) {
   }
   return fields;
 }
-function toCommanderOptionAttribute(path43, casing) {
-  const optionAttribute = toOptionAttribute(path43, casing);
-  const optionFlag = toOptionFlag(path43, casing);
+function toCommanderOptionAttribute(path48, casing) {
+  const optionAttribute = toOptionAttribute(path48, casing);
+  const optionFlag = toOptionFlag(path48, casing);
   if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
     return optionAttribute;
   }
@@ -24427,10 +24448,10 @@ function addGlobalOptions(command) {
     throw new InvalidArgumentError('Invalid value for "--output". Expected one of: rich, md, json.');
   }).option("--verbose", "Print stack traces for unexpected errors.");
 }
-function setNestedValue(target, path43, value) {
+function setNestedValue(target, path48, value) {
   let cursor = target;
-  for (let index = 0; index < path43.length - 1; index += 1) {
-    const segment = path43[index] ?? "";
+  for (let index = 0; index < path48.length - 1; index += 1) {
+    const segment = path48[index] ?? "";
     const existing = cursor[segment];
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -24440,7 +24461,7 @@ function setNestedValue(target, path43, value) {
     cursor[segment] = next;
     cursor = next;
   }
-  const leaf = path43[path43.length - 1];
+  const leaf = path48[path48.length - 1];
   if (leaf !== void 0) {
     cursor[leaf] = value;
   }
@@ -24530,13 +24551,13 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs() {
   return {
-    readFile: async (path43, encoding = "utf8") => readFile12(path43, { encoding }),
-    writeFile: async (path43, contents) => {
-      await writeFile7(path43, contents);
+    readFile: async (path48, encoding = "utf8") => readFile12(path48, { encoding }),
+    writeFile: async (path48, contents) => {
+      await writeFile7(path48, contents);
     },
-    exists: async (path43) => {
+    exists: async (path48) => {
       try {
-        await access2(path43);
+        await access2(path48);
         return true;
       } catch {
         return false;
@@ -24557,9 +24578,9 @@ function isPlainObject(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path43) {
+function hasNestedField(fields, path48) {
   return fields.some(
-    (field) => path43.length < field.path.length && path43.every((segment, index) => field.path[index] === segment)
+    (field) => path48.length < field.path.length && path48.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -24643,9 +24664,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path43) {
+  function visitObject(current, path48) {
     for (const [key, value] of Object.entries(current)) {
-      const nextPath = [...path43, key];
+      const nextPath = [...path48, key];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -28899,23 +28920,24 @@ var init_configs3 = __esm({
   }
 });
 
+// packages/agent-skill-config/src/templates/poe-generate.md
+var poe_generate_default;
+var init_poe_generate = __esm({
+  "packages/agent-skill-config/src/templates/poe-generate.md"() {
+    poe_generate_default = '---\nname: poe-generate\ndescription: \'Poe code generation skill\'\n---\n\n# poe-code generate\n\nUse `poe-code generate` to create text, images, audio, or video via the Poe API.\n\n## Text generation\n\n```bash\npoe-code generate "Write a short function that parses a JSON string safely."\n```\n\nSpecify the model/bot:\n\n```bash\n# CLI option\npoe-code generate --model "gpt-4.1" "Summarize this codebase change."\n\n# Some agent runtimes call the model selector `--bot`\npoe-code generate --bot "gpt-4.1" "Summarize this codebase change."\n```\n\n## Media generation\n\nThe CLI supports media generation as subcommands:\n\n```bash\npoe-code generate image "A 3D render of a rubber duck wearing sunglasses" --model "gpt-image-1" -o duck.png\npoe-code generate video "A cinematic timelapse of a city at night" --model "veo" -o city.mp4\npoe-code generate audio "A calm 10 second lo-fi beat" --model "audio-model" -o beat.wav\n```\n\nSome agent runtimes expose the same media types as flags. If available, these are equivalent:\n\n```bash\npoe-code generate --image "A 3D render of a rubber duck wearing sunglasses" --bot "gpt-image-1" -o duck.png\npoe-code generate --video "A cinematic timelapse of a city at night" --bot "veo" -o city.mp4\npoe-code generate --audio "A calm 10 second lo-fi beat" --bot "audio-model" -o beat.wav\n```\n\n## Tips\n\n- Use `--param key=value` to pass provider/model parameters (repeatable).\n- Use `--output <path>` (or `-o`) for media outputs.\n';
+  }
+});
+
+// packages/agent-skill-config/src/templates/terminal-pilot.md
+var terminal_pilot_default;
+var init_terminal_pilot = __esm({
+  "packages/agent-skill-config/src/templates/terminal-pilot.md"() {
+    terminal_pilot_default = "---\nname: terminal-pilot\ndescription: 'Terminal automation skill using the terminal-pilot CLI'\n---\n\n# Terminal Pilot\n\nUse the `terminal-pilot` CLI when you need to automate or inspect interactive\nCLI applications through a real PTY session.\n\n## Commands\n\n- `terminal-pilot create-session` - start a PTY-backed command\n- `terminal-pilot fill` - paste text into a session\n- `terminal-pilot type` - type character-by-character for TUIs and readline\n- `terminal-pilot press-key` - send named keys such as `Enter` or `ArrowDown`\n- `terminal-pilot wait-for` - wait for terminal output to match a pattern\n- `terminal-pilot wait-for-exit` - block until a session exits\n- `terminal-pilot read-screen` - inspect the current visible terminal screen\n- `terminal-pilot read-history` - read scrollback output\n- `terminal-pilot list-sessions` - list active sessions\n- `terminal-pilot close-session` - close a session and return its exit code\n\n## Examples\n\n```bash\nterminal-pilot --help\nterminal-pilot create-session --help\nterminal-pilot read-screen --help\n```\n\nUse JSON output when another tool or script needs to read the result:\n\n```bash\nterminal-pilot list-sessions --output json\nterminal-pilot read-screen --session s1 --output json\n```\n\n## Tips\n\n- Use `fill` for pasted text and multi-line input.\n- Use `type` when the app reacts to individual keystrokes.\n- Use `press-key` for Enter, Tab, arrow keys, Escape, and control-key chords.\n- Use `wait-for --literal` for exact string matching.\n- Default terminal size is 120x40.\n";
+  }
+});
+
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile13 } from "node:fs/promises";
-async function getTemplates() {
-  if (templatesCache) {
-    return templatesCache;
-  }
-  const entries = await Promise.all(
-    TEMPLATE_NAMES.map(async (name) => {
-      const url = new URL(`./templates/${name}`, import.meta.url);
-      return [name, await readFile13(url, "utf8")];
-    })
-  );
-  templatesCache = Object.fromEntries(entries);
-  return templatesCache;
-}
 async function loadTemplate2(templateId) {
-  const templates = await getTemplates();
   const template = templates[templateId];
   if (!template) {
     throw new Error(`Template not found: ${templateId}`);
@@ -28925,12 +28947,16 @@ async function loadTemplate2(templateId) {
 function createTemplateLoader() {
   return loadTemplate2;
 }
-var TEMPLATE_NAMES, templatesCache;
+var templates;
 var init_templates = __esm({
   "packages/agent-skill-config/src/templates.ts"() {
     "use strict";
-    TEMPLATE_NAMES = ["poe-generate.md", "terminal-pilot.md"];
-    templatesCache = null;
+    init_poe_generate();
+    init_terminal_pilot();
+    templates = {
+      "poe-generate.md": poe_generate_default,
+      "terminal-pilot.md": terminal_pilot_default
+    };
   }
 });
 
@@ -29943,7 +29969,7 @@ var init_models2 = __esm({
 
 // src/cli/commands/pipeline.ts
 import path40 from "node:path";
-import { readFile as readFile14, stat as stat11 } from "node:fs/promises";
+import { readFile as readFile13, stat as stat11 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 async function resolvePipelinePlanDirectory(container) {
   const configDoc = await readMergedDocument(
@@ -30013,8 +30039,8 @@ async function loadPipelineTemplates() {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile14(path40.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile14(path40.join(templateRoot, "steps.yaml.hbs"), "utf8")
+      readFile13(path40.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile13(path40.join(templateRoot, "steps.yaml.hbs"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -30348,12 +30374,12 @@ function registerPipelineCommand(program, container) {
         scope = selected;
       }
       resources.logger.intro(`pipeline install (${support.id}, ${scope})`);
-      const templates = await loadPipelineTemplates();
+      const templates2 = await loadPipelineTemplates();
       const skillResult = await installSkill(
         support.id,
         {
           name: "poe-code-pipeline-plan",
-          content: templates.skillPlan
+          content: templates2.skillPlan
         },
         {
           fs: container.fs,
@@ -30394,7 +30420,7 @@ function registerPipelineCommand(program, container) {
         await container.fs.mkdir(path40.dirname(pipelinePaths.stepsPath), {
           recursive: true
         });
-        await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
+        await container.fs.writeFile(pipelinePaths.stepsPath, templates2.steps, {
           encoding: "utf8"
         });
         resources.logger.info(
@@ -30429,8 +30455,828 @@ var init_pipeline3 = __esm({
   }
 });
 
-// src/cli/commands/ralph.ts
+// packages/plan-browser/src/format.ts
 import path41 from "node:path";
+function isPipelineTaskDone(task) {
+  if (typeof task.status === "string") {
+    return task.status === "done";
+  }
+  return Object.values(task.status).every((status) => status === "done");
+}
+function formatPipelineProgress(content) {
+  const plan = parsePlan(content);
+  const done = plan.tasks.filter((task) => isPipelineTaskDone(task)).length;
+  return `${done}/${plan.tasks.length} done`;
+}
+function formatRalphDetail(frontmatter) {
+  const parts = [];
+  if (frontmatter.agent !== void 0) {
+    parts.push(Array.isArray(frontmatter.agent) ? frontmatter.agent.join(", ") : frontmatter.agent);
+  }
+  if (frontmatter.iterations !== void 0) {
+    parts.push(`\xD7${frontmatter.iterations}`);
+  }
+  if (frontmatter.status.state !== "open" || frontmatter.status.iteration > 0) {
+    parts.push(`${frontmatter.status.state} ${frontmatter.status.iteration}`);
+  } else {
+    parts.push("open");
+  }
+  return parts.join(" \xB7 ");
+}
+function formatExperimentDetail(frontmatter, state) {
+  const parts = [];
+  if (frontmatter.agent !== void 0) {
+    parts.push(Array.isArray(frontmatter.agent) ? frontmatter.agent.join(", ") : frontmatter.agent);
+  }
+  const metrics = frontmatter.metric === void 0 ? [] : Array.isArray(frontmatter.metric) ? frontmatter.metric : [frontmatter.metric];
+  if (metrics.length > 0) {
+    const directions = Array.from(new Set(metrics.map((metric) => metric.direction)));
+    parts.push(directions.join("/"));
+  }
+  parts.push(state);
+  return parts.join(" \xB7 ");
+}
+function getLastExperimentState(journalContent) {
+  const lines = journalContent.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const parsed = JSON.parse(lines[index]);
+      if (typeof parsed.status === "string" && parsed.status.length > 0) {
+        return parsed.status;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "open";
+}
+function deriveMarkdownTitle(content, fallbackName) {
+  const heading = content.split("\n").map((line) => line.trim()).find((line) => line.startsWith("# "));
+  return heading ? heading.slice(2).trim() || fallbackName : fallbackName;
+}
+function formatPipelineTaskDetails(task) {
+  if (typeof task.status === "string") {
+    return null;
+  }
+  const entries = Object.entries(task.status).map(([name, status]) => `${name}=${status}`);
+  return entries.length > 0 ? `Step status: ${entries.join(", ")}` : null;
+}
+function formatPipelinePlanMarkdown(options) {
+  const plan = parsePlan(options.content);
+  const lines = [
+    `# ${options.title}`,
+    "",
+    `Status: ${formatPipelineProgress(options.content)}`,
+    "",
+    "## Tasks",
+    ""
+  ];
+  for (const task of plan.tasks) {
+    const mark = isPipelineTaskDone(task) ? "x" : " ";
+    lines.push(`- [${mark}] ${task.title} (\`${task.id}\`)`);
+    const detail = formatPipelineTaskDetails(task);
+    if (detail) {
+      lines.push(`  - ${detail}`);
+    }
+    for (const promptLine of task.prompt.split("\n")) {
+      lines.push(`  > ${promptLine}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function resolveExperimentJournalPath(absolutePath) {
+  return path41.join(
+    path41.dirname(absolutePath),
+    `${path41.basename(absolutePath, path41.extname(absolutePath))}.journal.jsonl`
+  );
+}
+async function readExperimentState(fs3, absolutePath) {
+  try {
+    const content = await fs3.readFile(resolveExperimentJournalPath(absolutePath), "utf8");
+    return getLastExperimentState(content);
+  } catch {
+    return "open";
+  }
+}
+async function loadPlanPreviewMarkdown(entry, fs3) {
+  const content = await fs3.readFile(entry.absolutePath, "utf8");
+  if (entry.source === "pipeline") {
+    return formatPipelinePlanMarkdown({
+      title: entry.title,
+      content
+    });
+  }
+  return content;
+}
+async function readPlanMetadata(options) {
+  const content = await options.fs.readFile(options.absolutePath, "utf8");
+  const fallbackName = path41.basename(options.path);
+  if (options.source === "pipeline") {
+    return {
+      title: fallbackName,
+      status: formatPipelineProgress(content),
+      format: "yaml"
+    };
+  }
+  if (options.source === "ralph") {
+    const parsed2 = parseFrontmatter(content);
+    return {
+      title: deriveMarkdownTitle(parsed2.body, fallbackName),
+      status: formatRalphDetail(parsed2.data),
+      format: "markdown"
+    };
+  }
+  const parsed = parseExperimentFrontmatter(content);
+  const state = await readExperimentState(options.fs, options.absolutePath);
+  return {
+    title: deriveMarkdownTitle(parsed.body, fallbackName),
+    status: formatExperimentDetail(parsed.frontmatter, state),
+    format: "markdown"
+  };
+}
+var init_format = __esm({
+  "packages/plan-browser/src/format.ts"() {
+    "use strict";
+    init_src10();
+    init_src14();
+    init_src13();
+  }
+});
+
+// packages/plan-browser/src/discovery.ts
+import path42 from "node:path";
+import * as fsPromises10 from "node:fs/promises";
+function createDefaultFs8() {
+  return {
+    readFile: fsPromises10.readFile,
+    writeFile: fsPromises10.writeFile,
+    readdir: fsPromises10.readdir,
+    stat: async (filePath) => {
+      const stat14 = await fsPromises10.stat(filePath);
+      return {
+        isFile: () => stat14.isFile(),
+        isDirectory: () => stat14.isDirectory(),
+        mtimeMs: stat14.mtimeMs
+      };
+    },
+    mkdir: async (directoryPath, mkdirOptions) => {
+      await fsPromises10.mkdir(directoryPath, mkdirOptions);
+    },
+    rename: fsPromises10.rename,
+    unlink: fsPromises10.unlink
+  };
+}
+function isNotFound4(error2) {
+  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT";
+}
+function resolveAbsoluteDirectory3(dir, cwd, homeDir) {
+  if (dir.startsWith("~/")) {
+    return path42.join(homeDir, dir.slice(2));
+  }
+  return path42.isAbsolute(dir) ? dir : path42.resolve(cwd, dir);
+}
+function resolveAbsoluteDisplayPath(displayPath, cwd, homeDir) {
+  if (displayPath.startsWith("~/")) {
+    return path42.join(homeDir, displayPath.slice(2));
+  }
+  return path42.isAbsolute(displayPath) ? displayPath : path42.resolve(cwd, displayPath);
+}
+function isPipelinePlanFile(name) {
+  const lower = name.toLowerCase();
+  return lower.startsWith("plan") && (lower.endsWith(".yaml") || lower.endsWith(".yml"));
+}
+function isMarkdownFile2(name) {
+  return name.toLowerCase().endsWith(".md");
+}
+async function resolvePlanDirectorySetting(options) {
+  const envValue = options.variables?.[options.envName]?.trim();
+  if (envValue) {
+    return envValue;
+  }
+  const document = await readMergedDocument(
+    options.fs,
+    options.configPath,
+    options.projectConfigPath
+  );
+  const configured = document[options.scope]?.plan_directory;
+  return typeof configured === "string" && configured.trim().length > 0 ? configured.trim() : void 0;
+}
+async function scanDirectory(options) {
+  let entries;
+  try {
+    entries = await options.fs.readdir(options.absoluteDir);
+  } catch (error2) {
+    if (isNotFound4(error2)) {
+      return [];
+    }
+    throw error2;
+  }
+  const plans = [];
+  for (const name of entries) {
+    if (!options.include(name)) {
+      continue;
+    }
+    const absolutePath = path42.join(options.absoluteDir, name);
+    const stat14 = await options.fs.stat(absolutePath);
+    if (!stat14.isFile()) {
+      continue;
+    }
+    const displayPath = path42.join(options.displayDir, name);
+    const metadata = await readPlanMetadata({
+      source: options.source,
+      absolutePath,
+      path: displayPath,
+      fs: options.fs
+    });
+    plans.push({
+      path: displayPath,
+      absolutePath: resolveAbsoluteDisplayPath(displayPath, options.cwd, options.homeDir),
+      source: options.source,
+      format: metadata.format,
+      title: metadata.title,
+      status: metadata.status,
+      updatedAt: stat14.mtimeMs
+    });
+  }
+  return plans;
+}
+async function discoverPipelinePlans(options) {
+  const configuredDir = await resolvePlanDirectorySetting({
+    fs: options.fs,
+    configPath: options.configPath,
+    projectConfigPath: options.projectConfigPath,
+    scope: "pipeline",
+    envName: "POE_PIPELINE_PLAN_DIRECTORY",
+    variables: options.variables
+  });
+  const targets = configuredDir ? [{
+    absoluteDir: resolveAbsoluteDirectory3(configuredDir, options.cwd, options.homeDir),
+    displayDir: configuredDir
+  }] : [
+    {
+      absoluteDir: path42.join(options.cwd, ".poe-code", "pipeline", "plans"),
+      displayDir: ".poe-code/pipeline/plans"
+    },
+    {
+      absoluteDir: path42.join(options.homeDir, ".poe-code", "pipeline", "plans"),
+      displayDir: "~/.poe-code/pipeline/plans"
+    }
+  ];
+  const plans = await Promise.all(
+    targets.map(
+      (target) => scanDirectory({
+        ...target,
+        fs: options.fs,
+        source: "pipeline",
+        include: isPipelinePlanFile,
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      })
+    )
+  );
+  return plans.flat();
+}
+async function discoverExperimentPlans(options) {
+  const configuredDir = await resolvePlanDirectorySetting({
+    fs: options.fs,
+    configPath: options.configPath,
+    projectConfigPath: options.projectConfigPath,
+    scope: "experiment",
+    envName: "POE_EXPERIMENT_PLAN_DIRECTORY",
+    variables: options.variables
+  });
+  const targets = configuredDir ? [{
+    absoluteDir: resolveAbsoluteDirectory3(configuredDir, options.cwd, options.homeDir),
+    displayDir: configuredDir
+  }] : [
+    {
+      absoluteDir: path42.join(options.cwd, ".poe-code", "experiments"),
+      displayDir: ".poe-code/experiments"
+    },
+    {
+      absoluteDir: path42.join(options.homeDir, ".poe-code", "experiments"),
+      displayDir: "~/.poe-code/experiments"
+    }
+  ];
+  const plans = await Promise.all(
+    targets.map(
+      (target) => scanDirectory({
+        ...target,
+        fs: options.fs,
+        source: "experiment",
+        include: isMarkdownFile2,
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      })
+    )
+  );
+  return plans.flat();
+}
+async function discoverRalphPlans(options) {
+  const configuredDir = await resolvePlanDirectorySetting({
+    fs: options.fs,
+    configPath: options.configPath,
+    projectConfigPath: options.projectConfigPath,
+    scope: "ralph",
+    envName: "POE_RALPH_PLAN_DIRECTORY",
+    variables: options.variables
+  });
+  const docs = await discoverDocs({
+    cwd: options.cwd,
+    homeDir: options.homeDir,
+    planDirectory: configuredDir,
+    fs: {
+      readdir: options.fs.readdir,
+      stat: async (filePath) => {
+        const stat14 = await options.fs.stat(filePath);
+        return {
+          isFile: () => stat14.isFile(),
+          mtimeMs: stat14.mtimeMs
+        };
+      }
+    }
+  });
+  const plans = await Promise.all(
+    docs.map(async (doc) => {
+      const absolutePath = resolveAbsoluteDisplayPath(doc.path, options.cwd, options.homeDir);
+      const stat14 = await options.fs.stat(absolutePath);
+      const metadata = await readPlanMetadata({
+        source: "ralph",
+        absolutePath,
+        path: doc.path,
+        fs: options.fs
+      });
+      return {
+        path: doc.path,
+        absolutePath,
+        source: "ralph",
+        format: metadata.format,
+        title: metadata.title,
+        status: metadata.status,
+        updatedAt: stat14.mtimeMs
+      };
+    })
+  );
+  return plans;
+}
+async function discoverAllPlans(options) {
+  const fs3 = options.fs ?? createDefaultFs8();
+  const discoverers = {
+    pipeline: () => discoverPipelinePlans({ ...options, fs: fs3 }),
+    experiment: () => discoverExperimentPlans({ ...options, fs: fs3 }),
+    ralph: () => discoverRalphPlans({ ...options, fs: fs3 })
+  };
+  const sources = options.source ? [options.source] : Object.keys(discoverers);
+  const results = (await Promise.all(sources.map((source) => discoverers[source]()))).flat();
+  const deduped = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!deduped.has(result.absolutePath)) {
+      deduped.set(result.absolutePath, result);
+    }
+  }
+  return [...deduped.values()].sort((left, right) => {
+    if (right.updatedAt !== left.updatedAt) {
+      return right.updatedAt - left.updatedAt;
+    }
+    return left.path.localeCompare(right.path);
+  });
+}
+var init_discovery3 = __esm({
+  "packages/plan-browser/src/discovery.ts"() {
+    "use strict";
+    init_src13();
+    init_src4();
+    init_format();
+  }
+});
+
+// packages/plan-browser/src/actions.ts
+import path43 from "node:path";
+import { spawnSync as nodeSpawnSync } from "node:child_process";
+function resolveEditor2(env = process.env) {
+  const editor = env.EDITOR?.trim() || env.VISUAL?.trim() || "vi";
+  return editor.length > 0 ? editor : "vi";
+}
+function editPlan(absolutePath, options = {}) {
+  const editor = resolveEditor2(options.env);
+  const spawnSync3 = options.spawnSync ?? nodeSpawnSync;
+  spawnSync3(editor, [absolutePath], { stdio: "inherit" });
+}
+async function archivePlan3(entry, fs3) {
+  const archiveDir = path43.join(path43.dirname(entry.absolutePath), "archive");
+  const archivedPath = path43.join(archiveDir, path43.basename(entry.absolutePath));
+  await fs3.mkdir(archiveDir, { recursive: true });
+  await fs3.rename(entry.absolutePath, archivedPath);
+  return archivedPath;
+}
+async function deletePlan(entry, fs3) {
+  await fs3.unlink(entry.absolutePath);
+}
+var init_actions = __esm({
+  "packages/plan-browser/src/actions.ts"() {
+    "use strict";
+  }
+});
+
+// packages/plan-browser/src/browser.ts
+import path44 from "node:path";
+async function runPlanBrowser(options) {
+  const renderPlanPreview = async (entry) => {
+    const markdown = await loadPlanPreviewMarkdown(entry, options.fs);
+    process.stdout.write(`${renderMarkdown(markdown).trimEnd()}
+`);
+  };
+  while (true) {
+    const plans = await discoverAllPlans({
+      cwd: options.cwd,
+      homeDir: options.homeDir,
+      configPath: options.configPath,
+      projectConfigPath: options.projectConfigPath,
+      fs: options.fs,
+      source: options.source,
+      variables: options.variables
+    });
+    if (plans.length === 0) {
+      process.stdout.write("No plans found.\n");
+      return;
+    }
+    if (options.assumeYes) {
+      const selectedPlan2 = plans[0];
+      await renderPlanPreview(selectedPlan2);
+      return;
+    }
+    const selectedPath = await select2({
+      message: "Select a plan",
+      options: plans.map((plan) => ({
+        label: text.selectLabel(path44.basename(plan.path), plan.status),
+        hint: plan.source,
+        value: plan.absolutePath
+      }))
+    });
+    if (Ct(selectedPath)) {
+      return;
+    }
+    const selectedPlan = plans.find((plan) => plan.absolutePath === selectedPath);
+    if (!selectedPlan) {
+      cancel("Plan selection cancelled.");
+      return;
+    }
+    await renderPlanPreview(selectedPlan);
+    process.stdout.write("\n");
+    const action = await select2({
+      message: "Action",
+      options: [
+        { label: "Back to list", value: "back" },
+        { label: "Edit in $EDITOR", value: "edit" },
+        { label: "Archive", value: "archive" },
+        { label: "Delete", value: "delete" }
+      ]
+    });
+    if (Ct(action) || action === "back") {
+      continue;
+    }
+    if (action === "edit") {
+      editPlan(selectedPlan.absolutePath, {
+        env: options.variables ?? process.env
+      });
+      continue;
+    }
+    if (action === "archive") {
+      try {
+        const confirmed = options.assumeYes || await confirmOrCancel({
+          message: `Archive ${path44.basename(selectedPlan.path)}?`,
+          initialValue: true
+        });
+        if (confirmed) {
+          await archivePlan3(selectedPlan, options.fs);
+        }
+      } catch (error2) {
+        if (!(error2 instanceof PromptCancelledError)) {
+          throw error2;
+        }
+      }
+      continue;
+    }
+    try {
+      const confirmed = options.assumeYes || await confirmOrCancel({
+        message: `Permanently delete ${path44.basename(selectedPlan.path)}?`,
+        initialValue: true
+      });
+      if (confirmed) {
+        await deletePlan(selectedPlan, options.fs);
+      }
+    } catch (error2) {
+      if (!(error2 instanceof PromptCancelledError)) {
+        throw error2;
+      }
+    }
+  }
+}
+var init_browser = __esm({
+  "packages/plan-browser/src/browser.ts"() {
+    "use strict";
+    init_src5();
+    init_src5();
+    init_actions();
+    init_discovery3();
+    init_format();
+  }
+});
+
+// packages/plan-browser/src/index.ts
+var init_src23 = __esm({
+  "packages/plan-browser/src/index.ts"() {
+    "use strict";
+    init_discovery3();
+    init_actions();
+    init_format();
+    init_browser();
+  }
+});
+
+// src/cli/commands/plan.ts
+import path45 from "node:path";
+function resolvePlanCommandOptions(command) {
+  const localOptions = command.opts();
+  const parentOptions = command.parent?.opts() ?? {};
+  return {
+    source: localOptions.source ?? parentOptions.source,
+    output: localOptions.output ?? parentOptions.output
+  };
+}
+function resolveOutputOption(value) {
+  if (!value || value.trim().length === 0) {
+    return "terminal";
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "json") {
+    return "json";
+  }
+  if (normalized === "md" || normalized === "markdown") {
+    return "markdown";
+  }
+  if (normalized === "terminal") {
+    return "terminal";
+  }
+  throw new ValidationError(`Invalid --output value "${value}". Expected one of: terminal, md, json.`);
+}
+function resolveSource(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  if (value === "pipeline" || value === "experiment" || value === "ralph") {
+    return value;
+  }
+  throw new ValidationError(`Invalid --source value "${value}". Expected pipeline, experiment, or ralph.`);
+}
+function formatDate2(timestamp) {
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+async function discoverPlans(container, source) {
+  return discoverAllPlans({
+    cwd: container.env.cwd,
+    homeDir: container.env.homeDir,
+    configPath: container.env.configPath,
+    projectConfigPath: container.env.projectConfigPath,
+    fs: container.fs,
+    source,
+    variables: container.env.variables
+  });
+}
+async function resolveSelectedPlan(options) {
+  const providedPath = options.providedPath?.trim();
+  if (providedPath) {
+    const resolvedAbsolute = providedPath.startsWith("~/") ? path45.join(options.container.env.homeDir, providedPath.slice(2)) : path45.isAbsolute(providedPath) ? providedPath : path45.resolve(options.container.env.cwd, providedPath);
+    const matched2 = options.plans.find(
+      (plan) => plan.path === providedPath || plan.absolutePath === providedPath || plan.absolutePath === resolvedAbsolute
+    );
+    if (!matched2) {
+      throw new ValidationError(`Plan not found: ${providedPath}`);
+    }
+    return matched2;
+  }
+  if (options.plans.length === 0) {
+    throw new ValidationError("No plans found.");
+  }
+  if (options.assumeYes) {
+    return options.plans[0];
+  }
+  const selected = await select2({
+    message: options.promptMessage,
+    options: options.plans.map((plan) => ({
+      label: text.selectLabel(path45.basename(plan.path), plan.status),
+      hint: plan.source,
+      value: plan.absolutePath
+    }))
+  });
+  if (Ct(selected)) {
+    throw new ValidationError("Plan selection cancelled.");
+  }
+  const matched = options.plans.find((plan) => plan.absolutePath === selected);
+  if (!matched) {
+    throw new ValidationError("Plan selection cancelled.");
+  }
+  return matched;
+}
+function writeOutput(format, value) {
+  if (format === "terminal") {
+    process.stdout.write(value.endsWith("\n") ? value : `${value}
+`);
+    return;
+  }
+  const scopedFormat = format === "markdown" ? "markdown" : "json";
+  withOutputFormat(scopedFormat, () => {
+    process.stdout.write(value.endsWith("\n") ? value : `${value}
+`);
+  });
+}
+async function renderPlanList(container, options) {
+  const format = resolveOutputOption(options.output);
+  const source = resolveSource(options.source);
+  const plans = await discoverPlans(container, source);
+  if (format === "json") {
+    writeOutput(
+      format,
+      JSON.stringify(
+        plans.map((plan) => ({
+          source: plan.source,
+          name: path45.basename(plan.path),
+          path: plan.path,
+          detail: plan.status,
+          updated: formatDate2(plan.updatedAt)
+        })),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const table = withOutputFormat(
+    format,
+    () => renderTable({
+      theme: getTheme(),
+      columns: [
+        { name: "source", title: "Source", alignment: "left", maxLen: 12 },
+        { name: "name", title: "Name", alignment: "left", maxLen: 32 },
+        { name: "detail", title: "Detail", alignment: "left", maxLen: 40 },
+        { name: "updated", title: "Updated", alignment: "left", maxLen: 12 }
+      ],
+      rows: plans.map((plan) => ({
+        source: plan.source,
+        name: path45.basename(plan.path),
+        detail: plan.status,
+        updated: formatDate2(plan.updatedAt)
+      }))
+    })
+  );
+  writeOutput(format, table);
+}
+async function executePlanAction(options) {
+  intro(`plan ${options.action}`);
+  const flags = resolveCommandFlags(options.program);
+  const format = resolveOutputOption(options.output);
+  const plans = await discoverPlans(options.container, resolveSource(options.source));
+  const plan = await resolveSelectedPlan({
+    container: options.container,
+    plans,
+    providedPath: options.pathArg,
+    assumeYes: flags.assumeYes,
+    promptMessage: `Select a plan to ${options.action}`
+  });
+  if (options.action === "edit") {
+    editPlan(plan.absolutePath, {
+      env: options.container.env.variables
+    });
+    writeOutput(
+      format,
+      format === "json" ? JSON.stringify({ action: "edit", path: plan.path }, null, 2) : `Edited ${plan.path}`
+    );
+    return;
+  }
+  if (!flags.assumeYes) {
+    const confirmed = await confirmOrCancel({
+      message: options.action === "archive" ? `Archive ${path45.basename(plan.path)}?` : `Permanently delete ${path45.basename(plan.path)}?`,
+      initialValue: true
+    });
+    if (!confirmed) {
+      return;
+    }
+  }
+  if (options.action === "archive") {
+    const archivedPath = await archivePlan3(
+      plan,
+      options.container.fs
+    );
+    writeOutput(
+      format,
+      format === "json" ? JSON.stringify({ action: "archive", path: plan.path, archivedPath }, null, 2) : `Archived ${plan.path}`
+    );
+    return;
+  }
+  await deletePlan(
+    plan,
+    options.container.fs
+  );
+  writeOutput(
+    format,
+    format === "json" ? JSON.stringify({ action: "delete", path: plan.path }, null, 2) : `Deleted ${plan.path}`
+  );
+}
+function registerPlanCommand(program, container) {
+  const plan = program.command("plan").description("Browse, view, and manage plans across pipeline, experiment, and Ralph.").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").action(async function() {
+    const opts = this.opts();
+    const flags = resolveCommandFlags(this);
+    intro("plan browser");
+    await runPlanBrowser({
+      cwd: container.env.cwd,
+      homeDir: container.env.homeDir,
+      configPath: container.env.configPath,
+      projectConfigPath: container.env.projectConfigPath,
+      fs: container.fs,
+      source: resolveSource(opts.source),
+      variables: container.env.variables,
+      assumeYes: flags.assumeYes
+    });
+  });
+  plan.command("list").description("List plans across all plan systems.").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").option("--output <format>", "Output format: terminal, md, or json").action(async function() {
+    intro("plan list");
+    await renderPlanList(container, resolvePlanCommandOptions(this));
+  });
+  plan.command("view").description("Render a single plan to the terminal.").argument("[path]", "Plan path").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").option("--output <format>", "Output format: terminal, md, or json").action(async function(pathArg) {
+    intro("plan view");
+    const flags = resolveCommandFlags(program);
+    const options = resolvePlanCommandOptions(this);
+    const format = resolveOutputOption(options.output);
+    const plans = await discoverPlans(container, resolveSource(options.source));
+    const plan2 = await resolveSelectedPlan({
+      container,
+      plans,
+      providedPath: pathArg,
+      assumeYes: flags.assumeYes,
+      promptMessage: "Select a plan to view"
+    });
+    const markdown = await loadPlanPreviewMarkdown(plan2, container.fs);
+    if (format === "json") {
+      writeOutput(
+        format,
+        JSON.stringify(
+          {
+            source: plan2.source,
+            path: plan2.path,
+            title: plan2.title,
+            detail: plan2.status,
+            content: markdown
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const output = format === "markdown" ? markdown : renderMarkdown(markdown);
+    writeOutput(format, output.trimEnd());
+  });
+  plan.command("edit").description("Open a plan in $EDITOR.").argument("[path]", "Plan path").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").option("--output <format>", "Output format: terminal, md, or json").action(async function(pathArg) {
+    await executePlanAction({
+      program,
+      container,
+      action: "edit",
+      pathArg,
+      ...resolvePlanCommandOptions(this)
+    });
+  });
+  plan.command("archive").description("Move a plan into archive/.").argument("[path]", "Plan path").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").option("--output <format>", "Output format: terminal, md, or json").action(async function(pathArg) {
+    await executePlanAction({
+      program,
+      container,
+      action: "archive",
+      pathArg,
+      ...resolvePlanCommandOptions(this)
+    });
+  });
+  plan.command("delete").description("Delete a plan file.").argument("[path]", "Plan path").option("--source <source>", "Filter by plan source: pipeline, experiment, or ralph").option("--output <format>", "Output format: terminal, md, or json").action(async function(pathArg) {
+    await executePlanAction({
+      program,
+      container,
+      action: "delete",
+      pathArg,
+      ...resolvePlanCommandOptions(this)
+    });
+  });
+}
+var init_plan = __esm({
+  "src/cli/commands/plan.ts"() {
+    "use strict";
+    init_src5();
+    init_src23();
+    init_errors();
+    init_shared();
+  }
+});
+
+// src/cli/commands/ralph.ts
+import path46 from "node:path";
 function formatDuration2(ms) {
   const totalSeconds = Math.round(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
@@ -30466,9 +31312,9 @@ function normalizeConfiguredIterations(value) {
 }
 function resolveAbsoluteDocPath4(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path41.join(container.env.homeDir, docPath.slice(2));
+    return path46.join(container.env.homeDir, docPath.slice(2));
   }
-  return path41.isAbsolute(docPath) ? docPath : path41.resolve(container.env.cwd, docPath);
+  return path46.isAbsolute(docPath) ? docPath : path46.resolve(container.env.cwd, docPath);
 }
 async function resolvePlanDirectory2(container) {
   const configDoc = await readMergedDocument(
@@ -30839,11 +31685,11 @@ var init_ralph3 = __esm({
 });
 
 // src/cli/commands/experiment.ts
-import path42 from "node:path";
-import { readFile as readFile15, stat as stat12 } from "node:fs/promises";
+import path47 from "node:path";
+import { readFile as readFile15, stat as stat13 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path42.join(homeDir, ".poe-code", "experiments") : path42.join(cwd, ".poe-code", "experiments");
+  const rootPath = scope === "global" ? path47.join(homeDir, ".poe-code", "experiments") : path47.join(cwd, ".poe-code", "experiments");
   const displayRoot = scope === "global" ? "~/.poe-code/experiments" : ".poe-code/experiments";
   return {
     experimentsPath: rootPath,
@@ -30852,7 +31698,7 @@ function resolveExperimentPaths(scope, cwd, homeDir) {
 }
 async function pathExistsOnDisk2(targetPath) {
   try {
-    await stat12(targetPath);
+    await stat13(targetPath);
     return true;
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
@@ -30862,12 +31708,12 @@ async function pathExistsOnDisk2(targetPath) {
   }
 }
 async function findPackageRoot2(entryFilePath) {
-  let currentPath = path42.dirname(entryFilePath);
+  let currentPath = path47.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk2(path42.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk2(path47.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path42.dirname(currentPath);
+    const parentPath = path47.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Experiment templates.");
     }
@@ -30880,16 +31726,16 @@ async function loadExperimentTemplates() {
   }
   const packageRoot = await findPackageRoot2(fileURLToPath8(import.meta.url));
   const templateRoots = [
-    path42.join(packageRoot, "src", "templates", "experiment"),
-    path42.join(packageRoot, "dist", "templates", "experiment")
+    path47.join(packageRoot, "src", "templates", "experiment"),
+    path47.join(packageRoot, "dist", "templates", "experiment")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk2(templateRoot)) {
       continue;
     }
     const [skillPlan, runYaml] = await Promise.all([
-      readFile15(path42.join(templateRoot, "SKILL_experiment.md"), "utf8"),
-      readFile15(path42.join(templateRoot, "run.yaml.hbs"), "utf8")
+      readFile15(path47.join(templateRoot, "SKILL_experiment.md"), "utf8"),
+      readFile15(path47.join(templateRoot, "run.yaml.hbs"), "utf8")
     ]);
     experimentTemplatesCache = { skillPlan, runYaml };
     return experimentTemplatesCache;
@@ -30976,15 +31822,15 @@ async function resolveExperimentPlanDirectory(container) {
 }
 function resolveAbsoluteDocPath5(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path42.join(container.env.homeDir, docPath.slice(2));
+    return path47.join(container.env.homeDir, docPath.slice(2));
   }
-  return path42.isAbsolute(docPath) ? docPath : path42.resolve(container.env.cwd, docPath);
+  return path47.isAbsolute(docPath) ? docPath : path47.resolve(container.env.cwd, docPath);
 }
-function resolveAbsoluteDirectory3(dir, cwd, homeDir) {
+function resolveAbsoluteDirectory4(dir, cwd, homeDir) {
   if (dir.startsWith("~/")) {
-    return path42.join(homeDir, dir.slice(2));
+    return path47.join(homeDir, dir.slice(2));
   }
-  return path42.isAbsolute(dir) ? dir : path42.resolve(cwd, dir);
+  return path47.isAbsolute(dir) ? dir : path47.resolve(cwd, dir);
 }
 async function scanExperimentDir(container, absoluteDir, displayDir) {
   let names;
@@ -31001,12 +31847,12 @@ async function scanExperimentDir(container, absoluteDir, displayDir) {
     if (!name.endsWith(".md")) {
       continue;
     }
-    const absolutePath = path42.join(absoluteDir, name);
+    const absolutePath = path47.join(absoluteDir, name);
     const fileStat = await container.fs.stat(absolutePath);
     if (!fileStat.isFile()) {
       continue;
     }
-    const displayPath = path42.join(displayDir, name);
+    const displayPath = path47.join(displayDir, name);
     docs.push({ path: displayPath, displayPath });
   }
   return docs;
@@ -31014,12 +31860,12 @@ async function scanExperimentDir(container, absoluteDir, displayDir) {
 async function discoverExperimentDocs(container, planDirectory) {
   const customDir = planDirectory?.trim();
   if (customDir) {
-    const absoluteDir = resolveAbsoluteDirectory3(customDir, container.env.cwd, container.env.homeDir);
+    const absoluteDir = resolveAbsoluteDirectory4(customDir, container.env.cwd, container.env.homeDir);
     return scanExperimentDir(container, absoluteDir, customDir);
   }
   return scanExperimentDir(
     container,
-    path42.join(container.env.cwd, EXPERIMENTS_DIRECTORY),
+    path47.join(container.env.cwd, EXPERIMENTS_DIRECTORY),
     EXPERIMENTS_DIRECTORY
   );
 }
@@ -31396,12 +32242,12 @@ function registerExperimentCommand(program, container) {
         scope = selected;
       }
       resources.logger.intro(`experiment install (${support.id}, ${scope})`);
-      const templates = await loadExperimentTemplates();
+      const templates2 = await loadExperimentTemplates();
       const skillResult = await installSkill(
         support.id,
         {
           name: "poe-code-experiment-plan",
-          content: templates.skillPlan
+          content: templates2.skillPlan
         },
         {
           fs: container.fs,
@@ -31435,13 +32281,13 @@ function registerExperimentCommand(program, container) {
           );
         }
       }
-      const runYamlPath = path42.join(experimentPaths.experimentsPath, "run.yaml");
-      const runYamlDisplayPath = path42.join(experimentPaths.displayExperimentsPath, "run.yaml");
+      const runYamlPath = path47.join(experimentPaths.experimentsPath, "run.yaml");
+      const runYamlDisplayPath = path47.join(experimentPaths.displayExperimentsPath, "run.yaml");
       if (!await pathExists4(container.fs, runYamlPath)) {
         if (flags.dryRun) {
           resources.logger.dryRun(`Would create: ${runYamlDisplayPath}`);
         } else {
-          await container.fs.writeFile(runYamlPath, templates.runYaml);
+          await container.fs.writeFile(runYamlPath, templates2.runYaml);
           resources.logger.info(`Create: ${runYamlDisplayPath}`);
         }
       }
@@ -31470,7 +32316,7 @@ var init_experiment2 = __esm({
     init_src4();
     DEFAULT_EXPERIMENT_AGENT = "claude-code";
     DEFAULT_EXPERIMENT_SCOPE = "local";
-    EXPERIMENTS_DIRECTORY = path42.join(".poe-code", "experiments");
+    EXPERIMENTS_DIRECTORY = path47.join(".poe-code", "experiments");
     experimentTemplatesCache = null;
   }
 });
@@ -31902,7 +32748,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.155",
+      version: "3.0.156",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -32010,6 +32856,7 @@ var init_package = __esm({
         "@poe-code/e2e-docker-test-runner": "*",
         "@poe-code/experiment-loop": "*",
         "@poe-code/github-workflows": "*",
+        "@poe-code/plan-browser": "*",
         "@poe-code/pipeline": "*",
         "@poe-code/poe-acp-client": "*",
         "@poe-code/poe-agent": "*",
@@ -32077,22 +32924,22 @@ function formatCommandHeader(cmd) {
   }
   return `Poe - ${parts.reverse().join(" ")}`;
 }
-function findCommandByPath(root, path43) {
+function findCommandByPath(root, path48) {
   let current = root;
-  for (const segment of path43) {
+  for (const segment of path48) {
     const next = current.commands.find(
       (command) => Reflect.get(command, "_hidden") !== true && command.name() === segment
     );
     if (!next) {
-      throw new Error(`Root help command is missing: ${path43.join(" ")}`);
+      throw new Error(`Root help command is missing: ${path48.join(" ")}`);
     }
     current = next;
   }
   return current;
 }
-function formatRootHelpCommandName(path43, command) {
+function formatRootHelpCommandName(path48, command) {
   const leaf = [command.name(), ...command.aliases()].join(", ");
-  return path43.length > 1 ? [...path43.slice(0, -1), leaf].join(" ") : leaf;
+  return path48.length > 1 ? [...path48.slice(0, -1), leaf].join(" ") : leaf;
 }
 function splitUsageParts(usage) {
   return usage.split(" ").map((part) => part.trim()).filter((part) => part.length > 0);
@@ -32309,6 +33156,7 @@ function bootstrapProgram(container) {
   registerMcpCommand(program, container);
   registerSkillCommand(program, container);
   registerPipelineCommand(program, container);
+  registerPlanCommand(program, container);
   registerRalphCommand(program, container);
   registerExperimentCommand(program, container);
   registerLaunchCommand(program, container);
@@ -32381,6 +33229,7 @@ var init_program = __esm({
     init_usage();
     init_models2();
     await init_pipeline3();
+    init_plan();
     await init_ralph3();
     await init_experiment2();
     init_launch2();
@@ -32407,6 +33256,7 @@ var init_program = __esm({
       { path: ["pipeline", "install"] },
       { path: ["pipeline", "run"] },
       { path: ["pipeline", "validate"] },
+      { path: ["plan"] },
       { path: ["experiment", "install"] },
       { path: ["experiment", "run"] },
       { path: ["experiment", "journal"] },