@open-tomato/rafa 0.40.0 → 0.41.0

package/dist/{index-zcbj07aq.js → index-wjsarzf5.js}

@@ -4,6 +4,8 @@ import {
   escapeBlockerText,
   findNextTask,
   insertTrackerTask,
+  listOpenTasks,
+  listTrackerTasks,
   loadPlanPrerequisites,
   malformedPrerequisiteLines,
   parsePlan,
@@ -11,10 +13,11 @@ import {
   prerequisitesPathForPlan,
   renderInjection,
   runPreflight,
+  splitBlockerComment,
   trackerPathFor,
   updateTrackerLine,
   writeTrackerBlocker
-} from "./index-krpmxpkh.js";
+} from "./index-zg0qsb5b.js";
 import {
   ACROSS_STORES_ORDER,
   CORE_ADAPTER_REGISTRY,
@@ -106,10 +109,12 @@ import {
   runClaude,
   runClaudeCaptured,
   runsDir,
+  samePlan,
   scanLayout,
   selectEffortStore,
   selectSync,
   selfAndAncestors,
+  sessionDecisions,
   sessionFilePath,
   sessionPhase,
   spawnClaude,
@@ -129,7 +134,7 @@ import {
   writeNames,
   writePositionFile,
   writeSqliteStore
-} from "./index-8veaj0t9.js";
+} from "./index-cd0wzc12.js";
 import {
   CHANGE_LEVELS,
   CONFIG_DEFAULTS,
@@ -146,6 +151,7 @@ import {
   collisionMessage,
   configFilePath,
   findTierItem,
+  isLoopRetryCount,
   optionalPrerequisite,
   parseConfigText,
   parseReport,
@@ -158,7 +164,7 @@ import {
   requiredPrerequisite,
   resolveTiers,
   stampPrompt
-} from "./index-334y39tn.js";
+} from "./index-3jpz9nr3.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -13832,7 +13838,7 @@ var CHECKOUT_ROSTER_TIMEOUT_MS = 30000;
 var DESCRIBE_LINE = `bun ${RAFA_ENTRY} describe --output=json`;
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-j7kjj0dd.js"),
+    import("./index-snf04fpt.js"),
     import("./describe-pwhh0vws.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
@@ -19475,7 +19481,7 @@ import {
   chmodSync,
   copyFileSync,
   existsSync as existsSync19,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync11,
   readFileSync as readFileSync26,
   realpathSync as realpathSync2,
@@ -19484,16 +19490,206 @@ import {
   statSync as statSync11,
   symlinkSync
 } from "fs";
-import { basename as basename7, delimiter as delimiter3, dirname as dirname10, join as join20, relative as relative6, resolve as resolve16 } from "path";
+import { basename as basename7, delimiter as delimiter3, dirname as dirname10, join as join21, relative as relative6, resolve as resolve16 } from "path";
 
 // src/start/runtime.ts
 import { existsSync as existsSync18, readdirSync as readdirSync10, realpathSync, statSync as statSync10 } from "fs";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute4, join as join19, relative as relative5, resolve as resolve15, sep } from "path";
+import { isAbsolute as isAbsolute4, join as join20, relative as relative5, resolve as resolve15, sep } from "path";
 
 // src/start/session.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { relative as relative4 } from "path";
+
+// src/loop/events-file.ts
+import { closeSync, fstatSync, openSync, readSync } from "fs";
+
+// src/start/loop-events.ts
+import { appendFileSync, mkdirSync as mkdirSync9 } from "fs";
+import { join as join19 } from "path";
+var MINUTE_MS = 60000;
+var TOKENS_PER_K = 1000;
+function quoted2(text) {
+  return `"${oneLine(text).replaceAll('"', "\\\"")}"`;
+}
+function taskKind(position, verb) {
+  return padKind(`task ${position.index}/${position.total} ${verb}`);
+}
+function minutes(durationMs) {
+  return `${Math.max(1, Math.round(durationMs / MINUTE_MS))}m`;
+}
+function summaryOf2(event) {
+  switch (event.kind) {
+    case "task-start":
+      return `${taskKind(event.position, "start")}${quoted2(event.text)}`;
+    case "task-done":
+      return event.tokens === null ? `${taskKind(event.position, "done")}${minutes(event.durationMs)}` : `${taskKind(event.position, "done")}${minutes(event.durationMs)}  ${Math.round(event.tokens / TOKENS_PER_K)}k tokens`;
+    case "task-blocked":
+      return `${taskKind(event.position, "blocked")}${oneLine(event.reason)}`;
+    case "wrap-up":
+      return `${padKind("wrap-up")}${event.phase}`;
+    case "pr":
+      return `pr #${event.number} opened`;
+    case "no-pr":
+      return `${padKind("no pr")}${oneLine(event.reason)}`;
+    case "halt":
+      return `${padKind("halt")}${oneLine(event.reason)}`;
+    case "retry":
+      return `${padKind(`retry ${event.attempt}/${event.of}`)}${oneLine(event.reason)}`;
+    case "decision":
+      return `${padKind(`decision ${event.strategy}`)}line ${event.line}: ${oneLine(event.reason)}`;
+    case "decision-needed":
+      return `${padKind("decision needed")}line ${event.line} ${quoted2(event.task)}`;
+    case "passed-over":
+      return `${padKind("passed over")}${passedOverList(event.tasks)}`;
+    case "inherited":
+      return `${padKind("inherited")}${oneLine(`${event.file} > ${event.name}`)}`;
+    case "error":
+      return `${padKind("error")}${firstLine4(event.message)}`;
+  }
+}
+function passedOverList(tasks) {
+  const noun = tasks.length === 1 ? "task" : "tasks";
+  return `${tasks.length} ${noun}: ${tasks.map((task) => `line ${task.line} (${task.strategy})`).join(", ")}`;
+}
+function firstLine4(message) {
+  return message.split(`
+`).map((line) => line.trim()).find((line) => line !== "") ?? "";
+}
+var EVENTS_EXTENSION = ".events.ndjson";
+var bound = null;
+function eventsFilePath(root, sessionId) {
+  if (!isSessionId(sessionId)) {
+    throw new Error(`events file: unusable session id ${JSON.stringify(sessionId)}`);
+  }
+  return join19(runsDir(root), `${sessionId}${EVENTS_EXTENSION}`);
+}
+function bindEventsFile(root, sessionId, warn = (line) => {
+  process.stderr.write(line);
+}) {
+  const file = eventsFilePath(root, sessionId);
+  try {
+    mkdirSync9(runsDir(root), { recursive: true });
+  } catch {}
+  bound = { file, warn, warned: false };
+  return file;
+}
+function unbindEventsFile() {
+  bound = null;
+}
+function appendEventLine(line) {
+  if (bound === null)
+    return;
+  try {
+    appendFileSync(bound.file, `${JSON.stringify(line)}
+`);
+  } catch (error) {
+    if (bound.warned)
+      return;
+    bound = { ...bound, warned: true };
+    bound.warn(`rafa: cannot write the events file ${bound.file}: ${messageOf(error)}
+`);
+  }
+}
+function emitLoopEvent(event, now = () => new Date) {
+  const { kind, ...data } = event;
+  const line = { name: kind, summary: summaryOf2(event), data, ts: now().toISOString() };
+  appendEventLine(line);
+  activeOutput().emit({ type: "event", ...line });
+}
+async function unlessText(read) {
+  return activeOutputMode() === "text" ? null : read();
+}
+function taskPosition(trackerContent, lineNum) {
+  const { tasks } = parsePlan(trackerContent);
+  return { index: tasks.findIndex((task) => task.lineNum === lineNum) + 1, total: tasks.length };
+}
+async function taskTokens(checkout, sessionId, home) {
+  try {
+    const { usage } = await readSessionLog(join19(sessionLogDir(checkout, home), `${sessionId}.jsonl`));
+    return usage.inputTokens + usage.cacheCreationInputTokens + usage.outputTokens;
+  } catch {
+    return null;
+  }
+}
+
+// src/loop/events-file.ts
+var NEWLINE = 10;
+function eventsFileOf(root, record) {
+  return eventsFilePath(root, record.sessionId);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseEventLine(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isPlainObject(value))
+    return null;
+  const { name: name2, summary, data, ts } = value;
+  if (typeof name2 !== "string" || typeof summary !== "string" || typeof ts !== "string")
+    return null;
+  if (!isPlainObject(data))
+    return null;
+  return Object.freeze({ name: name2, summary, data: Object.freeze({ ...data }), ts });
+}
+function bytesFrom(fd, offset) {
+  const length = fstatSync(fd).size - offset;
+  if (length <= 0)
+    return null;
+  const buffer = Buffer.alloc(length);
+  let filled = 0;
+  while (filled < length) {
+    const read = readSync(fd, buffer, filled, length - filled, offset + filled);
+    if (read === 0)
+      break;
+    filled += read;
+  }
+  return buffer.subarray(0, filled);
+}
+function readTail(file, offset) {
+  let fd;
+  try {
+    fd = openSync(file, "r");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return "absent";
+    throw error;
+  }
+  try {
+    return bytesFrom(fd, offset);
+  } finally {
+    closeSync(fd);
+  }
+}
+function readEventsFrom(file, offset) {
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    throw new RangeError(`events file: unusable offset ${String(offset)}`);
+  }
+  const tail = readTail(file, offset);
+  if (tail === "absent")
+    return Object.freeze({ kind: "absent" });
+  const end = tail?.lastIndexOf(NEWLINE) ?? -1;
+  if (tail === null || end < 0) {
+    return Object.freeze({ kind: "read", events: Object.freeze([]), malformed: 0, offset });
+  }
+  const lines = tail.subarray(0, end).toString("utf8").split(`
+`);
+  const parsed2 = lines.map(parseEventLine);
+  const events = parsed2.filter((event) => event !== null);
+  return Object.freeze({
+    kind: "read",
+    events: Object.freeze(events),
+    malformed: parsed2.length - events.length,
+    offset: offset + end + 1
+  });
+}
+
+// src/start/session.ts
 var NOTHING_DISPATCHED = "   Nothing was checked and nothing was dispatched.";
 function recordLabel(repoRoot, sessionId) {
   return relative4(repoRoot, sessionFilePath(repoRoot, sessionId));
@@ -19552,6 +19748,7 @@ function sessionHandle(repoRoot, sessionId) {
     pullRequestStarted: () => change("the pull-request phase", { phase: "pull-request" }),
     ciStarted: () => change("the ci phase", { phase: "ci" }),
     repairStarted: () => change("the repair phase", { phase: "repair" }),
+    decisionsChanged: (list) => change("the pass-over list", { decisions: list }),
     finished: () => {
       reachedEnd = true;
     },
@@ -19607,6 +19804,37 @@ function openRunSession(options) {
   }
   return sessionHandle(repoRoot, draft.sessionId);
 }
+function sameRunPlace(repoRoot, record, plan) {
+  if (record.branch !== plan.branch)
+    return false;
+  if (record.worktree === undefined)
+    return true;
+  return plan.checkout !== repoRoot && record.worktree === plan.checkout;
+}
+var ENDED_STATES = new Set(["stopped", "done"]);
+function endedRunsNewestFirst(repoRoot, plan, seams) {
+  const wanted = { planStub: plan.planStub, plan: relative4(repoRoot, plan.planPath) };
+  return readSessions(repoRoot, seams).filter((record) => ENDED_STATES.has(record.state) && samePlan(record, wanted) && sameRunPlace(repoRoot, record, plan)).reverse();
+}
+function readPreviousPassOver(repoRoot, plan, seams = {}) {
+  const newest = endedRunsNewestFirst(repoRoot, plan, seams)[0];
+  return newest === undefined ? [] : sessionDecisions(newest);
+}
+var TASK_EVENTS = new Set(["task-start", "decision", "decision-needed"]);
+function neededOf(data) {
+  const { task, line } = data;
+  return typeof task === "string" && typeof line === "number" ? { task, line } : null;
+}
+function readPreviousDecisionNeeded(repoRoot, plan, seams = {}) {
+  for (const record of endedRunsNewestFirst(repoRoot, plan, seams)) {
+    const read = readEventsFrom(eventsFileOf(repoRoot, record), 0);
+    const last = read.kind === "read" ? read.events.filter((event) => TASK_EVENTS.has(event.name)).at(-1) : undefined;
+    if (last === undefined)
+      continue;
+    return last.name === "decision-needed" ? neededOf(last.data) : null;
+  }
+  return null;
+}
 
 // src/start/run-config.ts
 function refuseEffortDirRun(env) {
@@ -19684,7 +19912,7 @@ function announcePlanIssues(planContent) {
 
 // src/start/runtime.ts
 var RUNTIME_FLAG = "--runtime";
-var RUNTIME_SUBDIR = join19(".rafa", "runtime");
+var RUNTIME_SUBDIR = join20(".rafa", "runtime");
 var RUNTIME_ENTRY = "cli.js";
 var SOURCE_DIR = "src";
 var RUNTIME_COMMAND = ["start"];
@@ -19711,7 +19939,7 @@ function resolveRuntime(value, places) {
     throw refusal2([`\u274C Refusing to start: \`--runtime\` names no runtime. Spell it ${SPELLING}.`]);
   }
   const isVersion = VERSION_SHAPE2.test(value);
-  const named3 = isVersion ? join19(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve15(places.cwd, value);
+  const named3 = isVersion ? join20(places.home, RUNTIME_SUBDIR, value, RUNTIME_ENTRY) : resolve15(places.cwd, value);
   refuseInsideSource(value, named3, places);
   const entry = entryOf2(value, named3, isVersion, places.home);
   const real = realpathSync(entry);
@@ -19722,7 +19950,7 @@ function entryOf2(value, named3, isVersion, home) {
   if (isVersion) {
     if (isFile2(named3))
       return named3;
-    const root = join19(home, RUNTIME_SUBDIR);
+    const root = join20(home, RUNTIME_SUBDIR);
     const installed = installedVersions(root);
     throw refusal2([
       `\u274C Refusing to start: \`--runtime=${value}\` names no installed runtime: ${named3} is no file.`,
@@ -19731,7 +19959,7 @@ function entryOf2(value, named3, isVersion, home) {
   }
   if (isFile2(named3))
     return named3;
-  const inside = join19(named3, RUNTIME_ENTRY);
+  const inside = join20(named3, RUNTIME_ENTRY);
   if (isDirectory(named3) && isFile2(inside))
     return inside;
   throw refusal2([
@@ -19749,7 +19977,7 @@ function refuseInsideSource(value, path3, places) {
   ]);
 }
 function sourceDirs({ cwd, root }) {
-  const dirs = [join19(cwd, SOURCE_DIR), join19(root, SOURCE_DIR)];
+  const dirs = [join20(cwd, SOURCE_DIR), join20(root, SOURCE_DIR)];
   const real = dirs.filter((dir) => existsSync18(dir)).map((dir) => realpathSync(dir));
   return [...new Set([...dirs, ...real])];
 }
@@ -19759,7 +19987,7 @@ function isInside2(path3, dir) {
 }
 function installedVersions(root) {
   try {
-    return readdirSync10(root).filter((name2) => isFile2(join19(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
+    return readdirSync10(root).filter((name2) => isFile2(join20(root, name2, RUNTIME_ENTRY))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
@@ -19953,19 +20181,19 @@ function runtimeRefusalLines(runtimeDir, version2) {
 }
 function listTrackers(repoRoot, planDir) {
   const dir = resolve16(repoRoot, planDir);
-  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join20(dir, entry)).filter((path3) => statSync11(path3).isFile()).map((path3) => relative6(repoRoot, path3));
+  return entryNames(dir).filter((entry) => TRACKER_NAME.test(entry)).sort((a, b) => a.localeCompare(b)).map((entry) => join21(dir, entry)).filter((path3) => statSync11(path3).isFile()).map((path3) => relative6(repoRoot, path3));
 }
 function openTrackers(repoRoot, planDir) {
   return listTrackers(repoRoot, planDir).flatMap((path3) => {
-    const task = findNextTask(readFileSync26(join20(repoRoot, path3), "utf8"));
+    const task = findNextTask(readFileSync26(join21(repoRoot, path3), "utf8"));
     return task ? [{ path: path3, task }] : [];
   });
 }
 function readManifestVersion2(repoRoot) {
-  const manifest = JSON.parse(readFileSync26(join20(repoRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync26(join21(repoRoot, "package.json"), "utf8"));
   const record = typeof manifest === "object" && manifest !== null ? manifest : {};
   if (record["name"] !== name) {
-    throw new Error(`${join20(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
+    throw new Error(`${join21(repoRoot, "package.json")} names ${JSON.stringify(record["name"])}, not ${name}: this is no rafa checkout`);
   }
   const version2 = record["version"];
   if (typeof version2 !== "string" || !VERSION_SHAPE2.test(version2)) {
@@ -19974,12 +20202,12 @@ function readManifestVersion2(repoRoot) {
   return version2;
 }
 function copyTree(from, to) {
-  mkdirSync9(to, { recursive: true });
+  mkdirSync10(to, { recursive: true });
   let copied = 0;
   const entries = readdirSync11(from, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const source = join20(from, entry.name);
-    const target = join20(to, entry.name);
+    const source = join21(from, entry.name);
+    const target = join21(to, entry.name);
     if (entry.isDirectory()) {
       copied += copyTree(source, target);
     } else if (entry.isFile()) {
@@ -20020,7 +20248,7 @@ function swapIn(staging, to) {
   rmSync2(outgoing, { recursive: true, force: true });
 }
 function relink(linkPath, target) {
-  mkdirSync9(dirname10(linkPath), { recursive: true });
+  mkdirSync10(dirname10(linkPath), { recursive: true });
   const temporary = temporaryName(linkPath);
   rmSync2(temporary, { force: true });
   try {
@@ -20074,8 +20302,8 @@ function installRuntime(seams, options = {}) {
 }
 function runInstall(seams, options) {
   const { repoRoot, home, log } = seams;
-  const runtimeRoot = join20(home, RUNTIME_SUBDIR);
-  const linkPath = join20(home, RAFA_BIN_DIR, LINK_NAME);
+  const runtimeRoot = join21(home, RUNTIME_SUBDIR);
+  const linkPath = join21(home, RAFA_BIN_DIR, LINK_NAME);
   log(`repo root: ${repoRoot}`);
   log(`runtime root: ${runtimeRoot}`);
   log(`link: ${linkPath}`);
@@ -20085,8 +20313,8 @@ function runInstall(seams, options) {
   const open = inStage("trackers", () => openTrackers(repoRoot, planDir));
   if (open.length > 0)
     return { kind: "refused", reason: "trackers", planDir, trackers: open };
-  const distDir = join20(repoRoot, "dist");
-  const runtimeDir = join20(runtimeRoot, version2);
+  const distDir = join21(repoRoot, "dist");
+  const runtimeDir = join21(runtimeRoot, version2);
   const installed = existsSync19(runtimeDir);
   if (installed && options.force !== true) {
     return { kind: "refused", reason: "runtime-exists", version: version2, runtimeDir };
@@ -20095,13 +20323,13 @@ function runInstall(seams, options) {
   const code = inStage("build", () => seams.build(repoRoot));
   if (code !== 0)
     throw new StageFailure("build", `the build exited ${code}`);
-  if (!existsSync19(join20(distDir, RUNTIME_ENTRY))) {
-    throw new StageFailure("build", `the build exited 0 and left no ${join20(distDir, RUNTIME_ENTRY)}`);
+  if (!existsSync19(join21(distDir, RUNTIME_ENTRY))) {
+    throw new StageFailure("build", `the build exited 0 and left no ${join21(distDir, RUNTIME_ENTRY)}`);
   }
   log(installed ? `copying ${distDir} over ${runtimeDir}, replacing it whole` : `copying ${distDir} into ${runtimeDir}`);
   const copied = inStage("copy", () => replaceTree(distDir, runtimeDir));
   log(`copied ${copied} file(s)`);
-  const resolved = inStage("link", () => relink(linkPath, join20(runtimeDir, RUNTIME_ENTRY)));
+  const resolved = inStage("link", () => relink(linkPath, join21(runtimeDir, RUNTIME_ENTRY)));
   log(`${linkPath} resolves to ${resolved}`);
   return { kind: "done", version: version2, runtimeDir, linkPath, resolved, copied };
 }
@@ -20135,7 +20363,7 @@ function replaceFile(source, target) {
   }
 }
 function temporaryName(path3) {
-  return join20(dirname10(path3), `.${basename7(path3)}.snapshot-${process.pid}`);
+  return join21(dirname10(path3), `.${basename7(path3)}.snapshot-${process.pid}`);
 }
 
 // src/commands/self-update.ts
@@ -20244,12 +20472,12 @@ var self_update_default = createSelfUpdateCommand();
 
 // src/commands/plan/list.ts
 import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync27 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var USAGE5 = "rafa plan list";
 var OPEN_HINT = "Type it bare: rafa plan list --open";
 function listing(dir, stub) {
-  const plan = join21(dir, planFileName(stub, false));
-  const trackerPath = join21(dir, planFileName(stub, true));
+  const plan = join22(dir, planFileName(stub, false));
+  const trackerPath = join22(dir, planFileName(stub, true));
   const tracker = isFile(trackerPath) ? trackerPath : null;
   const planModel = parsePlan(readFileSync27(plan, "utf8"));
   const counted4 = tracker === null ? planModel : parsePlan(readFileSync27(tracker, "utf8"));
@@ -20259,7 +20487,7 @@ function listPlans(plans) {
   const dir = plans.path;
   if (!existsSync20(dir))
     return { dir, plans: [] };
-  const stubs = readdirSync12(dir).filter((name2) => isFile(join21(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
+  const stubs = readdirSync12(dir).filter((name2) => isFile(join22(dir, name2))).map((name2) => stubOfPlanFile(name2)).filter((stub) => stub !== null).sort((a, b) => a.localeCompare(b));
   return { dir, plans: stubs.map((stub) => listing(dir, stub)) };
 }
 function isOpen(plan) {
@@ -20442,7 +20670,7 @@ async function openNextRelations(context, seams) {
 // src/commands/loop/loop-sessions.ts
 import { execFileSync } from "child_process";
 import { readFileSync as readFileSync28 } from "fs";
-import { join as join22, relative as relative7 } from "path";
+import { join as join23, relative as relative7 } from "path";
 
 // src/effort/store/task-finishes.ts
 import { existsSync as existsSync21 } from "fs";
@@ -20458,8 +20686,8 @@ function readTaskFinishes(repoRoot, query) {
   const path3 = sqliteStorePath(repoRoot);
   if (!existsSync21(path3))
     return [];
-  const bound = [query.planStub, query.since, query.planStub, query.since];
-  const rows = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_FINISHES).all(...bound));
+  const bound2 = [query.planStub, query.since, query.planStub, query.since];
+  const rows = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_FINISHES).all(...bound2));
   return rows.map((row) => row.collected_at);
 }
 
@@ -20594,7 +20822,7 @@ function writeSession(root, record, change) {
   }
 }
 function readSessionChecklist(root, record) {
-  const plan = join22(root, record.plan);
+  const plan = join23(root, record.plan);
   const file = [trackerPathFor(plan), plan].find((path3) => isFile(path3));
   if (file === undefined)
     return null;
@@ -20630,11 +20858,11 @@ function readSessionFinishes(root, record) {
 function formatDuration(seconds) {
   if (seconds < 60)
     return "under a minute";
-  const minutes = Math.round(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const rest = minutes % 60;
+  const minutes2 = Math.round(seconds / 60);
+  const hours = Math.floor(minutes2 / 60);
+  const rest = minutes2 % 60;
   if (hours === 0)
-    return `${minutes}m`;
+    return `${minutes2}m`;
   return rest === 0 ? `${hours}h` : `${hours}h ${rest}m`;
 }
 function etaLine(eta) {
@@ -20753,7 +20981,7 @@ function readBoardBody(body) {
 
 // src/board/codeowners.ts
 import { readFileSync as readFileSync29, statSync as statSync12 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var CODEOWNERS_LOCATIONS = Object.freeze([
   ".github/CODEOWNERS",
   "CODEOWNERS",
@@ -20805,7 +21033,7 @@ function isFile3(path3) {
   }
 }
 function findCodeowners(root) {
-  return CODEOWNERS_LOCATIONS.find((location) => isFile3(join23(root, location))) ?? null;
+  return CODEOWNERS_LOCATIONS.find((location) => isFile3(join24(root, location))) ?? null;
 }
 function readCodeowners(root) {
   const path3 = findCodeowners(root);
@@ -20813,7 +21041,7 @@ function readCodeowners(root) {
     return null;
   let text;
   try {
-    text = readFileSync29(join23(root, path3), "utf8");
+    text = readFileSync29(join24(root, path3), "utf8");
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
     throw new Error(`Cannot read ${path3}: ${why}`, { cause: error });
@@ -21588,7 +21816,7 @@ function pickerFor(followed, seams) {
 
 // src/commands/pr/merge-cleanup.ts
 import { existsSync as existsSync22, readFileSync as readFileSync30 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/release/enabled.ts
 import { statSync as statSync13 } from "fs";
@@ -21773,11 +22001,11 @@ function settleWaitingOn(place, git) {
   return { base: place.base, fragments: reading2.fragments.length, version: reading2.version };
 }
 function followUpsFor(place, git) {
-  const facts = readPackageFacts(textOf2(join24(place.root, "package.json")));
+  const facts = readPackageFacts(textOf2(join25(place.root, "package.json")));
   return readFollowUps({
     version: facts.version,
     rafaCheckout: facts.rafaCheckout,
-    runtimeInstalled: facts.version !== null && existsSync22(join24(place.home, RUNTIME_SUBDIR, facts.version)),
+    runtimeInstalled: facts.version !== null && existsSync22(join25(place.home, RUNTIME_SUBDIR, facts.version)),
     settle: settleWaitingOn(place, git),
     liveLoopBranches: liveLoopBranchesOf(place.root, place.isAlive)
   });
@@ -23722,19 +23950,19 @@ var ready_default = createIssueReadyCommand();
 import fs from "fs";
 import { homedir as homedir10 } from "os";
 import path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/notices/run.ts
 import { homedir as homedir6 } from "os";
 
 // src/notices/notices.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync31, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname11, join as join25 } from "path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync31, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname11, join as join26 } from "path";
 var NOTICE_IDS = Object.freeze(["alpha", "danger"]);
 var FEEDBACK_URL = "https://github.com/open-tomato/rafa/issues/new/choose";
 var ROADMAP_URL = "https://github.com/open-tomato/rafa/issues/31";
 function noticesPath(home) {
-  return join25(home, ".rafa", "notices.json");
+  return join26(home, ".rafa", "notices.json");
 }
 function isNoticeId(value) {
   return typeof value === "string" && NOTICE_IDS.includes(value);
@@ -23761,7 +23989,7 @@ function readDismissed(home) {
 function writeDismissed(home, ids) {
   const all = NOTICE_IDS.filter((id2) => ids.includes(id2) || readDismissed(home).includes(id2));
   const path3 = noticesPath(home);
-  mkdirSync10(dirname11(path3), { recursive: true });
+  mkdirSync11(dirname11(path3), { recursive: true });
   writeFileSync11(path3, `${JSON.stringify({ dismissed: all }, null, 2)}
 `);
 }
@@ -23879,7 +24107,7 @@ function realDirOf(path3) {
     return null;
   }
 }
-function firstLine4(git, args) {
+function firstLine5(git, args) {
   const result = git(args);
   if (!result.ok)
     return null;
@@ -23892,13 +24120,13 @@ function readCheckout2(checkout, seams = {}) {
   if (realDir === null)
     return { kind: "missing" };
   const git = (seams.git ?? createGitRunner)(checkout);
-  const toplevel = firstLine4(git, ["rev-parse", "--show-toplevel"]);
+  const toplevel = firstLine5(git, ["rev-parse", "--show-toplevel"]);
   if (toplevel === null || toplevel !== realDir)
     return { kind: "foreign", toplevel };
   return {
     kind: "read",
-    branch: firstLine4(git, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
-    head: firstLine4(git, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])
+    branch: firstLine5(git, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
+    head: firstLine5(git, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])
   };
 }
 function compareCheckout(expected2, reading2) {
@@ -23968,7 +24196,7 @@ function guardCheckout(expected2, seams = {}) {
   const move = compareCheckout(expected2, reading2);
   if (move === null)
     return { held: true };
-  const branchTip = move === "branch" ? firstLine4((seams.git ?? createGitRunner)(expected2.checkout), ["rev-parse", "--verify", "--quiet", `refs/heads/${expected2.branch}^{commit}`]) : null;
+  const branchTip = move === "branch" ? firstLine5((seams.git ?? createGitRunner)(expected2.checkout), ["rev-parse", "--verify", "--quiet", `refs/heads/${expected2.branch}^{commit}`]) : null;
   return { held: false, move, reading: reading2, lines: checkoutMovedLines({ expected: expected2, move, reading: reading2, branchTip }) };
 }
 
@@ -24048,7 +24276,7 @@ function haltIfWrapUpMoved(options, seams = {}) {
 // src/project/roots.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { accessSync, constants, readFileSync as readFileSync32, statSync as statSync14 } from "fs";
-import { isAbsolute as isAbsolute5, join as join26, resolve as resolve18 } from "path";
+import { isAbsolute as isAbsolute5, join as join27, resolve as resolve18 } from "path";
 var REFUSED_ROOTS = Object.freeze([
   { path: "/", why: "is the filesystem root" },
   { path: "/var", why: "holds system state" },
@@ -24180,8 +24408,8 @@ function readManifest(file, fs) {
   }
 }
 function readDir(dir, fs) {
-  const manifest = readManifest(join26(dir, PACKAGE_JSON), fs);
-  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join26(dir, name2)));
+  const manifest = readManifest(join27(dir, PACKAGE_JSON), fs);
+  const files = MONOREPO_MARKER_FILES.filter((name2) => fs.exists(join27(dir, name2)));
   const markers = manifest.marks ? [PACKAGE_JSON, ...files] : files;
   return { ...manifest, dir, markers };
 }
@@ -24546,6 +24774,12 @@ var NO_REPORT_HOLD = "no report: the session wrote no rafa:report block the loop
 var BACKGROUND_WAIT_HOLD = "no report: the session ended its turn waiting on a command left running in the background:";
 var NO_COMMIT_HOLD = "no commit: the task changed no tracked file";
 var NOTHING_REPORTED_OR_COMMITTED = "the session wrote no report block and changed no tracked file";
+function isNothingLeftBehindHold(hold) {
+  return hold === NO_REPORT_HOLD || hold === NO_COMMIT_HOLD || hold === NOTHING_REPORTED_OR_COMMITTED || hold.startsWith(`${BACKGROUND_WAIT_HOLD} `);
+}
+function heldOnNothingLeftBehind(finished) {
+  return finished.attempt.outcome !== "failed" && finished.holds.length > 0 && finished.holds.every(isNothingLeftBehindHold);
+}
 function indentBlock(text) {
   return text.split(`
 `).map((line) => `   ${line}`).join(`
@@ -24636,6 +24870,571 @@ function finishCleanExit(options) {
   };
 }
 
+// src/start/decision-parse.ts
+var DECISION_KIND = "decision";
+var DECISION_STRATEGIES = ["retry", "stop", "jump", "defer"];
+var UNREADABLE_PREFIX = "the decision could not be read, so the run stops: ";
+function isMapping3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fieldOf(mapping, key) {
+  return Object.entries(mapping).find(([own]) => own === key)?.[1];
+}
+function describeValue3(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null || value === undefined)
+    return "nothing";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return `the ${typeof value} ${String(value)}`;
+}
+function messageOf7(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function unreadable(why) {
+  return { strategy: "stop", reason: `${UNREADABLE_PREFIX}${why}` };
+}
+function isStrategy(value) {
+  return DECISION_STRATEGIES.includes(value);
+}
+function textField(document, key, needs = "") {
+  const raw = fieldOf(document, key);
+  if (raw === undefined || raw === null)
+    return { problem: `${key} is missing${needs}` };
+  if (typeof raw !== "string")
+    return { problem: `${key} is ${describeValue3(raw)}, expected text` };
+  const value = raw.trim();
+  return value === "" ? { problem: `${key} is blank${needs}` } : { value };
+}
+function afterField(document) {
+  const raw = fieldOf(document, "after");
+  if (raw === undefined || raw === null)
+    return { problem: "after is missing, and defer needs one" };
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 ? { value: raw } : { problem: `after is ${describeValue3(raw)}, expected a line number from 1` };
+}
+function readDecision(document) {
+  const strategy = fieldOf(document, "strategy");
+  if (strategy === undefined || strategy === null)
+    return unreadable("strategy is missing");
+  if (!isStrategy(strategy)) {
+    return unreadable(`strategy is ${describeValue3(strategy)}, expected one of: ${DECISION_STRATEGIES.join(", ")}`);
+  }
+  const reason = textField(document, "reason");
+  if ("problem" in reason)
+    return unreadable(reason.problem);
+  if (strategy === "retry") {
+    const approach = textField(document, "approach", ", and retry needs one");
+    return "problem" in approach ? unreadable(approach.problem) : { strategy, reason: reason.value, approach: approach.value };
+  }
+  if (strategy === "defer") {
+    const after = afterField(document);
+    return "problem" in after ? unreadable(after.problem) : { strategy, reason: reason.value, after: after.value };
+  }
+  return { strategy, reason: reason.value };
+}
+function parseDecision(output) {
+  const block = readRafaBlocks(output).filter((each) => each.kind === DECISION_KIND).at(-1);
+  if (block === undefined)
+    return unreadable("the output holds no rafa:decision block");
+  const at = `the rafa:decision block at line ${String(block.span.first)}`;
+  if (!block.closed)
+    return unreadable(`${at} is never closed`);
+  let document;
+  try {
+    document = Bun.YAML.parse(block.body);
+  } catch (error) {
+    return unreadable(`${at} is not valid YAML (${messageOf7(error)})`);
+  }
+  if (!isMapping3(document))
+    return unreadable(`${at} holds ${describeValue3(document)}, not a mapping`);
+  return readDecision(document);
+}
+
+// src/start/decision-prompt.ts
+import { existsSync as existsSync26, readFileSync as readFileSync35 } from "fs";
+import { dirname as dirname14, join as join30, resolve as resolve19 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/epic/verify-plan.ts
+import { existsSync as existsSync25, readFileSync as readFileSync34 } from "fs";
+import { dirname as dirname13, join as join29 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/board/epic-template.ts
+import { existsSync as existsSync24, readFileSync as readFileSync33 } from "fs";
+import { dirname as dirname12, join as join28 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var MODULE_DIR2 = dirname12(fileURLToPath2(import.meta.url));
+var EPIC_TEMPLATE_FILE = "epic.md";
+var CRITERIA_PLACEHOLDERS = Object.freeze([
+  "- Placeholder: one line per thing that makes this epic finished," + " written so a check against main can tell whether it holds."
+]);
+var PLACEHOLDER_REASON = "the line is still the epic template's placeholder, so there is nothing to check";
+function epicTemplateSource(moduleDir = MODULE_DIR2) {
+  return join28(moduleDir, TEMPLATES_DIRNAME, EPIC_TEMPLATE_FILE);
+}
+function readEpicTemplate(moduleDir = MODULE_DIR2) {
+  const source = epicTemplateSource(moduleDir);
+  if (!existsSync24(source)) {
+    throw new Error(`epic template: the epic issue template is missing: no file at ${source}`);
+  }
+  return readFileSync33(source, "utf8");
+}
+function placeholderCriteria(criteria) {
+  if (criteria === null)
+    return Object.freeze([]);
+  const held = criteria.split(/\r\n?|\n/u).map((line) => line.trim()).filter((line) => CRITERIA_PLACEHOLDERS.includes(line));
+  return Object.freeze(held.map((text) => Object.freeze({ text, reason: PLACEHOLDER_REASON })));
+}
+function renderEpicBody(template = readEpicTemplate()) {
+  const read = readEpicBody(template);
+  if (read.criteria === null) {
+    throw new Error("epic template: the template carries no acceptance criteria section with a placeholder under it");
+  }
+  const missing = CRITERIA_PLACEHOLDERS.length - placeholderCriteria(read.criteria).length;
+  if (missing > 0) {
+    throw new Error(`epic template: the acceptance criteria section has lost ${String(missing)} of its placeholder lines`);
+  }
+  if (read.lines.length > 0) {
+    throw new Error(`epic template: the template carries ${String(read.lines.length)} checklist lines; a new epic has none`);
+  }
+  return template;
+}
+
+// src/epic/verify-plan.ts
+var MODULE_DIR3 = dirname13(fileURLToPath3(import.meta.url));
+var VERIFY_PROMPT_FILE = "epic-verify-prompt.md";
+var VERIFY_BLOCK_FENCE = "rafa:verify";
+var VERIFY_PROMPT_SLOTS = ["EPIC_NUMBER", "EPIC_TITLE", "CRITERIA"];
+var SKIPPED_REASON = "the verification plan did not answer it";
+var FENCE4 = /^\s*(?:`{3,}|~{3,})/u;
+var LIST_ITEM2 = /^( {0,3})(?:[-*+]|\d{1,9}[.)])(?:\s|$)/u;
+var INDENTED2 = /^\s/u;
+var MIN_FENCE_LENGTH = 3;
+var VERIFY_KIND = VERIFY_BLOCK_FENCE.slice("rafa:".length);
+var SLOT_PATTERN = new RegExp(`\\{(${VERIFY_PROMPT_SLOTS.join("|")})\\}`, "gu");
+var ANSWER_KEYS = ["check", "uncheckable"];
+function opensCriterion(text, state) {
+  const item = LIST_ITEM2.exec(text);
+  if (item !== null) {
+    const indent = item[1]?.length ?? 0;
+    state.topIndent ??= indent;
+    return indent <= state.topIndent;
+  }
+  return state.afterBlank && !INDENTED2.test(text);
+}
+function splitCriteria(criteria) {
+  if (criteria === null)
+    return Object.freeze([]);
+  const gathered = [];
+  const state = { fenced: false, afterBlank: false, topIndent: null };
+  for (const text of criteria.split(/\r\n?|\n/u)) {
+    const insideFence = state.fenced;
+    if (FENCE4.test(text))
+      state.fenced = !state.fenced;
+    if (!insideFence && text.trim() === "") {
+      state.afterBlank = true;
+      gathered.at(-1)?.push(text);
+      continue;
+    }
+    const current = gathered.at(-1);
+    const opens = !insideFence && opensCriterion(text, state);
+    if (current === undefined || opens) {
+      gathered.push([text]);
+    } else {
+      current.push(text);
+    }
+    state.afterBlank = false;
+  }
+  const numbered2 = gathered.map((lines, index) => {
+    const text = lines.join(`
+`).trim();
+    return Object.freeze({ number: index + 1, text, placeholder: CRITERIA_PLACEHOLDERS.includes(text) });
+  });
+  return Object.freeze(numbered2);
+}
+function criteriaToAsk(criteria) {
+  return Object.freeze(criteria.filter((criterion) => !criterion.placeholder));
+}
+function verifyPromptCandidates(moduleDir = MODULE_DIR3) {
+  return [join29(moduleDir, VERIFY_PROMPT_FILE), join29(dirname13(moduleDir), VERIFY_PROMPT_FILE)];
+}
+function readVerifyPrompt(moduleDir = MODULE_DIR3) {
+  const candidates = verifyPromptCandidates(moduleDir);
+  const found = candidates.find((candidate) => existsSync25(candidate));
+  if (found === undefined) {
+    throw new Error(`epic verify prompt: the verification prompt is missing: no file at ${candidates.join(" or ")}`);
+  }
+  return readFileSync34(found, "utf8");
+}
+function fenceFor(text) {
+  const longestRun = Math.max(0, ...(text.match(/`+/gu) ?? []).map((run) => run.length));
+  return "`".repeat(Math.max(MIN_FENCE_LENGTH, longestRun + 1));
+}
+function renderCriterion(criterion) {
+  const fence = fenceFor(criterion.text);
+  return [`### Criterion ${String(criterion.number)}`, "", `${fence}text`, criterion.text, fence].join(`
+`);
+}
+function buildVerifyPrompt(template, input) {
+  const missing = VERIFY_PROMPT_SLOTS.find((slot) => !template.includes(`{${slot}}`));
+  if (missing !== undefined) {
+    throw new Error(`epic verify prompt: the template carries no {${missing}} slot`);
+  }
+  const values = {
+    EPIC_NUMBER: String(input.epic),
+    EPIC_TITLE: input.title.replace(/\s+/gu, " ").trim(),
+    CRITERIA: criteriaToAsk(input.criteria).map(renderCriterion).join(`
+
+`)
+  };
+  return template.replace(SLOT_PATTERN, (_whole, slot) => values[slot]);
+}
+function isMapping4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fieldOf2(mapping, key) {
+  return Object.entries(mapping).find(([own]) => own === key)?.[1];
+}
+function describeValue4(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null || value === undefined)
+    return "nothing";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return `the ${typeof value} ${String(value)}`;
+}
+function messageOf8(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function absent2(reason, block, text) {
+  return Object.freeze({ present: false, reason, block, text });
+}
+function readEntry(item, field4, asked) {
+  if (!isMapping4(item))
+    return { problem: `${field4} is ${describeValue4(item)}, not a mapping`, number: null };
+  const number = fieldOf2(item, "criterion");
+  if (typeof number !== "number" || !Number.isInteger(number) || number < 1) {
+    return { problem: `${field4}.criterion is ${describeValue4(number)}, not a criterion number from 1`, number: null };
+  }
+  if (!asked.has(number)) {
+    return { problem: `${field4}.criterion ${String(number)} is no criterion the plan was asked about`, number: null };
+  }
+  const carried = ANSWER_KEYS.filter((key2) => fieldOf2(item, key2) !== undefined);
+  const [key] = carried;
+  if (carried.length !== 1 || key === undefined) {
+    const count = carried.length === 0 ? "neither" : "both";
+    return { problem: `${field4} carries ${count} check and uncheckable`, number };
+  }
+  const value = fieldOf2(item, key);
+  if (typeof value !== "string" || value.trim() === "") {
+    return { problem: `${field4}.${key} is ${describeValue4(value)}, not a non-blank string`, number };
+  }
+  return { answer: { number, key, text: value.trim() } };
+}
+function verdictFor(criterion, answer4, problem) {
+  if (criterion.placeholder) {
+    return { kind: "uncheckable", criterion, reason: PLACEHOLDER_REASON, source: "placeholder" };
+  }
+  if (answer4?.key === "check")
+    return { kind: "check", criterion, check: answer4.text };
+  if (answer4?.key === "uncheckable")
+    return { kind: "uncheckable", criterion, reason: answer4.text, source: "answer" };
+  const reason = problem === undefined ? SKIPPED_REASON : `${SKIPPED_REASON}: its entry was dropped, as ${problem}`;
+  return { kind: "uncheckable", criterion, reason, source: "skipped" };
+}
+function readVerdicts(items2, criteria, block) {
+  const asked = new Set(criteriaToAsk(criteria).map((criterion) => criterion.number));
+  const answers = new Map;
+  const problems = new Map;
+  const issues = [];
+  for (const [index, item] of items2.entries()) {
+    const field4 = `criteria[${String(index)}]`;
+    const reading2 = readEntry(item, field4, asked);
+    if ("problem" in reading2) {
+      issues.push(Object.freeze({ field: field4, text: `${reading2.problem}; dropped` }));
+      if (reading2.number !== null && !problems.has(reading2.number))
+        problems.set(reading2.number, reading2.problem);
+      continue;
+    }
+    if (answers.has(reading2.answer.number)) {
+      const text = `${field4} answers criterion ${String(reading2.answer.number)} a second time; dropped`;
+      issues.push(Object.freeze({ field: field4, text }));
+      continue;
+    }
+    answers.set(reading2.answer.number, reading2.answer);
+  }
+  const verdicts = criteria.map((criterion) => Object.freeze(verdictFor(criterion, answers.get(criterion.number), problems.get(criterion.number))));
+  return Object.freeze({
+    present: true,
+    verdicts: Object.freeze(verdicts),
+    block,
+    issues: Object.freeze(issues)
+  });
+}
+function parseVerifyPlan(output, criteria) {
+  const block = readRafaBlocks(output).filter((each) => each.kind === VERIFY_KIND).at(-1);
+  if (block === undefined) {
+    return absent2("no-block", null, `the session output holds no ${VERIFY_BLOCK_FENCE} block`);
+  }
+  const at = `${VERIFY_BLOCK_FENCE} block at line ${String(block.span.first)}`;
+  if (!block.closed) {
+    return absent2("unclosed-block", block, `${at} is never closed, so it is not read`);
+  }
+  let document;
+  try {
+    document = Bun.YAML.parse(block.body);
+  } catch (error) {
+    return absent2("malformed-block", block, `${at} is not valid YAML (${messageOf8(error)})`);
+  }
+  if (!isMapping4(document)) {
+    return absent2("malformed-block", block, `${at} holds ${describeValue4(document)}, not a mapping`);
+  }
+  const listed = fieldOf2(document, "criteria") ?? [];
+  if (!Array.isArray(listed)) {
+    return absent2("malformed-block", block, `${at} has criteria ${describeValue4(listed)}, not a list`);
+  }
+  return readVerdicts(listed, criteria, block);
+}
+
+// src/start/decision-prompt.ts
+var MODULE_DIR4 = dirname14(fileURLToPath4(import.meta.url));
+var DECISION_PROMPT_FILE = "continue-decision-prompt.md";
+var CONTINUE_CRITERIA_FILE = "continue-criteria.md";
+var PROJECT_CRITERIA_HEADING = "### Project criteria";
+var DECISION_PROMPT_SLOTS = [
+  "plan",
+  "line",
+  "task",
+  "holds",
+  "retriesLeft",
+  "openTasks",
+  "criteria"
+];
+var SLOT_PATTERN2 = new RegExp(`\\{\\{(${DECISION_PROMPT_SLOTS.join("|")})\\}\\}`, "gu");
+var RETRY_SECTION = /^<!-- (retry|no-retry) -->\n([\s\S]*?)^<!-- \/\1 -->\n/gmu;
+function chooseRetrySections(template, retriesLeft) {
+  const kept = retriesLeft > 0 ? "retry" : "no-retry";
+  return template.replace(RETRY_SECTION, (_whole, section, body) => section === kept ? body : "");
+}
+var NO_HOLDS = "(no reason was recorded)";
+var NO_OPEN_TASKS = "(no open task is left)";
+function bundledCandidates(file, moduleDir = MODULE_DIR4) {
+  return [join30(moduleDir, file), join30(dirname14(moduleDir), file)];
+}
+function readBundledFile(file, moduleDir = MODULE_DIR4) {
+  const candidates = bundledCandidates(file, moduleDir);
+  const found = candidates.find((candidate) => existsSync26(candidate));
+  if (found === undefined) {
+    throw new Error(`loop continue: ${file} is missing: no file at ${candidates.join(" or ")}`);
+  }
+  return readFileSync35(found, "utf8");
+}
+function readProjectFile(path3) {
+  if (!existsSync26(path3))
+    return { text: null };
+  try {
+    return { text: readFileSync35(path3, "utf8") };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { refusal: `loop.continue.criteria cannot be read at ${path3}: ${message}` };
+  }
+}
+function resolveContinueCriteria(settings, moduleDir = MODULE_DIR4) {
+  const path3 = resolve19(settings.root, settings.path);
+  const read = readProjectFile(path3);
+  if ("refusal" in read)
+    return { ok: false, refusal: read.refusal };
+  const projectText = read.text?.trim() ?? "";
+  const project = read.text === null ? null : path3;
+  if (settings.mode === "replace") {
+    if (read.text === null) {
+      return {
+        ok: false,
+        refusal: `loop.continue.criteriaMode is replace, and loop.continue.criteria names no file at ${path3}`
+      };
+    }
+    if (projectText === "") {
+      return { ok: false, refusal: `loop.continue.criteriaMode is replace, and ${path3} holds no criteria` };
+    }
+    return { ok: true, criteria: projectText, project };
+  }
+  const base = readBundledFile(CONTINUE_CRITERIA_FILE, moduleDir).trimEnd();
+  const criteria = projectText === "" ? base : `${base}
+
+${PROJECT_CRITERIA_HEADING}
+
+${projectText}`;
+  return { ok: true, criteria, project };
+}
+function fenced(text) {
+  const fence = fenceFor(text);
+  return `${fence}text
+${text}
+${fence}`;
+}
+function shownLine(lineNum) {
+  return String(lineNum + 1);
+}
+function renderOpenTasks(tasks) {
+  if (tasks.length === 0)
+    return NO_OPEN_TASKS;
+  return fenced(tasks.map((task) => `line ${shownLine(task.lineNum)}: ${task.task}`).join(`
+`));
+}
+function renderDecisionPrompt(template, input) {
+  const missing = DECISION_PROMPT_SLOTS.find((slot) => !template.includes(`{{${slot}}}`));
+  if (missing !== undefined) {
+    throw new Error(`loop continue: the decision prompt carries no {{${missing}}} slot`);
+  }
+  const values = {
+    plan: input.plan,
+    line: shownLine(input.task.lineNum),
+    task: fenced(input.task.task),
+    holds: input.holds.length === 0 ? NO_HOLDS : fenced(input.holds.join(`
+`)),
+    retriesLeft: String(input.retriesLeft),
+    openTasks: renderOpenTasks(input.openTasks),
+    criteria: input.criteria
+  };
+  return chooseRetrySections(template, input.retriesLeft).replace(SLOT_PATTERN2, (_whole, slot) => values[slot]);
+}
+function buildDecisionPrompt(input, moduleDir = MODULE_DIR4) {
+  return renderDecisionPrompt(readBundledFile(DECISION_PROMPT_FILE, moduleDir), input);
+}
+
+// src/start/continue-args.ts
+var CONTINUE_FLAG = "--continue";
+var DECIDE_FLAG = "--decide";
+var APPROACH_FLAG = "--approach";
+var AFTER_FLAG = "--after";
+var FORCE_WRAP_UP_FLAG = "--force-wrap-up";
+var DIRECTIVE_REASON = `named on the line with ${DECIDE_FLAG}`;
+var CONTINUE_OFF = Object.freeze({ on: false, directive: null, forceWrapUp: false });
+var LINE_NUMBER = /^[1-9][0-9]*$/;
+function refuse10(reason, hint) {
+  throw new CommandExit(1, [`\u274C Refusing ${reason}: ${hint}`, NOTHING_DISPATCHED].join(`
+`));
+}
+function flagWords(args) {
+  const end = args.indexOf("--");
+  return end === -1 ? args : args.slice(0, end);
+}
+function lastValue(words, flag, shape) {
+  if (words.includes(flag))
+    refuse10(`a bare ${flag}`, `it takes a value as ${flag}=<${shape}>.`);
+  const prefix = `${flag}=`;
+  return [...words].reverse().find((word) => word.startsWith(prefix))?.slice(prefix.length);
+}
+function isStrategy2(value) {
+  return DECISION_STRATEGIES.includes(value);
+}
+function readStrategy(words) {
+  const typed = lastValue(words, DECIDE_FLAG, "strategy");
+  if (typed === undefined)
+    return;
+  if (!isStrategy2(typed)) {
+    refuse10(`${DECIDE_FLAG}=${typed}`, `it takes retry, stop, jump or defer as ${DECIDE_FLAG}=<strategy>.`);
+  }
+  return typed;
+}
+function readAfter(words) {
+  const typed = lastValue(words, AFTER_FLAG, "line");
+  if (typed === undefined)
+    return;
+  if (!LINE_NUMBER.test(typed)) {
+    refuse10(`${AFTER_FLAG}=${typed}`, "it takes a tracker line number from 1, as the decision prompt shows lines.");
+  }
+  return Number(typed);
+}
+function directiveOf(strategy, approach, after) {
+  if (approach !== undefined && strategy !== "retry") {
+    refuse10(APPROACH_FLAG, `${APPROACH_FLAG} is read only beside ${DECIDE_FLAG}=retry.`);
+  }
+  if (after !== undefined && strategy !== "defer") {
+    refuse10(AFTER_FLAG, `${AFTER_FLAG} is read only beside ${DECIDE_FLAG}=defer.`);
+  }
+  if (strategy === undefined)
+    return null;
+  if (strategy === "retry") {
+    const text = approach?.trim() ?? "";
+    if (text === "")
+      refuse10(`${DECIDE_FLAG}=retry`, `${DECIDE_FLAG}=retry needs ${APPROACH_FLAG}=<text>, the new approach.`);
+    return { strategy, reason: DIRECTIVE_REASON, approach: text };
+  }
+  if (strategy === "defer") {
+    if (after === undefined)
+      refuse10(`${DECIDE_FLAG}=defer`, `${DECIDE_FLAG}=defer needs ${AFTER_FLAG}=<line>, the task to run first.`);
+    return { strategy, reason: DIRECTIVE_REASON, after };
+  }
+  return { strategy, reason: DIRECTIVE_REASON };
+}
+function readContinueArgs(args) {
+  const words = flagWords(args);
+  const on = words.includes(CONTINUE_FLAG);
+  const forceWrapUp = words.includes(FORCE_WRAP_UP_FLAG);
+  const strategy = readStrategy(words);
+  const approach = lastValue(words, APPROACH_FLAG, "text");
+  const after = readAfter(words);
+  if (!on) {
+    if (strategy !== undefined)
+      refuse10(DECIDE_FLAG, `${DECIDE_FLAG} needs ${CONTINUE_FLAG}, the run it decides for.`);
+    if (forceWrapUp)
+      refuse10(FORCE_WRAP_UP_FLAG, `${FORCE_WRAP_UP_FLAG} needs ${CONTINUE_FLAG}, the run that passes tasks over.`);
+  }
+  const directive = directiveOf(strategy, approach, after);
+  return on ? { on, directive, forceWrapUp } : CONTINUE_OFF;
+}
+function configuredRetries(config, continueOn) {
+  return continueOn ? config.loopRetriesOnContinue : config.loopRetries;
+}
+function refuseRetryWithoutBudget(continueArgs, retries) {
+  if (continueArgs.directive?.strategy !== "retry" || retries !== false)
+    return;
+  refuse10(`${DECIDE_FLAG}=retry`, "the run has no retry to spend: loop.retriesOnContinue is false and --retry names no count. Name one with --retry=<n>, or decide another strategy.");
+}
+function refuseUnusableCriteria(continueArgs, root, config) {
+  if (!continueArgs.on)
+    return;
+  const reading2 = resolveContinueCriteria({
+    root,
+    path: config.loopContinueCriteria,
+    mode: config.loopContinueCriteriaMode
+  });
+  if (reading2.ok)
+    return;
+  refuse10(CONTINUE_FLAG, `${reading2.refusal}. Write the criteria there, or set loop.continue.criteriaMode: extend.`);
+}
+
+// src/start/continue-exits.ts
+var DECISION_STOP_EXIT = 20;
+var DECISION_NEEDED_EXIT = 21;
+var PASSED_OVER_EXIT = 22;
+var CONTINUE_EXITS = Object.freeze([
+  DECISION_STOP_EXIT,
+  DECISION_NEEDED_EXIT,
+  PASSED_OVER_EXIT
+]);
+
+class LoopEnd extends CommandExit {
+  constructor(exitCode, message) {
+    super(exitCode, message);
+    this.name = "LoopEnd";
+  }
+}
+
+// src/start/continue-run.ts
+import { existsSync as existsSync33, readFileSync as readFileSync40 } from "fs";
+
+// src/start/decision-session.ts
+import { randomUUID as randomUUID9 } from "crypto";
+
 // src/start/dispatch.ts
 import { randomUUID as randomUUID8 } from "crypto";
 
@@ -24708,13 +25507,13 @@ function bodyLines2(body) {
 function bodySections(body) {
   const lines = bodyLines2(body);
   const headings = [];
-  let fenced = false;
+  let fenced2 = false;
   lines.forEach((line, index) => {
     if (FENCE_LINE6.test(line)) {
-      fenced = !fenced;
+      fenced2 = !fenced2;
       return;
     }
-    if (fenced)
+    if (fenced2)
       return;
     const match = HEADING_LINE2.exec(line);
     if (match === null)
@@ -24740,7 +25539,7 @@ function bodySections(body) {
 }
 function numberedRuns(body) {
   const runs = [];
-  let fenced = false;
+  let fenced2 = false;
   let steps = 0;
   let line = 0;
   const close = () => {
@@ -24750,10 +25549,10 @@ function numberedRuns(body) {
   };
   bodyLines2(body).forEach((text, index) => {
     if (FENCE_LINE6.test(text)) {
-      fenced = !fenced;
+      fenced2 = !fenced2;
       return;
     }
-    if (fenced || text.trim() === "")
+    if (fenced2 || text.trim() === "")
       return;
     if (NUMBERED_ITEM.test(text)) {
       if (steps === 0)
@@ -24835,13 +25634,13 @@ function firstSection(sections2, heading) {
 }
 function withoutFences(text) {
   const kept = [];
-  let fenced = false;
+  let fenced2 = false;
   for (const line of bodyLines2(text)) {
     if (FENCE_LINE6.test(line)) {
-      fenced = !fenced;
+      fenced2 = !fenced2;
       continue;
     }
-    if (!fenced)
+    if (!fenced2)
       kept.push(line);
   }
   return kept;
@@ -24894,13 +25693,13 @@ function extractedDate(body) {
   return match?.[1] ?? null;
 }
 function errorString(body) {
-  let fenced = false;
+  let fenced2 = false;
   for (const line of bodyLines2(body)) {
     if (FENCE_LINE6.test(line)) {
-      fenced = !fenced;
+      fenced2 = !fenced2;
       continue;
     }
-    if (fenced) {
+    if (fenced2) {
       if (ERROR_WORDS.test(line))
         return line.trim();
       continue;
@@ -25046,7 +25845,7 @@ function reportLessons(record, context, now) {
 
 // src/effort/store/absences.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 var ABSENCE_REASONS = {
   "no-block": true,
   "unclosed-block": true,
@@ -25106,7 +25905,7 @@ function writeReportAbsence(repoRoot, write, seams = {}) {
     write.outcome,
     collectedAt
   ];
-  const appended3 = withSqliteStore(path3, "write", !existsSync24(path3), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
+  const appended3 = withSqliteStore(path3, "write", !existsSync27(path3), (db) => db.query(INSERT_ABSENCE).run(...values).changes);
   return { path: path3, appended: appended3, skipped: 1 - appended3 };
 }
 
@@ -25369,8 +26168,8 @@ function renderLessonsSection(lessons) {
 }
 
 // src/utils/progress.ts
-import { existsSync as existsSync25, writeFileSync as writeFileSync12 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync28, writeFileSync as writeFileSync12 } from "fs";
+import { join as join31 } from "path";
 var PROGRESS_FILE_NAME = "progress.txt";
 var PROGRESS_CAP_BYTES = 16000;
 var LISTED_FIELDS = [
@@ -25412,7 +26211,7 @@ var ESCAPED_CODE_POINTS = new Set([
   8233
 ]);
 function progressFilePath(repoRoot) {
-  return join27(repoRoot, PROGRESS_FILE_NAME);
+  return join31(repoRoot, PROGRESS_FILE_NAME);
 }
 function escapeValue(value) {
   let escaped = "";
@@ -25473,7 +26272,7 @@ function renderProgressText(findings, capBytes = PROGRESS_CAP_BYTES) {
 }
 function readProgressFindings(repoRoot, planStub2) {
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync25(path3))
+  if (!existsSync28(path3))
     return [];
   const rows = withSqliteStore(path3, "read", false, (db) => {
     const query = db.query(SELECT_FINDINGS2);
@@ -25499,7 +26298,7 @@ function writeProgress(repoRoot, planStub2, dir = repoRoot) {
 }
 
 // src/inventory/search/rank.ts
-import { readFileSync as readFileSync33 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 var SEARCH_LIMIT = 12;
 var MIN_WORD_LENGTH = 2;
 var MIN_PREFIX_LENGTH = 4;
@@ -25621,7 +26420,7 @@ function rankCandidates(question, candidates, limit = SEARCH_LIMIT) {
     return [];
   return candidates.map((candidate) => scoreCandidate(candidate, words)).filter((ranked) => ranked.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
 }
-function readRankCandidate(record, read = (path3) => readFileSync33(path3, "utf8")) {
+function readRankCandidate(record, read = (path3) => readFileSync36(path3, "utf8")) {
   let text;
   try {
     text = read(record.path);
@@ -25700,7 +26499,7 @@ function renderSkillIndex(resolution) {
 // src/task/resolve-skills.ts
 var RANK_FLOOR = 0;
 var TAG_LIMIT = 3;
-function summaryOf2(row) {
+function summaryOf3(row) {
   const { summary } = row;
   return typeof summary === "string" ? summary : "";
 }
@@ -25709,7 +26508,7 @@ function offered(item) {
     name: item.name,
     source: item.winner.source,
     path: item.winner.path,
-    description: summaryOf2(item.winner)
+    description: summaryOf3(item.winner)
   };
 }
 function asRecord(row) {
@@ -25822,14 +26621,14 @@ function taskInputFor(taskInfo, text, declaration, planContent) {
     stageContext: stageContextOf(taskInfo, planContent)
   };
 }
-function messageOf7(error) {
+function messageOf9(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function pullBundle(learning, repoRoot) {
   try {
     return await taskLearningAdapter(learning, repoRoot).pullBlessed();
   } catch (error) {
-    activeOutput().warn(`   Lessons: none handed to this task: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf7(error)}`);
+    activeOutput().warn(`   Lessons: none handed to this task: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf9(error)}`);
     activeOutput().warn("   The task is not failed for it: it is dispatched without a lessons section.");
     return null;
   }
@@ -25870,17 +26669,17 @@ function renderInheritedSection(failures) {
 
 // src/start/preflight.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync28, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync38 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename8, join as join28 } from "path";
+import { basename as basename8, join as join32 } from "path";
 
 // src/effort/store/schema-report.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { Database } from "bun:sqlite";
 var NO_NEXT_STEP = "none";
 function readSchemaReport(path3, options = {}) {
   guardTestProcess(path3);
-  if (!existsSync26(path3))
+  if (!existsSync29(path3))
     return absentReport(path3);
   const catalogue = sqliteCatalogue(options.migrations ?? SQLITE_MIGRATIONS);
   const store = readReadOnly(path3);
@@ -25988,11 +26787,11 @@ function developmentApplied(report2) {
 }
 
 // src/preflight/first-dispatch.ts
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 var TICKED_TASK = /^- \[[xX]\] (.+)/;
 function readIfReadable(path3) {
   try {
-    return readFileSync34(path3, "utf8");
+    return readFileSync37(path3, "utf8");
   } catch {
     return null;
   }
@@ -26019,7 +26818,7 @@ function isFirstDispatch(planPath) {
 }
 
 // src/claims/device.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 var NO_CLAIMANT = "no claim can name this device";
 function ndjsonReason() {
   return "this project's effort store is NDJSON (store: ndjson), which records no store id," + ` so ${NO_CLAIMANT}. Next safe step: ${MOVE_TO_SQLITE}`;
@@ -26034,7 +26833,7 @@ function readDeviceStoreId(repoRoot, config) {
   if (config.store === "ndjson")
     return { ok: false, cause: "ndjson", reason: ndjsonReason() };
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync27(path3))
+  if (!existsSync30(path3))
     return { ok: false, cause: "absent", reason: absentReason(path3) };
   const meta = withSqliteStore(path3, "read", false, (db) => readStoreMeta(db));
   return meta === null ? { ok: false, cause: "unminted", reason: unmintedReason(path3) } : { ok: true, storeId: meta.storeId };
@@ -26453,11 +27252,11 @@ function knownMissingNotice(lines) {
 }
 function agentSourcePath(planPath) {
   const tracker = trackerPathFor(planPath);
-  return existsSync28(tracker) ? tracker : planPath;
+  return existsSync31(tracker) ? tracker : planPath;
 }
 function readIfReadable2(path3) {
   try {
-    return readFileSync35(path3, "utf8");
+    return readFileSync38(path3, "utf8");
   } catch {
     return null;
   }
@@ -26592,7 +27391,7 @@ function announceReminders(planPath, reminders) {
 function announceUnknownMigrations(repoRoot) {
   const output = activeOutput();
   try {
-    const report2 = readSchemaReport(join28(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME));
+    const report2 = readSchemaReport(join32(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME));
     for (const migration of unknownAdditive(report2))
       output.warn(unknownAdditiveWarning(migration));
   } catch (error) {
@@ -26669,6 +27468,294 @@ function withStamp(prompt) {
   return activePlanStub === null ? prompt : stampPrompt(activePlanStub, prompt);
 }
 
+// src/start/type-step.ts
+import { existsSync as existsSync32, mkdtempSync, realpathSync as realpathSync4, rmSync as rmSync4, symlinkSync as symlinkSync2, writeFileSync as writeFileSync13 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname15, join as join33, relative as relative8, resolve as resolve20, sep as sep2 } from "path";
+var TEST_FILE_SUFFIX = ".test.ts";
+var TSC_FLAGS = ["--noEmit", "--pretty", "false"];
+var ERRORS_LISTED = 10;
+var NODE_MODULES = "node_modules";
+var TSC_BIN = [".bin", "tsc"];
+var SCRATCH_NAME = "tsconfig.json";
+var FILE_ERROR = /^(.+)\((\d+),(\d+)\): error (TS\d+): (.*)$/;
+var GLOBAL_ERROR = /^error (TS\d+): (.*)$/;
+var NOTHING_RAN = { ran: false, red: false, interrupted: false, blocker: null };
+var GREEN = { ran: true, red: false, interrupted: false, blocker: null };
+var INTERRUPTED = { ran: true, red: false, interrupted: true, blocker: null };
+async function runTsc(options) {
+  const proc = Bun.spawn([...options.argv], {
+    cwd: options.cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
+}
+function typeLabel(task) {
+  return `type step after "${task}"`;
+}
+function pathsOf(status) {
+  return /^[RC]/.test(status) ? 2 : 1;
+}
+function readTypeFiles(git, base) {
+  const result = git(["diff", "--name-status", "-z", "--find-renames", "--diff-filter=d", base, "HEAD"]);
+  if (!result.ok) {
+    activeOutput().warn(`\u26A0\uFE0F  git diff from ${base} did not answer (${gitSaid(result) || "nothing said"}); the type step runs nothing.`);
+    return null;
+  }
+  const fields = result.stdout.split("\x00").filter((field4) => field4 !== "");
+  const files = [];
+  for (let index = 0;index < fields.length; ) {
+    const status = fields[index] ?? "";
+    const count = pathsOf(status);
+    const paths = fields.slice(index + 1, index + 1 + count);
+    index += 1 + count;
+    const head = paths[paths.length - 1];
+    if (head === undefined || !head.endsWith(TEST_FILE_SUFFIX))
+      continue;
+    files.push({ head, base: status.startsWith("A") ? null : paths[0] ?? null });
+  }
+  return files;
+}
+function realPath(path3) {
+  try {
+    return realpathSync4(path3);
+  } catch {
+    return resolve20(path3);
+  }
+}
+function walkStop(git) {
+  const result = git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  const common = result.stdout.trim();
+  return result.ok && common !== "" ? dirname15(realPath(common)) : null;
+}
+function isUnder(dir, root) {
+  return dir === root || dir.startsWith(root.endsWith(sep2) ? root : `${root}${sep2}`);
+}
+function findNodeModules(checkout, git) {
+  const start = realPath(checkout);
+  const stop = walkStop(git);
+  const top = stop !== null && isUnder(start, stop) ? stop : start;
+  for (let dir = start;; dir = dirname15(dir)) {
+    const modules = join33(dir, NODE_MODULES);
+    if (existsSync32(join33(modules, ...TSC_BIN)))
+      return modules;
+    if (dir === top || dirname15(dir) === dir)
+      return null;
+  }
+}
+function scratchTsconfigFields(tree, files, modules) {
+  const root = resolve20(tree);
+  return {
+    extends: join33(root, "tsconfig.json"),
+    compilerOptions: { typeRoots: [join33(resolve20(modules), "@types")] },
+    files: files.map((file) => join33(root, file)),
+    include: []
+  };
+}
+function scratchTsconfig(tree, files, modules) {
+  return `${JSON.stringify(scratchTsconfigFields(tree, files, modules), null, 2)}
+`;
+}
+function tscArgv(modules, scratch) {
+  return [join33(modules, ...TSC_BIN), "-p", scratch, ...TSC_FLAGS];
+}
+function modulesFor(checkout, git) {
+  return findNodeModules(checkout, git) ?? join33(resolve20(checkout), NODE_MODULES);
+}
+function readTypeCheckRecipe(checkout, git) {
+  if (!existsSync32(join33(checkout, "tsconfig.json")))
+    return null;
+  const modules = findNodeModules(checkout, git);
+  return modules === null ? null : { checkout, modules };
+}
+function parseTscOutput(stdout, cwd) {
+  const errors = [];
+  for (const line of stdout.split(`
+`)) {
+    const atFile = FILE_ERROR.exec(line);
+    const global = atFile === null ? GLOBAL_ERROR.exec(line) : null;
+    const last = errors[errors.length - 1];
+    if (atFile !== null) {
+      const [, file = "", row = "0", column = "0", code = "", message = ""] = atFile;
+      errors.push({ file: relative8(cwd, resolve20(cwd, file)), line: Number(row), column: Number(column), code, message });
+    } else if (global !== null) {
+      errors.push({ file: null, line: 0, column: 0, code: global[1] ?? "", message: global[2] ?? "" });
+    } else if (line.startsWith("  ") && last !== undefined) {
+      errors[errors.length - 1] = { ...last, message: `${last.message}
+${line.trimEnd()}` };
+    }
+  }
+  return errors;
+}
+function identity(error) {
+  return `${error.code} ${error.message}`;
+}
+function newErrors(head, base) {
+  const left = new Map;
+  for (const error of base) {
+    const key = `${error.file ?? ""}\x00${identity(error)}`;
+    left.set(key, (left.get(key) ?? 0) + 1);
+  }
+  return head.filter((error) => {
+    const key = `${error.file ?? ""}\x00${identity(error)}`;
+    const count = left.get(key) ?? 0;
+    if (count === 0)
+      return true;
+    left.set(key, count - 1);
+    return false;
+  });
+}
+function errorLine(error) {
+  const first = error.message.split(`
+`)[0] ?? "";
+  return `${error.file ?? "(no file)"}:${error.line}:${error.column} ${error.code} ${first}`;
+}
+function listed(errors) {
+  const shown2 = errors.slice(0, ERRORS_LISTED).map(errorLine);
+  return errors.length > ERRORS_LISTED ? [...shown2, `...and ${errors.length - ERRORS_LISTED} more`] : shown2;
+}
+function typeBlockerText(label, base, errors) {
+  const files = [...new Set(errors.map((error) => error.file ?? ""))];
+  const shown2 = listed(errors).join("; ").replace(/\.$/u, "");
+  return `The runner's ${label} found type errors in the task's test files that ${base} did not hold. ` + `New errors: ${shown2}. ` + `Fix them, then check ${files.join(" ")} with tsc ${TSC_FLAGS.join(" ")} -p over a tsconfig outside the checkout ` + "that extends its tsconfig.json by absolute path and lists them under files.";
+}
+function brokenBlockerText(label, run, said) {
+  return `The runner's ${label} could not type-check the task's test files: tsc exited ${run.exitCode}${said === undefined ? " and printed no error." : `: ${said}`}`;
+}
+function configError(errors, scratch, cwd) {
+  const config = relative8(cwd, scratch);
+  return errors.find((error) => error.file === null || error.file === config);
+}
+function firstLine6(run) {
+  return `${run.stdout}
+${run.stderr}`.split(`
+`).map((line) => line.trim()).find((line) => line !== "");
+}
+async function checkTree(input, modules, tree, files) {
+  const scratchDir = mkdtempSync(join33(tmpdir(), "rafa-type-step-"));
+  const scratch = join33(scratchDir, SCRATCH_NAME);
+  try {
+    writeFileSync13(scratch, scratchTsconfig(tree, files, modules), "utf8");
+    let run;
+    try {
+      run = await (input.runTypes ?? runTsc)({ cwd: tree, argv: tscArgv(modules, scratch) });
+    } catch (error) {
+      return { kind: "threw", why: messageOf(error) };
+    }
+    if (run.exitCode === input.stopCode || input.isInterrupted?.() === true)
+      return { kind: "interrupted" };
+    const errors = parseTscOutput(run.stdout, tree);
+    const config = configError(errors, scratch, tree);
+    if (config !== undefined)
+      return { kind: "broken", run, said: `error ${config.code}: ${config.message.split(`
+`)[0] ?? ""}` };
+    if (run.exitCode !== 0 && errors.length === 0)
+      return { kind: "broken", run, said: firstLine6(run) };
+    const wanted = new Set(files);
+    return { kind: "read", errors: errors.filter((error) => error.file !== null && wanted.has(error.file)) };
+  } finally {
+    rmSync4(scratchDir, { recursive: true, force: true });
+  }
+}
+async function inBaseTree(input, label, modules, check) {
+  const parent = mkdtempSync(join33(tmpdir(), "rafa-type-base-"));
+  const tree = join33(parent, "tree");
+  try {
+    const added = input.git(["worktree", "add", "--detach", tree, input.base]);
+    if (!added.ok) {
+      activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check out ${input.base} (${gitSaid(added) || "nothing said"}); it reads no error as new.`);
+      return null;
+    }
+    if (existsSync32(modules) && !existsSync32(join33(tree, NODE_MODULES)))
+      symlinkSync2(modules, join33(tree, NODE_MODULES));
+    if (!existsSync32(join33(tree, "tsconfig.json")))
+      return { kind: "read", errors: [] };
+    return await check(tree);
+  } finally {
+    if (existsSync32(tree)) {
+      const removed = input.git(["worktree", "remove", "--force", tree]);
+      if (!removed.ok)
+        activeOutput().warn(`\u26A0\uFE0F  The ${label} could not remove its worktree ${tree} (${gitSaid(removed) || "nothing said"}).`);
+    }
+    rmSync4(parent, { recursive: true, force: true });
+  }
+}
+async function baseErrors(input, label, modules, files) {
+  const pairs = files.filter((file) => file.base !== null);
+  if (pairs.length === 0)
+    return { errors: [] };
+  const run = await inBaseTree(input, label, modules, (tree) => checkTree(input, modules, tree, pairs.map((file) => file.base)));
+  if (run === null)
+    return { outcome: GREEN };
+  if (run.kind === "interrupted")
+    return { outcome: interrupted(label) };
+  if (run.kind !== "read") {
+    const why = run.kind === "threw" ? run.why : brokenBlockerText(label, run.run, run.said);
+    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check the files at ${input.base} (${why}); it reads no error as new.`);
+    return { outcome: GREEN };
+  }
+  const headOf = new Map(pairs.map((file) => [file.base, file.head]));
+  return { errors: run.errors.map((error) => ({ ...error, file: headOf.get(error.file ?? "") ?? error.file })) };
+}
+function interrupted(label) {
+  activeOutput().info(`\u23F9  The ${label} was interrupted by SIGINT: read as a stop, not as errors.`);
+  return INTERRUPTED;
+}
+function filesToCheck(input, label) {
+  if (!existsSync32(join33(input.checkout, "tsconfig.json"))) {
+    activeOutput().info(`\uD83D\uDD0E ${label}: no tsconfig.json at the checkout root; nothing to type-check.`);
+    return null;
+  }
+  const files = readTypeFiles(input.git, input.base);
+  if (files === null)
+    return null;
+  if (files.length > 0)
+    return files;
+  activeOutput().info(`\uD83D\uDD0E ${label}: the task changed no ${TEST_FILE_SUFFIX} file; nothing to type-check.`);
+  return null;
+}
+async function runTypeStep(input) {
+  const label = typeLabel(input.task);
+  const files = filesToCheck(input, label);
+  if (files === null)
+    return NOTHING_RAN;
+  const modules = modulesFor(input.checkout, input.git);
+  const head = await checkTree(input, modules, input.checkout, files.map((file) => file.head));
+  if (head.kind === "threw") {
+    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not run tsc (${head.why}); the run goes on without it.`);
+    return NOTHING_RAN;
+  }
+  if (head.kind === "interrupted")
+    return interrupted(label);
+  if (head.kind === "broken") {
+    const blocker = brokenBlockerText(label, head.run, head.said);
+    activeOutput().info(`\uD83D\uDD0E ${label}: ${blocker}`);
+    return { ran: true, red: true, interrupted: false, blocker };
+  }
+  const ran = `\uD83D\uDD0E ${label}: tsc over ${files.length} test file(s)`;
+  if (head.errors.length === 0) {
+    activeOutput().info(`${ran}: no type error.`);
+    return GREEN;
+  }
+  const base = await baseErrors(input, label, modules, files.filter((file) => head.errors.some((error) => error.file === file.head)));
+  if ("outcome" in base)
+    return base.outcome;
+  const added = newErrors(head.errors, base.errors);
+  activeOutput().info(`${ran}: ${head.errors.length} error(s), ${head.errors.length - added.length} already held at ${input.base}, ${added.length} not held.`);
+  for (const line of listed(added))
+    activeOutput().info(`   ${line}`);
+  if (added.length === 0)
+    return GREEN;
+  return { ran: true, red: true, interrupted: false, blocker: typeBlockerText(label, input.base, added) };
+}
+
 // src/start/task-gate-lines.ts
 var BASE_PROMPT_PREFIX = "The base commit of this task is ";
 var COMMIT_NAME = /^[0-9a-f]{7,64}$/;
@@ -26696,9 +27783,11 @@ function readAlwaysRunFiles(git, globs) {
   }
   return alwaysRunFiles(globs, result.stdout.split("\x00").filter((path3) => path3 !== ""));
 }
+function shellWord(word) {
+  return SHELL_SAFE_PATH.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+}
 function testArgument(path3) {
-  const prefixed = `./${path3}`;
-  return SHELL_SAFE_PATH.test(prefixed) ? prefixed : `'${prefixed.replaceAll("'", "'\\''")}'`;
+  return shellWord(`./${path3}`);
 }
 function alwaysRunLines(files) {
   if (files.length === 0)
@@ -26706,6 +27795,17 @@ function alwaysRunLines(files) {
   const args = files.map(testArgument).join(" ");
   return [`Also run \`bun test ${args}\`: these are the \`tests.alwaysRun\` files, content sweeps no changed file selects.`];
 }
+var TYPE_CHECK_FILE = "<test file>";
+var TYPE_CHECK_SCRATCH = "<that tsconfig.json>";
+function typeCheckLines(recipe) {
+  if (recipe === null)
+    return [];
+  const scratch = JSON.stringify(scratchTsconfigFields(recipe.checkout, [TYPE_CHECK_FILE], recipe.modules));
+  const run = tscArgv(recipe.modules, TYPE_CHECK_SCRATCH).map((word) => word === TYPE_CHECK_SCRATCH ? word : shellWord(word)).join(" ");
+  return [
+    `Before you report done, type-check the \`*${TEST_FILE_SUFFIX}\` files your change adds or edits, if any, as the runner's type step will:` + ` write \`${scratch}\` to \`tsconfig.json\` in a new directory outside the checkout,` + ` one \`files\` entry per such file with \`${TYPE_CHECK_FILE}\` replaced by its path relative to the checkout, such as \`src/x${TEST_FILE_SUFFIX}\`` + ` (the entry already opens with the checkout's path), then run \`${run}\` in the checkout.` + " In a test file your change adds, fix every error it reports." + ` In one your change edits, fix the errors on the lines your change touches, which \`git diff <base> -- ${TYPE_CHECK_FILE}\` names` + " with `<base>` the base commit above, and leave the others: the file held them before this task."
+  ];
+}
 
 // src/start/dispatch.ts
 var SESSION_ID_FLAG2 = "--session-id";
@@ -26722,13 +27822,14 @@ var NO_TASK_SECTIONS = { skills: "", lessons: "" };
 function sectionLines(sections2) {
   return [sections2.skills, sections2.lessons, sections2.inherited].filter((section) => section.trim().length > 0).flatMap((section) => [section, ""]);
 }
-function buildTaskPrompt(taskText, promptContent, planText, knownMissing = [], blocker = null, sections2 = NO_TASK_SECTIONS, base = null, inherited = [], alwaysRun = []) {
+function buildTaskPrompt(taskText, promptContent, planText, knownMissing = [], blocker = null, sections2 = NO_TASK_SECTIONS, base = null, inherited = [], alwaysRun = [], typeCheck = null) {
   return [
     `Your scoped task is: ${taskText}`,
     "Consider tasks listed above this one in the plan checklist as completed. Do not re-evaluate or re-do them. Focus only on the scoped task.",
     ...blockerLines(blocker),
     ...baseLines(base),
     ...alwaysRunLines(alwaysRun),
+    ...typeCheckLines(typeCheck),
     "",
     ...sectionLines({ ...sections2, inherited: renderInheritedSection(inherited) }),
     promptContent,
@@ -26772,7 +27873,7 @@ async function dispatchTask(options) {
   const resolution = options.serving === null ? EMPTY_RESOLUTION : resolveSessionTiers(options.serving);
   const task = taskInputFor(taskInfo, taskText, declaration, options.planContent);
   const handed = await handOut(options.handout, task, resolution, options.repoRoot);
-  const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }, options.base, options.inherited, options.alwaysRun));
+  const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }, options.base, options.inherited, options.alwaysRun, options.typeCheck ?? null));
   const served = serveForSession(options.serving, resolution);
   const record = {
     taskText,
@@ -26805,7 +27906,7 @@ function serveForSession(serving, resolution) {
     activeOutput().warn(`   ${skipped2.message}`);
   return served.flags;
 }
-function messageOf8(error) {
+function messageOf10(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function renderProgressForDispatch(repoRoot, planStub2, checkout = repoRoot) {
@@ -26818,7 +27919,7 @@ function renderProgressForDispatch(repoRoot, planStub2, checkout = repoRoot) {
     return true;
   } catch (error) {
     activeOutput().error(`
-\u274C progress.txt could not be rendered from the findings store: ${messageOf8(error)}`);
+\u274C progress.txt could not be rendered from the findings store: ${messageOf10(error)}`);
     activeOutput().error("   Nothing was dispatched. Make the store readable, then run again.");
     return false;
   }
@@ -26842,7 +27943,7 @@ async function pushTaskLessons(options, record) {
     const rules = result.decisions.map((decision) => decision.rule).join(", ");
     activeOutput().info(`   Pushed ${count} lesson(s) to the \`${learning.kind}\` learning adapter: ${rules}.`);
   } catch (error) {
-    activeOutput().warn(`   ${count} lesson(s) of session ${dispatch.sessionId} were not pushed to the \`${learning.kind}\` learning adapter: ${messageOf8(error)}`);
+    activeOutput().warn(`   ${count} lesson(s) of session ${dispatch.sessionId} were not pushed to the \`${learning.kind}\` learning adapter: ${messageOf10(error)}`);
     activeOutput().warn("   The task is not failed for it: its report is stored, findings and all.");
   }
 }
@@ -26876,7 +27977,7 @@ async function storeTaskReport(options) {
       activeOutput().warn(`   ${warning}`);
   } catch (error) {
     activeOutput().error(`
-\u274C The report of session ${dispatch.sessionId} was not stored: ${messageOf8(error)}`);
+\u274C The report of session ${dispatch.sessionId} was not stored: ${messageOf10(error)}`);
     activeOutput().error("   The session printed it above as it ran.");
     return false;
   }
@@ -26884,101 +27985,570 @@ async function storeTaskReport(options) {
   return true;
 }
 
-// src/start/loop-events.ts
-import { appendFileSync, mkdirSync as mkdirSync11 } from "fs";
-import { join as join29 } from "path";
-var MINUTE_MS = 60000;
-var TOKENS_PER_K = 1000;
-function quoted2(text) {
-  return `"${oneLine(text).replaceAll('"', "\\\"")}"`;
+// src/start/decision-session.ts
+var DECISION_TOOLS = Object.freeze(["Read", "Grep", "Glob"]);
+function decisionFlags(sessionId) {
+  return [SESSION_ID_FLAG2, sessionId, "--tools", DECISION_TOOLS.join(",")];
 }
-function taskKind(position, verb) {
-  return padKind(`task ${position.index}/${position.total} ${verb}`);
+function runDecisionSession(input) {
+  const id2 = (input.sessionId ?? randomUUID9)();
+  return runClaudeCaptured(withStamp(input.prompt), input.settingSources, decisionFlags(id2), input.spawn, [], { cwd: input.checkout });
 }
-function minutes(durationMs) {
-  return `${Math.max(1, Math.round(durationMs / MINUTE_MS))}m`;
+
+// src/start/pass-over.ts
+var EMPTY_PASS_OVER = Object.freeze([]);
+function taskIdentity(text) {
+  return stripTaskDeclaration(splitBlockerComment(text.trim()).text).trim();
 }
-function summaryOf3(event) {
-  switch (event.kind) {
-    case "task-start":
-      return `${taskKind(event.position, "start")}${quoted2(event.text)}`;
-    case "task-done":
-      return event.tokens === null ? `${taskKind(event.position, "done")}${minutes(event.durationMs)}` : `${taskKind(event.position, "done")}${minutes(event.durationMs)}  ${Math.round(event.tokens / TOKENS_PER_K)}k tokens`;
-    case "task-blocked":
-      return `${taskKind(event.position, "blocked")}${oneLine(event.reason)}`;
-    case "wrap-up":
-      return `${padKind("wrap-up")}${event.phase}`;
-    case "pr":
-      return `pr #${event.number} opened`;
-    case "no-pr":
-      return `${padKind("no pr")}${oneLine(event.reason)}`;
-    case "halt":
-      return `${padKind("halt")}${oneLine(event.reason)}`;
-    case "inherited":
-      return `${padKind("inherited")}${oneLine(`${event.file} > ${event.name}`)}`;
-    case "error":
-      return `${padKind("error")}${firstLine5(event.message)}`;
-  }
+function ordinalOf(ref8) {
+  return ref8.ordinal ?? 1;
 }
-function firstLine5(message) {
-  return message.split(`
-`).map((line) => line.trim()).find((line) => line !== "") ?? "";
+function sameTask(a, b) {
+  return a.task === b.task && ordinalOf(a) === ordinalOf(b);
 }
-var EVENTS_EXTENSION = ".events.ndjson";
-var bound = null;
-function eventsFilePath(root, sessionId) {
-  if (!isSessionId(sessionId)) {
-    throw new Error(`events file: unusable session id ${JSON.stringify(sessionId)}`);
+function taskRefIn(task, trackerContent) {
+  const identity2 = taskIdentity(task.task);
+  const copies = listTrackerTasks(trackerContent).filter((line) => line.lineNum <= task.lineNum && taskIdentity(line.task) === identity2);
+  return { lineNum: task.lineNum, task: identity2, ordinal: Math.max(1, copies.length) };
+}
+function locate(ref8, tasks) {
+  const copies = tasks.filter((task) => taskIdentity(task.task) === ref8.task);
+  return copies[ordinalOf(ref8) - 1] ?? null;
+}
+function movedTo(ref8, task) {
+  return { lineNum: task.lineNum, task: ref8.task, ordinal: ordinalOf(ref8) };
+}
+function locateOpen(ref8, tasks) {
+  const found = locate(ref8, tasks);
+  return found === null || found.status === "done" ? null : found;
+}
+function stillPassedOver(entry, tasks) {
+  const task = locateOpen(entry.task, tasks);
+  if (task === null)
+    return null;
+  const moved = { ...entry, task: movedTo(entry.task, task) };
+  if (entry.after === undefined)
+    return moved;
+  const after = locateOpen(entry.after, tasks);
+  return after === null ? null : { ...moved, after: movedTo(entry.after, after) };
+}
+function addDecision(list, task, decision, trackerContent) {
+  const ref8 = taskRefIn(task, trackerContent);
+  const others = list.filter((entry) => !sameTask(entry.task, ref8));
+  const { strategy, reason } = decision;
+  if (strategy === "jump")
+    return [...others, { task: ref8, strategy, reason }];
+  if (strategy !== "defer" || decision.after === undefined)
+    return others;
+  const afterLine = decision.after - 1;
+  const target = listOpenTasks(trackerContent).find((open) => open.lineNum === afterLine && open.lineNum !== task.lineNum);
+  return target === undefined ? others : [...others, { task: ref8, strategy, reason, after: taskRefIn(target, trackerContent) }];
+}
+function markDone(list, task, trackerContent) {
+  const done = taskRefIn(task, trackerContent);
+  const waitsOnDone = (entry) => entry.after !== undefined && sameTask(entry.after, done);
+  return list.filter((entry) => !sameTask(entry.task, done) && !waitsOnDone(entry));
+}
+function skippedLines(list, trackerContent) {
+  return new Set(remaining(list, trackerContent).map((entry) => entry.task.lineNum));
+}
+function remaining(list, trackerContent) {
+  if (list.length === 0)
+    return EMPTY_PASS_OVER;
+  const tasks = listTrackerTasks(trackerContent);
+  return list.flatMap((entry) => stillPassedOver(entry, tasks) ?? []);
+}
+function seedFrom(list, trackerContent) {
+  if (list.length === 0)
+    return EMPTY_PASS_OVER;
+  const tasks = listTrackerTasks(trackerContent);
+  const isBlocked = (entry) => locate(entry.task, tasks)?.status === "blocked";
+  return list.filter(isBlocked).flatMap((entry) => stillPassedOver(entry, tasks) ?? []);
+}
+
+// src/start/suite-blocker.ts
+import { readFileSync as readFileSync39, writeFileSync as writeFileSync14 } from "fs";
+function failingFiles(failures) {
+  const counts = new Map;
+  for (const failure3 of failures)
+    counts.set(failure3.file, (counts.get(failure3.file) ?? 0) + 1);
+  return [...counts.entries()];
+}
+var UNHANDLED_NAMED = 10;
+function unhandledName(error) {
+  const file = error.file ?? "a file Bun did not name";
+  return error.firstLine === null ? `${file} threw an error Bun printed no line for` : `${file} threw "${error.firstLine}"`;
+}
+function unhandledNames(errors) {
+  if (errors.length === 0)
+    return "no block of Bun's stderr named a file";
+  const named3 = errors.slice(0, UNHANDLED_NAMED).map(unhandledName);
+  const left = errors.length - named3.length;
+  const more = left > 0 ? [`and ${left} more`] : [];
+  return [...named3, ...more].join("; ");
+}
+function unhandledFiles(errors) {
+  return [...new Set(errors.flatMap((error) => error.file === null ? [] : [error.file]))];
+}
+function runnablePath(path3) {
+  return path3.startsWith("/") || path3.startsWith("./") ? path3 : `./${path3}`;
+}
+function errorsText(newErrors2, errors) {
+  const counted4 = `${newErrors2} more error(s) outside any test than the baseline`;
+  if (errors.length === 0)
+    return `${counted4}: a test file that throws while it loads, which the JUnit report names no file for.`;
+  const files = unhandledFiles(errors);
+  const run = files.length === 0 ? "" : ` Run bun test ${files.map(runnablePath).join(" ")} and make each load.`;
+  return `${counted4}; Bun's stderr named them as ${unhandledNames(errors)}.${run}`;
+}
+function blockerText(label, result, verdict) {
+  const files = failingFiles(verdict.fresh);
+  const parts = [`The runner's ${label} found failures the suite baseline does not hold.`];
+  if (files.length > 0) {
+    const named3 = files.map(([file, count]) => `${file} (${count} ${count === 1 ? "test" : "tests"})`);
+    parts.push(`New failing test files: ${named3.join(", ")}. Run bun test ${files.map(([file]) => runnablePath(file)).join(" ")} and make them pass.`);
   }
-  return join29(runsDir(root), `${sessionId}${EVENTS_EXTENSION}`);
+  if (verdict.newErrors > 0)
+    parts.push(errorsText(verdict.newErrors, result.unhandled));
+  if (verdict.unreported)
+    parts.push(`bun test exited ${result.exitCode} and printed no summary line.`);
+  return parts.join(" ");
 }
-function bindEventsFile(root, sessionId, warn2 = (line) => {
-  process.stderr.write(line);
-}) {
-  const file = eventsFilePath(root, sessionId);
-  try {
-    mkdirSync11(runsDir(root), { recursive: true });
-  } catch {}
-  bound = { file, warn: warn2, warned: false };
-  return file;
+var REPAIR_AGENT = "build-error-resolver";
+var REPAIR_TASK = /^Repair the red (?:task|stage|pre-wrap-up) step at commit \S+$/;
+var PRE_WRAP_UP_REPAIR = /^Repair the red pre-wrap-up step at commit \S+$/;
+var COMMIT_SHOWN = 12;
+var TICKED_PREFIX = "- [x] ";
+function repairTaskText(kind, commit) {
+  const shown2 = commit === null ? "(unread)" : commit.slice(0, COMMIT_SHOWN);
+  return `Repair the red ${kind} step at commit ${shown2}`;
 }
-function unbindEventsFile() {
-  bound = null;
+function isRepairTask(text) {
+  return REPAIR_TASK.test(text.trim());
 }
-function appendEventLine(line) {
-  if (bound === null)
-    return;
-  try {
-    appendFileSync(bound.file, `${JSON.stringify(line)}
-`);
-  } catch (error) {
-    if (bound.warned)
-      return;
-    bound = { ...bound, warned: true };
-    bound.warn(`rafa: cannot write the events file ${bound.file}: ${messageOf(error)}
+function lineOfTask(content, text) {
+  const found = parsePlan(content).tasks.filter((task) => task.text === text.trim());
+  return found.at(-1)?.lineNum ?? null;
+}
+function lineOfTickedPreWrapUpRepair(content) {
+  const found = parsePlan(content).tasks.filter((task) => task.status === "done" && PRE_WRAP_UP_REPAIR.test(task.text.trim()));
+  return found.at(-1)?.lineNum ?? null;
+}
+function existingRepairOf(content, site) {
+  if (site.kind === "pre-wrap-up")
+    return lineOfTickedPreWrapUpRepair(content);
+  return site.task !== undefined && isRepairTask(site.task) ? lineOfTask(content, site.task) : null;
+}
+function blockRepairAgain(trackerPath, content, line, blocker) {
+  const lines = content.split(`
 `);
+  const current = lines[line] ?? "";
+  if (current.startsWith(TICKED_PREFIX)) {
+    const reopened = [...lines.slice(0, line), `- [ ] ${current.slice(TICKED_PREFIX.length)}`, ...lines.slice(line + 1)];
+    writeFileSync14(trackerPath, reopened.join(`
+`), "utf8");
   }
+  return writeTrackerBlocker(trackerPath, line, blocker) ? { line, inserted: false } : null;
 }
-function emitLoopEvent(event, now = () => new Date) {
-  const { kind, ...data } = event;
-  const line = { name: kind, summary: summaryOf3(event), data, ts: now().toISOString() };
-  appendEventLine(line);
-  activeOutput().emit({ type: "event", ...line });
+function writeRepairTask(trackerPath, blocker, site) {
+  const content = readFileSync39(trackerPath, "utf8");
+  const repaired = existingRepairOf(content, site);
+  if (repaired !== null)
+    return blockRepairAgain(trackerPath, content, repaired, blocker);
+  const firstOpen = parsePlan(content).tasks.find((task) => task.status !== "done")?.lineNum ?? null;
+  const entry = { task: repairTaskText(site.kind, site.commit), declaration: `agent=${REPAIR_AGENT}`, blocker };
+  return { line: insertTrackerTask(trackerPath, entry, firstOpen), inserted: true };
 }
-async function unlessText(read) {
-  return activeOutputMode() === "text" ? null : read();
+
+// src/start/retry-budget.ts
+function resolveRunRetries(flag, configured) {
+  return flag ?? configured;
 }
-function taskPosition(trackerContent, lineNum) {
-  const { tasks } = parsePlan(trackerContent);
-  return { index: tasks.findIndex((task) => task.lineNum === lineNum) + 1, total: tasks.length };
+function openRetryBudget(retries) {
+  return Object.freeze({
+    of: retries === false ? 0 : retries,
+    used: 0
+  });
 }
-async function taskTokens(checkout, sessionId, home) {
-  try {
-    const { usage } = await readSessionLog(join29(sessionLogDir(checkout, home), `${sessionId}.jsonl`));
-    return usage.inputTokens + usage.cacheCreationInputTokens + usage.outputTokens;
-  } catch {
-    return null;
+function takeRetry(budget) {
+  if (budget.used >= budget.of)
+    return { granted: false, budget };
+  const used = budget.used + 1;
+  return {
+    granted: true,
+    attempt: used,
+    of: budget.of,
+    budget: Object.freeze({ of: budget.of, used })
+  };
+}
+function retryTaskOf(taskInfo, trackerContent) {
+  const ref8 = taskRefIn(taskInfo, trackerContent);
+  return Object.freeze({ key: `${String(ref8.ordinal)}:${ref8.task}`, repair: isRepairTask(ref8.task) });
+}
+function settleOnDone(budget, stoppedOn, done) {
+  if (done.repair || done.key === stoppedOn)
+    return budget;
+  return Object.freeze({ of: budget.of, used: 0 });
+}
+function retryLine2(grant, reason) {
+  return `\uD83D\uDD01 Retrying (retry ${grant.attempt} of ${grant.of} in a row) after the stop: ${reason}.` + " The loop goes on without a new rafa loop start.";
+}
+function movedLine2(reason) {
+  return `\u26A0\uFE0F  No retry after the stop: ${reason}. The checkout has moved from the loop's last commit,` + " so the task keeps its own stop.";
+}
+function createRunRetries(options) {
+  let budget = openRetryBudget(options.retries);
+  let refusal4 = null;
+  let stoppedOn = null;
+  const refuse11 = (why) => {
+    refusal4 = why;
+    return false;
+  };
+  const retry = (reason, stopped2) => {
+    stoppedOn = stopped2?.key ?? null;
+    if (options.isInterrupted())
+      return refuse11("interrupted");
+    const grant = takeRetry(budget);
+    if (!grant.granted)
+      return refuse11("spent");
+    if (!options.isCheckoutHeld()) {
+      activeOutput().warn(movedLine2(reason));
+      return refuse11("checkout moved");
+    }
+    budget = grant.budget;
+    refusal4 = null;
+    activeOutput().warn(retryLine2(grant, reason));
+    emitLoopEvent({ kind: "retry", attempt: grant.attempt, of: grant.of, reason });
+    return true;
+  };
+  return {
+    retry,
+    taskDone: (done) => {
+      budget = settleOnDone(budget, stoppedOn, done);
+    },
+    left: () => budget.of - budget.used,
+    lastRefusal: () => refusal4
+  };
+}
+
+// src/start/continue-run.ts
+var SUITE_STEP_RED = "suite step red";
+var INTERRUPTED2 = "interrupted";
+var NO_LINES = new Set;
+var NO_DECISIONS = Object.freeze({
+  skipLines: () => NO_LINES,
+  atStop: () => Promise.resolve(false),
+  atFirstTask: () => Promise.resolve(false),
+  taskDone: () => {
+    return;
+  },
+  atRunEnd: () => {
+    return;
+  },
+  atPlanEnd: () => [],
+  gateForcedWrapUp: (gate) => gate
+});
+function whenOf(stop) {
+  if (stop.kind !== "clean-exit")
+    return "spent";
+  if (stop.finished.attempt.outcome === "failed")
+    return "never";
+  return heldOnNothingLeftBehind(stop.finished) ? "spent" : "now";
+}
+function openingList(seed, trackerPath) {
+  if (seed.length === 0)
+    return seed;
+  const kept = existsSync33(trackerPath) ? seedFrom(seed, readFileSync40(trackerPath, "utf8")) : [];
+  const back = seed.length - kept.length;
+  if (back > 0) {
+    activeOutput().info(`\u21A9\uFE0F  ${back} task(s) the last --continue run passed over no longer read [BLOCKED], so this run takes them again.`);
   }
+  return kept;
+}
+function boundKey(taskInfo, trackerContent) {
+  const ref8 = taskRefIn(taskInfo, trackerContent);
+  return `${String(ref8.ordinal)}:${ref8.task}`;
+}
+function refusedRetry(refusal4) {
+  if (refusal4 === "checkout moved")
+    return "retry was chosen, but the checkout has moved from the loop's last commit";
+  if (refusal4 === "interrupted")
+    return "retry was chosen, but the run was interrupted";
+  return "retry was chosen with no retry left in a row";
+}
+function shownLine2(taskInfo) {
+  return taskInfo.lineNum + 1;
+}
+function createRunDecisions(options) {
+  if (!options.continueArgs.on)
+    return NO_DECISIONS;
+  const { trackerPath, retries, session } = options;
+  const mode = options.mode ?? activeOutputMode;
+  let directive = options.continueArgs.directive;
+  let firstPass = true;
+  const readTracker = () => readFileSync40(trackerPath, "utf8");
+  let list = openingList(options.seed, trackerPath);
+  const deferred = new Set;
+  const passedOver = new Set;
+  if (list.length > 0) {
+    session.decisionsChanged(list);
+    activeOutput().info(`\u23ED  Passing over ${list.length} task(s) the plan's last --continue run passed over, while they stay [BLOCKED].`);
+  }
+  const skipLines = (trackerContent) => skippedLines(list, trackerContent);
+  const subjectOf = (stop) => {
+    if (stop.kind === "clean-exit")
+      return { taskInfo: stop.taskInfo, retryTask: stop.retryTask, holds: stop.finished.holds, stopEvent: stop.stopEvent };
+    if (stop.kind === "session-exit") {
+      return { taskInfo: stop.taskInfo, retryTask: stop.retryTask, holds: [`session exited ${stop.exitCode}`], stopEvent: stop.stopEvent };
+    }
+    const content = readTracker();
+    const blocked3 = findNextTask(content, { skipLines: skipLines(content) });
+    if (blocked3?.status !== "blocked")
+      return null;
+    return {
+      taskInfo: blocked3,
+      retryTask: retryTaskOf(blocked3, content),
+      holds: [blocked3.blocker ?? SUITE_STEP_RED],
+      stopEvent: { kind: "halt", reason: SUITE_STEP_RED }
+    };
+  };
+  const stopWith = (decision, subject) => {
+    const line = shownLine2(subject.taskInfo);
+    emitLoopEvent({ kind: "decision", strategy: "stop", line, reason: decision.reason });
+    emitLoopEvent(subject.stopEvent);
+    throw new LoopEnd(DECISION_STOP_EXIT, `\u26D4 The --continue decision on line ${line} is stop: ${decision.reason}`);
+  };
+  const promptFor = (subject, content) => {
+    const criteria = resolveContinueCriteria({
+      root: options.repoRoot,
+      path: options.settings.loopContinueCriteria,
+      mode: options.settings.loopContinueCriteriaMode
+    });
+    if (!criteria.ok)
+      return { strategy: "stop", reason: `the criteria cannot be read, so the run stops: ${criteria.refusal}` };
+    return buildDecisionPrompt({
+      plan: options.planPath,
+      task: subject.taskInfo,
+      holds: subject.holds,
+      retriesLeft: retries.left(),
+      openTasks: listOpenTasks(content),
+      criteria: criteria.criteria
+    });
+  };
+  const needDecision = (subject, content, prompt) => {
+    const line = shownLine2(subject.taskInfo);
+    emitLoopEvent({
+      kind: "decision-needed",
+      task: subject.taskInfo.task,
+      line,
+      holds: subject.holds,
+      openTasks: listOpenTasks(content).map((task) => ({ line: shownLine2(task), text: task.task })),
+      retriesLeft: retries.left(),
+      prompt
+    });
+    emitLoopEvent(subject.stopEvent);
+    throw new LoopEnd(DECISION_NEEDED_EXIT, [
+      `\uD83E\uDDED A decision is needed for the stop on line ${line}; the decision-needed event holds its prompt.`,
+      "   Run again with --continue --decide=retry|stop|jump|defer (--approach=<text> for retry, --after=<line> for defer)."
+    ].join(`
+`));
+  };
+  const sessionDecision = async (subject, prompt) => {
+    activeOutput().info(`
+\uD83E\uDDED Deciding how the run goes on after the stop on line ${shownLine2(subject.taskInfo)}: one read-only session (--continue).`);
+    const answer4 = await runDecisionSession({
+      prompt,
+      settingSources: options.settingSources,
+      checkout: options.checkout,
+      ...options.spawn === undefined ? {} : { spawn: options.spawn }
+    });
+    if (options.isInterrupted())
+      return null;
+    if (answer4.exitCode !== 0) {
+      return { strategy: "stop", reason: `the decision session exited ${answer4.exitCode}, so the run stops` };
+    }
+    return parseDecision(answer4.stdout);
+  };
+  const takeDirective = (subject) => {
+    const taken = directive;
+    if (taken === null)
+      return null;
+    directive = null;
+    activeOutput().info(`
+\uD83E\uDDED Applying --decide=${taken.strategy}, named on the line, to line ${shownLine2(subject.taskInfo)}.`);
+    return taken;
+  };
+  const decisionFor2 = async (subject, content) => {
+    const directed = takeDirective(subject);
+    if (directed !== null)
+      return directed;
+    const prompt = promptFor(subject, content);
+    if (typeof prompt !== "string")
+      return prompt;
+    if (mode() === "json")
+      needDecision(subject, content, prompt);
+    return sessionDecision(subject, prompt);
+  };
+  const bounded = (decision, identity2) => {
+    const passing = decision.strategy === "jump" || decision.strategy === "defer";
+    if (passing && passedOver.has(identity2)) {
+      return { strategy: "stop", reason: `the task was passed over once already in this run and stopped again, so the run stops: ${decision.reason}` };
+    }
+    if (decision.strategy === "defer" && deferred.has(identity2)) {
+      return { strategy: "jump", reason: `the task was deferred once already in this run, so it is passed over as a jump: ${decision.reason}` };
+    }
+    return decision;
+  };
+  const passOver = (decision, subject, content, identity2) => {
+    const line = shownLine2(subject.taskInfo);
+    list = addDecision(list, subject.taskInfo, decision, content);
+    session.decisionsChanged(list);
+    if (decision.strategy === "defer")
+      deferred.add(identity2);
+    else
+      passedOver.add(identity2);
+    emitLoopEvent({ kind: "decision", strategy: decision.strategy, line, reason: decision.reason });
+    const how = decision.strategy === "defer" ? `deferred until line ${String(decision.after)} is done` : "passed over for the rest of this run";
+    activeOutput().warn(`\u23ED  Line ${line} is ${how}: ${decision.reason}`);
+    return true;
+  };
+  const interruptedDeciding = (subject) => {
+    emitLoopEvent({ ...subject.stopEvent, reason: INTERRUPTED2 });
+    throw new LoopEnd(0, `
+\u26A0\uFE0F  Interrupted during the --continue decision on line ${shownLine2(subject.taskInfo)}: nothing was decided, and the task stays [BLOCKED]. Run again to resume.`);
+  };
+  const retryWith = (decision, subject) => {
+    if (!retries.retry("the decision chose retry", subject.retryTask)) {
+      return stopWith({ strategy: "stop", reason: `${refusedRetry(retries.lastRefusal())}, so the run stops: ${decision.reason}` }, subject);
+    }
+    const line = shownLine2(subject.taskInfo);
+    writeTrackerBlocker(trackerPath, subject.taskInfo.lineNum, decision.approach ?? "");
+    emitLoopEvent({ kind: "decision", strategy: "retry", line, reason: decision.reason });
+    activeOutput().warn(`\uD83D\uDD01 Line ${line} is retried with a new approach: ${decision.reason}`);
+    return true;
+  };
+  const apply = (decision, subject, content, identity2) => {
+    switch (decision.strategy) {
+      case "retry":
+        return retryWith(decision, subject);
+      case "stop":
+        return stopWith(decision, subject);
+      case "jump":
+      case "defer":
+        return passOver(decision, subject, content, identity2);
+    }
+  };
+  const decide3 = async (subject) => {
+    const content = readTracker();
+    const decision = await decisionFor2(subject, content);
+    if (decision === null)
+      return interruptedDeciding(subject);
+    const identity2 = boundKey(subject.taskInfo, content);
+    return apply(bounded(decision, identity2), subject, content, identity2);
+  };
+  const atStop = async (stop) => {
+    if (options.isInterrupted())
+      return false;
+    const when = whenOf(stop);
+    if (when === "never")
+      return false;
+    const refusal4 = retries.lastRefusal();
+    if (when === "spent" && refusal4 !== "spent")
+      return false;
+    const subject = subjectOf(stop);
+    return subject === null ? false : decide3(subject);
+  };
+  const refuseMisdirected = (taskInfo, taken) => {
+    const needed2 = options.previousNeeded ?? null;
+    if (needed2 === null || taskIdentity(needed2.task) === taskIdentity(taskInfo.task))
+      return;
+    directive = null;
+    throw new CommandExit(1, [
+      `\u274C Refusing --decide=${taken.strategy}: the last run needed a decision on line ${needed2.line} "${taskIdentity(needed2.task)}",` + ` but this run opens on line ${shownLine2(taskInfo)} "${taskIdentity(taskInfo.task)}".`,
+      "   Check the tracker, then run again with --continue alone for a decision on the task this run opens on.",
+      "   Nothing was decided and nothing was dispatched."
+    ].join(`
+`));
+  };
+  const atFirstTask = async (taskInfo, trackerContent) => {
+    if (!firstPass)
+      return false;
+    firstPass = false;
+    if (directive === null || taskInfo?.status !== "blocked")
+      return false;
+    refuseMisdirected(taskInfo, directive);
+    const stopEvent = {
+      kind: "task-blocked",
+      position: taskPosition(trackerContent, taskInfo.lineNum),
+      reason: `--decide=${directive.strategy}`
+    };
+    return decide3({
+      taskInfo,
+      retryTask: retryTaskOf(taskInfo, trackerContent),
+      holds: [taskInfo.blocker ?? "blocked by an earlier run"],
+      stopEvent
+    });
+  };
+  const taskDone = (taskInfo) => {
+    const next = markDone(list, taskInfo, readTracker());
+    if (next.length === list.length)
+      return;
+    list = next;
+    session.decisionsChanged(list);
+  };
+  let announced = false;
+  const atPlanEnd = (trackerContent) => {
+    const left = remaining(list, trackerContent);
+    if (left.length === 0)
+      return [];
+    const tasks = left.map((entry) => ({
+      line: entry.task.lineNum + 1,
+      text: entry.task.task,
+      strategy: entry.strategy,
+      reason: entry.reason
+    }));
+    const forcing = options.continueArgs.forceWrapUp;
+    if (!announced) {
+      activeOutput().warn(forcing ? `
+\u23ED  Every task left is one this run passed over; --force-wrap-up wraps up anyway, as a draft pull request listing them:` : `
+\u23ED  Every task left is one this run passed over; no wrap-up runs and no pull request is opened:`);
+      for (const task of tasks)
+        activeOutput().warn(`   line ${task.line} (${task.strategy}): ${task.text}
+      ${task.reason}`);
+      emitLoopEvent({ kind: "passed-over", tasks });
+      announced = true;
+    }
+    if (forcing)
+      return tasks;
+    emitLoopEvent({ kind: "halt", reason: `passed over ${tasks.length} task(s)` });
+    throw new LoopEnd(PASSED_OVER_EXIT, [
+      `\u23ED  The run ended with ${tasks.length} passed-over task(s) left [BLOCKED]. A run with --continue passes them over again.`,
+      "   To put a task back, mark its tracker line - [ ] and run again, or run again without --continue, which resumes the first [BLOCKED] line.",
+      "   Or run again with --continue --force-wrap-up to open a draft pull request listing them."
+    ].join(`
+`));
+  };
+  const gateForcedWrapUp = (gate, forced, outcome2) => {
+    if (gate !== "stop" || forced.length === 0 || outcome2 === null || !outcome2.red || outcome2.interrupted)
+      return gate;
+    const max = options.settings.loopForceWrapUpMaxNewFailures;
+    const tolerated = max === false ? 0 : max;
+    const count = outcome2.step?.newFailures.length ?? 0;
+    if (count > 0 && count <= tolerated) {
+      activeOutput().warn(`\u26A0\uFE0F  --force-wrap-up goes on past the red pre-wrap-up step: ${count} new failure(s), within loop.forceWrapUp.maxNewFailures ${tolerated}.`);
+      return "go-on";
+    }
+    const why = count === 0 ? "the red pre-wrap-up step holds no failure it can count (errors outside any test, or no summary)" : `${count} new failure(s), over loop.forceWrapUp.maxNewFailures ${String(max)}`;
+    const halt2 = count === 0 ? "forced wrap-up refused: no failure to count" : `forced wrap-up refused: ${why}`;
+    emitLoopEvent({ kind: "halt", reason: halt2 });
+    throw new LoopEnd(DECISION_STOP_EXIT, `\u26D4 --force-wrap-up refused the wrap-up: ${why}. Repair them, or raise loop.forceWrapUp.maxNewFailures.`);
+  };
+  const atRunEnd = () => {
+    if (directive === null)
+      return;
+    activeOutput().warn(`\u26A0\uFE0F  --decide=${directive.strategy} was not applied: the run met no decision point. It applies once, to the next run's first [BLOCKED] task or first stop.`);
+  };
+  return { skipLines, atStop, atFirstTask, taskDone, atRunEnd, atPlanEnd, gateForcedWrapUp };
 }
 
 // src/start/pause.ts
@@ -27030,22 +28600,22 @@ async function holdWhilePaused(options) {
 }
 
 // src/start/plan-path.ts
-import { existsSync as existsSync29 } from "fs";
-import { resolve as resolve19 } from "path";
+import { existsSync as existsSync34 } from "fs";
+import { resolve as resolve21 } from "path";
 var DEFAULT_PLAN_FILE = "PLAN.md";
 function resolvePlanPath(repoRoot, planDir, planArg) {
   if (planArg)
-    return resolve19(repoRoot, planArg);
-  const inPlanDir = resolve19(repoRoot, planDir, DEFAULT_PLAN_FILE);
-  return existsSync29(inPlanDir) ? inPlanDir : resolve19(repoRoot, DEFAULT_PLAN_FILE);
+    return resolve21(repoRoot, planArg);
+  const inPlanDir = resolve21(repoRoot, planDir, DEFAULT_PLAN_FILE);
+  return existsSync34(inPlanDir) ? inPlanDir : resolve21(repoRoot, DEFAULT_PLAN_FILE);
 }
 
 // src/start/risk-total.ts
-import { readFileSync as readFileSync37 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 
 // src/plan/risk.ts
-import { readFileSync as readFileSync36 } from "fs";
-import { isAbsolute as isAbsolute6, join as join30, relative as relative8 } from "path";
+import { readFileSync as readFileSync41 } from "fs";
+import { isAbsolute as isAbsolute6, join as join34, relative as relative9 } from "path";
 
 // src/plan/risk/accounts.ts
 var PUSH_REMOTE = "origin";
@@ -27126,7 +28696,7 @@ function repoPhrase(view) {
 async function viewRepo(gh, target) {
   const result = await gh(["repo", "view", ...target, "--json", "nameWithOwner,visibility"]);
   if (!result.ok) {
-    return { ok: false, reason: `gh repo view: ${firstLine6(result.stderr) ?? "gh exited non-zero"}` };
+    return { ok: false, reason: `gh repo view: ${firstLine7(result.stderr) ?? "gh exited non-zero"}` };
   }
   const parsed2 = parseJsonObject(result.stdout);
   if (parsed2 === null) {
@@ -27150,7 +28720,7 @@ function stringField2(object, key) {
   const value = object[key];
   return typeof value === "string" && value !== "" ? value : null;
 }
-function firstLine6(text) {
+function firstLine7(text) {
   return text.split(`
 `).map((line) => line.trim()).find((line) => line !== "") ?? null;
 }
@@ -27581,15 +29151,15 @@ function toolsFinding(task, plan, seams) {
     return { level: "high", kind: "tools", text: `${EVERY_TOOL} \u2014 ${access.source}; ${model}; ${budget}`, ...where };
   }
   if (holdsShell(access.tools) && access.budget === null) {
-    const listed = access.tools.join(", ");
-    return { level: "note", kind: "tools", text: `${SHELL_TOOL} with no budget= \u2014 ${access.source}: ${listed}; ${model}`, ...where };
+    const listed2 = access.tools.join(", ");
+    return { level: "note", kind: "tools", text: `${SHELL_TOOL} with no budget= \u2014 ${access.source}: ${listed2}; ${model}`, ...where };
   }
   return null;
 }
 function displayPath(path3, seams) {
-  const absolute = isAbsolute6(path3) ? path3 : join30(seams.repoRoot, path3);
+  const absolute = isAbsolute6(path3) ? path3 : join34(seams.repoRoot, path3);
   const within = (root) => {
-    const step = relative8(root, absolute);
+    const step = relative9(root, absolute);
     return step === "" || step.startsWith("..") || isAbsolute6(step) ? null : step;
   };
   const inRepo = within(seams.repoRoot);
@@ -27604,7 +29174,7 @@ function located(finding2, file, task) {
 }
 function readText5(path3) {
   try {
-    return readFileSync36(path3, "utf8");
+    return readFileSync41(path3, "utf8");
   } catch {
     return null;
   }
@@ -27612,7 +29182,7 @@ function readText5(path3) {
 function findSkillFile(name2, seams) {
   const tiers = resolveSkillTiers({ home: seams.home, projectRoot: seams.repoRoot, entry: seams.entry });
   for (const { dir } of tiers) {
-    const path3 = join30(dir, name2, "SKILL.md");
+    const path3 = join34(dir, name2, "SKILL.md");
     if (readText5(path3) !== null)
       return path3;
   }
@@ -27706,7 +29276,7 @@ function spawningRunners(root) {
 }
 async function readRiskTotalLine(input, seams = {}) {
   const makeRunners = seams.runners ?? spawningRunners;
-  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync37(input.planPath, "utf8") }, {
+  const report2 = await assessPlanRisk({ path: input.planPath, text: readFileSync42(input.planPath, "utf8") }, {
     repoRoot: input.repoRoot,
     home: input.home,
     settingSources: input.config.settingSources,
@@ -28253,6 +29823,33 @@ function guardRunBranch(planStub2, branch, args) {
   }
 }
 var NO_CI_WAIT_FLAG = "--no-ci-wait";
+var RETRY_FLAG = "--retry";
+var NO_RETRY_FLAG = "--no-retry";
+var RETRY_COUNT = /^[1-9][0-9]*$/;
+function refuseRetry(reason) {
+  throw new CommandExit(1, [
+    `\u274C Refusing ${reason}: ${RETRY_FLAG} takes a whole number from 1 to 3 as ${RETRY_FLAG}=<n>,`,
+    "   the retries this run makes after a retry-safe stop. Leave it out to take `loop.retries`,",
+    "   and set `loop.retries: false` in .rafa/config.yaml for none.",
+    NOTHING_DISPATCHED
+  ].join(`
+`));
+}
+function readRetryFlag(args) {
+  const end = args.indexOf("--");
+  const words = end === -1 ? args : args.slice(0, end);
+  if (words.includes(NO_RETRY_FLAG))
+    refuseRetry(NO_RETRY_FLAG);
+  if (words.includes(RETRY_FLAG))
+    refuseRetry(`a bare ${RETRY_FLAG}`);
+  const typed = argValue([...words].reverse(), RETRY_FLAG);
+  if (typed === undefined)
+    return;
+  const count = RETRY_COUNT.test(typed) ? Number(typed) : Number.NaN;
+  if (!isLoopRetryCount(count))
+    refuseRetry(`${RETRY_FLAG}=${typed}`);
+  return count;
+}
 function readRunArgs(args) {
   return {
     startAt: argValue(args, "--start-at"),
@@ -28260,13 +29857,15 @@ function readRunArgs(args) {
     ciWait: !args.includes(NO_CI_WAIT_FLAG),
     ciTimeoutMin: Number(argValue(args, "--ci-timeout") ?? DEFAULT_CI_TIMEOUT_MIN),
     ciAttempts: Number(argValue(args, "--ci-attempts") ?? DEFAULT_CI_ATTEMPTS),
-    roadmap: args.includes(ROADMAP_FLAG2)
+    roadmap: args.includes(ROADMAP_FLAG2),
+    retry: readRetryFlag(args),
+    continueRun: readContinueArgs(args)
   };
 }
 
 // src/start/worktree.ts
-import { realpathSync as realpathSync4 } from "fs";
-import { join as join31, resolve as resolve21 } from "path";
+import { realpathSync as realpathSync5 } from "fs";
+import { join as join35, resolve as resolve23 } from "path";
 
 // src/start/claim-catch-up.ts
 var OWN_COMMIT_FORMAT = "--format=%H%x09%P%x09%s";
@@ -28299,18 +29898,18 @@ function isClaimOnly(git, commit, baseTip) {
 function readClaimCatchUp(git, branch, base) {
   const named3 = { branch, base };
   const remoteBase = `${REMOTE}/${base}`;
-  const unreadable = (reason) => ({ kind: "unreadable", ...named3, reason });
+  const unreadable2 = (reason) => ({ kind: "unreadable", ...named3, reason });
   const baseRef = remoteTrackingRef(base);
   const branchRef = localRef(branch);
   const baseTip = commitAt(git, baseRef);
   if (baseTip === null)
-    return unreadable(`${remoteBase} is not known here`);
+    return unreadable2(`${remoteBase} is not known here`);
   if (commitAt(git, branchRef) === null)
-    return unreadable(`${branch} is not known here`);
+    return unreadable2(`${branch} is not known here`);
   const counted5 = git(["rev-list", "--count", `${branchRef}..${baseRef}`]);
   const behind = Number(counted5.stdout.trim());
   if (!counted5.ok || counted5.stdout.trim() === "" || !Number.isInteger(behind)) {
-    return unreadable(`could not count how far ${branch} is behind ${remoteBase}: ${gitSaid(counted5)}`);
+    return unreadable2(`could not count how far ${branch} is behind ${remoteBase}: ${gitSaid(counted5)}`);
   }
   if (behind === 0)
     return { kind: "current", ...named3 };
@@ -28318,22 +29917,22 @@ function readClaimCatchUp(git, branch, base) {
   const mergeBase = shared.stdout.trim();
   if (!shared.ok || mergeBase === "") {
     const said = gitSaid(shared);
-    return unreadable(said === "" ? `${branch} shares no history with ${remoteBase}` : `could not read where ${branch} left ${remoteBase}: ${said}`);
+    return unreadable2(said === "" ? `${branch} shares no history with ${remoteBase}` : `could not read where ${branch} left ${remoteBase}: ${said}`);
   }
-  const listed = git(["log", OWN_COMMIT_FORMAT, `${baseRef}..${branchRef}`]);
-  if (!listed.ok) {
-    return unreadable(`could not list ${branch}'s commits past ${remoteBase}: ${gitSaid(listed)}`);
+  const listed2 = git(["log", OWN_COMMIT_FORMAT, `${baseRef}..${branchRef}`]);
+  if (!listed2.ok) {
+    return unreadable2(`could not list ${branch}'s commits past ${remoteBase}: ${gitSaid(listed2)}`);
   }
-  const own = ownCommitsOf(listed.stdout);
+  const own = ownCommitsOf(listed2.stdout);
   const workCommits = own.filter((commit) => !isClaimOnly(git, commit, baseTip)).length;
   const standing = { ...named3, behind, ahead: own.length, mergeBase, baseTip };
   return workCommits === 0 ? { kind: "catch-up", ...standing } : { kind: "behind", ...standing, workCommits };
 }
 
 // src/start/worktree-dir.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve22 } from "path";
 function worktreeDirAt(projectRoot3, worktreeDir) {
-  return resolve20(projectRoot3, worktreeDir);
+  return resolve22(projectRoot3, worktreeDir);
 }
 
 // src/start/worktree.ts
@@ -28341,7 +29940,7 @@ var INDENT7 = "   ";
 var UNTOUCHED = `${INDENT7}The main checkout's branch and working tree were not touched.`;
 var DEFAULT_WORKTREE_SEAMS = Object.freeze({});
 function worktreePathFor(projectRoot3, worktreeDir, stub) {
-  return join31(worktreeDirAt(projectRoot3, worktreeDir), stub);
+  return join35(worktreeDirAt(projectRoot3, worktreeDir), stub);
 }
 function addStep(route, plan, path3) {
   const label = `add the worktree for ${plan.branch} at ${path3}`;
@@ -28395,9 +29994,9 @@ function heldRefusal(branch, holder, detail) {
 }
 function canonicalPath(path3) {
   try {
-    return realpathSync4(path3);
+    return realpathSync5(path3);
   } catch {
-    return resolve21(path3);
+    return resolve23(path3);
   }
 }
 function readExisting(listing2, branch, path3) {
@@ -28433,8 +30032,8 @@ function refExists2(git, ref8) {
   return git(["show-ref", "--verify", "--quiet", ref8]).ok;
 }
 function readListing(git) {
-  const listed = git(["worktree", "list", "--porcelain"]);
-  return listed.ok ? parseWorktrees(listed.stdout) : [];
+  const listed2 = git(["worktree", "list", "--porcelain"]);
+  return listed2.ok ? parseWorktrees(listed2.stdout) : [];
 }
 function openingLine2(route, plan) {
   return route === "create" ? `
@@ -28570,13 +30169,13 @@ async function settleRunCheckout(request, seams = {}) {
 }
 
 // src/start/suite-step.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync14, readFileSync as readFileSync44, renameSync as renameSync7, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync14, readFileSync as readFileSync48, renameSync as renameSync7, writeFileSync as writeFileSync17 } from "fs";
 import { constants as constants2 } from "os";
-import { basename as basename11, dirname as dirname15, join as join37 } from "path";
+import { basename as basename11, dirname as dirname18, join as join40 } from "path";
 
 // src/suite/baseline.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync12, readFileSync as readFileSync38, renameSync as renameSync6, writeFileSync as writeFileSync13 } from "fs";
-import { basename as basename9, dirname as dirname12, join as join32 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync12, readFileSync as readFileSync43, renameSync as renameSync6, writeFileSync as writeFileSync15 } from "fs";
+import { basename as basename9, dirname as dirname16, join as join36 } from "path";
 var BASELINE_VERSION = 1;
 var BASELINE_FILE_PREFIX = "SUITE_BASELINE";
 var PLAN_FILE_NAME2 = /^PLAN(?:_TRACKER)?(-.+)?\.md$/;
@@ -28586,7 +30185,7 @@ function baselinePathFor(trackerPath) {
   if (match === null) {
     throw new RangeError(`baselinePathFor: ${trackerPath} is not a PLAN or PLAN_TRACKER file`);
   }
-  return join32(dirname12(trackerPath), `${BASELINE_FILE_PREFIX}${match[1] ?? ""}.json`);
+  return join36(dirname16(trackerPath), `${BASELINE_FILE_PREFIX}${match[1] ?? ""}.json`);
 }
 function copyFailure(failure3) {
   return failure3.message === undefined ? { file: failure3.file, name: failure3.name } : { file: failure3.file, name: failure3.name, message: failure3.message };
@@ -28605,9 +30204,9 @@ function baselineOf(result, recordedAt, commit) {
   };
 }
 function writeBaseline(path3, baseline) {
-  mkdirSync12(dirname12(path3), { recursive: true });
+  mkdirSync12(dirname16(path3), { recursive: true });
   const temporary = `${path3}.${process.pid}.tmp`;
-  writeFileSync13(temporary, `${JSON.stringify(baseline, null, 2)}
+  writeFileSync15(temporary, `${JSON.stringify(baseline, null, 2)}
 `, "utf8");
   renameSync6(temporary, path3);
 }
@@ -28649,11 +30248,11 @@ function asBaseline(parsed2) {
   return { state: "read", baseline: parsed2 };
 }
 function readBaseline(path3) {
-  if (!existsSync30(path3))
+  if (!existsSync35(path3))
     return { state: "missing" };
   let text;
   try {
-    text = readFileSync38(path3, "utf8");
+    text = readFileSync43(path3, "utf8");
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return { state: "unreadable", reason };
@@ -28748,8 +30347,8 @@ async function readPlanOwns(options) {
 }
 
 // src/suite/run.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync39, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "fs";
-import { basename as basename10, dirname as dirname13, extname as extname2, isAbsolute as isAbsolute7, join as join33 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync13, readFileSync as readFileSync44, rmSync as rmSync5, writeFileSync as writeFileSync16 } from "fs";
+import { basename as basename10, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute7, join as join37 } from "path";
 
 // src/suite/unhandled.ts
 var UNHANDLED_HEADING = "# Unhandled error between tests";
@@ -28790,14 +30389,14 @@ function rawBlocks(lines) {
     return [{ header: headerAbove(lines, index), body: lines.slice(start, bodyEnd(lines, start)) }];
   });
 }
-function errorLine(body) {
+function errorLine2(body) {
   const found = body.find((line) => line.trim() !== "" && !FRAME_LINE.test(line) && !CARET_LINE.test(line));
   return found?.trim() ?? null;
 }
 function parseUnhandled(stderr) {
   return rawBlocks(linesOf2(stderr)).map((raw) => ({
     file: raw.header === null ? null : raw.header.slice(0, -1),
-    firstLine: errorLine(raw.body)
+    firstLine: errorLine2(raw.body)
   }));
 }
 function summaryLines(lines) {
@@ -28859,7 +30458,7 @@ var OUTPUT_SUFFIX = ".output.txt";
 function outputFileFor(junitFile) {
   const name2 = basename10(junitFile);
   const stem = name2.endsWith(JUNIT_SUFFIX) ? name2.slice(0, -JUNIT_SUFFIX.length) : name2.slice(0, name2.length - extname2(name2).length);
-  return join33(dirname13(junitFile), `${stem}${OUTPUT_SUFFIX}`);
+  return join37(dirname17(junitFile), `${stem}${OUTPUT_SUFFIX}`);
 }
 function suiteEnv(base) {
   return Object.fromEntries(Object.entries(base).filter(([key]) => key !== CLAUDE_CODE_ENV));
@@ -28963,11 +30562,11 @@ function parseJunitFailures(xml) {
   return walk.failures;
 }
 function readJunit(path3) {
-  if (!existsSync31(path3))
+  if (!existsSync36(path3))
     return { junit: "missing", failures: [] };
   let text;
   try {
-    text = readFileSync39(path3, "utf8");
+    text = readFileSync44(path3, "utf8");
   } catch {
     return { junit: "unreadable", failures: [] };
   }
@@ -28991,13 +30590,13 @@ async function runSuite(options) {
   }
   const command = suiteCommand(options.junitFile, options.paths, options.changedSince);
   const outputFile = outputFileFor(options.junitFile);
-  mkdirSync13(dirname13(options.junitFile), { recursive: true });
-  rmSync4(options.junitFile, { force: true });
-  rmSync4(outputFile, { force: true });
+  mkdirSync13(dirname17(options.junitFile), { recursive: true });
+  rmSync5(options.junitFile, { force: true });
+  rmSync5(outputFile, { force: true });
   const spawn = options.spawn ?? spawnSuite;
   const env = suiteEnv(options.env ?? process.env);
   const { exitCode, stderr } = await spawn(command, { cwd: options.cwd, env });
-  writeFileSync14(outputFile, unhandledText(stderr));
+  writeFileSync16(outputFile, unhandledText(stderr));
   const { summary, errors } = readSummary2(stderr);
   const { junit, failures } = readJunit(options.junitFile);
   const unhandled = parseUnhandled(stderr);
@@ -29006,8 +30605,8 @@ async function runSuite(options) {
 }
 
 // src/suite/scope.ts
-import { existsSync as existsSync32, readdirSync as readdirSync14, readFileSync as readFileSync40 } from "fs";
-import { isAbsolute as isAbsolute8, join as join34, relative as relative9, sep as sep2 } from "path";
+import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync45 } from "fs";
+import { isAbsolute as isAbsolute8, join as join38, relative as relative10, sep as sep3 } from "path";
 var BUNFIG_FILE = "bunfig.toml";
 var TEST_FILE_NAME = /[._](?:test|spec)\.(?:tsx?|jsx?|[cm][jt]s)$/;
 var DEPENDENCY_FOLDER = "node_modules";
@@ -29067,7 +30666,7 @@ function stageStepScope(input) {
   return { scope: "paths", folders, integration, paths };
 }
 function preloadPath(root, entry) {
-  const path3 = isAbsolute8(entry) ? relative9(root, entry).split(sep2).join("/") : entry;
+  const path3 = isAbsolute8(entry) ? relative10(root, entry).split(sep3).join("/") : entry;
   const repoRelative2 = normaliseFolder(path3);
   if (repoRelative2 === "" || isAbsolute8(repoRelative2))
     return null;
@@ -29090,11 +30689,11 @@ function preloadFilesOf(text, root) {
   return paths.filter((path3) => path3 !== null);
 }
 function readPreloadFiles(root) {
-  const path3 = join34(root, BUNFIG_FILE);
-  if (!existsSync32(path3))
+  const path3 = join38(root, BUNFIG_FILE);
+  if (!existsSync37(path3))
     return { state: "missing", files: [] };
   try {
-    return { state: "read", files: preloadFilesOf(readFileSync40(path3, "utf8"), root) };
+    return { state: "read", files: preloadFilesOf(readFileSync45(path3, "utf8"), root) };
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return { state: "unreadable", files: [], reason };
@@ -29103,7 +30702,7 @@ function readPreloadFiles(root) {
 function listTestFiles(root) {
   const found = [];
   const walk = (folder) => {
-    for (const entry of readdirSync14(join34(root, folder), { withFileTypes: true })) {
+    for (const entry of readdirSync14(join38(root, folder), { withFileTypes: true })) {
       const path3 = folder === "" ? entry.name : `${folder}/${entry.name}`;
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== DEPENDENCY_FOLDER)
         walk(path3);
@@ -29116,8 +30715,8 @@ function listTestFiles(root) {
 }
 
 // src/start/lint-step.ts
-import { existsSync as existsSync33 } from "fs";
-import { join as join35, relative as relative10 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { join as join39, relative as relative11 } from "path";
 var LINT_COMMAND = ["bunx", "eslint", "--no-warn-ignored"];
 var LINT_REPORT_FLAGS = ["--format", "json"];
 var ESLINT_CONFIG_FILES = [
@@ -29128,9 +30727,9 @@ var ESLINT_CONFIG_FILES = [
   "eslint.config.mts",
   "eslint.config.cts"
 ];
-var ERRORS_LISTED = 10;
+var ERRORS_LISTED2 = 10;
 var CRASH_BANNER = /^(?:Oops!|ESLint: \d)/;
-var NOTHING_RAN = { ran: false, red: false, interrupted: false, blocker: null };
+var NOTHING_RAN2 = { ran: false, red: false, interrupted: false, blocker: null };
 async function runEslint(options) {
   const proc = Bun.spawn([...options.argv], {
     cwd: options.cwd,
@@ -29146,7 +30745,7 @@ async function runEslint(options) {
   return { exitCode, stdout, stderr };
 }
 function hasEslintConfig(checkout) {
-  return ESLINT_CONFIG_FILES.some((name2) => existsSync33(join35(checkout, name2)));
+  return ESLINT_CONFIG_FILES.some((name2) => existsSync38(join39(checkout, name2)));
 }
 function readLintFiles(git, base) {
   const result = git(["diff", "--name-only", "-z", "--no-renames", "--diff-filter=d", base, "HEAD"]);
@@ -29163,7 +30762,7 @@ function fileErrorsOf(entry, cwd) {
   const errors = entry["errorCount"];
   if (typeof entry["filePath"] !== "string" || typeof errors !== "number" || errors === 0)
     return null;
-  const file = relative10(cwd, entry["filePath"]);
+  const file = relative11(cwd, entry["filePath"]);
   const messages = Array.isArray(entry["messages"]) ? entry["messages"] : [];
   const lines = messages.filter((message) => message["severity"] === 2).map((message) => messageLine(file, message));
   return { file, errors, lines };
@@ -29208,10 +30807,10 @@ function announce(label, count, run, files) {
   const errors = files.reduce((sum, file) => sum + file.errors, 0);
   activeOutput().info(`${ran}; ${errors} error(s) in ${files.length} file(s).`);
   const lines = files.flatMap((file) => file.lines);
-  for (const line of lines.slice(0, ERRORS_LISTED))
+  for (const line of lines.slice(0, ERRORS_LISTED2))
     activeOutput().info(`   ${line}`);
-  if (lines.length > ERRORS_LISTED)
-    activeOutput().info(`   ...and ${lines.length - ERRORS_LISTED} more.`);
+  if (lines.length > ERRORS_LISTED2)
+    activeOutput().info(`   ...and ${lines.length - ERRORS_LISTED2} more.`);
 }
 function filesToLint(input, label) {
   if (!hasEslintConfig(input.checkout)) {
@@ -29230,13 +30829,13 @@ async function runLintStep(input) {
   const label = lintLabel(input.task);
   const files = filesToLint(input, label);
   if (files === null)
-    return NOTHING_RAN;
+    return NOTHING_RAN2;
   let run;
   try {
     run = await (input.runLint ?? runEslint)({ cwd: input.checkout, argv: [...LINT_COMMAND, ...LINT_REPORT_FLAGS, ...files] });
   } catch (error) {
     activeOutput().warn(`\u26A0\uFE0F  The ${label} could not run (${messageOf(error)}); the run goes on without it.`);
-    return NOTHING_RAN;
+    return NOTHING_RAN2;
   }
   if (run.exitCode === input.stopCode || input.isInterrupted?.() === true) {
     activeOutput().info(`\u23F9  The ${label} was interrupted by SIGINT: read as a stop, not as errors.`);
@@ -29249,102 +30848,8 @@ async function runLintStep(input) {
   return { ran: true, red: true, interrupted: false, blocker: lintBlockerText(label, run, reported) };
 }
 
-// src/start/suite-blocker.ts
-import { readFileSync as readFileSync41, writeFileSync as writeFileSync15 } from "fs";
-function failingFiles(failures) {
-  const counts = new Map;
-  for (const failure3 of failures)
-    counts.set(failure3.file, (counts.get(failure3.file) ?? 0) + 1);
-  return [...counts.entries()];
-}
-var UNHANDLED_NAMED = 10;
-function unhandledName(error) {
-  const file = error.file ?? "a file Bun did not name";
-  return error.firstLine === null ? `${file} threw an error Bun printed no line for` : `${file} threw "${error.firstLine}"`;
-}
-function unhandledNames(errors) {
-  if (errors.length === 0)
-    return "no block of Bun's stderr named a file";
-  const named3 = errors.slice(0, UNHANDLED_NAMED).map(unhandledName);
-  const left = errors.length - named3.length;
-  const more = left > 0 ? [`and ${left} more`] : [];
-  return [...named3, ...more].join("; ");
-}
-function unhandledFiles(errors) {
-  return [...new Set(errors.flatMap((error) => error.file === null ? [] : [error.file]))];
-}
-function runnablePath(path3) {
-  return path3.startsWith("/") || path3.startsWith("./") ? path3 : `./${path3}`;
-}
-function errorsText(newErrors, errors) {
-  const counted5 = `${newErrors} more error(s) outside any test than the baseline`;
-  if (errors.length === 0)
-    return `${counted5}: a test file that throws while it loads, which the JUnit report names no file for.`;
-  const files = unhandledFiles(errors);
-  const run = files.length === 0 ? "" : ` Run bun test ${files.map(runnablePath).join(" ")} and make each load.`;
-  return `${counted5}; Bun's stderr named them as ${unhandledNames(errors)}.${run}`;
-}
-function blockerText(label, result, verdict) {
-  const files = failingFiles(verdict.fresh);
-  const parts = [`The runner's ${label} found failures the suite baseline does not hold.`];
-  if (files.length > 0) {
-    const named3 = files.map(([file, count]) => `${file} (${count} ${count === 1 ? "test" : "tests"})`);
-    parts.push(`New failing test files: ${named3.join(", ")}. Run bun test ${files.map(([file]) => runnablePath(file)).join(" ")} and make them pass.`);
-  }
-  if (verdict.newErrors > 0)
-    parts.push(errorsText(verdict.newErrors, result.unhandled));
-  if (verdict.unreported)
-    parts.push(`bun test exited ${result.exitCode} and printed no summary line.`);
-  return parts.join(" ");
-}
-var REPAIR_AGENT = "build-error-resolver";
-var REPAIR_TASK = /^Repair the red (?:task|stage|pre-wrap-up) step at commit \S+$/;
-var PRE_WRAP_UP_REPAIR = /^Repair the red pre-wrap-up step at commit \S+$/;
-var COMMIT_SHOWN = 12;
-var TICKED_PREFIX = "- [x] ";
-function repairTaskText(kind, commit) {
-  const shown2 = commit === null ? "(unread)" : commit.slice(0, COMMIT_SHOWN);
-  return `Repair the red ${kind} step at commit ${shown2}`;
-}
-function isRepairTask(text) {
-  return REPAIR_TASK.test(text.trim());
-}
-function lineOfTask(content, text) {
-  const found = parsePlan(content).tasks.filter((task) => task.text === text.trim());
-  return found.at(-1)?.lineNum ?? null;
-}
-function lineOfTickedPreWrapUpRepair(content) {
-  const found = parsePlan(content).tasks.filter((task) => task.status === "done" && PRE_WRAP_UP_REPAIR.test(task.text.trim()));
-  return found.at(-1)?.lineNum ?? null;
-}
-function existingRepairOf(content, site) {
-  if (site.kind === "pre-wrap-up")
-    return lineOfTickedPreWrapUpRepair(content);
-  return site.task !== undefined && isRepairTask(site.task) ? lineOfTask(content, site.task) : null;
-}
-function blockRepairAgain(trackerPath, content, line, blocker) {
-  const lines = content.split(`
-`);
-  const current = lines[line] ?? "";
-  if (current.startsWith(TICKED_PREFIX)) {
-    const reopened = [...lines.slice(0, line), `- [ ] ${current.slice(TICKED_PREFIX.length)}`, ...lines.slice(line + 1)];
-    writeFileSync15(trackerPath, reopened.join(`
-`), "utf8");
-  }
-  return writeTrackerBlocker(trackerPath, line, blocker) ? { line, inserted: false } : null;
-}
-function writeRepairTask(trackerPath, blocker, site) {
-  const content = readFileSync41(trackerPath, "utf8");
-  const repaired = existingRepairOf(content, site);
-  if (repaired !== null)
-    return blockRepairAgain(trackerPath, content, repaired, blocker);
-  const firstOpen = parsePlan(content).tasks.find((task) => task.status !== "done")?.lineNum ?? null;
-  const entry = { task: repairTaskText(site.kind, site.commit), declaration: `agent=${REPAIR_AGENT}`, blocker };
-  return { line: insertTrackerTask(trackerPath, entry, firstOpen), inserted: true };
-}
-
 // src/start/sweep-timing.ts
-import { existsSync as existsSync34, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync46 } from "fs";
 var SLOW_SWEEP_SECONDS = 10;
 var SUITE_TAG = /<(\/?)testsuite\b([^>]*?)(\/?)>/g;
 function fileTimeOf(attributes) {
@@ -29384,10 +30889,10 @@ function slowSweepLine(slow) {
   return `\uD83D\uDC22 ${slow.length} tests.alwaysRun file(s) took over ${SLOW_SWEEP_SECONDS}s in the task step: ${named3}.`;
 }
 function readFileTimes(path3) {
-  if (!existsSync34(path3))
+  if (!existsSync39(path3))
     return [];
   try {
-    return parseJunitFileTimes(readFileSync42(path3, "utf8")) ?? [];
+    return parseJunitFileTimes(readFileSync46(path3, "utf8")) ?? [];
   } catch {
     return [];
   }
@@ -29462,280 +30967,6 @@ function foldResults(first, second, stopCode) {
   return first.noTestFiles === true && second.noTestFiles === true ? { ...folded2, noTestFiles: true } : folded2;
 }
 
-// src/start/type-step.ts
-import { existsSync as existsSync35, mkdtempSync, realpathSync as realpathSync5, rmSync as rmSync5, symlinkSync as symlinkSync2, writeFileSync as writeFileSync16 } from "fs";
-import { tmpdir } from "os";
-import { dirname as dirname14, join as join36, relative as relative11, resolve as resolve22, sep as sep3 } from "path";
-var TEST_FILE_SUFFIX = ".test.ts";
-var TSC_FLAGS = ["--noEmit", "--pretty", "false"];
-var ERRORS_LISTED2 = 10;
-var NODE_MODULES = "node_modules";
-var TSC_BIN = [".bin", "tsc"];
-var SCRATCH_NAME = "tsconfig.json";
-var FILE_ERROR = /^(.+)\((\d+),(\d+)\): error (TS\d+): (.*)$/;
-var GLOBAL_ERROR = /^error (TS\d+): (.*)$/;
-var NOTHING_RAN2 = { ran: false, red: false, interrupted: false, blocker: null };
-var GREEN = { ran: true, red: false, interrupted: false, blocker: null };
-var INTERRUPTED = { ran: true, red: false, interrupted: true, blocker: null };
-async function runTsc(options) {
-  const proc = Bun.spawn([...options.argv], {
-    cwd: options.cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  return { exitCode, stdout, stderr };
-}
-function typeLabel(task) {
-  return `type step after "${task}"`;
-}
-function pathsOf(status) {
-  return /^[RC]/.test(status) ? 2 : 1;
-}
-function readTypeFiles(git, base) {
-  const result = git(["diff", "--name-status", "-z", "--find-renames", "--diff-filter=d", base, "HEAD"]);
-  if (!result.ok) {
-    activeOutput().warn(`\u26A0\uFE0F  git diff from ${base} did not answer (${gitSaid(result) || "nothing said"}); the type step runs nothing.`);
-    return null;
-  }
-  const fields = result.stdout.split("\x00").filter((field4) => field4 !== "");
-  const files = [];
-  for (let index = 0;index < fields.length; ) {
-    const status = fields[index] ?? "";
-    const count = pathsOf(status);
-    const paths = fields.slice(index + 1, index + 1 + count);
-    index += 1 + count;
-    const head = paths[paths.length - 1];
-    if (head === undefined || !head.endsWith(TEST_FILE_SUFFIX))
-      continue;
-    files.push({ head, base: status.startsWith("A") ? null : paths[0] ?? null });
-  }
-  return files;
-}
-function realPath(path3) {
-  try {
-    return realpathSync5(path3);
-  } catch {
-    return resolve22(path3);
-  }
-}
-function walkStop(git) {
-  const result = git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  const common = result.stdout.trim();
-  return result.ok && common !== "" ? dirname14(realPath(common)) : null;
-}
-function isUnder(dir, root) {
-  return dir === root || dir.startsWith(root.endsWith(sep3) ? root : `${root}${sep3}`);
-}
-function findNodeModules(checkout, git) {
-  const start = realPath(checkout);
-  const stop = walkStop(git);
-  const top = stop !== null && isUnder(start, stop) ? stop : start;
-  for (let dir = start;; dir = dirname14(dir)) {
-    const modules = join36(dir, NODE_MODULES);
-    if (existsSync35(join36(modules, ...TSC_BIN)))
-      return modules;
-    if (dir === top || dirname14(dir) === dir)
-      return null;
-  }
-}
-function scratchTsconfig(tree, files, modules) {
-  const root = resolve22(tree);
-  return `${JSON.stringify({
-    extends: join36(root, "tsconfig.json"),
-    compilerOptions: { typeRoots: [join36(resolve22(modules), "@types")] },
-    files: files.map((file) => join36(root, file)),
-    include: []
-  }, null, 2)}
-`;
-}
-function parseTscOutput(stdout, cwd) {
-  const errors = [];
-  for (const line of stdout.split(`
-`)) {
-    const atFile = FILE_ERROR.exec(line);
-    const global = atFile === null ? GLOBAL_ERROR.exec(line) : null;
-    const last = errors[errors.length - 1];
-    if (atFile !== null) {
-      const [, file = "", row = "0", column = "0", code = "", message = ""] = atFile;
-      errors.push({ file: relative11(cwd, resolve22(cwd, file)), line: Number(row), column: Number(column), code, message });
-    } else if (global !== null) {
-      errors.push({ file: null, line: 0, column: 0, code: global[1] ?? "", message: global[2] ?? "" });
-    } else if (line.startsWith("  ") && last !== undefined) {
-      errors[errors.length - 1] = { ...last, message: `${last.message}
-${line.trimEnd()}` };
-    }
-  }
-  return errors;
-}
-function identity(error) {
-  return `${error.code} ${error.message}`;
-}
-function newErrors(head, base) {
-  const left = new Map;
-  for (const error of base) {
-    const key = `${error.file ?? ""}\x00${identity(error)}`;
-    left.set(key, (left.get(key) ?? 0) + 1);
-  }
-  return head.filter((error) => {
-    const key = `${error.file ?? ""}\x00${identity(error)}`;
-    const count = left.get(key) ?? 0;
-    if (count === 0)
-      return true;
-    left.set(key, count - 1);
-    return false;
-  });
-}
-function errorLine2(error) {
-  const first = error.message.split(`
-`)[0] ?? "";
-  return `${error.file ?? "(no file)"}:${error.line}:${error.column} ${error.code} ${first}`;
-}
-function listed(errors) {
-  const shown2 = errors.slice(0, ERRORS_LISTED2).map(errorLine2);
-  return errors.length > ERRORS_LISTED2 ? [...shown2, `...and ${errors.length - ERRORS_LISTED2} more`] : shown2;
-}
-function typeBlockerText(label, base, errors) {
-  const files = [...new Set(errors.map((error) => error.file ?? ""))];
-  const shown2 = listed(errors).join("; ").replace(/\.$/u, "");
-  return `The runner's ${label} found type errors in the task's test files that ${base} did not hold. ` + `New errors: ${shown2}. ` + `Fix them, then check ${files.join(" ")} with tsc ${TSC_FLAGS.join(" ")} -p over a tsconfig outside the checkout ` + "that extends its tsconfig.json by absolute path and lists them under files.";
-}
-function brokenBlockerText(label, run, said) {
-  return `The runner's ${label} could not type-check the task's test files: tsc exited ${run.exitCode}${said === undefined ? " and printed no error." : `: ${said}`}`;
-}
-function configError(errors, scratch, cwd) {
-  const config = relative11(cwd, scratch);
-  return errors.find((error) => error.file === null || error.file === config);
-}
-function firstLine7(run) {
-  return `${run.stdout}
-${run.stderr}`.split(`
-`).map((line) => line.trim()).find((line) => line !== "");
-}
-async function checkTree(input, modules, tree, files) {
-  const scratchDir = mkdtempSync(join36(tmpdir(), "rafa-type-step-"));
-  const scratch = join36(scratchDir, SCRATCH_NAME);
-  try {
-    writeFileSync16(scratch, scratchTsconfig(tree, files, modules), "utf8");
-    const tsc = join36(modules, ...TSC_BIN);
-    let run;
-    try {
-      run = await (input.runTypes ?? runTsc)({ cwd: tree, argv: [tsc, "-p", scratch, ...TSC_FLAGS] });
-    } catch (error) {
-      return { kind: "threw", why: messageOf(error) };
-    }
-    if (run.exitCode === input.stopCode || input.isInterrupted?.() === true)
-      return { kind: "interrupted" };
-    const errors = parseTscOutput(run.stdout, tree);
-    const config = configError(errors, scratch, tree);
-    if (config !== undefined)
-      return { kind: "broken", run, said: `error ${config.code}: ${config.message.split(`
-`)[0] ?? ""}` };
-    if (run.exitCode !== 0 && errors.length === 0)
-      return { kind: "broken", run, said: firstLine7(run) };
-    const wanted = new Set(files);
-    return { kind: "read", errors: errors.filter((error) => error.file !== null && wanted.has(error.file)) };
-  } finally {
-    rmSync5(scratchDir, { recursive: true, force: true });
-  }
-}
-async function inBaseTree(input, label, modules, check) {
-  const parent = mkdtempSync(join36(tmpdir(), "rafa-type-base-"));
-  const tree = join36(parent, "tree");
-  try {
-    const added = input.git(["worktree", "add", "--detach", tree, input.base]);
-    if (!added.ok) {
-      activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check out ${input.base} (${gitSaid(added) || "nothing said"}); it reads no error as new.`);
-      return null;
-    }
-    if (existsSync35(modules) && !existsSync35(join36(tree, NODE_MODULES)))
-      symlinkSync2(modules, join36(tree, NODE_MODULES));
-    if (!existsSync35(join36(tree, "tsconfig.json")))
-      return { kind: "read", errors: [] };
-    return await check(tree);
-  } finally {
-    if (existsSync35(tree)) {
-      const removed = input.git(["worktree", "remove", "--force", tree]);
-      if (!removed.ok)
-        activeOutput().warn(`\u26A0\uFE0F  The ${label} could not remove its worktree ${tree} (${gitSaid(removed) || "nothing said"}).`);
-    }
-    rmSync5(parent, { recursive: true, force: true });
-  }
-}
-async function baseErrors(input, label, modules, files) {
-  const pairs = files.filter((file) => file.base !== null);
-  if (pairs.length === 0)
-    return { errors: [] };
-  const run = await inBaseTree(input, label, modules, (tree) => checkTree(input, modules, tree, pairs.map((file) => file.base)));
-  if (run === null)
-    return { outcome: GREEN };
-  if (run.kind === "interrupted")
-    return { outcome: interrupted(label) };
-  if (run.kind !== "read") {
-    const why = run.kind === "threw" ? run.why : brokenBlockerText(label, run.run, run.said);
-    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not check the files at ${input.base} (${why}); it reads no error as new.`);
-    return { outcome: GREEN };
-  }
-  const headOf = new Map(pairs.map((file) => [file.base, file.head]));
-  return { errors: run.errors.map((error) => ({ ...error, file: headOf.get(error.file ?? "") ?? error.file })) };
-}
-function interrupted(label) {
-  activeOutput().info(`\u23F9  The ${label} was interrupted by SIGINT: read as a stop, not as errors.`);
-  return INTERRUPTED;
-}
-function filesToCheck(input, label) {
-  if (!existsSync35(join36(input.checkout, "tsconfig.json"))) {
-    activeOutput().info(`\uD83D\uDD0E ${label}: no tsconfig.json at the checkout root; nothing to type-check.`);
-    return null;
-  }
-  const files = readTypeFiles(input.git, input.base);
-  if (files === null)
-    return null;
-  if (files.length > 0)
-    return files;
-  activeOutput().info(`\uD83D\uDD0E ${label}: the task changed no ${TEST_FILE_SUFFIX} file; nothing to type-check.`);
-  return null;
-}
-async function runTypeStep(input) {
-  const label = typeLabel(input.task);
-  const files = filesToCheck(input, label);
-  if (files === null)
-    return NOTHING_RAN2;
-  const modules = findNodeModules(input.checkout, input.git) ?? join36(resolve22(input.checkout), NODE_MODULES);
-  const head = await checkTree(input, modules, input.checkout, files.map((file) => file.head));
-  if (head.kind === "threw") {
-    activeOutput().warn(`\u26A0\uFE0F  The ${label} could not run tsc (${head.why}); the run goes on without it.`);
-    return NOTHING_RAN2;
-  }
-  if (head.kind === "interrupted")
-    return interrupted(label);
-  if (head.kind === "broken") {
-    const blocker = brokenBlockerText(label, head.run, head.said);
-    activeOutput().info(`\uD83D\uDD0E ${label}: ${blocker}`);
-    return { ran: true, red: true, interrupted: false, blocker };
-  }
-  const ran = `\uD83D\uDD0E ${label}: tsc over ${files.length} test file(s)`;
-  if (head.errors.length === 0) {
-    activeOutput().info(`${ran}: no type error.`);
-    return GREEN;
-  }
-  const base = await baseErrors(input, label, modules, files.filter((file) => head.errors.some((error) => error.file === file.head)));
-  if ("outcome" in base)
-    return base.outcome;
-  const added = newErrors(head.errors, base.errors);
-  activeOutput().info(`${ran}: ${head.errors.length} error(s), ${head.errors.length - added.length} already held at ${input.base}, ${added.length} not held.`);
-  for (const line of listed(added))
-    activeOutput().info(`   ${line}`);
-  if (added.length === 0)
-    return GREEN;
-  return { ran: true, red: true, interrupted: false, blocker: typeBlockerText(label, input.base, added) };
-}
-
 // src/start/task-step-checks.ts
 function lintTask(context, seams, input) {
   const isInterrupted = context.isInterrupted ?? (() => false);
@@ -29754,7 +30985,7 @@ async function taskDiffChecks(context, seams, input, result) {
   return { lint, types: await typeCheckTask(context, seams, input) };
 }
 // src/start/suite-stage-step.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync47 } from "fs";
 function stageSince(trackerPath, baseline) {
   const taken = readStageLedger(stageLedgerPathFor(trackerPath)).filter((entry) => entry.commit !== null);
   return taken.at(-1)?.commit ?? baseline?.commit ?? null;
@@ -29810,7 +31041,7 @@ async function runStageStep(context, stage, baseline) {
 }
 async function runDueStageSteps(context, baseline) {
   const ledger = readStageLedger(stageLedgerPathFor(context.trackerPath));
-  const due = dueStages(readFileSync43(context.trackerPath, "utf8"), ledger);
+  const due = dueStages(readFileSync47(context.trackerPath, "utf8"), ledger);
   const outcomes = [];
   for (const stage of due) {
     const outcome2 = await runStageStep(context, stage, baseline);
@@ -29842,15 +31073,15 @@ function seamsOf(context) {
   };
 }
 function junitFileFor(repoRoot, sessionId, kind) {
-  return join37(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
+  return join40(runsDir(repoRoot), sessionId, "suite", `${kind}.junit.xml`);
 }
 function alwaysRunJunitFileFor(repoRoot, sessionId, kind = "task") {
-  return join37(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
+  return join40(runsDir(repoRoot), sessionId, "suite", `${kind}-always-run.junit.xml`);
 }
 function stageLedgerPathFor(trackerPath) {
   const baselinePath = baselinePathFor(trackerPath);
   const name2 = basename11(baselinePath).replace(BASELINE_FILE_PREFIX, STAGE_LEDGER_PREFIX);
-  return join37(dirname15(baselinePath), name2);
+  return join40(dirname18(baselinePath), name2);
 }
 function isLedgerEntry(value) {
   if (typeof value !== "object" || value === null)
@@ -29874,11 +31105,11 @@ function parseLedger(text) {
   return stages;
 }
 function readStageLedger(path3) {
-  if (!existsSync36(path3))
+  if (!existsSync40(path3))
     return [];
   let parsed2;
   try {
-    parsed2 = parseLedger(readFileSync44(path3, "utf8"));
+    parsed2 = parseLedger(readFileSync48(path3, "utf8"));
   } catch (error) {
     parsed2 = messageOf(error);
   }
@@ -29888,7 +31119,7 @@ function readStageLedger(path3) {
   return [];
 }
 function writeStageLedger(path3, entries) {
-  mkdirSync14(dirname15(path3), { recursive: true });
+  mkdirSync14(dirname18(path3), { recursive: true });
   const temporary = `${path3}.${process.pid}.tmp`;
   writeFileSync17(temporary, `${JSON.stringify({ version: STAGE_LEDGER_VERSION, stages: entries }, null, 2)}
 `, "utf8");
@@ -30063,7 +31294,7 @@ async function ensureBaseline(context) {
     activeOutput().warn(`\u26A0\uFE0F  Could not write ${basename11(path3)} (${messageOf(error)}); the next run records the baseline again.`);
   }
   const outcome2 = settleStep(context, seams, settling);
-  const covered = completeStages(readFileSync44(context.trackerPath, "utf8"));
+  const covered = completeStages(readFileSync48(context.trackerPath, "utf8"));
   addToLedger(context.trackerPath, covered.map((stage) => ({ ...stage, commit, via: "baseline" })));
   return { baseline, step: outcome2.step, interrupted: false };
 }
@@ -30202,10 +31433,17 @@ function createRunSuiteSteps(options) {
     ...options.seams === undefined ? {} : { seams: options.seams },
     ...options.isInterrupted === undefined ? {} : { isInterrupted: options.isInterrupted }
   };
+  let signalled = false;
+  const goesOnNoting = (outcome2) => {
+    if (outcome2?.interrupted === true)
+      signalled = true;
+    return goesOn(outcome2);
+  };
   let held = null;
   const baseline = () => {
     held ??= guarded("suite baseline", () => calls.ensureBaseline(context)).then((outcome2) => {
       if (outcome2?.interrupted === true) {
+        signalled = true;
         announceInterrupted();
         return "interrupted";
       }
@@ -30217,8 +31455,10 @@ function createRunSuiteSteps(options) {
     return held;
   };
   let repairSent = false;
+  let lastPreWrapUp = null;
   const preWrapUp = async (known) => {
     const outcome2 = await guarded("pre-wrap-up step", () => calls.runPreWrapUpStep(context, known));
+    lastPreWrapUp = outcome2;
     if (insertedRepair(outcome2) && !repairSent) {
       repairSent = true;
       announceRepair();
@@ -30228,7 +31468,7 @@ function createRunSuiteSteps(options) {
       announceRedAgain();
       return "stop";
     }
-    return answerOf(goesOn(outcome2));
+    return answerOf(goesOnNoting(outcome2));
   };
   const beforeSession = async (taskInfo) => {
     const known = await baseline();
@@ -30241,7 +31481,7 @@ function createRunSuiteSteps(options) {
     if (taskInfo.status === "blocked")
       return "go-on";
     const stages = await guarded("stage steps", () => calls.runDueStageSteps(context, known));
-    return answerOf((stages ?? []).every((outcome2) => goesOn(outcome2)));
+    return answerOf((stages ?? []).every((outcome2) => goesOnNoting(outcome2)));
   };
   const afterTask = async (taskInfo, base) => {
     const known = await baseline();
@@ -30251,9 +31491,9 @@ function createRunSuiteSteps(options) {
       return true;
     const { text, declaration } = parseTaskDeclaration(taskInfo.task);
     const input = { baseline: known, base, declared: readTestScope(declaration), task: text };
-    return goesOn(await guarded("task step", () => calls.runTaskStep(context, input)));
+    return goesOnNoting(await guarded("task step", () => calls.runTaskStep(context, input)));
   };
-  return { beforeSession, afterTask };
+  return { beforeSession, afterTask, stoppedOnSignal: () => signalled, lastPreWrapUp: () => lastPreWrapUp };
 }
 
 // src/start/triage.ts
@@ -30400,12 +31640,12 @@ function inheritedFailureOf(bug, failures) {
 // src/triage/issue-text.ts
 var TITLE_MAX_LENGTH = 120;
 var TITLE_CUT = "...";
-var MIN_FENCE_LENGTH = 3;
+var MIN_FENCE_LENGTH2 = 3;
 var ISSUE_OPENING = "An out-of-scope bug a rafa task session reported. The loop filed it and" + " dispatches no task for it: a plan that wants it fixed declares a task.";
 var COMMENT_OPENING = "Reported again by a rafa task session.";
-function fenced(value) {
+function fenced2(value) {
   const runs = Array.from(value.matchAll(/`+/g), (run) => run[0].length);
-  const fence = "`".repeat(Math.max(MIN_FENCE_LENGTH, ...runs.map((length) => length + 1)));
+  const fence = "`".repeat(Math.max(MIN_FENCE_LENGTH2, ...runs.map((length) => length + 1)));
   const body = value.endsWith(`
 `) ? value : `${value}
 `;
@@ -30445,8 +31685,8 @@ function supersedesSection(closed, redact) {
 
 ${redact(sentence)}`;
 }
-function section(heading, value, absent2, redact) {
-  const shown2 = value === null ? absent2 : fenced(redact(value));
+function section(heading, value, absent3, redact) {
+  const shown2 = value === null ? absent3 : fenced2(redact(value));
   return `## ${heading}
 
 ${shown2}`;
@@ -30471,7 +31711,7 @@ function issueText(opening, values, redact) {
 
 // src/triage/local-paths.ts
 import { realpathSync as realpathSync6 } from "fs";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 var HOME_MARKER = "[redacted: HOME]";
 var SEGMENT = "[^/\\s'\"`()<>:,;]+";
 var HOME_PATTERN = `(?:/${SEGMENT})*?/(?:Users|home)/${SEGMENT}`;
@@ -30482,7 +31722,7 @@ function literalPattern(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function forms(path3) {
-  const given = resolve23(path3);
+  const given = resolve24(path3);
   try {
     const real = realpathSync6(given);
     return real === given ? [given] : [given, real];
@@ -30515,11 +31755,11 @@ function localPathRedactor(repoRoot, home) {
 
 // src/triage/triage.ts
 import { homedir as homedir8 } from "os";
-import { join as join38 } from "path";
+import { join as join41 } from "path";
 
 // src/effort/store/tracker-refs.ts
-import { randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync37 } from "fs";
+import { randomUUID as randomUUID10 } from "crypto";
+import { existsSync as existsSync41 } from "fs";
 var SELECT_HELD2 = `
   SELECT seq, tracker_ref FROM findings
   WHERE session_id = ? AND artifact = ?
@@ -30657,7 +31897,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
   const path3 = sqliteStorePath(repoRoot);
   const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
-  const newId = seams.newId ?? randomUUID9;
+  const newId = seams.newId ?? randomUUID10;
   const insertValues = () => [
     newId(),
     sessionId,
@@ -30668,7 +31908,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
     wanted.json,
     collectedAt
   ];
-  const [action, stored] = withSqliteStore(path3, "write", !existsSync37(path3), (db) => {
+  const [action, stored] = withSqliteStore(path3, "write", !existsSync41(path3), (db) => {
     const place = db.transaction(() => placeRef(db, path3, write, wanted, superseded, insertValues));
     return place.immediate();
   });
@@ -30677,7 +31917,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
 function readTrackerRef(repoRoot, artifact) {
   checkArtifact("read", artifact);
   const path3 = sqliteStorePath(repoRoot);
-  if (!existsSync37(path3))
+  if (!existsSync41(path3))
     return null;
   const newest = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_NEWEST).get(artifact));
   return newest === null ? null : heldRefOf(path3, newest.seq, newest.tracker_ref).ref;
@@ -30806,12 +32046,12 @@ function nearestOpenBugs(report2, openBugs) {
 }
 
 // src/triage/triage.ts
-var PRIVATE_TRIAGE_DIR = join38(".rafa", "triage", "private");
+var PRIVATE_TRIAGE_DIR = join41(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR2 = "; ";
 function privateTriageDir(repoRoot) {
-  return join38(repoRoot, PRIVATE_TRIAGE_DIR);
+  return join41(repoRoot, PRIVATE_TRIAGE_DIR);
 }
 function createPrivateTriageTracker(repoRoot, options = {}) {
   return createLocalTracker({
@@ -31115,16 +32355,16 @@ function foundByText(bug) {
   return bug.score === undefined ? found : `${found} (score ${scoreText(bug.score)})`;
 }
 function unresolvedTracker(kind, reason) {
-  const refuse10 = () => Promise.reject(new Error(reason));
+  const refuse11 = () => Promise.reject(new Error(reason));
   return Object.freeze({
     kind,
     capabilities: () => ({ projects: false, customFields: false, issueTypes: false }),
     preflight: () => Promise.resolve({ ok: false, reason }),
-    find: refuse10,
-    get: refuse10,
-    create: refuse10,
-    comment: refuse10,
-    transition: refuse10
+    find: refuse11,
+    get: refuse11,
+    create: refuse11,
+    comment: refuse11,
+    transition: refuse11
   });
 }
 function filesPublicly(bug) {
@@ -31173,9 +32413,9 @@ function describeStartTriage(result, inherited = new Map) {
   };
 }
 async function resolvePublicTracker(options, redact) {
-  const resolve24 = options.resolve ?? resolveTracker;
+  const resolve25 = options.resolve ?? resolveTracker;
   try {
-    const { tracker, attempts } = await resolve24({
+    const { tracker, attempts } = await resolve25({
       config: options.config,
       context: { repoRoot: options.repoRoot }
     });
@@ -31690,8 +32930,8 @@ function firstLine8(text) {
 }
 
 // src/cleanup/runs.ts
-import { existsSync as existsSync38, readdirSync as readdirSync15, readFileSync as readFileSync45 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync15, readFileSync as readFileSync49 } from "fs";
+import { join as join42 } from "path";
 var LIVE_STATES = new Set(["running", "paused"]);
 function readRunRecords(root, seams = {}) {
   const dir = runsDir(root);
@@ -31707,7 +32947,7 @@ function readRunRecords(root, seams = {}) {
   const notes = [];
   const finished = [];
   for (const name2 of names2.filter((entry) => entry.endsWith(RECORD_EXTENSION)).sort()) {
-    const file = join39(dir, name2);
+    const file = join42(dir, name2);
     const read = readRecord(file);
     if (typeof read === "string") {
       notes.push(read);
@@ -31726,7 +32966,7 @@ function readRunRecords(root, seams = {}) {
 }
 function readRecord(file) {
   try {
-    return parseSessionRecord(readFileSync45(file, "utf8"), file);
+    return parseSessionRecord(readFileSync49(file, "utf8"), file);
   } catch (error) {
     return `run records: skipped ${file}: ${messageOf(error)}`;
   }
@@ -31739,11 +32979,11 @@ function byStart(a, b) {
 }
 function runRow(dir, entry) {
   const { record } = entry;
-  const events = join39(dir, `${record.sessionId}${EVENTS_EXTENSION}`);
+  const events = join42(dir, `${record.sessionId}${EVENTS_EXTENSION}`);
   return {
     sessionId: record.sessionId,
     path: entry.file,
-    eventsPath: existsSync38(events) ? events : null,
+    eventsPath: existsSync42(events) ? events : null,
     plan: record.planStub ?? record.plan,
     startedAt: record.startedAt,
     ticked: true
@@ -31752,19 +32992,19 @@ function runRow(dir, entry) {
 
 // src/cleanup/worktrees.ts
 import { realpathSync as realpathSync8, statSync as statSync15 } from "fs";
-import { join as join41, sep as sep4 } from "path";
+import { join as join44, sep as sep4 } from "path";
 
 // src/pr/worktree.ts
-import { existsSync as existsSync39, realpathSync as realpathSync7 } from "fs";
-import { join as join40 } from "path";
-var WORKTREES_SUBDIR = join40(".rafa", "worktrees");
+import { existsSync as existsSync43, realpathSync as realpathSync7 } from "fs";
+import { join as join43 } from "path";
+var WORKTREES_SUBDIR = join43(".rafa", "worktrees");
 var WORKTREE_PREFIX = "pr-";
 var DEFAULT_REMOTE3 = "origin";
 var REFUSAL_PREFIX2 = "rafa pr triage --resolve refuses";
 var FORCING_FLAG = /^(?:-f|--force(?:-with-lease|-if-includes)?(?:=.*)?|--mirror)$/;
 var FORCING_REFSPEC_MARK = "+";
 function resolveWorktreePath(home, number) {
-  return join40(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
+  return join43(home, WORKTREES_SUBDIR, `${WORKTREE_PREFIX}${number}`);
 }
 function crossRepositoryRefusal(pr) {
   if (!pr.isCrossRepository)
@@ -31831,7 +33071,7 @@ function pushResolved(git, branch, remote = DEFAULT_REMOTE3) {
   return { id: step2.id, ok: false, command: worktreeCommandLine(step2), said: refusal4 };
 }
 function pathForms(path3) {
-  if (!existsSync39(path3))
+  if (!existsSync43(path3))
     return [path3];
   return [path3, realpathSync7(path3)];
 }
@@ -31844,7 +33084,7 @@ function worktreeAt(git, path3) {
 }
 
 // src/cleanup/worktrees.ts
-var CLAUDE_WORKTREES_SUBDIR = join41(".claude", "worktrees");
+var CLAUDE_WORKTREES_SUBDIR = join44(".claude", "worktrees");
 var WORKTREE_LIST = Object.freeze(["worktree", "list", "--porcelain"]);
 var GIT_DIR = Object.freeze(["rev-parse", "--absolute-git-dir"]);
 var WORKTREE_STATUS = Object.freeze([
@@ -31853,7 +33093,7 @@ var WORKTREE_STATUS = Object.freeze([
   "--porcelain=v1",
   "--untracked-files=all"
 ]);
-var ADMIN_FILES = Object.freeze(["HEAD", join41("logs", "HEAD"), "index"]);
+var ADMIN_FILES = Object.freeze(["HEAD", join44("logs", "HEAD"), "index"]);
 var MS_PER_DAY3 = 24 * 60 * 60 * 1000;
 var UNTRACKED_MARK = "?? ";
 var LOCKED_LINE = "locked";
@@ -31890,8 +33130,8 @@ function readWorktrees(seams, read) {
     return { ok: true, worktrees: [] };
   }
   const roots = [
-    ...pathForms2(seams, join41(main, CLAUDE_WORKTREES_SUBDIR)),
-    ...pathForms2(seams, join41(read.home, WORKTREES_SUBDIR)),
+    ...pathForms2(seams, join44(main, CLAUDE_WORKTREES_SUBDIR)),
+    ...pathForms2(seams, join44(read.home, WORKTREES_SUBDIR)),
     ...pathForms2(seams, worktreeDirAt(read.projectRoot, read.worktreeDir))
   ];
   const locks = parseLocks(listed2.stdout);
@@ -31962,7 +33202,7 @@ function lastModified(seams, git, path3) {
   if (!gitDir.ok || adminDir === "") {
     return failure4("git rev-parse --absolute-git-dir", gitDir);
   }
-  const times = [path3, ...ADMIN_FILES.map((file) => join41(adminDir, file))].map((file) => seams.modifiedAt(file)).filter((time) => time !== null).map((time) => time.getTime());
+  const times = [path3, ...ADMIN_FILES.map((file) => join44(adminDir, file))].map((file) => seams.modifiedAt(file)).filter((time) => time !== null).map((time) => time.getTime());
   if (times.length === 0) {
     return `no modification time could be read under ${path3} or ${adminDir}`;
   }
@@ -32291,6 +33531,66 @@ function firstLine9(text) {
 `).map((line) => line.trim()).find((line) => line !== "") ?? "";
 }
 
+// src/start/forced-draft.ts
+var PASSED_OVER_HEADING = "## Passed-over tasks";
+function forcedDraftSeamsIn(dir) {
+  return { gh: createGhRunner({ cwd: dir }), pulls: ghPullRequestsIn(dir) };
+}
+function passedOverSection(tasks) {
+  return [
+    PASSED_OVER_HEADING,
+    "",
+    "This pull request is a draft: `rafa loop start --continue --force-wrap-up` wrapped up with these tasks still open.",
+    "",
+    ...tasks.map((task) => `- line ${task.line} (${task.strategy}): ${task.text}. ${task.reason}`)
+  ].join(`
+`);
+}
+function bodyWithPassedOver(body, tasks) {
+  if (body.includes(PASSED_OVER_HEADING))
+    return body;
+  const kept = body.trimEnd();
+  return kept === "" ? passedOverSection(tasks) : `${kept}
+
+${passedOverSection(tasks)}`;
+}
+async function convertToDraft(number, gh) {
+  const command = `gh pr ready ${number} --undo`;
+  const result = await gh(["pr", "ready", String(number), "--undo"]);
+  if (result.ok)
+    return true;
+  const said = result.stderr.trim() || result.stdout.trim() || "nothing said";
+  activeOutput().warn(`\u26A0\uFE0F  The forced wrap-up could not mark pull request #${number} as a draft (${said}); run ${command} by hand.`);
+  return false;
+}
+async function writeSection(number, tasks, pulls) {
+  try {
+    const pull = await pulls.get(number);
+    if (pull === null)
+      throw new Error(`no pull request #${number}`);
+    const body = bodyWithPassedOver(pull.body, tasks);
+    if (body !== pull.body)
+      await pulls.editBody(number, body);
+  } catch (error) {
+    activeOutput().warn(`\u26A0\uFE0F  The forced wrap-up could not write the passed-over tasks into pull request #${number} (${messageOf(error)}).`);
+  }
+}
+async function markForcedDraft(number, tasks, seams) {
+  const drafted = await convertToDraft(number, seams.gh);
+  await writeSection(number, tasks, seams.pulls);
+  if (drafted)
+    activeOutput().info(`\uD83D\uDCDD Pull request #${number} is a draft, listing the ${tasks.length} passed-over task(s) in its body.`);
+  return drafted;
+}
+function refuseUndraftedPullRequest(number) {
+  emitLoopEvent({ kind: "halt", reason: `forced draft refused: pull request #${number} is ready for review` });
+  throw new LoopEnd(DECISION_STOP_EXIT, [
+    `\u26D4 The forced wrap-up's pull request #${number} could not be made a draft, so it is open ready for review with passed-over tasks left.`,
+    `   Run gh pr ready ${number} --undo by hand. The run is recorded stopped, not done, and the CI wait was skipped.`
+  ].join(`
+`));
+}
+
 // src/start/pr-retarget.ts
 function retargetedLine(number, from, to) {
   return `\u21AA Retargeted pull request #${String(number)} from ${from} to ${to} (pr.base).`;
@@ -32381,8 +33681,8 @@ async function carryReleaseIntoPullRequest(finish, target, seams = {}) {
 }
 
 // src/release/prepare.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync46, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname16, join as join42, posix as posix5 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync50, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname19, join as join45, posix as posix5 } from "path";
 var NO_FRAGMENT = "no release fragment";
 var WHITESPACE3 = /\s+/g;
 function levelFields(reading2) {
@@ -32440,7 +33740,7 @@ function readBase(input) {
 }
 function textOf3(path3) {
   try {
-    return readFileSync46(path3, "utf8");
+    return readFileSync50(path3, "utf8");
   } catch {
     return null;
   }
@@ -32450,7 +33750,7 @@ function nameOf2(path3) {
 }
 function writeFragment(path3, resolved, text) {
   try {
-    mkdirSync15(dirname16(resolved), { recursive: true });
+    mkdirSync15(dirname19(resolved), { recursive: true });
     writeFileSync18(resolved, text);
     return null;
   } catch (error) {
@@ -32475,7 +33775,7 @@ function prepareRelease(input) {
   const fragment = { plan: input.plan, title, level, notes: lines2.notes };
   const name2 = allocateFragmentName(input.plan, read.base.waiting.map((waiting) => nameOf2(waiting.path)));
   const path3 = posix5.join(input.settings.releaseFragments.replace(/\\/g, "/"), name2);
-  const resolved = join42(input.repoRoot, path3);
+  const resolved = join45(input.repoRoot, path3);
   const before = textOf3(resolved);
   const after = serializeFragment(fragment);
   const problems = lines2.problem === null ? read.problems : [...read.problems, lines2.problem];
@@ -32495,12 +33795,12 @@ function prepareRelease(input) {
 }
 
 // src/release/verify.ts
-import { readFileSync as readFileSync47, writeFileSync as writeFileSync19 } from "fs";
+import { readFileSync as readFileSync51, writeFileSync as writeFileSync19 } from "fs";
 import { posix as posix6 } from "path";
 var STATUS_PREFIX_LENGTH = 3;
 function textOf4(path3) {
   try {
-    return readFileSync47(path3, "utf8");
+    return readFileSync51(path3, "utf8");
   } catch {
     return null;
   }
@@ -32526,7 +33826,7 @@ function restoreFragment(file) {
     };
   }
 }
-function refuse10(prepared, refusal4) {
+function refuse11(prepared, refusal4) {
   const restore = restoreFragment(prepared.file);
   const clause = restore.problem ?? `${restore.path} was restored to the text the loop wrote`;
   return {
@@ -32594,20 +33894,20 @@ function checkFragment(prepared, text) {
 function verifyRelease(prepared, context) {
   const changed = changedBesideFragment(prepared, context);
   if (!changed.ok)
-    return refuse10(prepared, changed.refusal);
+    return refuse11(prepared, changed.refusal);
   if (changed.paths.length > 0)
-    return refuse10(prepared, otherFilesRefusal(prepared, changed.paths));
+    return refuse11(prepared, otherFilesRefusal(prepared, changed.paths));
   const path3 = prepared.file.path;
   const text = textOf4(prepared.file.resolved);
   if (text === null) {
-    return refuse10(prepared, {
+    return refuse11(prepared, {
       reason: "fragment-unreadable",
       because: `${path3} could not be read back after the wrap-up session`
     });
   }
   const fragment = checkFragment(prepared, text);
   if ("reason" in fragment)
-    return refuse10(prepared, fragment);
+    return refuse11(prepared, fragment);
   return { kind: "verified", path: path3, fragment, text };
 }
 
@@ -32794,7 +34094,7 @@ async function finishRelease(input, seams = {}) {
 }
 
 // src/start/runner-pr.ts
-import { readFileSync as readFileSync48 } from "fs";
+import { readFileSync as readFileSync52 } from "fs";
 import path3 from "path";
 var RELEASE_NOTES_HEADING = "## Release notes";
 var UNFINISHED_WRAP_UP_LINE = "> \u26A0\uFE0F The wrap-up did not finish: no wrap-up session opened this pull request, so the loop opened it. Check that the base is merged in, the release notes were rewritten and the lessons were promoted before merging.";
@@ -32827,7 +34127,7 @@ function fragmentNotesIn(checkout, fragment) {
     return [];
   let text;
   try {
-    text = readFileSync48(path3.resolve(checkout, fragment), "utf8");
+    text = readFileSync52(path3.resolve(checkout, fragment), "utf8");
   } catch {
     return [];
   }
@@ -32942,7 +34242,7 @@ function parsePromoted(output) {
   if (!block.closed)
     return { status: "unclosed", answers: [], unreadable: [] };
   const answers = [];
-  const unreadable = [];
+  const unreadable2 = [];
   const firstLine10 = new Map;
   block.body.split(`
 `).forEach((text, index) => {
@@ -32951,20 +34251,20 @@ function parsePromoted(output) {
     const line = block.span.first + 1 + index;
     const reading2 = readLine2(text, line);
     if ("reason" in reading2) {
-      unreadable.push({ line, text, reason: reading2.reason });
+      unreadable2.push({ line, text, reason: reading2.reason });
       return;
     }
     const { id: id2 } = reading2.answer;
     const earlier = firstLine10.get(id2);
     if (earlier !== undefined) {
       const reason = `\`${id2}\` was already answered at line ${String(earlier)}`;
-      unreadable.push({ line, text, reason });
+      unreadable2.push({ line, text, reason });
       return;
     }
     firstLine10.set(id2, line);
     answers.push(reading2.answer);
   });
-  return { status: "read", answers, unreadable };
+  return { status: "read", answers, unreadable: unreadable2 };
 }
 
 // src/start/promoted-check.ts
@@ -33212,7 +34512,7 @@ async function openPullRequestNumber(checkout, branch) {
     return null;
   }
 }
-function messageOf9(error) {
+function messageOf11(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function wrapUpAdapter(learning) {
@@ -33233,7 +34533,7 @@ async function lessonsToPromote(learning) {
       minConfidence: learning.promoteMinConfidence
     });
   } catch (error) {
-    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf9(error)}`);
+    activeOutput().warn(`   The wrap-up lists no lesson to promote: the \`${learning.kind}\` learning adapter answered no blessed set: ${messageOf11(error)}`);
     return [];
   }
 }
@@ -33343,9 +34643,11 @@ async function runWrapUp(input) {
     ciTimeoutMin,
     ciAttempts
   } = input;
+  const passedOver = input.passedOver ?? [];
   session.wrapUpStarted();
-  activeOutput().info(`
-\u2705 All tasks completed!`);
+  activeOutput().info(passedOver.length === 0 ? `
+\u2705 All tasks completed!` : `
+\u26A0\uFE0F  Wrapping up with ${passedOver.length} passed-over task(s) left open (--force-wrap-up): the pull request becomes a draft listing them.`);
   activeOutput().info("\uD83E\uDDF9 Wrap-up session starting: promote the listed lessons, sync with main, then commit, push and open the PR.");
   activeOutput().info("   This is one full Claude session with no intermediate output \u2014 expect several quiet minutes. Interrupting it skips the push and PR; if that happens, run again to retry just this stage.");
   emitLoopEvent({ kind: "wrap-up", phase: "fragment" });
@@ -33371,15 +34673,23 @@ async function runWrapUp(input) {
   }
   emitLoopEvent({ kind: "wrap-up", phase: "release" });
   const finish = await finishRelease({ repoRoot: checkout, branch: expected2.branch, settings, preparation: release }, { readProvider });
+  if (passedOver.length > 0 && readProvider().provider === "none") {
+    activeOutput().warn("\u26A0\uFE0F  pr.provider is none: the forced wrap-up has no pull request to mark as a draft.");
+  }
   if (readProvider().provider !== "none") {
     const delivery = await deliverPullRequest({ branch: expected2.branch, retries: settings.loopWrapUpRetries, previousMessage: finalMessage }, deliverySeamsIn({ ...input, base, fragment: finish.fragment }));
-    await emitPullRequestEvent(expected2.branch, delivery.kind === "delivered" ? delivery.pull.number : null, lookup);
+    const drafted = delivery.kind !== "delivered" || passedOver.length === 0 || await markForcedDraft(delivery.pull.number, passedOver, forcedDraftSeamsIn(checkout));
+    if (drafted) {
+      await emitPullRequestEvent(expected2.branch, delivery.kind === "delivered" ? delivery.pull.number : null, lookup);
+    }
     if (delivery.kind === "interrupted")
       return;
     if (delivery.kind === "blocked")
       throw new CommandExit(1, delivery.message);
     await carryReleaseIntoPullRequest(finish, { repoRoot: checkout, branch: expected2.branch }, { readProvider });
     await retargetPullRequest(delivery.pull, base, { pulls: ghPullRequestsIn(checkout), output: activeOutput() });
+    if (!drafted)
+      refuseUndraftedPullRequest(delivery.pull.number);
   } else {
     await emitPullRequestEvent(expected2.branch, null, lookup);
   }
@@ -33532,8 +34842,8 @@ function msUntil(startAt, now = new Date) {
   return target.getTime() - now.getTime();
 }
 function sleepFor(ms) {
-  return new Promise((resolve24) => {
-    setTimeout(resolve24, ms);
+  return new Promise((resolve25) => {
+    setTimeout(resolve25, ms);
   });
 }
 async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
@@ -33543,7 +34853,7 @@ async function deferUntil(startAt, now = new Date, sleep = sleepFor) {
 }
 
 // src/start.ts
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path4.dirname(fileURLToPath5(import.meta.url));
 var interrupted2 = false;
 async function start(args, repoRoot) {
   refuseDetachedRun(args);
@@ -33563,7 +34873,10 @@ async function start(args, repoRoot) {
   }
   refuseWorktreeWhileTracking(args, runConfig.config);
   const { inject: injectMode, settingSources } = runConfig.config;
-  const { startAt, plan, ciWait, ciTimeoutMin, ciAttempts, roadmap } = readRunArgs(args);
+  const { startAt, plan, ciWait, ciTimeoutMin, ciAttempts, roadmap, retry, continueRun } = readRunArgs(args);
+  refuseUnusableCriteria(continueRun, repoRoot, runConfig.config);
+  const runRetries = resolveRunRetries(retry, configuredRetries(runConfig.config, continueRun.on));
+  refuseRetryWithoutBudget(continueRun, runRetries);
   if (startAt)
     await deferUntil(startAt);
   const planPath = resolvePlanPath(repoRoot, runConfig.config.planDir, plan);
@@ -33593,6 +34906,9 @@ async function start(args, repoRoot) {
   setActivePlanStub(planStub2);
   const session = openRunSession({ repoRoot, planPath, planStub: planStub2, branch, roadmap, checkout });
   bindEventsFile(repoRoot, session.id);
+  let decisionsAtEnd = () => {
+    return;
+  };
   try {
     const planContent = fs.readFileSync(planPath, "utf8");
     const promptContent = fs.readFileSync(promptPath, "utf8");
@@ -33650,6 +34966,27 @@ async function start(args, repoRoot) {
       planContent,
       isInterrupted: () => interrupted2
     });
+    const retries = createRunRetries({
+      retries: runRetries,
+      isInterrupted: () => interrupted2,
+      isCheckoutHeld: () => guardCheckout(expected2).held
+    });
+    const runPlace = { planPath, planStub: planStub2, branch, checkout };
+    const decisions = createRunDecisions({
+      continueArgs: continueRun,
+      repoRoot,
+      checkout,
+      trackerPath,
+      planPath,
+      settings: runConfig.config,
+      settingSources,
+      session,
+      retries,
+      isInterrupted: () => interrupted2,
+      seed: continueRun.on ? readPreviousPassOver(repoRoot, runPlace) : [],
+      previousNeeded: continueRun.directive === null ? null : readPreviousDecisionNeeded(repoRoot, runPlace)
+    });
+    decisionsAtEnd = decisions.atRunEnd;
     if (!fs.existsSync(trackerPath)) {
       activeOutput().info(`\uD83D\uDCCB Creating new plan tracker at ${path4.basename(trackerPath)}...`);
       fs.copyFileSync(planPath, trackerPath);
@@ -33667,7 +35004,10 @@ async function start(args, repoRoot) {
       if (interrupted2)
         break;
       const trackerContent = fs.readFileSync(trackerPath, "utf8");
-      const taskInfo = findNextTask(trackerContent);
+      const taskInfo = findNextTask(trackerContent, { skipLines: decisions.skipLines(trackerContent) });
+      const passedOver = taskInfo ? [] : decisions.atPlanEnd(trackerContent);
+      if (await decisions.atFirstTask(taskInfo, trackerContent))
+        continue;
       const moved = taskInfo ? haltIfCheckoutMoved({ expected: expected2, trackerPath, taskInfo }) : haltIfWrapUpMoved({ expected: expected2, before: "dispatch" });
       if (moved) {
         emitLoopEvent({ kind: "halt", reason: "checkout moved" });
@@ -33675,8 +35015,12 @@ async function start(args, repoRoot) {
       }
       if (!taskInfo)
         emitLoopEvent({ kind: "wrap-up", phase: "tests" });
-      const suiteGate = await suiteSteps.beforeSession(taskInfo);
+      const suiteGate = decisions.gateForcedWrapUp(await suiteSteps.beforeSession(taskInfo), passedOver, suiteSteps.lastPreWrapUp());
       if (suiteGate === "stop") {
+        if (!suiteSteps.stoppedOnSignal() && retries.retry("suite step red", null))
+          continue;
+        if (!suiteSteps.stoppedOnSignal() && await decisions.atStop({ kind: "suite-red" }))
+          continue;
         emitLoopEvent({ kind: "halt", reason: "suite step red" });
         return;
       }
@@ -33701,12 +35045,14 @@ async function start(args, repoRoot) {
           ciWait,
           ciTimeoutMin,
           ciAttempts,
-          isInterrupted: () => interrupted2
+          isInterrupted: () => interrupted2,
+          passedOver
         });
         break;
       }
       const base = expected2.head;
       const position = taskPosition(trackerContent, taskInfo.lineNum);
+      const retryTask = retryTaskOf(taskInfo, trackerContent);
       const startedAt = Date.now();
       emitLoopEvent({ kind: "task-start", position, text: parseTaskDeclaration(taskInfo.task).text });
       session.taskStarted(taskInfo);
@@ -33722,6 +35068,7 @@ async function start(args, repoRoot) {
         knownMissing,
         inherited: runStartFailures(trackerPath),
         alwaysRun: readAlwaysRunFiles(createGitRunner(checkout), runConfig.config.testsAlwaysRun),
+        typeCheck: readTypeCheckRecipe(checkout, createGitRunner(checkout)),
         serving,
         handout,
         base,
@@ -33755,10 +35102,15 @@ async function start(args, repoRoot) {
       }
       if (exitCode !== 0) {
         updateTrackerLine(trackerPath, taskInfo.lineNum, "blocked");
+        await storeReport("failed");
+        const failed3 = { kind: "task-blocked", position, reason: `session exited ${exitCode}` };
+        if (retries.retry(`session exited ${exitCode}`, retryTask))
+          continue;
+        if (await decisions.atStop({ kind: "session-exit", taskInfo, retryTask, exitCode, stopEvent: failed3 }))
+          continue;
         activeOutput().error(`
 \u274C Task failed (exit ${exitCode}). Marked as blocked. Run again to retry.`);
-        emitLoopEvent({ kind: "task-blocked", position, reason: `session exited ${exitCode}` });
-        await storeReport("failed");
+        emitLoopEvent(failed3);
         return;
       }
       if (haltIfCheckoutMoved({ expected: expected2, trackerPath, taskInfo, before: "commit" })) {
@@ -33776,9 +35128,16 @@ async function start(args, repoRoot) {
       expected2 = advanceExpectation(expected2, finished.attempt);
       const stored = await storeReport(finished.outcome);
       if (finished.outcome !== "done") {
-        emitLoopEvent({ kind: "task-blocked", position, reason: finished.holds[0] ?? "held by its report" });
+        const held = { kind: "task-blocked", position, reason: finished.holds[0] ?? "held by its report" };
+        if (heldOnNothingLeftBehind(finished) && retries.retry("left neither a report nor a commit", retryTask))
+          continue;
+        if (await decisions.atStop({ kind: "clean-exit", taskInfo, retryTask, finished, stopEvent: held }))
+          continue;
+        emitLoopEvent(held);
         return;
       }
+      decisions.taskDone(taskInfo);
+      retries.taskDone(retryTask);
       const tokens = await unlessText(async () => taskTokens(checkout, dispatch.sessionId));
       emitLoopEvent({ kind: "task-done", position, durationMs: Date.now() - startedAt, tokens });
       if (!stored) {
@@ -33787,14 +35146,20 @@ async function start(args, repoRoot) {
         return;
       }
       if (!await suiteSteps.afterTask(taskInfo, base)) {
+        if (!suiteSteps.stoppedOnSignal() && retries.retry("suite step red", retryTask))
+          continue;
+        if (!suiteSteps.stoppedOnSignal() && await decisions.atStop({ kind: "suite-red" }))
+          continue;
         emitLoopEvent({ kind: "halt", reason: "suite step red" });
         return;
       }
     }
   } catch (error) {
-    emitLoopEvent({ kind: "error", message: messageOf(error) });
+    if (!(error instanceof LoopEnd))
+      emitLoopEvent({ kind: "error", message: messageOf(error) });
     throw error;
   } finally {
+    decisionsAtEnd();
     unbindEventsFile();
     session.end();
   }
@@ -33804,7 +35169,7 @@ async function start(args, repoRoot) {
 import fs4 from "fs";
 import { homedir as homedir11 } from "os";
 import path8 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/claims/plan-claim.ts
 import path5 from "path";
@@ -33944,7 +35309,7 @@ function otherBranchRefusal(attempt3, reading2, context) {
 function claimOwnBranch(attempt3, reading2, context) {
   if (reading2.state === "absent")
     return { kind: "fresh" };
-  const unreadable = () => ({
+  const unreadable2 = () => ({
     kind: "answer",
     answer: refused2(attempt3, attempt3.branch, null, `the claim on ${attempt3.branch} could not be read`)
   });
@@ -33952,12 +35317,12 @@ function claimOwnBranch(attempt3, reading2, context) {
   if (unnamed !== null)
     return { kind: "answer", answer: unnamed };
   if (reading2.state !== "found")
-    return unreadable();
+    return unreadable2();
   const weighed = weighBranchClaim(reading2, { labels: attempt3.labels ?? [], staleAfter: context.staleAfter, now: context.now });
   if (weighed.state === "released" || weighed.state === "stale-claimed")
     return { kind: "take", tip: reading2.tip };
   if (weighed.state === "none" || weighed.state === "unreadable")
-    return unreadable();
+    return unreadable2();
   if (weighed.owner === attempt3.storeId)
     return { kind: "held" };
   const note = weighed.state === "stale-in-development" ? ", stale but in development, which is never taken over automatically" : "";
@@ -34414,11 +35779,11 @@ async function resolveCreateSpec(options, seams = DEFAULT_ROUTE_SEAMS) {
   const source = readSpecSourceFlags(options.args);
   if (source.request === null)
     throw new CommandExit(SOURCE_REFUSAL_EXIT, usageRefusal(specsDir));
-  const resolve24 = seams.resolve ?? resolvePlanSpec;
+  const resolve25 = seams.resolve ?? resolvePlanSpec;
   const makeReadyOffer = seams.makeReadyOffer ?? createPlanReadyOffer;
   const makeAlternativeOffer = seams.makeAlternativeOffer ?? createPlanBlockedOffer;
   const makeRefreshOffer = seams.makeRefreshOffer ?? createPlanRefreshOffer;
-  return await resolve24({
+  return await resolve25({
     request: source.request,
     refresh: source.refresh,
     dryRun: source.dryRun,
@@ -34437,7 +35802,7 @@ async function resolveCreateSpec(options, seams = DEFAULT_ROUTE_SEAMS) {
 }
 
 // src/plan.ts
-var __dirname3 = path8.dirname(fileURLToPath3(import.meta.url));
+var __dirname3 = path8.dirname(fileURLToPath6(import.meta.url));
 function argValue2(args, flag) {
   const hit = args.find((a) => a.startsWith(`${flag}=`));
   return hit?.slice(flag.length + 1);
@@ -34581,7 +35946,7 @@ var PLAN_PROMPT_SLOTS = [
   "EPIC_CONTEXT",
   "SPEC_CONTENT"
 ];
-var SLOT_PATTERN = new RegExp(`\\{(${PLAN_PROMPT_SLOTS.join("|")})\\}`, "g");
+var SLOT_PATTERN3 = new RegExp(`\\{(${PLAN_PROMPT_SLOTS.join("|")})\\}`, "g");
 function buildPlanPrompt(template, planFormat, specContent, stub, planDir, progressContent, routing = DEFAULT_ROUTING, skillIndex = "", epic = null) {
   const values = {
     PLAN_FILE: planFilePath(planDir, `PLAN-${stub}.md`),
@@ -34593,7 +35958,7 @@ function buildPlanPrompt(template, planFormat, specContent, stub, planDir, progr
     EPIC_CONTEXT: formatEpicContextSection(epic),
     SPEC_CONTENT: specContent
   };
-  return template.replace(SLOT_PATTERN, (_slot, name2) => values[name2]);
+  return template.replace(SLOT_PATTERN3, (_slot, name2) => values[name2]);
 }
 function stubFromSpecPath(specPath2) {
   return path8.basename(specPath2).replace(/\.md$/, "");
@@ -34666,7 +36031,7 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   const epic = await readPlanEpicContext(resolved.spec, createGhRunner({ cwd: repoRoot }));
   const template = fs4.readFileSync(path8.join(__dirname3, "plan-prompt.md"), "utf8");
   const planFormat = readPlanFormat(__dirname3);
-  const skillIndex = readPlanSkillIndex(repoRoot, home, config, fileURLToPath3(import.meta.url));
+  const skillIndex = readPlanSkillIndex(repoRoot, home, config, fileURLToPath6(import.meta.url));
   const planner = registry.resolve("planner", "claude").create({
     repoRoot,
     planDir,
@@ -34701,4 +36066,4 @@ async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
   }
 }
 
-export { SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, sessionLogDir, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, loadModules, moduleSettings, pullBeforeRead, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, parseReportArgs, formatCount, alignRows, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, formatTokens, formatTrendSegment, formatLoopsSegment, readTrendInputs, trendReportOf, buildReport, readSkillsReport, report, SPEC_EXTENSION, boardId, notesFileName, branchName, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, parseWorkingTree, parseTreePaths, untrackedLeftLine, parseWorktrees, worktreesHolding, readMergeRefusal, resolvePrProvider, requireGhProvider, createGhPullRequests, ghPullRequestsIn, REMOTE, BRANCH_PREFIX2 as BRANCH_PREFIX, parseBaseStanding, hasDiverged, parseClaimMessage, claimBranchIssue, makeOwnershipCommit, fetchClaimBranches, readClaimBranch, pushOwnershipCommit, CLAIMED_LABEL, IN_DEVELOPMENT_LABEL, readClaimState, idleText, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, readEpicBody, SPEC_BLOCKED_LABEL, BLOCKED_BY_FIELD, hasSpecBlockedLabel, readBlockedBy, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, SPEC_READY_LABEL, findReadinessGaps, requireCompleteSpec, validate_default, RefsBlockError, fingerprintText, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, hasSpecLabel, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, setUpLabels, anythingAt, writeShippedFile, setUpBoard, resolveDefaultBoard, unlabelledRoadmapMessage, createGhRoadmapBody, tickSentence, appendLine, tickLine, editChecklist, noBoardListsLine, epicTickSentence, tickRoadmapAfterMerge, createGhIssueBoard, commandRetrySeams, openProjectRunner, matchProjectFields, PROJECT_SCOPE_FIX, BOARD_SYNC_FIX, isMissingProjectScope, scopeWarning, rateLimitWarning, notFoundWarning, skippedFieldWarning, notRefreshedWarning, isWaiting, blockerArg, createNativeRelations, selectBoardRelations, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, NATIVE_MODE, NATIVE_RETRY_HINT, nativeEpicLeft, nativeAlreadyMessage, nativeParentLine, readBoardRepository, configuredMoveRelations, FRAGMENT_PLAN_ID_PATTERN, serializeFragment, allocateFragmentName, directoryPrefix, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readEpicDependents, REASON_FLAG, normaliseReason, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, readRefsText, readCopyRefs, restampCopyRefs, RefVerifyError, readConfiguredRelations, requireNoLeak, blockedLineSentence, boardRepoLabel, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, isFirstDispatch, STAGE_LABELS, unlabelReleased, createStartPreflightClaim, invalidateRows, checkDrift, driftLines, readDoctorEffortSync, renderDoctorEffortSync, effortSyncRefusal, SESSION_ID_FLAG2 as SESSION_ID_FLAG, readBoardBody, openBoards, boardOfEpic, createOwnerResolver, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, openPhase, commandProgressFeed, createGhProjectPort, resolveLoopSeams, sessionIdFlag, lineRefusal2 as lineRefusal1, refusal3 as refusal, NoSessionRefusal, isLive, planLabel, sessionLine, projectRoot2 as projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, phaseNote, phasedCounts, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, RELEASE_REMOTE, RELEASE_BASE_BRANCH, parseSemanticVersion, readManifestVersion, replaceManifestVersion, gitPathOf, receiptProblem, readReceiptVerdict, CHANGELOG_TITLE, releaseCommitSubject, readSettle, buildSettle, waitingSettingsOf, readWaiting, forecastPhrase, DEFAULT_RELEASE_SEAMS, compareVersions, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, nextOwnerGate, resolveReleaseEnabled, refuseMisplacedRuntime, readBinPath, self_update_default, versionTag, INDENT4 as INDENT, cleanUpAfterMerge, reportFollowUps, RELEASE_BLOCK_OPEN, RELEASE_BLOCK_CLOSE, localPlanNotes, readGuard, guardLines, mergeGuardSettings, readMergeGuard, guardReaction, followsMerge, readSettleAfterMerge, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, readRemoteHead, eventsFilePath, WORKTREES_SUBDIR, resolveWorktreePath, crossRepositoryRefusal, addResolveWorktree, removeResolveWorktree, pushResolved, worktreeAt, worktreeDirAt, WORKTREE_STATUS, countChanges, cleanupSteps, dryRunLines, runCleanupSteps, defaultCleanupSeams, readCleanup, cleanupCounts, createLinePrompter, openNextRelations, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, readHomeAfterLoop, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter2 as lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, readBlockedIssues, renderBlockedIssues, blockerToken, addBlockerToBody, resolveCreateSpec, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, DISK_ROOTS_FILE_SYSTEM, gitToplevel, rootRefusal, rootCandidates, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, retargetedLine, MECHANICAL_CONFLICT_SENTENCE, start, createPlanRefsVerifier, readDoctorRefs, renderDoctorRefs, createPlanDirNames, hasPlanFor, HORIZONS, horizonOf, readListedEpics, stageOf, rankOf, readIssueFacts, readRefreshBoard, refreshProjectItems, refreshIssueItems, refreshFailedWarning, unblock_default, unblockAfterMerge, labelsLineBlockersOf, LABELS_READS, createLabelsRelations, EPIC_TYPE_LABEL, plan };
+export { SERVE_CLI_VERSION, PROVENANCE_FIELD, SKILL_FILE2 as SKILL_FILE, provenanceBlock, serveVerdict, SKILL_USE_CLI_VERSION, sessionLogDir, MANIFEST_VERSION, FEATURE_TYPES, OUTPUT_CHANNELS, RUNNING_MANIFEST_SEAMS, validateManifest, loadModules, moduleSettings, pullBeforeRead, collectSessionRow, collect, AGENT_DEFINITION_DIR, VENDOR_COMMAND, readAgentDirectory, resolveAgentRoster, missingPlanAgents, isStackList, stackPaths, stacksFromEccSkillName, DESCRIPTION_LIMIT, LISTING_LIMIT, SKILL_SIGNALS, countCharacters, toolOf, pathDirectories, checkReferences, checkFile, checkDirectory, bundledAgentsDirectory, sourceItem, byName, skillItem, readTrees, parseReportArgs, formatCount, alignRows, verdictOf, failingRows, formatRows, waitForChecks, recordPlanCi, formatTokens, formatTrendSegment, formatLoopsSegment, readTrendInputs, trendReportOf, buildReport, readSkillsReport, report, SPEC_EXTENSION, boardId, notesFileName, branchName, shellQuote, ghMissingMessage, ghUnauthenticatedMessage, ghHostOf, ghPreflightItems, parseWorkingTree, parseTreePaths, untrackedLeftLine, parseWorktrees, worktreesHolding, readMergeRefusal, resolvePrProvider, requireGhProvider, createGhPullRequests, ghPullRequestsIn, REMOTE, BRANCH_PREFIX2 as BRANCH_PREFIX, parseBaseStanding, hasDiverged, parseClaimMessage, claimBranchIssue, makeOwnershipCommit, fetchClaimBranches, readClaimBranch, pushOwnershipCommit, CLAIMED_LABEL, IN_DEVELOPMENT_LABEL, readClaimState, idleText, ROADMAP_TITLE, ROADMAP_SETTING, parseRoadmapBody, createGhRoadmapSearch, severalRoadmapsMessage, createGhOpenPullRequests, closedIssuesIn, branchClaims, scanClaimBranches, readEpicBody, SPEC_BLOCKED_LABEL, BLOCKED_BY_FIELD, hasSpecBlockedLabel, readBlockedBy, EPIC_LABEL_PREFIX, epicSlugsOf, isNotPlanned, groupByEpicLabel, localDay, readEpics, BOARD_LISTING_LIMIT, createGhBoardListing, SPEC_READY_LABEL, findReadinessGaps, requireCompleteSpec, validate_default, RefsBlockError, fingerprintText, PREVIOUS_COPY_WARN_ABOVE, previousDir, countPreviousCopies, createGhSpecIssueReader, hasSpecLabel, readRoadmapSetting, ROADMAP_LABEL, BOARD_LABELS, LABEL_LIST_LIMIT, SPEC_TEMPLATE_PATH, TEMPLATES_DIRNAME, boardChanged, listBoardLabels, missingBoardLabels, setUpLabels, anythingAt, writeShippedFile, setUpBoard, resolveDefaultBoard, unlabelledRoadmapMessage, createGhRoadmapBody, tickSentence, appendLine, tickLine, editChecklist, noBoardListsLine, epicTickSentence, tickRoadmapAfterMerge, createGhIssueBoard, commandRetrySeams, openProjectRunner, matchProjectFields, PROJECT_SCOPE_FIX, BOARD_SYNC_FIX, isMissingProjectScope, scopeWarning, rateLimitWarning, notFoundWarning, skippedFieldWarning, notRefreshedWarning, isWaiting, blockerArg, createNativeRelations, selectBoardRelations, resolveTracker, DEFAULT_ISSUE_SEAMS, lineRefusal, expectTwoArguments, readTextFlag, readNonBlankFlag, readRequiredFlag, readChoice, readChoiceFlag, issueProject, issueSubjectConfig, resolveIssueTracker, issueRef, issueName, urlLines, onTracker, NATIVE_MODE, NATIVE_RETRY_HINT, nativeEpicLeft, nativeAlreadyMessage, nativeParentLine, readBoardRepository, configuredMoveRelations, FRAGMENT_PLAN_ID_PATTERN, serializeFragment, allocateFragmentName, directoryPrefix, HORIZON_LABEL_PREFIX, readEpicProblems, epicProblemMessage, readEpicDependents, REASON_FLAG, normaliseReason, renderHorizonComment, renderParkedPullRequestComment, renderMoveComment, renderCloseComment, renderCancelComment, cancelMoveReason, renderDependentComment, renderUnblockNote, readReason, unaskedReasonMessage, blankReasonMessage, readRefsText, readCopyRefs, restampCopyRefs, RefVerifyError, readConfiguredRelations, requireNoLeak, blockedLineSentence, boardRepoLabel, memoiseVerifier, LEARNED_DIRECTORY, ORIGIN_FIELD, DEMOTION_VERDICTS, WHEN_TO_USE_HEADING, bodySections, classifySkill, firstSentence, convertToInstinct, rankCandidates, readRankCandidate, NO_NEXT_STEP, readSchemaReport, gateMeaning, unknownAdditive, unknownAdditiveWarning, developmentApplied, isFirstDispatch, STAGE_LABELS, unlabelReleased, createStartPreflightClaim, invalidateRows, checkDrift, driftLines, readDoctorEffortSync, renderDoctorEffortSync, effortSyncRefusal, SESSION_ID_FLAG2 as SESSION_ID_FLAG, readBoardBody, openBoards, boardOfEpic, createOwnerResolver, runIssueList, ISSUE_LIST_FLAGS, list_default, firstNowEpic, show_default, samePlace, resolvePlace, openPhase, commandProgressFeed, createGhProjectPort, resolveLoopSeams, sessionIdFlag, lineRefusal2 as lineRefusal1, refusal3 as refusal, NoSessionRefusal, isLive, planLabel, sessionLine, projectRoot2 as projectRoot, readRecords, pickSession, writeSession, readSessionChecklist, phaseNote, phasedCounts, checkboxAt, estimateEta, readSessionFinishes, formatDuration, etaLine, RELEASE_REMOTE, RELEASE_BASE_BRANCH, parseSemanticVersion, readManifestVersion, replaceManifestVersion, gitPathOf, receiptProblem, readReceiptVerdict, CHANGELOG_TITLE, releaseCommitSubject, readSettle, buildSettle, waitingSettingsOf, readWaiting, forecastPhrase, DEFAULT_RELEASE_SEAMS, compareVersions, changelogVersions, readTags, status_default, epicEndLines, watchDryEpic, nextOwnerGate, resolveReleaseEnabled, eventsFileOf, readEventsFrom, refuseMisplacedRuntime, readBinPath, self_update_default, versionTag, INDENT4 as INDENT, cleanUpAfterMerge, reportFollowUps, RELEASE_BLOCK_OPEN, RELEASE_BLOCK_CLOSE, localPlanNotes, readGuard, guardLines, mergeGuardSettings, readMergeGuard, guardReaction, followsMerge, readSettleAfterMerge, DEFAULT_BASE_BRANCH, ghNextBoard, openNextSources, readRemoteHead, WORKTREES_SUBDIR, resolveWorktreePath, crossRepositoryRefusal, addResolveWorktree, removeResolveWorktree, pushResolved, worktreeAt, worktreeDirAt, WORKTREE_STATUS, countChanges, cleanupSteps, dryRunLines, runCleanupSteps, defaultCleanupSeams, readCleanup, cleanupCounts, createLinePrompter, openNextRelations, list_default2 as list_default1, readBranch2 as readBranch, readPlans, readOpenPull, readBranchPlan, readNextState, readHomeAfterLoop, commandWords, nextQuestion, NEXT_COMMAND_ACTIONS, LABELS_ONLY_ACTIONS, actionInvocation, runAction, HINT_FLAG_SPEC, actionOutput, endWithNextStep, endingWith, lazyPrompter2 as lazyPrompter, ready_default, DEFAULT_PLAN_FILE, resolvePlanPath, assessPlanRisk, renderRiskText, announceRiskTotal, readBlockedIssues, renderBlockedIssues, blockerToken, addBlockerToBody, resolveCreateSpec, PLACEHOLDER_REASON, renderEpicBody, splitCriteria, criteriaToAsk, readVerifyPrompt, fenceFor, buildVerifyPrompt, parseVerifyPlan, TRIAGE_MODULE, namedSecrets, triageReport, unresolvedTracker, DISK_ROOTS_FILE_SYSTEM, gitToplevel, rootRefusal, rootCandidates, DEFAULT_CI_TIMEOUT_MIN, CI_POLL_INTERVAL_MS, DEFAULT_CI_ATTEMPTS, retargetedLine, MECHANICAL_CONFLICT_SENTENCE, start, createPlanRefsVerifier, readDoctorRefs, renderDoctorRefs, createPlanDirNames, hasPlanFor, HORIZONS, horizonOf, readListedEpics, stageOf, rankOf, readIssueFacts, readRefreshBoard, refreshProjectItems, refreshIssueItems, refreshFailedWarning, unblock_default, unblockAfterMerge, labelsLineBlockersOf, LABELS_READS, createLabelsRelations, EPIC_TYPE_LABEL, plan };