poe-code 3.0.114 → 3.0.116

package/dist/index.js

@@ -891,16 +891,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path28) {
-  const ext = getExtension(path28);
+function detectFormat(path29) {
+  const ext = getExtension(path29);
   return extensionMap[ext];
 }
-function getExtension(path28) {
-  const lastDot = path28.lastIndexOf(".");
+function getExtension(path29) {
+  const lastDot = path29.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path28.slice(lastDot).toLowerCase();
+  return path29.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -1750,6 +1750,61 @@ var init_store = __esm({
 });
 
 // packages/poe-code-config/src/resolve.ts
+function resolveScope(schema, fileValues, env = {}) {
+  const resolved = {};
+  for (const key of Object.keys(schema)) {
+    const field = schema[key];
+    const envValue = resolveEnvValue(field, env);
+    const fileValue = resolveFileValue(field, fileValues?.[key]);
+    resolved[key] = envValue ?? fileValue ?? field.default;
+  }
+  return resolved;
+}
+function resolveEnvValue(field, env) {
+  if (!field.env) {
+    return void 0;
+  }
+  const raw = env[field.env];
+  if (raw === void 0) {
+    return void 0;
+  }
+  return coerceValue(field, raw);
+}
+function resolveFileValue(field, value) {
+  return coerceValue(field, value);
+}
+function coerceValue(field, value) {
+  switch (field.type) {
+    case "string":
+      return typeof value === "string" ? value : void 0;
+    case "number":
+      return coerceNumber(value);
+    case "boolean":
+      return coerceBoolean(value);
+  }
+}
+function coerceNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function coerceBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === "true" || value === "1") {
+    return true;
+  }
+  if (value === "false" || value === "0") {
+    return false;
+  }
+  return void 0;
+}
 var init_resolve = __esm({
   "packages/poe-code-config/src/resolve.ts"() {
     "use strict";
@@ -1900,38 +1955,38 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path28, encoding) {
+    async readFile(path29, encoding) {
       if (encoding) {
-        return base.readFile(path28, encoding);
+        return base.readFile(path29, encoding);
       }
-      return base.readFile(path28);
+      return base.readFile(path29);
     },
-    async writeFile(path28, data, options) {
-      const previousContent = await tryReadText(base, path28);
+    async writeFile(path29, data, options) {
+      const previousContent = await tryReadText(base, path29);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path28,
+        path: path29,
         nextContent,
         previousContent
       });
     },
-    async mkdir(path28, options) {
-      recorder.record({ type: "mkdir", path: path28, options });
+    async mkdir(path29, options) {
+      recorder.record({ type: "mkdir", path: path29, options });
     },
-    async stat(path28) {
-      return base.stat(path28);
+    async stat(path29) {
+      return base.stat(path29);
     },
-    async unlink(path28) {
-      recorder.record({ type: "unlink", path: path28 });
+    async unlink(path29) {
+      recorder.record({ type: "unlink", path: path29 });
     },
-    async readdir(path28) {
-      return base.readdir(path28);
+    async readdir(path29) {
+      return base.readdir(path29);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path28, options) => {
-      recorder.record({ type: "rm", path: path28, options });
+    proxy.rm = async (path29, options) => {
+      recorder.record({ type: "rm", path: path29, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -2021,8 +2076,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path28, change) {
-  const command = `cat > ${path28}`;
+function renderWriteCommand(path29, change) {
+  const command = `cat > ${path29}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -2184,9 +2239,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path28) {
+async function tryReadText(base, path29) {
   try {
-    return await base.readFile(path28, "utf8");
+    return await base.readFile(path29, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -3324,6 +3379,12 @@ var init_text = __esm({
       badge(content) {
         const theme = getTheme();
         return theme.badge(content);
+      },
+      selectLabel(label, detail) {
+        if (!detail) {
+          return label;
+        }
+        return `${label} ${typography.dim("\u2014")} ${typography.dim(detail)}`;
       }
     };
   }
@@ -4028,21 +4089,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 path28;
+        let path29;
         if (typeof item.content === "string") {
-          path28 = item.content;
+          path29 = item.content;
         } else {
           try {
-            path28 = JSON.stringify(item.content);
+            path29 = JSON.stringify(item.content);
           } catch {
-            path28 = String(item.content);
+            path29 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path28
+          path: path29
         };
       }
     }
@@ -4164,10 +4225,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 path28 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path29 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path28 };
+        yield { event: "tool_complete", id: item.id, kind, path: path29 };
       }
     }
   }
@@ -4616,7 +4677,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path28 = readString(event.path);
+  const path29 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -4631,8 +4692,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path28) {
-    toolCall.path = path28;
+  if (path29) {
+    toolCall.path = path29;
   }
 }
 var sessionCapture;
@@ -6630,21 +6691,21 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path28, encoding) => {
+    readFile: ((path29, encoding) => {
       if (encoding) {
-        return fs2.readFile(path28, encoding);
+        return fs2.readFile(path29, encoding);
       }
-      return fs2.readFile(path28);
+      return fs2.readFile(path29);
     }),
-    writeFile: (path28, data, opts) => fs2.writeFile(path28, data, opts),
-    mkdir: (path28, opts) => fs2.mkdir(path28, opts).then(() => {
+    writeFile: (path29, data, opts) => fs2.writeFile(path29, data, opts),
+    mkdir: (path29, opts) => fs2.mkdir(path29, opts).then(() => {
     }),
-    stat: (path28) => fs2.stat(path28),
-    rm: (path28, opts) => fs2.rm(path28, opts),
-    unlink: (path28) => fs2.unlink(path28),
-    readdir: (path28) => fs2.readdir(path28),
+    stat: (path29) => fs2.stat(path29),
+    rm: (path29, opts) => fs2.rm(path29, opts),
+    unlink: (path29) => fs2.unlink(path29),
+    readdir: (path29) => fs2.readdir(path29),
     copyFile: (src, dest) => fs2.copyFile(src, dest),
-    chmod: (path28, mode) => fs2.chmod(path28, mode)
+    chmod: (path29, mode) => fs2.chmod(path29, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -7189,16 +7250,46 @@ async function scanPlansDir(fs3, plansDir, displayPrefix) {
   }
   return candidates;
 }
-async function listPlanCandidates(fs3, cwd, homeDir) {
+async function listPlanCandidates(fs3, cwd, homeDir, planDirectory) {
+  const customDir = planDirectory?.trim();
+  const candidates = customDir ? await scanCustomPlanDir(fs3, customDir, cwd, homeDir) : await scanDefaultPlanDirs(fs3, cwd, homeDir);
+  candidates.sort((left, right) => left.path.localeCompare(right.path));
+  return candidates;
+}
+async function scanCustomPlanDir(fs3, planDirectory, cwd, homeDir) {
+  const absoluteDir = resolveAbsoluteDirectory(planDirectory, cwd, homeDir);
+  return scanPlansDir(fs3, absoluteDir, planDirectory);
+}
+async function scanDefaultPlanDirs(fs3, cwd, homeDir) {
   const projectDir = path13.join(cwd, ".poe-code", "pipeline", "plans");
   const globalDir = path13.join(homeDir, ".poe-code", "pipeline", "plans");
   const [projectCandidates, globalCandidates] = await Promise.all([
     scanPlansDir(fs3, projectDir, ".poe-code/pipeline/plans"),
     scanPlansDir(fs3, globalDir, "~/.poe-code/pipeline/plans")
   ]);
-  const candidates = [...projectCandidates, ...globalCandidates];
-  candidates.sort((left, right) => left.path.localeCompare(right.path));
-  return candidates;
+  return [...projectCandidates, ...globalCandidates];
+}
+function resolveAbsoluteDirectory(dir, cwd, homeDir) {
+  if (dir.startsWith("~/")) {
+    return path13.join(homeDir, dir.slice(2));
+  }
+  return path13.isAbsolute(dir) ? dir : path13.resolve(cwd, dir);
+}
+async function resolvePlanDirectory(options) {
+  const customDir = options.planDirectory?.trim();
+  if (customDir) {
+    return resolveAbsoluteDirectory(customDir, options.cwd, options.homeDir);
+  }
+  const fs3 = options.fs ?? createDefaultFs();
+  const projectDir = path13.join(options.cwd, ".poe-code");
+  try {
+    const stat8 = await fs3.stat(projectDir);
+    if (stat8.isDirectory()) {
+      return path13.join(options.cwd, ".poe-code", "pipeline", "plans");
+    }
+  } catch {
+  }
+  return path13.join(options.homeDir, ".poe-code", "pipeline", "plans");
 }
 function resolveAbsolutePlanPath(planPath, cwd, homeDir) {
   if (planPath.startsWith("~/")) {
@@ -7222,7 +7313,7 @@ async function resolvePlanPath(options) {
     await ensurePlanExists(fs3, options.cwd, config2.planPath);
     return config2.planPath;
   }
-  const candidates = await listPlanCandidates(fs3, options.cwd, options.homeDir);
+  const candidates = await listPlanCandidates(fs3, options.cwd, options.homeDir, options.planDirectory);
   if (candidates.length >= 1) {
     if (options.assumeYes) {
       return candidates[0].path;
@@ -7507,6 +7598,7 @@ async function runPipeline(options) {
     cwd: options.cwd,
     homeDir: options.homeDir,
     plan: options.plan,
+    planDirectory: options.planDirectory,
     assumeYes: options.assumeYes,
     fs: fs3,
     selectPlan: options.selectPlan,
@@ -7745,7 +7837,7 @@ async function runPipeline2(options) {
         mode: input.mode
       });
       await renderAcpStream(events);
-      return result;
+      return await result;
     }
   });
 }
@@ -7755,51 +7847,134 @@ var init_pipeline2 = __esm({
     init_src8();
     init_src6();
     await init_spawn3();
+    init_src8();
   }
 });
 
 // packages/ralph/src/frontmatter/frontmatter.ts
-import { stringify, parse as parse6 } from "yaml";
+import { parse as parse6, stringify } from "yaml";
 function parseFrontmatter(content) {
-  const defaults = { status: "pending", iteration: 0 };
   if (!content.startsWith(`${FENCE}
 `)) {
-    return { data: defaults, body: content };
+    return {
+      data: createDefaultFrontmatter(),
+      body: content
+    };
   }
   const closingIndex = content.indexOf(`
 ${FENCE}
 `, FENCE.length);
   if (closingIndex === -1) {
-    return { data: defaults, body: content };
+    return {
+      data: createDefaultFrontmatter(),
+      body: content
+    };
   }
   const yamlBlock = content.slice(FENCE.length + 1, closingIndex);
   const body = content.slice(closingIndex + FENCE.length + 2);
   const parsed = parse6(yamlBlock);
   return {
-    data: {
-      status: isValidStatus(parsed?.status) ? parsed.status : defaults.status,
-      iteration: typeof parsed?.iteration === "number" ? parsed.iteration : defaults.iteration
-    },
+    data: parseFrontmatterData(parsed),
     body
   };
 }
 function writeFrontmatter(data, body) {
-  const yaml = stringify(data).trimEnd();
+  const serialized = {
+    ...data.agent !== void 0 ? { agent: data.agent } : {},
+    ...data.iterations !== void 0 ? { iterations: data.iterations } : {},
+    status: {
+      state: data.status.state,
+      iteration: data.status.iteration
+    }
+  };
+  const yaml = stringify(serialized).trimEnd();
   return `${FENCE}
 ${yaml}
 ${FENCE}
 ${body}`;
 }
-function isValidStatus(value) {
-  return typeof value === "string" && ["pending", "in_progress", "completed", "overbake_abort", "cancelled"].includes(
-    value
-  );
+function createDefaultFrontmatter() {
+  return {
+    status: {
+      state: DEFAULT_STATUS.state,
+      iteration: DEFAULT_STATUS.iteration
+    }
+  };
+}
+function parseFrontmatterData(value) {
+  const defaults = createDefaultFrontmatter();
+  const parsed = isRecord4(value) ? value : void 0;
+  const parsedStatus = isRecord4(parsed?.status) ? parsed.status : void 0;
+  const state = parsePlanStatus(parsedStatus?.state) ?? parseLegacyStatus(parsed?.status) ?? defaults.status.state;
+  const iteration = parseNonNegativeInteger(parsedStatus?.iteration) ?? parseNonNegativeInteger(parsed?.iteration) ?? defaults.status.iteration;
+  const agent2 = parseAgent(parsed?.agent);
+  const iterations = parsePositiveInteger(parsed?.iterations);
+  return {
+    ...agent2 !== void 0 ? { agent: agent2 } : {},
+    ...iterations !== void 0 ? { iterations } : {},
+    status: {
+      state,
+      iteration
+    }
+  };
+}
+function parseAgent(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  if (value.length === 0) {
+    return [];
+  }
+  const agents = [];
+  for (const item of value) {
+    if (typeof item !== "string") {
+      return void 0;
+    }
+    const trimmed = item.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    agents.push(trimmed);
+  }
+  return agents;
 }
-var FENCE;
+function parsePlanStatus(value) {
+  if (value === "open" || value === "in_progress" || value === "completed") {
+    return value;
+  }
+  return void 0;
+}
+function parseLegacyStatus(value) {
+  if (value === "in_progress" || value === "completed") {
+    return value;
+  }
+  if (value === "open" || value === "pending" || value === "cancelled" || value === "overbake_abort") {
+    return "open";
+  }
+  return void 0;
+}
+function parseNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function parsePositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : void 0;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var FENCE, DEFAULT_STATUS;
 var init_frontmatter = __esm({
   "packages/ralph/src/frontmatter/frontmatter.ts"() {
     "use strict";
     FENCE = "---";
+    DEFAULT_STATUS = {
+      state: "open",
+      iteration: 0
+    };
   }
 });
 
@@ -7854,23 +8029,39 @@ async function scanDir(fs3, absoluteDir, displayDir) {
 }
 async function discoverDocs(options) {
   const fs3 = options.fs ?? createDefaultFs4();
+  const customDir = options.planDirectory?.trim();
+  const docs = customDir ? await scanCustomDir(fs3, customDir, options.cwd, options.homeDir) : await scanDefaultDirs(fs3, options.cwd, options.homeDir);
+  return docs.sort((left, right) => {
+    const leftName = path15.basename(left.displayPath).toLowerCase();
+    const rightName = path15.basename(right.displayPath).toLowerCase();
+    return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
+  });
+}
+async function scanCustomDir(fs3, planDirectory, cwd, homeDir) {
+  const absoluteDir = resolveAbsoluteDirectory2(planDirectory, cwd, homeDir);
+  const displayDir = planDirectory;
+  return scanDir(fs3, absoluteDir, displayDir);
+}
+async function scanDefaultDirs(fs3, cwd, homeDir) {
   const [localDocs, globalDocs] = await Promise.all([
     scanDir(
       fs3,
-      path15.join(options.cwd, ".poe-code", "ralph", "plans"),
+      path15.join(cwd, ".poe-code", "ralph", "plans"),
       ".poe-code/ralph/plans"
     ),
     scanDir(
       fs3,
-      path15.join(options.homeDir, ".poe-code", "ralph", "plans"),
+      path15.join(homeDir, ".poe-code", "ralph", "plans"),
       "~/.poe-code/ralph/plans"
     )
   ]);
-  return [...localDocs, ...globalDocs].sort((left, right) => {
-    const leftName = path15.basename(left.displayPath).toLowerCase();
-    const rightName = path15.basename(right.displayPath).toLowerCase();
-    return leftName === rightName ? left.displayPath.localeCompare(right.displayPath) : leftName.localeCompare(rightName);
-  });
+  return [...localDocs, ...globalDocs];
+}
+function resolveAbsoluteDirectory2(dir, cwd, homeDir) {
+  if (dir.startsWith("~/")) {
+    return path15.join(homeDir, dir.slice(2));
+  }
+  return path15.isAbsolute(dir) ? dir : path15.resolve(cwd, dir);
 }
 var init_discovery2 = __esm({
   "packages/ralph/src/discovery/discovery.ts"() {
@@ -7878,37 +8069,6 @@ var init_discovery2 = __esm({
   }
 });
 
-// packages/ralph/src/overbaking/detector.ts
-var OverbakingDetector;
-var init_detector = __esm({
-  "packages/ralph/src/overbaking/detector.ts"() {
-    "use strict";
-    OverbakingDetector = class {
-      threshold;
-      consecutiveFailures = 0;
-      constructor(threshold) {
-        this.threshold = threshold;
-      }
-      record(_success) {
-        if (_success) {
-          this.consecutiveFailures = 0;
-          return {
-            consecutiveFailures: 0,
-            overbaked: false,
-            shouldWarn: false
-          };
-        }
-        this.consecutiveFailures += 1;
-        return {
-          consecutiveFailures: this.consecutiveFailures,
-          overbaked: this.consecutiveFailures >= this.threshold,
-          shouldWarn: this.consecutiveFailures === this.threshold
-        };
-      }
-    };
-  }
-});
-
 // packages/ralph/src/run/ralph.ts
 import path16 from "node:path";
 import * as fsPromises5 from "node:fs/promises";
@@ -7921,27 +8081,31 @@ async function runRalph(options) {
   if (!Number.isInteger(options.maxIterations) || options.maxIterations < 1) {
     throw new Error("maxIterations must be a positive integer.");
   }
-  const threshold = options.maxFailures ?? 3;
-  if (!Number.isInteger(threshold) || threshold < 1) {
-    throw new Error("maxFailures must be a positive integer.");
-  }
+  const agents = normalizeAgents(options.agent);
   const absoluteDocPath = resolveAbsoluteDocPath(
     options.docPath,
     options.cwd,
     options.homeDir
   );
   const rawContent = await fs3.readFile(absoluteDocPath, "utf8");
-  const { body: prompt } = parseFrontmatter(rawContent);
-  const detector = new OverbakingDetector(threshold);
+  const { data: frontmatter, body: prompt } = parseFrontmatter(rawContent);
   const startTime = Date.now();
   let iterationsCompleted = 0;
-  await updateFrontmatter(fs3, absoluteDocPath, prompt, "in_progress", 0);
+  await updateFrontmatter(
+    fs3,
+    absoluteDocPath,
+    prompt,
+    frontmatter,
+    "in_progress",
+    0
+  );
   async function finalize2(stopReason) {
     const status = stopReasonToStatus(stopReason);
     await updateFrontmatter(
       fs3,
       absoluteDocPath,
       prompt,
+      frontmatter,
       status,
       iterationsCompleted
     );
@@ -7958,12 +8122,13 @@ async function runRalph(options) {
   try {
     for (let iteration = 1; iteration <= options.maxIterations; iteration += 1) {
       assertNotAborted2(options.signal);
-      options.onIterationStart?.(iteration, options.maxIterations);
+      const currentAgent = agents[(iteration - 1) % agents.length];
+      options.onIterationStart?.(iteration, options.maxIterations, currentAgent);
       const iterationStart = Date.now();
       let result;
       try {
         result = await runAgent({
-          agent: options.agent,
+          agent: currentAgent,
           prompt,
           cwd: options.cwd,
           ...options.model ? { model: options.model } : {},
@@ -7981,6 +8146,7 @@ async function runRalph(options) {
         fs3,
         absoluteDocPath,
         prompt,
+        frontmatter,
         "in_progress",
         iterationsCompleted
       );
@@ -7989,21 +8155,6 @@ async function runRalph(options) {
         Date.now() - iterationStart,
         success2
       );
-      const overbake = detector.record(success2);
-      if (!overbake.shouldWarn) {
-        continue;
-      }
-      options.onOverbakeWarning?.(
-        overbake.consecutiveFailures,
-        threshold
-      );
-      const action = options.promptOverbake ? await options.promptOverbake({
-        consecutiveFailures: overbake.consecutiveFailures,
-        threshold
-      }) : "abort";
-      if (action === "abort") {
-        return finalize2("overbake_abort");
-      }
     }
   } catch (error2) {
     if (isAbortError2(error2)) {
@@ -8031,6 +8182,23 @@ function createDefaultFs5() {
     rename: fsPromises5.rename
   };
 }
+function normalizeAgents(agent2) {
+  if (typeof agent2 === "string") {
+    const trimmed = agent2.trim();
+    if (trimmed.length === 0) {
+      throw new Error("agent must contain at least one entry.");
+    }
+    return [trimmed];
+  }
+  if (agent2.length === 0) {
+    throw new Error("agent must contain at least one entry.");
+  }
+  const agents = agent2.map((entry) => entry.trim());
+  if (agents.some((entry) => entry.length === 0)) {
+    throw new Error("agent entries must be non-empty strings.");
+  }
+  return agents;
+}
 function resolveAbsoluteDocPath(docPath, cwd, homeDir) {
   if (docPath.startsWith("~/")) {
     return path16.join(homeDir, docPath.slice(2));
@@ -8051,8 +8219,18 @@ function createAbortError4() {
 function isAbortError2(error2) {
   return error2 instanceof Error && error2.name === "AbortError";
 }
-async function updateFrontmatter(fs3, absoluteDocPath, body, status, iteration) {
-  const content = writeFrontmatter({ status, iteration }, body);
+async function updateFrontmatter(fs3, absoluteDocPath, body, frontmatter, state, iteration) {
+  const content = writeFrontmatter(
+    {
+      ...frontmatter.agent !== void 0 ? { agent: frontmatter.agent } : {},
+      ...frontmatter.iterations !== void 0 ? { iterations: frontmatter.iterations } : {},
+      status: {
+        state,
+        iteration
+      }
+    },
+    body
+  );
   await fs3.writeFile(absoluteDocPath, content);
 }
 async function archivePlan2(fs3, absoluteDocPath) {
@@ -8067,16 +8245,13 @@ function stopReasonToStatus(stopReason) {
     case "completed":
     case "max_iterations":
       return "completed";
-    case "overbake_abort":
-      return "overbake_abort";
     case "cancelled":
-      return "cancelled";
+      return "open";
   }
 }
 var init_ralph = __esm({
   "packages/ralph/src/run/ralph.ts"() {
     "use strict";
-    init_detector();
     init_frontmatter();
   }
 });
@@ -8087,7 +8262,6 @@ var init_src9 = __esm({
     "use strict";
     init_frontmatter();
     init_discovery2();
-    init_detector();
     init_ralph();
   }
 });
@@ -8182,13 +8356,13 @@ async function readErrorBody(response) {
   }
 }
 function extractTextContent(data) {
-  if (!isRecord4(data)) return void 0;
+  if (!isRecord5(data)) return void 0;
   const choices = data.choices;
   if (!Array.isArray(choices) || choices.length === 0) return void 0;
   const first = choices[0];
-  if (!isRecord4(first)) return void 0;
+  if (!isRecord5(first)) return void 0;
   const message = first.message;
-  if (!isRecord4(message)) return void 0;
+  if (!isRecord5(message)) return void 0;
   return typeof message.content === "string" ? message.content : void 0;
 }
 function extractMediaFromCompletion(data) {
@@ -8196,14 +8370,14 @@ function extractMediaFromCompletion(data) {
   if (!content) return {};
   try {
     const parsed = JSON.parse(content);
-    if (isRecord4(parsed) && typeof parsed.url === "string") {
+    if (isRecord5(parsed) && typeof parsed.url === "string") {
       return {
         url: parsed.url,
         mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0,
         data: typeof parsed.data === "string" ? parsed.data : void 0
       };
     }
-    if (isRecord4(parsed) && typeof parsed.data === "string") {
+    if (isRecord5(parsed) && typeof parsed.data === "string") {
       return {
         data: parsed.data,
         mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0
@@ -8237,7 +8411,7 @@ function isValidUrl(value) {
     return false;
   }
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 var init_llm_client = __esm({
@@ -8876,8 +9050,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path28) {
-  if (!isAbsolute(path28)) {
+function assertAbsolutePath(path29) {
+  if (!isAbsolute(path29)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -14348,7 +14522,7 @@ function parseLegacyConfigDocument(raw) {
   }
 }
 function normalizeLegacyConfigDocument(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord6(value)) {
     return {};
   }
   const document = {};
@@ -14362,12 +14536,12 @@ function normalizeLegacyConfigDocument(value) {
   return document;
 }
 function normalizeConfiguredServices(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord6(value)) {
     return {};
   }
   const entries = {};
   for (const [key, entry] of Object.entries(value)) {
-    if (!isRecord5(entry)) {
+    if (!isRecord6(entry)) {
       continue;
     }
     entries[key] = normalizeConfiguredServiceMetadata({
@@ -14386,10 +14560,10 @@ function createInvalidBackupPath2(filePath) {
   const baseName = path21.basename(filePath);
   return path21.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-var coreConfigScope, knownConfigScopes, CORE_SCOPE, configuredServicesScope, EMPTY_DOCUMENT3;
+var coreConfigScope, ralphConfigScope, pipelineConfigScope, knownConfigScopes, CORE_SCOPE, configuredServicesScope, EMPTY_DOCUMENT3;
 var init_config3 = __esm({
   "src/services/config.ts"() {
     "use strict";
@@ -14409,7 +14583,23 @@ var init_config3 = __esm({
         doc: "Poe API base URL"
       }
     });
-    knownConfigScopes = [coreConfigScope];
+    ralphConfigScope = defineScope("ralph", {
+      plan_directory: {
+        type: "string",
+        default: "",
+        env: "POE_RALPH_PLAN_DIRECTORY",
+        doc: "Custom directory for Ralph plan documents"
+      }
+    });
+    pipelineConfigScope = defineScope("pipeline", {
+      plan_directory: {
+        type: "string",
+        default: "",
+        env: "POE_PIPELINE_PLAN_DIRECTORY",
+        doc: "Custom directory for Pipeline plan files"
+      }
+    });
+    knownConfigScopes = [coreConfigScope, ralphConfigScope, pipelineConfigScope];
     CORE_SCOPE = coreConfigScope.scope;
     configuredServicesScope = "configured_services";
     EMPTY_DOCUMENT3 = `${JSON.stringify({}, null, 2)}
@@ -17663,8 +17853,8 @@ var init_parseUtil = __esm({
     init_errors3();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path28, errorMaps, issueData } = params;
-      const fullPath = [...path28, ...issueData.path || []];
+      const { data, path: path29, errorMaps, issueData } = params;
+      const fullPath = [...path29, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -17944,11 +18134,11 @@ var init_types4 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path28, key) {
+      constructor(parent, value, path29, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path28;
+        this._path = path29;
         this._key = key;
       }
       get path() {
@@ -21452,10 +21642,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path28) {
-  if (!path28)
+function getElementAtPath(obj, path29) {
+  if (!path29)
     return obj;
-  return path28.reduce((acc, key) => acc?.[key], obj);
+  return path29.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -21767,11 +21957,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path28, issues) {
+function prefixIssues(path29, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path28);
+    iss.path.unshift(path29);
     return iss;
   });
 }
@@ -33932,8 +34122,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path28) {
-      let input = path28;
+    function removeDotSegments(path29) {
+      let input = path29;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -34132,8 +34322,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path28, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path28 && path28 !== "/" ? path28 : void 0;
+        const [path29, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path29 && path29 !== "/" ? path29 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -39427,6 +39617,20 @@ var init_models2 = __esm({
 import path27 from "node:path";
 import { readFile as readFile7, stat as stat7 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
+async function resolvePipelinePlanDirectory(container) {
+  const configDoc = await readMergedDocument(
+    container.fs,
+    container.env.configPath,
+    container.env.projectConfigPath
+  );
+  const pipelineConfig = resolveScope(
+    pipelineConfigScope.schema,
+    configDoc[pipelineConfigScope.scope],
+    container.env.variables
+  );
+  const dir = pipelineConfig.plan_directory?.trim();
+  return dir || void 0;
+}
 function formatDuration(ms) {
   const totalSeconds = Math.round(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
@@ -39553,10 +39757,12 @@ function registerPipelineCommand(program, container) {
         }
         agent2 = resolvePipelineAgent(selected);
       }
+      const planDirectory = await resolvePipelinePlanDirectory(container);
       const result = await runPipeline2({
         agent: agent2,
         cwd: container.env.cwd,
         homeDir: container.env.homeDir,
+        ...planDirectory ? { planDirectory } : {},
         ...options.model ? { model: options.model } : {},
         ...options.task ? { task: options.task } : {},
         ...options.plan ? { plan: options.plan } : {},
@@ -39682,6 +39888,17 @@ function registerPipelineCommand(program, container) {
       resources.context.finalize();
     }
   });
+  pipeline.command("plan-path").description("Print the directory where pipeline plan files should be placed.").action(async function() {
+    const planDirectory = await resolvePipelinePlanDirectory(container);
+    const resolvedPath = await resolvePlanDirectory({
+      cwd: container.env.cwd,
+      homeDir: container.env.homeDir,
+      planDirectory,
+      fs: container.fs
+    });
+    process.stdout.write(`${resolvedPath}
+`);
+  });
   pipeline.command("install").description("Install the Pipeline /plan skill and scaffold pipeline files.").option("--agent <name>", "Agent to install the Pipeline skill for").option("--local", "Install project-local skill and pipeline files").option("--global", "Install user-global skill and pipeline files").option("--force", "Overwrite an existing steps.yaml scaffold").action(async function() {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(
@@ -39808,6 +40025,8 @@ var init_pipeline4 = __esm({
     init_src5();
     init_src2();
     init_src15();
+    init_src4();
+    init_config3();
     init_errors();
     init_shared();
     await init_pipeline2();
@@ -39819,19 +40038,20 @@ var init_pipeline4 = __esm({
 });
 
 // src/cli/commands/ralph.ts
+import path28 from "node:path";
 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 resolveRalphAgent(value) {
+function resolveRalphAgent(value, sourceLabel = "agent") {
   if (!value || value.trim().length === 0) {
     return DEFAULT_RALPH_AGENT;
   }
   const resolved = resolveAgentId(value.trim());
   if (!resolved) {
-    throw new ValidationError(`Unsupported agent: ${value}`);
+    throw new ValidationError(`Unsupported ${sourceLabel}: ${value}`);
   }
   return resolved;
 }
@@ -39847,26 +40067,54 @@ function parsePositiveInt(value, fieldName) {
   }
   return parsed;
 }
-async function resolveAgent(options) {
-  if (options.providedAgent) {
-    return resolveRalphAgent(options.providedAgent);
+function normalizeConfiguredIterations(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : void 0;
+}
+function resolveAbsoluteDocPath2(container, docPath) {
+  if (docPath.startsWith("~/")) {
+    return path28.join(container.env.homeDir, docPath.slice(2));
   }
-  const flags = resolveCommandFlags(options.program);
-  if (flags.assumeYes) {
-    return DEFAULT_RALPH_AGENT;
+  return path28.isAbsolute(docPath) ? docPath : path28.resolve(container.env.cwd, docPath);
+}
+async function resolvePlanDirectory2(container) {
+  const configDoc = await readMergedDocument(
+    container.fs,
+    container.env.configPath,
+    container.env.projectConfigPath
+  );
+  const ralphConfig = resolveScope(
+    ralphConfigScope.schema,
+    configDoc[ralphConfigScope.scope],
+    container.env.variables
+  );
+  const configDir = ralphConfig.plan_directory?.trim();
+  return configDir || void 0;
+}
+function formatDocHint(frontmatter) {
+  const parts = [];
+  if (frontmatter.agent !== void 0) {
+    const agents = Array.isArray(frontmatter.agent) ? frontmatter.agent : [frontmatter.agent];
+    if (agents.length > 0) {
+      parts.push(agents.join(", "));
+    }
   }
-  const selected = await select2({
-    message: "Select agent to run Ralph with:",
-    options: allSpawnConfigs.map((config2) => ({
-      label: config2.agentId,
-      value: config2.agentId
-    }))
-  });
-  if (isCancel2(selected)) {
-    cancel2("Ralph run cancelled.");
-    return null;
+  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}`);
+  }
+  return parts.length > 0 ? parts.join(" \xB7 ") : void 0;
+}
+async function readDocHint(container, docPath) {
+  const absolutePath = resolveAbsoluteDocPath2(container, docPath);
+  try {
+    const content = await container.fs.readFile(absolutePath, "utf8");
+    const { data } = parseFrontmatter(content);
+    return formatDocHint(data);
+  } catch {
+    return void 0;
   }
-  return resolveRalphAgent(typeof selected === "string" ? selected : void 0);
 }
 async function resolveDocPath(options) {
   if (options.providedDoc && options.providedDoc.trim().length > 0) {
@@ -39875,6 +40123,7 @@ async function resolveDocPath(options) {
   const docs = await discoverDocs({
     cwd: options.container.env.cwd,
     homeDir: options.container.env.homeDir,
+    planDirectory: options.planDirectory,
     fs: options.container.fs
   });
   if (docs.length === 0) {
@@ -39886,10 +40135,13 @@ async function resolveDocPath(options) {
   if (flags.assumeYes) {
     return docs[0].path;
   }
+  const hints = await Promise.all(
+    docs.map((doc) => readDocHint(options.container, doc.path))
+  );
   const selected = await select2({
     message: "Select the Ralph markdown doc to run:",
-    options: docs.map((doc) => ({
-      label: doc.displayPath,
+    options: docs.map((doc, index) => ({
+      label: text.selectLabel(doc.displayPath, hints[index]),
       value: doc.path
     }))
   });
@@ -39899,7 +40151,61 @@ async function resolveDocPath(options) {
   }
   return typeof selected === "string" ? selected : null;
 }
-async function resolveIterations(options) {
+async function readRalphDoc(container, docPath) {
+  const absolutePath = resolveAbsoluteDocPath2(container, docPath);
+  try {
+    const content = await container.fs.readFile(absolutePath, "utf8");
+    const parsed = parseFrontmatter(content);
+    return {
+      absolutePath,
+      body: parsed.body,
+      data: parsed.data
+    };
+  } catch {
+    throw new ValidationError(`Ralph doc not found: ${docPath}`);
+  }
+}
+function resolveConfiguredAgents(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return resolveRalphAgent(value, "frontmatter agent");
+  }
+  if (value.length === 0) {
+    throw new ValidationError("Frontmatter agent array must not be empty.");
+  }
+  return value.map((entry) => resolveRalphAgent(entry, "frontmatter agent"));
+}
+async function promptForAgent(program) {
+  const flags = resolveCommandFlags(program);
+  if (flags.assumeYes) {
+    return DEFAULT_RALPH_AGENT;
+  }
+  const selected = await select2({
+    message: "Select agent to run Ralph with:",
+    options: allSpawnConfigs.map((config2) => ({
+      label: config2.agentId,
+      value: config2.agentId
+    }))
+  });
+  if (isCancel2(selected)) {
+    cancel2("Ralph run cancelled.");
+    return null;
+  }
+  return resolveRalphAgent(typeof selected === "string" ? selected : void 0);
+}
+async function resolveRunAgent(options) {
+  if (options.providedAgent) {
+    return resolveRalphAgent(options.providedAgent);
+  }
+  const configured = resolveConfiguredAgents(options.frontmatterAgent);
+  if (configured !== void 0) {
+    return configured;
+  }
+  return promptForAgent(options.program);
+}
+async function resolveRunIterations(options) {
   const explicitIterations = parsePositiveInt(
     options.providedIterations,
     "iterations"
@@ -39907,11 +40213,15 @@ async function resolveIterations(options) {
   if (explicitIterations != null) {
     return explicitIterations;
   }
+  const configuredIterations = normalizeConfiguredIterations(
+    options.frontmatterIterations
+  );
+  if (configuredIterations != null) {
+    return configuredIterations;
+  }
   const flags = resolveCommandFlags(options.program);
   if (flags.assumeYes) {
-    throw new ValidationError(
-      "Iterations are required when using --yes. Provide poe-code ralph run <iterations> [doc]."
-    );
+    return DEFAULT_RALPH_ITERATIONS;
   }
   const entered = await text3({
     message: "How many Ralph iterations should run?"
@@ -39925,43 +40235,157 @@ async function resolveIterations(options) {
     "iterations"
   ) ?? null;
 }
+async function resolveInitAgent(options) {
+  if (options.providedAgent) {
+    return resolveRalphAgent(options.providedAgent);
+  }
+  return promptForAgent(options.program);
+}
+async function resolveInitIterations(options) {
+  const explicitIterations = parsePositiveInt(
+    options.providedIterations,
+    "iterations"
+  );
+  if (explicitIterations != null) {
+    return explicitIterations;
+  }
+  const flags = resolveCommandFlags(options.program);
+  if (flags.assumeYes) {
+    return DEFAULT_RALPH_ITERATIONS;
+  }
+  const entered = await text3({
+    message: "How many Ralph iterations should run?"
+  });
+  if (isCancel2(entered)) {
+    cancel2("Ralph init cancelled.");
+    return null;
+  }
+  return parsePositiveInt(
+    typeof entered === "string" ? entered.trim() : void 0,
+    "iterations"
+  ) ?? null;
+}
+function formatCurrentConfig(frontmatter) {
+  if (frontmatter.agent === void 0 && frontmatter.iterations === void 0) {
+    return null;
+  }
+  const items = [];
+  if (frontmatter.iterations !== void 0) {
+    items.push(String(frontmatter.iterations));
+  }
+  const agentList = expandAgentList(frontmatter.agent, frontmatter.iterations);
+  if (agentList.length > 0) {
+    items.push(...agentList);
+  }
+  return items.length > 0 ? `Current: ${items.join(", ")}` : null;
+}
+function expandAgentList(agent2, iterations) {
+  if (agent2 === void 0) {
+    return [];
+  }
+  if (typeof agent2 === "string") {
+    const count2 = normalizeConfiguredIterations(iterations) ?? 1;
+    return Array.from({ length: count2 }, () => agent2);
+  }
+  if (agent2.length === 0) {
+    return [];
+  }
+  const count = normalizeConfiguredIterations(iterations) ?? agent2.length;
+  return Array.from({ length: count }, (_, index) => agent2[index % agent2.length]);
+}
 function registerRalphCommand(program, container) {
   const ralph = program.command("ralph").description("Run a simple iterative markdown loop.");
-  ralph.command("run").description("Run the selected markdown doc through repeated agent iterations.").argument("[iterations]", "Number of Ralph iterations to run").argument("[doc]", "Markdown doc path").option("--agent <name>", "Agent to run each iteration with").option("--model <model>", "Model override passed to the agent").option(
-    "--max-failures <n>",
-    "Consecutive failure threshold before overbake protection prompts"
-  ).action(async function(iterationsArg, docArg) {
+  ralph.command("init").description("Write Ralph config into an existing markdown doc frontmatter.").argument("[doc]", "Markdown doc path").option("--agent <name>", "Agent to write into frontmatter").option("--iterations <n>", "Number of iterations to write into frontmatter").action(async function(docArg) {
+    const flags = resolveCommandFlags(program);
+    const resources = createExecutionResources(container, flags, "ralph:init");
+    const options = this.opts();
+    resources.logger.intro("ralph init");
+    try {
+      const planDirectory = await resolvePlanDirectory2(container);
+      const docPath = await resolveDocPath({
+        container,
+        program,
+        providedDoc: docArg,
+        planDirectory
+      });
+      if (!docPath) {
+        return;
+      }
+      const doc = await readRalphDoc(container, docPath);
+      const currentConfig = formatCurrentConfig(doc.data);
+      if (!options.agent && !options.iterations && !flags.assumeYes && currentConfig) {
+        resources.logger.info(currentConfig);
+      }
+      const agent2 = await resolveInitAgent({
+        program,
+        providedAgent: options.agent
+      });
+      if (!agent2) {
+        return;
+      }
+      const iterations = await resolveInitIterations({
+        program,
+        providedIterations: options.iterations
+      });
+      if (iterations == null) {
+        return;
+      }
+      const updated = writeFrontmatter(
+        {
+          agent: agent2,
+          iterations,
+          status: {
+            state: doc.data.status.state,
+            iteration: doc.data.status.iteration
+          }
+        },
+        doc.body
+      );
+      await container.fs.writeFile(doc.absolutePath, updated, { encoding: "utf8" });
+      resources.logger.resolved(
+        "Initialized Ralph config",
+        `Doc: ${docPath}
+   Agent: ${agent2}
+   Iterations: ${iterations}`
+      );
+      resources.logger.success("Ralph config saved.");
+    } finally {
+      resources.context.finalize();
+    }
+  });
+  ralph.command("run").description("Run the selected markdown doc through repeated agent iterations.").argument("[doc]", "Markdown doc path").option("--agent <name>", "Override the agent from frontmatter").option("--iterations <n>", "Override iterations from frontmatter").option("--model <model>", "Model override passed to the agent").action(async function(docArg) {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(container, flags, "ralph:run");
     const options = this.opts();
     resources.logger.intro("ralph run");
     try {
+      const planDirectory = await resolvePlanDirectory2(container);
       const docPath = await resolveDocPath({
         container,
         program,
-        providedDoc: docArg
+        providedDoc: docArg,
+        planDirectory
       });
       if (!docPath) {
         return;
       }
-      const agent2 = await resolveAgent({
+      const doc = await readRalphDoc(container, docPath);
+      const agent2 = await resolveRunAgent({
         program,
-        providedAgent: options.agent
+        providedAgent: options.agent,
+        frontmatterAgent: doc.data.agent
       });
       if (!agent2) {
         return;
       }
-      const maxIterations = await resolveIterations({
+      const maxIterations = await resolveRunIterations({
         program,
-        providedIterations: iterationsArg
+        providedIterations: options.iterations,
+        frontmatterIterations: doc.data.iterations
       });
       if (maxIterations == null) {
         return;
       }
-      const maxFailures = parsePositiveInt(
-        options.maxFailures,
-        "max-failures"
-      );
       const result = await runRalph2({
         agent: agent2,
         cwd: container.env.cwd,
@@ -39969,34 +40393,14 @@ function registerRalphCommand(program, container) {
         docPath,
         maxIterations,
         ...options.model ? { model: options.model } : {},
-        ...maxFailures != null ? { maxFailures } : {},
-        promptOverbake: async (input) => {
-          const selected = await select2({
-            message: `Ralph hit ${input.consecutiveFailures} consecutive failures (threshold ${input.threshold}). What should happen next?`,
-            options: [
-              { label: "Continue", value: "continue" },
-              { label: "Abort", value: "abort" }
-            ]
-          });
-          if (isCancel2(selected)) {
-            cancel2("Ralph run cancelled.");
-            return "abort";
-          }
-          return selected === "continue" ? "continue" : "abort";
-        },
-        onIterationStart(iteration, total) {
-          resources.logger.info(`Iteration ${iteration}/${total}`);
+        onIterationStart(iteration, total, currentAgent) {
+          resources.logger.info(`Iteration ${iteration}/${total} (${currentAgent})`);
         },
         onIterationComplete(iteration, durationMs, success2) {
           const status = success2 ? "done" : "failed";
           resources.logger.info(
             `Iteration ${iteration} ${status} in ${formatDuration2(durationMs)}`
           );
-        },
-        onOverbakeWarning(consecutiveFailures, threshold) {
-          resources.logger.warn(
-            `Overbake protection triggered at ${consecutiveFailures} consecutive failures (threshold ${threshold}).`
-          );
         }
       });
       const summary = [
@@ -40010,12 +40414,6 @@ function registerRalphCommand(program, container) {
         resources.logger.resolved("Run summary", summary);
         return;
       }
-      if (result.stopReason === "overbake_abort") {
-        process.exitCode = 1;
-        resources.logger.warn("Ralph stopped after repeated failures.");
-        resources.logger.resolved("Run summary", summary);
-        return;
-      }
       resources.logger.resolved("Run summary", summary);
       resources.logger.success("Ralph run finished.");
     } finally {
@@ -40023,7 +40421,7 @@ function registerRalphCommand(program, container) {
     }
   });
 }
-var DEFAULT_RALPH_AGENT;
+var DEFAULT_RALPH_AGENT, DEFAULT_RALPH_ITERATIONS;
 var init_ralph3 = __esm({
   async "src/cli/commands/ralph.ts"() {
     "use strict";
@@ -40031,10 +40429,13 @@ var init_ralph3 = __esm({
     init_src2();
     init_src6();
     init_src9();
+    init_src4();
+    init_config3();
     init_errors();
     init_shared();
     await init_ralph2();
     DEFAULT_RALPH_AGENT = "claude-code";
+    DEFAULT_RALPH_ITERATIONS = 3;
   }
 });
 
@@ -40044,7 +40445,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.114",
+      version: "3.0.116",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -40262,9 +40663,14 @@ function formatHelpText(input) {
       args: "",
       description: "Run a fixed-step task pipeline plan"
     },
+    {
+      name: "ralph init",
+      args: "[doc]",
+      description: "Write Ralph config into a markdown doc frontmatter"
+    },
     {
       name: "ralph run",
-      args: "[iterations] [doc]",
+      args: "[doc]",
       description: "Run a markdown doc through repeated agent iterations"
     },
     {