@glrs-dev/cli 2.4.1 → 2.6.0

package/dist/node_modules/@glrs-dev/autopilot/dist/{chunk-VITL2Z45.js → chunk-2X3CWH47.js}

@@ -1,7 +1,10 @@
+import {
+  resolveModel
+} from "./chunk-S34HOCZ4.js";
 import {
   childLogger,
   createAutopilotLogger
-} from "./chunk-Q4ULU6ER.js";
+} from "./chunk-2ZQ6SBV3.js";
 import {
   detectSpecPhases,
   filterUncheckedSpecPhases,
@@ -12,7 +15,7 @@ import {
   readSpecGoal,
   validateMainSpec,
   validatePhaseSpec
-} from "./chunk-7OSEI5TF.js";
+} from "./chunk-GXXCEGDD.js";
 
 // src/loop-session.ts
 import * as fs7 from "fs";
@@ -348,6 +351,7 @@ var MAX_ITERATIONS_PER_PHASE_BY_TIER = {
   "autopilot-execute": 10,
   fast: 10
 };
+var MAX_ITERATIONS_PER_ITEM = 5;
 var KILL_SWITCH_PATH = ".agent/autopilot-disable";
 var SENTINEL_TAG = "<autopilot-done>";
 var STATUS_INTERVAL_MS = (() => {
@@ -462,7 +466,10 @@ function formatSlackMessage(event) {
 function isSlackWebhookUrl(url) {
   return url.includes("hooks.slack.com/");
 }
-async function notifyWebhook(url, event) {
+async function notifyWebhook(url, event, allowedEvents) {
+  if (allowedEvents && !allowedEvents.includes(event.event)) {
+    return;
+  }
   try {
     const body = isSlackWebhookUrl(url) ? JSON.stringify(formatSlackMessage(event)) : JSON.stringify(event);
     const response = await fetch(url, {
@@ -712,13 +719,36 @@ async function getHeadSha(cwd) {
     return "HEAD";
   }
 }
+async function amendCommitWithPrefix(cwd, prefix) {
+  try {
+    const { stdout: subject } = await execFile2("git", ["log", "-1", "--pretty=%s"], { cwd });
+    const currentSubject = subject.trim();
+    if (!currentSubject || currentSubject.startsWith(prefix)) {
+      return false;
+    }
+    const newSubject = `${prefix} ${currentSubject}`;
+    await execFile2("git", ["commit", "--amend", "-m", newSubject], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function runRalphLoop(opts) {
   process.env["GLRS_AUTOPILOT_HEADLESS"] = "1";
   const maxIterations = opts.maxIterations ?? MAX_ITERATIONS;
   const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
   const tier = opts.agentName === "autopilot-fast" ? "autopilot-execute" : "deep";
-  const stallMs = opts.stallMs ?? STALL_MS_BY_TIER[tier];
+  const cfgObj = opts.config;
+  const cfgStallMs = cfgObj?.stall_timeout;
+  const stallMs = opts.stallMs ?? cfgStallMs ?? STALL_MS_BY_TIER[tier];
   const struggleThreshold = opts.struggleThreshold ?? STRUGGLE_THRESHOLD;
+  const autoCommit = cfgObj?.auto_commit ?? true;
+  const commitPrefix = cfgObj?.commit_prefix;
+  const cfgNotifyUrl = cfgObj?.notify_url;
+  const cfgNotifyEvents = cfgObj?.notify_events;
+  const resolvedNotifyUrl = opts.notifyUrl ?? cfgNotifyUrl;
+  const resolvedNotifyEvents = cfgNotifyEvents;
+  const finalNotifyEvents = opts.notifyEvents ?? resolvedNotifyEvents;
   if (!opts.adapter) {
     throw new Error("runRalphLoop: adapter is required");
   }
@@ -727,8 +757,8 @@ async function runRalphLoop(opts) {
   const struggle = new StruggleDetector(struggleThreshold);
   const startTime = Date.now();
   const notify = (event) => {
-    if (opts.notifyUrl) {
-      notifyWebhook(opts.notifyUrl, event).catch(() => {
+    if (resolvedNotifyUrl) {
+      notifyWebhook(resolvedNotifyUrl, event, finalNotifyEvents).catch(() => {
       });
     }
   };
@@ -773,7 +803,7 @@ async function runRalphLoop(opts) {
     log.info({ file: autopilotLog.logFilePath }, `Logging to ${autopilotLog.logFilePath}`);
   }
   log.info({ cwd: opts.cwd, maxIterations, timeoutMs }, `Starting agent (${adapter.name})`);
-  const handle = await adapter.start({ cwd: opts.cwd });
+  const handle = await adapter.start({ cwd: opts.cwd, agents: opts.agentOverrides });
   log.info({ agentId: handle.id }, "Agent ready");
   const abort = new AbortController();
   const timeoutHandle = setTimeout(() => {
@@ -808,13 +838,14 @@ async function runRalphLoop(opts) {
   try {
     const agentName = opts.agentName ?? "autopilot-prime";
     const tierLabel = agentName === "autopilot-fast" ? "autopilot-execute tier" : "deep tier";
-    sessionId = await adapter.createSession(handle, { agentName });
+    sessionId = await adapter.createSession(handle, { agentName, model: opts.model });
     log.info({ sessionId, agentName, tier: tierLabel }, `Session created with ${agentName} (${tierLabel})`);
+    const statusFileEnabled = opts.config?.status_file !== false;
     heartbeat = createStatusHeartbeat({
       logger: statusLog,
       intervalMs: STATUS_INTERVAL_MS,
       pollCost: async () => adapter.getSessionCost(handle, sessionId),
-      statusFilePath: join4(opts.cwd, ".agent", "autopilot-status.json")
+      statusFilePath: statusFileEnabled ? join4(opts.cwd, ".agent", "autopilot-status.json") : void 0
     });
     heartbeat.start();
     for (let iteration = 1; iteration <= maxIterations; iteration++) {
@@ -832,6 +863,7 @@ async function runRalphLoop(opts) {
           iterations: iteration - 1,
           message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -849,6 +881,7 @@ async function runRalphLoop(opts) {
           iterations: iteration - 1,
           message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1011,6 +1044,7 @@ async function runRalphLoop(opts) {
           iterations: iteration,
           message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1028,6 +1062,7 @@ async function runRalphLoop(opts) {
           iterations: iteration,
           message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1093,6 +1128,7 @@ async function runRalphLoop(opts) {
           iterations: iteration,
           message: `Error in iteration ${iteration}: ${result.message}`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1118,6 +1154,7 @@ async function runRalphLoop(opts) {
           iterations: iteration,
           message: `Agent emitted <autopilot-done> at iteration ${iteration}.`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1196,6 +1233,10 @@ async function runRalphLoop(opts) {
           commitSubject = logOut.trim().replace(/^[0-9a-f]+ /, "");
         } catch {
         }
+        if (commitSubject && commitPrefix) {
+          amendCommitWithPrefix(opts.cwd, commitPrefix).catch(() => {
+          });
+        }
         if (commitSubject) {
           log.info(`${lanePrefix}commit: ${commitSubject}`);
         }
@@ -1289,6 +1330,7 @@ async function runRalphLoop(opts) {
           iterations: iteration,
           message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`,
           sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
           agentHandle: transferHandle()
         };
       }
@@ -1306,6 +1348,7 @@ async function runRalphLoop(opts) {
       iterations: maxIterations,
       message: `Reached maximum iterations (${maxIterations}). Stopping.`,
       sessionId,
+      cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
       agentHandle: transferHandle()
     };
   } finally {
@@ -1318,12 +1361,20 @@ async function runRalphLoop(opts) {
       try {
         const { stdout: porcelain } = await execFile2("git", ["status", "--porcelain"], { cwd: opts.cwd });
         if (porcelain.trim().length > 0) {
-          log.info({ signal: interruptedSignal }, "Committing WIP before exit");
-          try {
-            await execFile2("git", ["add", "-A"], { cwd: opts.cwd });
-            await execFile2("git", ["commit", "-m", "[WIP] autopilot interrupted"], { cwd: opts.cwd });
-          } catch (err) {
-            log.warn({ err: err instanceof Error ? err.message : String(err) }, "WIP commit failed (hooks may have rejected)");
+          if (autoCommit) {
+            log.info({ signal: interruptedSignal }, "Committing WIP before exit");
+            try {
+              await execFile2("git", ["add", "-A"], { cwd: opts.cwd });
+              const commitMsg = commitPrefix ? `${commitPrefix} [WIP] autopilot interrupted` : "[WIP] autopilot interrupted";
+              await execFile2("git", ["commit", "-m", commitMsg], { cwd: opts.cwd });
+            } catch (err) {
+              log.warn({ err: err instanceof Error ? err.message : String(err) }, "WIP commit failed (hooks may have rejected)");
+            }
+          } else {
+            log.warn(
+              { signal: interruptedSignal },
+              "Pending changes left unstaged (auto_commit: false)"
+            );
           }
         }
       } catch (err) {
@@ -1387,6 +1438,28 @@ function atomicWriteFileSync(target, content) {
   fs5.writeFileSync(tmp, content, "utf-8");
   fs5.renameSync(tmp, target);
 }
+function markItemUnchecked(planDir, phaseFile, itemId) {
+  const phasePath = path4.join(planDir, "spec", phaseFile);
+  try {
+    const content = fs5.readFileSync(phasePath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw !== "object" || raw === null) return;
+    const obj = raw;
+    if (!Array.isArray(obj["items"])) return;
+    const items = obj["items"];
+    let found = false;
+    for (const item of items) {
+      if (item["id"] === itemId) {
+        item["checked"] = false;
+        found = true;
+        break;
+      }
+    }
+    if (!found) return;
+    atomicWriteFileSync(phasePath, yamlStringify(raw));
+  } catch {
+  }
+}
 function markPhaseCompleted(planDir, phaseFile) {
   const mainPath = path4.join(planDir, "spec", "main.yaml");
   try {
@@ -1652,6 +1725,22 @@ import { execFile as execFileCb6 } from "child_process";
 import { promisify as promisify6 } from "util";
 var execFileDefault3 = promisify6(execFileCb6);
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function getTimeoutForProofType(proofType, customTimeoutMs) {
+  if (!proofType) return customTimeoutMs;
+  switch (proofType) {
+    case "unit_test":
+      return 30 * 1e3;
+    case "api_check":
+      return 10 * 1e3;
+    case "structural":
+    case "typecheck":
+      return 60 * 1e3;
+    case "e2e":
+      return 120 * 1e3;
+    default:
+      return customTimeoutMs;
+  }
+}
 async function runVerifyCommands(items, cwd, opts = {}) {
   const execFile4 = opts._deps?.execFile ?? execFileDefault3;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -1659,11 +1748,12 @@ async function runVerifyCommands(items, cwd, opts = {}) {
   for (const item of items) {
     const command = item.verify?.trim();
     if (!command) continue;
+    const itemTimeoutMs = getTimeoutForProofType(item.proof_type, timeoutMs);
     const start = Date.now();
     try {
       const { stdout, stderr } = await execFile4("/bin/sh", ["-c", command], {
         cwd,
-        signal: AbortSignal.timeout(timeoutMs),
+        signal: AbortSignal.timeout(itemTimeoutMs),
         // Capture as much output as the command produces — verify
         // commands are typically test runs; truncating their output
         // would hide the failure detail we want in the next prompt.
@@ -1683,7 +1773,7 @@ async function runVerifyCommands(items, cwd, opts = {}) {
       const stdout = e.stdout !== void 0 ? typeof e.stdout === "string" ? e.stdout : e.stdout.toString() : "";
       let stderr = e.stderr !== void 0 ? typeof e.stderr === "string" ? e.stderr : e.stderr.toString() : "";
       if (isTimeout) {
-        stderr = (stderr ? stderr + "\n" : "") + `[verify-runner] command timed out after ${Math.round(timeoutMs / 1e3)}s`;
+        stderr = (stderr ? stderr + "\n" : "") + `[verify-runner] command timed out after ${Math.round(itemTimeoutMs / 1e3)}s`;
       } else if (!stderr && e.message) {
         stderr = e.message;
       }
@@ -1700,6 +1790,37 @@ async function runVerifyCommands(items, cwd, opts = {}) {
   return results;
 }
 
+// src/hook-runner.ts
+import { execFile as execFileCb7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execFileDefault4 = promisify7(execFileCb7);
+async function runHook(cmd, cwd, timeoutMs, opts = {}) {
+  if (!cmd?.trim()) {
+    return { ok: true, output: "" };
+  }
+  const execFile4 = opts._deps?.execFile ?? execFileDefault4;
+  const timeout = opts.timeoutMs ?? timeoutMs;
+  try {
+    const { stdout, stderr } = await execFile4("/bin/sh", ["-c", cmd], {
+      cwd,
+      signal: AbortSignal.timeout(timeout),
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const combinedOutput = (typeof stdout === "string" ? stdout : String(stdout ?? "")) + (typeof stderr === "string" ? stderr : String(stderr ?? ""));
+    return { ok: true, output: combinedOutput };
+  } catch (err) {
+    const e = err;
+    const isTimeout = e.name === "AbortError" || e.code === "ABORT_ERR";
+    let stderr = e.stderr !== void 0 ? typeof e.stderr === "string" ? e.stderr : e.stderr.toString() : "";
+    if (isTimeout) {
+      stderr = (stderr ? stderr + "\n" : "") + `[hook-runner] command timed out after ${Math.round(timeout / 1e3)}s`;
+    } else if (!stderr && e.message) {
+      stderr = e.message;
+    }
+    return { ok: false, output: stderr };
+  }
+}
+
 // src/plan-validator.ts
 import * as fs6 from "fs";
 import * as path6 from "path";
@@ -1900,7 +2021,76 @@ function checkItemsSoft(content, file, warnings) {
   }
 }
 
+// src/phase-config.ts
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+      continue;
+    }
+    for (const key in obj) {
+      const srcValue = obj[key];
+      if (srcValue && typeof srcValue === "object" && !Array.isArray(srcValue) && !(srcValue instanceof Date)) {
+        const targetValue = result[key];
+        if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date)) {
+          result[key] = deepMerge(
+            targetValue,
+            srcValue
+          );
+        } else {
+          result[key] = srcValue;
+        }
+      } else {
+        result[key] = srcValue;
+      }
+    }
+  }
+  return result;
+}
+function resolvePhaseConfig(baseConfig, phaseName) {
+  if (!baseConfig || typeof baseConfig !== "object" || Array.isArray(baseConfig)) {
+    return {};
+  }
+  const base = baseConfig;
+  const phases = base.phases;
+  if (!phases || typeof phases !== "object") {
+    return base;
+  }
+  const phaseOverride = phases[phaseName];
+  if (!phaseOverride || typeof phaseOverride !== "object" || Array.isArray(phaseOverride)) {
+    return base;
+  }
+  return deepMerge(base, phaseOverride);
+}
+
 // src/loop-session.ts
+function extractVerifyConfig(config) {
+  const cfgObj = config;
+  const strategy = cfgObj?.verify ?? "after_phase";
+  const timeoutMs = cfgObj?.verify_timeout ?? 5 * 60 * 1e3;
+  const retryOnFailure = cfgObj?.verify_retry ?? true;
+  return { strategy, timeoutMs, retryOnFailure };
+}
+function extractHooksConfig(config) {
+  const cfgObj = config;
+  const hooks = cfgObj?.hooks;
+  return {
+    pre_phase: hooks?.pre_phase,
+    post_phase: hooks?.post_phase,
+    post_run: hooks?.post_run,
+    on_error: hooks?.on_error
+  };
+}
+function uncheckItemsInMarkdown(content, itemIds) {
+  if (itemIds.length === 0) return content;
+  let result = content;
+  for (const itemId of itemIds) {
+    const escaped = itemId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^(- )\\[[xX]\\](\\s+id:\\s+${escaped}\\b)`, "m");
+    result = result.replace(re, "$1[ ]$2");
+  }
+  return result;
+}
 function extractSection(content, sectionName) {
   const re = new RegExp(
     `^## ${sectionName}\\s*\\n([\\s\\S]*?)(?=^## |$)`,
@@ -2029,14 +2219,40 @@ async function runLoopSession(opts) {
   })();
   if (!isDirectory) {
     const prompt = `Work the plan at ${opts.planPath}. Complete all items in ## Acceptance criteria. Mark items done as they complete.`;
-    return _runRalphLoop({ prompt, cwd: opts.cwd, agentName: opts.fast ? "autopilot-fast" : void 0, logger: opts.logger, emitter, adapter: opts.adapter });
+    const adapterName = opts.adapter?.name;
+    const singleFileCfgObj = opts.config;
+    const models = singleFileCfgObj?.models;
+    const executionSpecifier = models?.execution;
+    const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+    const singleFileStallMs = singleFileCfgObj?.stall_timeout ?? STALL_MS_BY_TIER[opts.fast ? "autopilot-execute" : "deep"];
+    const singleFileAdapters = opts.config?.adapters;
+    const singleFileOcAdapter = singleFileAdapters?.opencode;
+    const singleFileAgentOverrides = singleFileOcAdapter?.agents;
+    return _runRalphLoop({
+      prompt,
+      cwd: opts.cwd,
+      agentName: opts.fast ? "autopilot-fast" : void 0,
+      model: executionModel,
+      stallMs: singleFileStallMs,
+      config: opts.config,
+      agentOverrides: singleFileAgentOverrides,
+      logger: opts.logger,
+      emitter,
+      adapter: opts.adapter
+    });
   }
   const log = opts.logger ? opts.logger.root.child({ component: "autopilot.orchestrator" }) : pino(
     { level: "info", timestamp: pino.stdTimeFunctions.isoTime },
     pino.destination({ fd: 2, sync: false })
   ).child({ component: "autopilot.orchestrator" });
   const tier = opts.fast ? "autopilot-execute" : "deep";
-  const maxIterationsPerPhase = opts.maxIterationsPerPhase ?? MAX_ITERATIONS_PER_PHASE_BY_TIER[tier];
+  const cfgObj = opts.config;
+  const cfgMaxIterPerPhase = cfgObj?.max_iterations_per_phase;
+  const maxIterationsPerPhase = opts.maxIterationsPerPhase ?? cfgMaxIterPerPhase ?? MAX_ITERATIONS_PER_PHASE_BY_TIER[tier];
+  const cfgStallMs = cfgObj?.stall_timeout;
+  const stallMs = cfgStallMs ?? STALL_MS_BY_TIER[tier];
+  const verifyConfig = extractVerifyConfig(opts.config);
+  const hooksConfig = extractHooksConfig(opts.config);
   const mainMdPath = path7.join(opts.planPath, "main.md");
   const useYamlSpec = hasSpec(opts.planPath);
   let goal;
@@ -2153,11 +2369,17 @@ async function runLoopSession(opts) {
     iterations: 0,
     message: "No phases to execute."
   };
-  const MAX_ITERATIONS_PER_ITEM = 5;
+  const cfgMaxIterPerItem = opts.config?.max_iterations_per_item;
+  const maxIterationsPerItem = cfgMaxIterPerItem ?? MAX_ITERATIONS_PER_ITEM;
   const runItemsForPhase = async (args) => {
     const { phaseFile, phasePath, laneId, runCwd, useParallel: useParallel2 } = args;
     const phaseContent = args.readFileSync(phasePath);
-    const items = (useYamlSpec ? parseSpecItems(phasePath) : parseItems(phaseContent)).filter((it) => !it.checked);
+    const allItems = useYamlSpec ? parseSpecItems(phasePath) : parseItems(phaseContent);
+    const items = allItems.filter((it) => !it.checked);
+    log.info(
+      { phase: phaseFile, total: allItems.length, unchecked: items.length, checked: allItems.length - items.length },
+      `phase items: ${items.length} unchecked of ${allItems.length} total`
+    );
     if (items.length === 0) {
       const prompt = `You are executing one phase of a multi-file plan. Work through every unchecked item in order. Check each box as you complete it. Commit when the phase is done.
 
@@ -2171,11 +2393,20 @@ ${constraints}
 ${phaseContent}
 
 Do not work on items from other phases. Do not ask questions.`;
+      const adapterName = args.adapter?.name;
+      const cfgObj2 = args.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
       return args.runRalphLoop({
         prompt,
         cwd: runCwd,
         agentName: "autopilot-fast",
+        model: executionModel,
         maxIterations: maxIterationsPerPhase,
+        ...args.stallMs ? { stallMs: args.stallMs } : {},
+        config: args.config,
+        agentOverrides: args.agentOverrides,
         laneId: useParallel2 ? laneId : void 0,
         logger: args.logger,
         emitter: args.emitter,
@@ -2185,7 +2416,7 @@ Do not work on items from other phases. Do not ask questions.`;
     const perItemCap = Math.max(
       1,
       Math.min(
-        MAX_ITERATIONS_PER_ITEM,
+        maxIterationsPerItem,
         Math.ceil(maxIterationsPerPhase / items.length)
       )
     );
@@ -2199,7 +2430,48 @@ Do not work on items from other phases. Do not ask questions.`;
     for (const item of items) {
       const filesList = item.files.map((f) => `${f.path}${f.isNew ? " (CREATE)" : " (EDIT)"}`).join(", ");
       const verify = item.verify?.trim() || "(no verify command declared)";
-      const itemPrompt = `You are executing ONE item of a multi-item phase. Complete only this item, mark its checkbox in ${phaseFile}, commit, and stop. Do not work on other items.
+      const enriched = item;
+      let enrichmentBlock = "";
+      if (enriched.mirror || enriched.context || enriched.conventions || enriched.proof) {
+        const parts = [];
+        if (typeof enriched.mirror === "string" && enriched.mirror.trim()) {
+          parts.push(`Pattern reference (read this file for the pattern to follow):
+  ${enriched.mirror}`);
+        }
+        if (typeof enriched.context === "string" && enriched.context.trim()) {
+          parts.push(`Code context:
+${enriched.context}`);
+        }
+        if (typeof enriched.conventions === "string" && enriched.conventions.trim()) {
+          parts.push(`Conventions: ${enriched.conventions}`);
+        }
+        if (typeof enriched.proof === "string" && enriched.proof.trim()) {
+          const proofType = typeof enriched.proof_type === "string" ? ` (${enriched.proof_type})` : "";
+          parts.push(`Acceptance proof${proofType}: ${enriched.proof}`);
+        }
+        enrichmentBlock = `
+## Enrichment context
+
+${parts.join("\n\n")}
+
+`;
+      }
+      const phaseConfigForItem = resolvePhaseConfig(
+        args.config,
+        phaseFile.replace(/\.(md|ya?ml)$/, "")
+      );
+      const executionStyle = phaseConfigForItem?.execution_style;
+      const isTddMode = executionStyle !== "direct";
+      let itemPrompt;
+      if (isTddMode) {
+        itemPrompt = `You are executing ONE item of a multi-item phase using TDD (test-driven development). Follow the red-green-refactor cycle strictly:
+
+1. RED: Write a failing test/proof first. Run verify to confirm it fails.
+2. GREEN: Implement the minimal code to make the test pass. Run verify to confirm it passes.
+3. REFACTOR: Clean up the code if needed, re-run verify to ensure it still passes.
+4. MARK: Mark the item checkbox and commit only after the verify command passes.
+
+Complete only this item, mark its checkbox in ${phaseFile}, commit, and stop. Do not work on other items.
 
 ## Overall goal
 ${goal}
@@ -2213,7 +2485,7 @@ ${constraints}
   files: ${filesList || "(none declared)"}
   verify: ${verify}
 
-## Structured context
+` + enrichmentBlock + `## Structured context
 
 Files you may touch (ONLY these):
 ` + (item.files.length > 0 ? item.files.map((f) => `  - ${f.path} (${f.isNew ? "CREATE" : "EDIT"})`).join("\n") : "  (none declared \u2014 confine edits to the phase's natural scope)") + `
@@ -2221,16 +2493,61 @@ Files you may touch (ONLY these):
 Verify command (must exit 0):
   - ${verify}
 
+TDD workflow:
+  1. Write a test that fails (RED phase)
+  2. Implement to make it pass (GREEN phase)
+  3. Refactor if needed, re-verify (REFACTOR phase)
+  4. Mark checkbox when verify passes
+
 Non-goals:
+  - Do NOT skip the RED phase \u2014 always write the test first.
   - Do NOT modify files outside the list above.
   - Do NOT work on items other than ${item.id}.
 
 When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit, and emit the autopilot-done sentinel.`;
+      } else {
+        itemPrompt = `You are executing ONE item of a multi-item phase. Complete only this item, mark its checkbox in ${phaseFile}, commit, and stop. Do not work on other items.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## Your item
+- [ ] id: ${item.id}
+  intent: ${item.intent}
+  files: ${filesList || "(none declared)"}
+  verify: ${verify}
+
+` + enrichmentBlock + `## Structured context
+
+Files you may touch (ONLY these):
+` + (item.files.length > 0 ? item.files.map((f) => `  - ${f.path} (${f.isNew ? "CREATE" : "EDIT"})`).join("\n") : "  (none declared \u2014 confine edits to the phase's natural scope)") + `
+
+Verify command (must exit 0):
+  - ${verify}
+
+Non-goals:
+  - Do NOT modify files outside the list above.
+  - Do NOT work on items other than ${item.id}.
+
+When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit, and emit the autopilot-done sentinel.`;
+      }
+      const adapterName = args.adapter?.name;
+      const cfgObj2 = args.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
       const itemResult = await args.runRalphLoop({
         prompt: itemPrompt,
         cwd: runCwd,
         agentName: "autopilot-fast",
+        model: executionModel,
         maxIterations: perItemCap,
+        ...args.stallMs ? { stallMs: args.stallMs } : {},
+        config: args.config,
+        agentOverrides: args.agentOverrides,
         laneId: useParallel2 ? laneId : void 0,
         logger: args.logger,
         emitter: args.emitter,
@@ -2261,6 +2578,48 @@ When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit,
           message: `Item ${item.id} failed: ${itemResult.message}`
         };
       }
+      if (args.verifyConfig?.strategy === "after_item" && item.verify?.trim()) {
+        const itemVerifyResult = await _runVerifyCommands([item], runCwd, {
+          timeoutMs: args.verifyConfig.timeoutMs
+        });
+        if (itemVerifyResult.length > 0 && !itemVerifyResult[0].passed) {
+          const failed = itemVerifyResult[0];
+          log.warn(
+            {
+              phase: phaseFile,
+              itemId: failed.itemId,
+              command: failed.command,
+              stderr: failed.stderr.slice(0, 500)
+            },
+            "per-item verify failed"
+          );
+          if (useYamlSpec && args.planPath) {
+            markItemUnchecked(args.planPath, phaseFile, item.id);
+            args.logger?.root.child({ component: "autopilot.per-item-verify" }).warn(
+              { phase: phaseFile, itemId: item.id },
+              "unchecked item that failed verify \u2014 will retry next iteration"
+            );
+          } else if (args.writeFileSync) {
+            const currentPhaseContent = args.readFileSync(phasePath);
+            const uncheckContent = uncheckItemsInMarkdown(currentPhaseContent, [item.id]);
+            if (uncheckContent !== currentPhaseContent) {
+              args.writeFileSync(phasePath, uncheckContent);
+              args.logger?.root.child({ component: "autopilot.per-item-verify" }).warn(
+                { phase: phaseFile, itemId: item.id },
+                "unchecked item that failed verify \u2014 will retry next iteration"
+              );
+            }
+          }
+          if (args.verifyConfig.retryOnFailure) {
+            return {
+              exitReason: "sentinel",
+              iterations: cumulativeIterations,
+              cumulativeCostUsd: cumulativeCost,
+              message: `Item ${item.id} verify failed: ${failed.stderr.split("\n")[0]}`
+            };
+          }
+        }
+      }
     }
     return {
       ...lastItemResult,
@@ -2286,7 +2645,17 @@ When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit,
       current: phasesCompleted + 1,
       total: uncheckedPhases.length
     });
+    const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+    const phaseConfig = resolvePhaseConfig(
+      opts.config,
+      phaseName
+    );
+    const phaseOcAdapter = phaseConfig.adapters?.opencode;
+    const baseAdapters = opts.config?.adapters;
+    const baseOcAdapter = baseAdapters?.opencode;
+    const phaseAgentOverrides = phaseOcAdapter?.agents ?? baseOcAdapter?.agents;
     let result;
+    const phaseVerifyConfig = extractVerifyConfig(phaseConfig);
     if (opts.fast) {
       result = await runItemsForPhase({
         phaseFile,
@@ -2295,10 +2664,16 @@ When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit,
         runCwd,
         runRalphLoop: _runRalphLoop,
         readFileSync: _readFileSync,
+        writeFileSync: _writeFileSync,
+        planPath: opts.planPath,
         useParallel,
+        stallMs,
         logger: opts.logger,
         emitter,
-        adapter: opts.adapter
+        adapter: opts.adapter,
+        config: opts.config,
+        agentOverrides: phaseAgentOverrides,
+        verifyConfig: phaseVerifyConfig
       });
     } else {
       const retrySection = retryContext ? `
@@ -2321,11 +2696,20 @@ ${constraints}
 ${phaseContent}
 ` + retrySection + `
 Do not work on items from other phases. Do not ask questions \u2014 pick sensible defaults and note decisions in ## Open questions.`;
+      const adapterName = opts.adapter?.name;
+      const cfgObj2 = opts.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
       result = await _runRalphLoop({
         prompt,
         cwd: runCwd,
         agentName: void 0,
+        model: executionModel,
         maxIterations: maxIterationsPerPhase,
+        stallMs,
+        config: opts.config,
+        agentOverrides: phaseAgentOverrides,
         laneId: useParallel ? laneId : void 0,
         logger: opts.logger,
         emitter,
@@ -2340,9 +2724,17 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
     const updatedPhaseContent = _readFileSync(phasePath);
     let phaseComplete = useYamlSpec ? (() => {
       const yamlItems = parseSpecItems(phasePath);
+      const checkedCount = yamlItems.filter((i) => i.checked).length;
+      log.info(
+        { phase: phaseFile, total: yamlItems.length, checked: checkedCount },
+        `phase completion check: ${checkedCount}/${yamlItems.length} items checked`
+      );
       return yamlItems.length > 0 && yamlItems.every((i) => i.checked);
     })() : isPhaseComplete(updatedPhaseContent);
-    if (phaseComplete) {
+    const verifyConfig2 = extractVerifyConfig(opts.config);
+    const shouldSkipVerify = verifyConfig2.strategy === "skip";
+    const isAfterItemMode = verifyConfig2.strategy === "after_item" && opts.fast;
+    if (phaseComplete && !shouldSkipVerify && !isAfterItemMode) {
       const items = useYamlSpec ? parseSpecItems(phasePath) : parseItems(updatedPhaseContent);
       const itemsWithVerify = items.filter((it) => it.verify?.trim());
       if (itemsWithVerify.length > 0) {
@@ -2356,7 +2748,9 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
           phase: phaseFile,
           itemCount: itemsWithVerify.length
         });
-        const phaseVerify = await _runVerifyCommands(itemsWithVerify, runCwd);
+        const phaseVerify = await _runVerifyCommands(itemsWithVerify, runCwd, {
+          timeoutMs: verifyConfig2.timeoutMs
+        });
         verifyResults.push({ phaseFile, results: phaseVerify });
         const failed = phaseVerify.filter((r) => !r.passed);
         for (const r of phaseVerify) {
@@ -2371,6 +2765,7 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
           });
         }
         if (failed.length > 0) {
+          const failedItemIds = failed.map((f) => f.itemId);
           for (const f of failed) {
             log.warn(
               {
@@ -2382,6 +2777,20 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
               "verify command failed"
             );
           }
+          for (const itemId of failedItemIds) {
+            if (useYamlSpec) {
+              markItemUnchecked(opts.planPath, phaseFile, itemId);
+            } else {
+              const uncheckContent = uncheckItemsInMarkdown(updatedPhaseContent, [itemId]);
+              if (uncheckContent !== updatedPhaseContent) {
+                _writeFileSync(phasePath, uncheckContent);
+                log.warn(
+                  { phase: phaseFile, itemId },
+                  "unchecked item that failed verify \u2014 will retry next iteration"
+                );
+              }
+            }
+          }
           phaseComplete = false;
           verifyFailureSummary = failed.map((f) => `- \`${f.command}\` failed (item ${f.itemId}): ${f.stderr.split("\n").slice(-3).join(" ").slice(0, 200)}`).join("\n");
         } else {
@@ -2401,13 +2810,16 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
     }
     if (!phaseComplete && !SUCCESS_REASONS.has(result.exitReason)) {
       log.warn({ phase: phaseFile, exitReason: result.exitReason }, "phase failed");
-      if (opts.fast && preHeadSha && preHeadSha !== "HEAD") {
+      const rollbackConfig = cfgObj?.rollback_on_failure ?? "soft";
+      if (rollbackConfig !== "off" && opts.fast && preHeadSha && preHeadSha !== "HEAD") {
         const ok = await resetSoft(runCwd, preHeadSha, {
           onWarn: (m) => log.warn(m)
         });
         if (ok) {
           log.info({ ref: preHeadSha.slice(0, 8) }, "soft-reset to pre-phase state");
         }
+      } else if (rollbackConfig === "off" && opts.fast && preHeadSha && preHeadSha !== "HEAD") {
+        log.info({ ref: preHeadSha.slice(0, 8) }, "rollback disabled by config \u2014 keeping phase changes");
       }
       emitter?.emitEvent({
         type: "phase:done",
@@ -2418,6 +2830,12 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
         iterations: result.iterations,
         costUsd: costThisPhase
       });
+      const phaseHooksConfig = extractHooksConfig(phaseConfig);
+      const effectiveOnErrorHook = phaseHooksConfig.on_error ?? hooksConfig.on_error;
+      if (effectiveOnErrorHook) {
+        runHook(effectiveOnErrorHook, runCwd, verifyConfig2.timeoutMs).catch(() => {
+        });
+      }
       return {
         phaseFile,
         laneId,
@@ -2434,13 +2852,16 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
         { phase: phaseFile, max: maxIterationsPerPhase },
         "phase budget exhausted \u2014 moving on"
       );
-      writeCheckpoint(opts.cwd, {
-        planPath: opts.planPath,
-        completedPhases: [...completedPhasesAcc],
-        totalCostUsd,
-        totalIterations,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
+      const checkpointEnabled = cfgObj?.checkpoint !== false;
+      if (checkpointEnabled) {
+        writeCheckpoint(opts.cwd, {
+          planPath: opts.planPath,
+          completedPhases: [...completedPhasesAcc],
+          totalCostUsd,
+          totalIterations,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
     }
     emitter?.emitEvent({
       type: "phase:done",
@@ -2463,7 +2884,7 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
       verifyFailures: verifyFailureSummary
     };
   };
-  const recordPhaseCompletion = (phaseFile, result) => {
+  const recordPhaseCompletion = async (phaseFile, result, phaseHooksConfig) => {
     phasesCompleted++;
     completedPhasesAcc.push(phaseFile);
     if (useYamlSpec) {
@@ -2472,13 +2893,16 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
       const updatedMain = markPhaseChecked(_readFileSync(mainMdPath), phaseFile);
       _writeFileSync(mainMdPath, updatedMain);
     }
-    writeCheckpoint(opts.cwd, {
-      planPath: opts.planPath,
-      completedPhases: [...completedPhasesAcc],
-      totalCostUsd,
-      totalIterations,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    const checkpointEnabled = cfgObj?.checkpoint !== false;
+    if (checkpointEnabled) {
+      writeCheckpoint(opts.cwd, {
+        planPath: opts.planPath,
+        completedPhases: [...completedPhasesAcc],
+        totalCostUsd,
+        totalIterations,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
     log.info(
       {
         phase: phaseFile,
@@ -2489,18 +2913,28 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
       },
       "phase complete"
     );
+    const effectivePostPhaseHook = phaseHooksConfig?.post_phase ?? hooksConfig.post_phase;
+    if (effectivePostPhaseHook) {
+      const hookResult = await runHook(effectivePostPhaseHook, opts.cwd, verifyConfig.timeoutMs);
+      if (!hookResult.ok) {
+        log.warn({ phase: phaseFile, output: hookResult.output }, "post_phase hook failed");
+      }
+    }
   };
   if (!useParallel) {
     for (const phaseFile of uncheckedPhases) {
       if (opts.signal?.aborted) {
         log.info({ completed: phasesCompleted, remaining: uncheckedPhases.length }, "abort signal received \u2014 writing checkpoint and stopping");
-        writeCheckpoint(opts.cwd, {
-          planPath: opts.planPath,
-          completedPhases: [...completedPhasesAcc],
-          totalCostUsd,
-          totalIterations,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        const checkpointEnabled = cfgObj?.checkpoint !== false;
+        if (checkpointEnabled) {
+          writeCheckpoint(opts.cwd, {
+            planPath: opts.planPath,
+            completedPhases: [...completedPhasesAcc],
+            totalCostUsd,
+            totalIterations,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         return {
           exitReason: "aborted",
           iterations: totalIterations,
@@ -2508,13 +2942,20 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
           message: `Aborted after ${phasesCompleted}/${uncheckedPhases.length} phases completed`
         };
       }
-      const MAX_PHASE_RETRIES = opts.maxPhaseRetries ?? (opts._deps ? 1 : 3);
+      const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+      const phaseConfig = resolvePhaseConfig(
+        opts.config,
+        phaseName
+      );
+      const phaseHooksConfig = extractHooksConfig(phaseConfig);
+      const verifyRetryConfig = extractVerifyConfig(opts.config);
+      const effectiveMaxRetries = verifyRetryConfig.retryOnFailure ? opts.maxPhaseRetries ?? (opts._deps ? 1 : 3) : 1;
       let attempt = 0;
       let phaseSuccess = false;
       let lastVerifyFailures;
-      while (attempt < MAX_PHASE_RETRIES && !phaseSuccess) {
+      while (attempt < effectiveMaxRetries && !phaseSuccess) {
         attempt++;
-        const isEscalation = attempt === MAX_PHASE_RETRIES && attempt > 1 && opts.fast;
+        const isEscalation = attempt === effectiveMaxRetries && attempt > 1 && opts.fast;
         if (attempt > 1) {
           log.info(
             { phase: phaseFile, attempt, escalate: isEscalation },
@@ -2533,13 +2974,25 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
         if (isEscalation) {
           opts.fast = false;
         }
+        const effectivePrePhaseHook = phaseHooksConfig.pre_phase ?? hooksConfig.pre_phase;
+        if (effectivePrePhaseHook) {
+          const hookResult = await runHook(effectivePrePhaseHook, opts.cwd, verifyConfig.timeoutMs);
+          if (!hookResult.ok) {
+            log.warn({ phase: phaseFile, output: hookResult.output }, "pre_phase hook failed \u2014 skipping phase");
+            if (isEscalation) {
+              opts.fast = originalFast;
+            }
+            phaseSuccess = false;
+            continue;
+          }
+        }
         const r = await runPhaseInner(phaseFile, "lane-1", opts.cwd, lastVerifyFailures);
         if (isEscalation) {
           opts.fast = originalFast;
         }
         lastVerifyFailures = r.verifyFailures;
         if (r.phaseComplete) {
-          recordPhaseCompletion(phaseFile, r.phaseLoopResult);
+          await recordPhaseCompletion(phaseFile, r.phaseLoopResult, phaseHooksConfig);
           phaseSuccess = true;
           break;
         }
@@ -2551,7 +3004,7 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
             message: `${r.phaseLoopResult.message} (phase ${phaseFile}, ${phasesCompleted}/${uncheckedPhases.length} phases completed, total $${totalCostUsd.toFixed(2)})`
           };
         }
-        if (attempt >= MAX_PHASE_RETRIES) {
+        if (attempt >= effectiveMaxRetries) {
           log.warn({ phase: phaseFile, attempts: attempt }, "phase exhausted retries \u2014 moving on");
         }
       }
@@ -2601,6 +3054,33 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
             log.warn({ phase: phaseFile, err: msg }, "worktree create failed \u2014 falling back to main cwd");
           }
           const runCwd = handle?.path ?? opts.cwd;
+          const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+          const phaseConfig = resolvePhaseConfig(
+            opts.config,
+            phaseName
+          );
+          const phaseHooksConfig = extractHooksConfig(phaseConfig);
+          const effectivePrePhaseHook = phaseHooksConfig.pre_phase ?? hooksConfig.pre_phase;
+          if (effectivePrePhaseHook) {
+            const hookResult = await runHook(effectivePrePhaseHook, runCwd, verifyConfig.timeoutMs);
+            if (!hookResult.ok) {
+              log.warn({ phase: phaseFile, output: hookResult.output }, "pre_phase hook failed \u2014 skipping phase");
+              return {
+                phaseFile,
+                laneId,
+                ok: false,
+                fatal: false,
+                iterations: 0,
+                costUsd: 0,
+                phaseLoopResult: {
+                  exitReason: "error",
+                  iterations: 0,
+                  message: "pre_phase hook failed"
+                },
+                phaseComplete: false
+              };
+            }
+          }
           const result = await runPhaseInner(phaseFile, laneId, runCwd);
           if (handle) {
             handles.set(phaseFile, handle);
@@ -2629,12 +3109,18 @@ Do not work on items from other phases. Do not ask questions \u2014 pick sensibl
       });
       for (const r of lanesResult.results) {
         if (r.ok) {
-          recordPhaseCompletion(r.phaseFile, {
+          const phaseName = r.phaseFile.replace(/\.(md|ya?ml)$/, "");
+          const phaseConfig = resolvePhaseConfig(
+            opts.config,
+            phaseName
+          );
+          const phaseHooksConfig = extractHooksConfig(phaseConfig);
+          await recordPhaseCompletion(r.phaseFile, {
             exitReason: "sentinel",
             iterations: r.iterations,
             message: "completed via parallel lane",
             cumulativeCostUsd: r.costUsd
-          });
+          }, phaseHooksConfig);
         }
       }
       const fatalResult = lanesResult.results.find((r) => r.fatal);
@@ -2678,19 +3164,49 @@ ${constraints}
 ${finalMainContent}
 
 Only work on the unchecked items in main.md's acceptance criteria. Phase items are already done. Do not ask questions.`;
-      const crossResult = await _runRalphLoop({ prompt: crossCuttingPrompt, cwd: opts.cwd, agentName: opts.fast ? "autopilot-fast" : void 0, logger: opts.logger, emitter, adapter: opts.adapter });
+      const adapterName = opts.adapter?.name;
+      const cfgObj2 = opts.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+      const crossAdapters = opts.config?.adapters;
+      const crossOcAdapter = crossAdapters?.opencode;
+      const crossCuttingAgentOverrides = crossOcAdapter?.agents;
+      const crossResult = await _runRalphLoop({
+        prompt: crossCuttingPrompt,
+        cwd: opts.cwd,
+        agentName: opts.fast ? "autopilot-fast" : void 0,
+        model: executionModel,
+        stallMs,
+        config: opts.config,
+        agentOverrides: crossCuttingAgentOverrides,
+        logger: opts.logger,
+        emitter,
+        adapter: opts.adapter
+      });
       totalIterations += crossResult.iterations;
       totalCostUsd += crossResult.cumulativeCostUsd ?? 0;
       lastResult = crossResult;
     }
   }
   log.info({ completed: phasesCompleted, total: uncheckedPhases.length, iterations: totalIterations, cost: totalCostUsd.toFixed(2) }, "all phases done");
+  if (hooksConfig.post_run) {
+    const hookResult = await runHook(hooksConfig.post_run, opts.cwd, verifyConfig.timeoutMs);
+    if (!hookResult.ok) {
+      log.warn({ output: hookResult.output }, "post_run hook failed");
+    }
+  }
   deleteCheckpoint(opts.cwd);
   let changesetPath;
-  if (!opts._deps && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
+  const changesetEnabled = cfgObj?.changeset !== false;
+  if (changesetEnabled && !opts._deps && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
     try {
-      const { generateChangeset } = await import("./changeset-generator-DG3MVWVV.js");
-      const cs = await generateChangeset(opts.planPath, opts.cwd);
+      const { generateChangeset } = await import("./changeset-generator-HAHYSSUR.js");
+      const changesetOpts = {
+        packageName: cfgObj?.changeset_package,
+        bumpLevel: cfgObj?.changeset_bump
+      };
+      const cs = await generateChangeset(opts.planPath, opts.cwd, changesetOpts);
       changesetPath = cs.path;
       log.info(
         { path: cs.path, bumpLevel: cs.bumpLevel },
@@ -2704,7 +3220,7 @@ Only work on the unchecked items in main.md's acceptance criteria. Phase items a
   let prUrl;
   if (!opts._deps && opts.ship && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
     try {
-      const { autoShip } = await import("./auto-ship-LCT6LIH7.js");
+      const { autoShip } = await import("./auto-ship-EVLBKHUZ.js");
       const shipResult = await autoShip({
         planPath: opts.planPath,
         repoRoot: opts.cwd