nightralph 0.0.53 → 0.0.56

package/dist/orchestrator.js

@@ -7,10 +7,11 @@ import {
   readFileSync,
   writeFileSync,
   unlinkSync,
-  readdirSync
+  readdirSync,
+  statSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, dirname, basename } from "node:path";
+import { join, dirname, basename, relative } from "node:path";
 import { createInterface } from "node:readline";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
@@ -23,7 +24,8 @@ import {
   buildBranchName,
   hasNewCommits,
   isDirty,
-  commitDirty
+  commitDirty,
+  headCommit
 } from "./worktree.js";
 import {
   generateProgress,
@@ -45,6 +47,57 @@ import {
   ticketLabel
 } from "./display.js";
 import { runTestCmd } from "./testcmd.js";
+import {
+  readDocsRule,
+  installRule,
+  subagentRule,
+  testGateRule,
+  LINT_RULE,
+  integrityRule,
+  CONFINEMENT_RULES,
+  commitRule,
+  notesRule,
+  agentsMdRule
+} from "./rules.js";
+import { runReviewPass, renderReviewSummary } from "./review.js";
+import {
+  addRun,
+  addStats,
+  emptyRunStats,
+  emptyStreamStats,
+  isRecord,
+  nextStreamStats,
+  renderRunStats
+} from "./stats.js";
+import {
+  EFFORT_LADDERS,
+  escalateEffort,
+  retryDelayFor,
+  runWithRetries,
+  sleep
+} from "./retry.js";
+import {
+  EFFORT_LADDERS as EFFORT_LADDERS2,
+  ALL_EFFORT_LEVELS,
+  escalateEffort as escalateEffort2,
+  retryDelayFor as retryDelayFor2
+} from "./retry.js";
+import {
+  LOG_TAIL_LINES,
+  appendEntry,
+  collectNotes,
+  ensureNotesIgnored,
+  learningsPathFor,
+  readEntries,
+  renderEntry,
+  renderHistory,
+  selectHistory,
+  tailLines
+} from "./learnings.js";
+import {
+  parseBlockerField,
+  provisionalRefs
+} from "./blockers.js";
 function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -113,21 +166,7 @@ function parseStatus(body) {
   return m ? m[1].trim().toLowerCase() : "";
 }
 __name(parseStatus, "parseStatus");
-function parseBlockers(body) {
-  const m = body.match(/\*\*Blocked by:\*\*\s*(.+)/i);
-  if (!m) return [];
-  const text = m[1];
-  if (/none/i.test(text)) return [];
-  const nums = [];
-  const re = /(\d+)/g;
-  let match;
-  while (match = re.exec(text)) {
-    nums.push(Number(match[1]));
-  }
-  return nums;
-}
-__name(parseBlockers, "parseBlockers");
-function scanTickets(dir, feature = "") {
+function scanTickets(dir, feature = "", knownFeatures = /* @__PURE__ */ new Set()) {
   const files = readdirSync(dir).filter((f) => TICKET_RE.test(f)).sort((a, b) => a.localeCompare(
     b,
     void 0,
@@ -144,7 +183,10 @@ function scanTickets(dir, feature = "") {
       filepath,
       body,
       status: parseStatus(body),
-      blockers: parseBlockers(body),
+      blockers: provisionalRefs(
+        parseBlockerField(body, knownFeatures).refs,
+        feature
+      ),
       feature
     };
   });
@@ -154,15 +196,35 @@ function ticketKey(feature, num) {
   return `${feature}:${num}`;
 }
 __name(ticketKey, "ticketKey");
+function blockerSatisfied(ref, doneKeys) {
+  switch (ref.where) {
+    case "run":
+      return doneKeys.has(ticketKey(ref.feature, ref.num));
+    case "done":
+      return true;
+    case "pending":
+    case "missing":
+      return false;
+  }
+}
+__name(blockerSatisfied, "blockerSatisfied");
+function blockerLabel(ref) {
+  const nn = String(ref.num).padStart(2, "0");
+  const base = ref.feature ? `${ref.feature}/${nn}` : nn;
+  if (ref.where === "pending") {
+    return `${base} (${ref.status ?? "not done"}, not in run)`;
+  }
+  if (ref.where === "missing") return `${base} (not found)`;
+  return base;
+}
+__name(blockerLabel, "blockerLabel");
 function findReadyTickets(tickets) {
   const doneKeys = new Set(
     tickets.filter((t) => t.status === "done").map((t) => ticketKey(t.feature, t.num))
   );
   return tickets.filter((t) => {
     if (t.status !== "ready-for-agent") return false;
-    return t.blockers.every(
-      (b) => doneKeys.has(ticketKey(t.feature, b))
-    );
+    return t.blockers.every((r) => blockerSatisfied(r, doneKeys));
   });
 }
 __name(findReadyTickets, "findReadyTickets");
@@ -171,14 +233,19 @@ function findBlockedTickets(tickets, failedKeys) {
     tickets.map((t) => [ticketKey(t.feature, t.num), t])
   );
   function collectDead(ticket, visited, found) {
-    for (const b of ticket.blockers) {
-      const key = ticketKey(ticket.feature, b);
+    for (const ref of ticket.blockers) {
+      const key = ticketKey(ref.feature, ref.num);
       if (visited.has(key)) continue;
       visited.add(key);
+      if (ref.where === "done") continue;
+      if (ref.where === "pending" || ref.where === "missing") {
+        found.set(key, ref);
+        continue;
+      }
       const blocker = byKey.get(key);
       if (!blocker || blocker.status === "done") continue;
       if (failedKeys.has(key) || blocker.status !== "ready-for-agent") {
-        found.add(key);
+        found.set(key, ref);
         continue;
       }
       collectDead(blocker, visited, found);
@@ -190,9 +257,9 @@ function findBlockedTickets(tickets, failedKeys) {
     const key = ticketKey(t.feature, t.num);
     if (t.status !== "ready-for-agent") continue;
     if (failedKeys.has(key)) continue;
-    const found = /* @__PURE__ */ new Set();
+    const found = /* @__PURE__ */ new Map();
     collectDead(t, /* @__PURE__ */ new Set([key]), found);
-    if (found.size > 0) blocked.set(key, [...found]);
+    if (found.size > 0) blocked.set(key, [...found.values()]);
   }
   return blocked;
 }
@@ -337,11 +404,23 @@ function stripSpecSection(specBody, heading) {
   return out.join("\n");
 }
 __name(stripSpecSection, "stripSpecSection");
+function reviewSpecBody(specBody, specBodies) {
+  if (!specBodies || specBodies.size <= 1) return specBody;
+  return [...specBodies].map(([name, body]) => `# Feature: ${name}
+
+${body}`).join("\n\n");
+}
+__name(reviewSpecBody, "reviewSpecBody");
 function lookupSpec(specBodies, fallback, feature) {
   if (!feature || !specBodies) return fallback;
   return specBodies.get(feature) ?? fallback;
 }
 __name(lookupSpec, "lookupSpec");
+function historyBlock(history) {
+  if (!history) return [];
+  return [history, ""];
+}
+__name(historyBlock, "historyBlock");
 function renderPrompt(specBody, ticket, opts) {
   return [
     "---- SPEC CONTEXT ----",
@@ -351,27 +430,30 @@ function renderPrompt(specBody, ticket, opts) {
     ticket.filename,
     ticket.body,
     "",
+    ...historyBlock(opts.history),
     "---- AGENT INSTRUCTIONS ----",
     "You are an autonomous coding agent. Implement the ticket using /tdd.",
     "",
     "Follow these rules:",
-    "- Read the files directly relevant to the ticket before writing code. Also read any AGENTS.md in or above the directories you will touch, plus CONTEXT.md and the relevant docs/adr/ entries if they exist. If they do not exist, proceed silently.",
+    readDocsRule("ticket"),
     "- Work ONLY on this ticket. Do not fix unrelated problems you notice.",
     "- Do NOT research external APIs or services via web search. Use the spec and ticket body as your sole reference for API shapes.",
-    "- Use /tdd for every checklist item. For each item, write a failing test at the seams named in the spec's Testing Decisions section, then write only enough code to make it pass, then refactor.",
-    `- While iterating, run only the tests relevant to what you changed. Run \`${opts.testCmd}\` in full once, as the final gate before your last commit. Do not commit with failing tests. The orchestrator runs the same command after you exit and rejects the ticket if it fails.`,
-    "- If the project has a lint script, run it and fix what it reports.",
-    "- INTEGRITY: never delete, skip, weaken, or write tautological tests to force a green result. Only report a checklist item done when its real tests genuinely pass. If an item cannot be completed honestly, leave it unchecked and say what blocked you.",
-    "- Do NOT read or modify files outside your current directory (the worktree).",
-    "- Do NOT run git push.",
-    "- Commit after each checklist item, and make sure everything is committed when finished.",
+    ...installRule(opts.installCmd),
+    ...subagentRule(opts.preferSubagent),
+    "- Use /tdd for every checklist item. For each item, write a failing test at the seams named in the spec's Testing Decisions section, then write only enough code to make it pass, then refactor. For a checklist item that is pure scaffolding, config, or docs (where a test adds no value), skip test-first and record that decision in your notes file.",
+    testGateRule(opts.testCmd, "ticket"),
+    LINT_RULE,
+    integrityRule("checklist item"),
+    ...CONFINEMENT_RULES,
+    commitRule("checklist item"),
+    notesRule("checklist item", "ticket"),
     "- After completing each checklist item in the ticket, print a line: [x] <item text> (matching the checklist text exactly).",
-    "- Before your final commit, record reusable learnings in the nearest AGENTS.md (in or above the directories you modified; prefer that over the repo root). Good additions: module conventions, gotchas, files that must change together, how to test that area, environment requirements. Do NOT add ticket-specific details or temporary debugging notes. Only write when you have knowledge that would help future work in that directory.",
+    agentsMdRule("ticket"),
     ""
   ].join("\n");
 }
 __name(renderPrompt, "renderPrompt");
-function renderMergePrompt(specBody, ticket) {
+function renderMergePrompt(specBody, ticket, opts = {}) {
   return [
     "---- SPEC CONTEXT ----",
     specBody,
@@ -392,6 +474,8 @@ function renderMergePrompt(specBody, ticket) {
     "4. Commit the resolved files.",
     "",
     "Do NOT re-implement the ticket from scratch.",
+    ...installRule(opts.installCmd),
+    ...subagentRule(opts.preferSubagent),
     "Do NOT read or modify files outside your current directory (the worktree).",
     "Do NOT run git push."
   ].join("\n");
@@ -400,7 +484,7 @@ __name(renderMergePrompt, "renderMergePrompt");
 function listTickets(tickets) {
   console.log("\nTickets:");
   for (const t of tickets) {
-    const blockerStr = t.blockers.length > 0 ? `blocked by [${t.blockers.join(", ")}]` : "no blockers";
+    const blockerStr = t.blockers.length > 0 ? `blocked by [${t.blockers.map(blockerLabel).join(", ")}]` : "no blockers";
     console.log(
       `  ${t.filename} (${t.status}) ${blockerStr}`
     );
@@ -424,11 +508,7 @@ function* simulateWaves(tickets) {
       if (sim.get(key) !== "ready-for-agent") {
         return false;
       }
-      return t.blockers.every(
-        (b) => doneKeys.has(
-          ticketKey(t.feature, b)
-        )
-      );
+      return t.blockers.every((r) => blockerSatisfied(r, doneKeys));
     });
     if (ready.length === 0) break;
     yield { wave, ready };
@@ -461,9 +541,7 @@ function detectDeadlocks(tickets) {
         (t) => ticketKey(t.feature, t.num) === key
       );
       if (ticket.blockers.every(
-        (b) => doneKeys.has(
-          ticketKey(ticket.feature, b)
-        )
+        (r) => blockerSatisfied(r, doneKeys)
       )) {
         doneKeys.add(key);
         readyKeys.delete(key);
@@ -505,76 +583,47 @@ function getProviderArgs(cmd) {
   return PROVIDER_ARGS[name] ?? [];
 }
 __name(getProviderArgs, "getProviderArgs");
-const EFFORT_LADDERS = {
-  pi: [
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max"
-  ],
-  claude: [
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max"
-  ],
-  codex: ["low", "medium", "high"]
-};
-const ALL_EFFORT_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-function escalateEffort(provider, level) {
-  if (!level) return "high";
-  const ladder = EFFORT_LADDERS[provider];
-  const i = ladder.indexOf(level);
-  if (i === -1) return level;
-  return ladder[Math.min(i + 1, ladder.length - 1)];
-}
-__name(escalateEffort, "escalateEffort");
 function formatStreamLine(line) {
-  let obj;
+  let value;
   try {
-    obj = JSON.parse(line);
+    value = JSON.parse(line);
   } catch {
     return line;
   }
+  return formatStreamObject(value);
+}
+__name(formatStreamLine, "formatStreamLine");
+function formatStreamObject(value) {
+  if (!isRecord(value)) return null;
+  const obj = value;
   if (obj.type === "assistant") {
-    const msg = obj.message;
-    const content = msg?.content;
+    if (obj.parent_tool_use_id != null) return null;
+    const msg = isRecord(obj.message) ? obj.message : void 0;
+    const content = Array.isArray(msg?.content) ? msg.content : void 0;
     if (!content) return null;
     for (const block of content) {
-      if (block.type === "text") {
-        return String(block.text);
-      }
+      if (!isRecord(block)) continue;
+      if (block.type !== "text") continue;
+      if (typeof block.text === "string") return block.text;
     }
     return null;
   }
   if (obj.type === "result") {
-    const sub = obj.subtype ?? "done";
-    const cost = obj.total_cost_usd;
-    const costStr = cost != null ? ` ($${cost.toFixed(2)})` : "";
+    const sub = typeof obj.subtype === "string" ? obj.subtype : "done";
+    const cost = typeof obj.total_cost_usd === "number" ? obj.total_cost_usd : void 0;
+    const costStr = cost !== void 0 ? ` ($${cost.toFixed(2)})` : "";
     return `${sub}${costStr}`;
   }
   if (obj.type === "system") {
-    const sub = obj.subtype;
+    const sub = typeof obj.subtype === "string" ? obj.subtype : void 0;
     if (sub === "api_retry") {
-      const error = obj.error;
-      return `retry: ${error ?? "unknown"}`;
+      const error = typeof obj.error === "string" ? obj.error : "unknown";
+      return `retry: ${error}`;
     }
   }
   return null;
 }
-__name(formatStreamLine, "formatStreamLine");
+__name(formatStreamObject, "formatStreamObject");
 function createPiStreamFormatter() {
   const calls = /* @__PURE__ */ new Map();
   let textBuf = "";
@@ -727,10 +776,15 @@ function spawnAgent(opts) {
     opts.logPath,
     { flags: "w" }
   );
+  const env = isClaude && opts.preferSubagent ? {
+    ...process.env,
+    CLAUDE_CODE_SUBAGENT_MODEL: opts.preferSubagent
+  } : void 0;
   const proc = spawn(opts.agentCmd, args, {
     stdio: ["pipe", "pipe", "pipe"],
     cwd: opts.cwd,
-    detached: true
+    detached: true,
+    ...env ? { env } : {}
   });
   if (proc.pid !== void 0) runningAgents.add(proc.pid);
   proc.stdout.pipe(logStream, { end: false });
@@ -748,10 +802,26 @@ function spawnAgent(opts) {
     }
   }
   __name(collectCompleted, "collectCompleted");
+  let streamStats = emptyStreamStats();
+  function formatClaudeLine(line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return line;
+    }
+    const next = nextStreamStats(streamStats, obj);
+    if (next !== streamStats) {
+      streamStats = next;
+      opts.onStats?.(next.stats);
+    }
+    return formatStreamObject(obj);
+  }
+  __name(formatClaudeLine, "formatClaudeLine");
   const rl = createInterface({ input: proc.stdout });
   rl.on("line", (line) => {
     if (isClaude) {
-      const formatted = formatStreamLine(line);
+      const formatted = formatClaudeLine(line);
       if (formatted !== null) {
         collectCompleted(formatted);
         const output = `${prefix}${formatted}`;
@@ -843,7 +913,12 @@ function spawnAgent(opts) {
       rlErr.close();
       logStream.end();
       if (promptFile) cleanupPromptFile(promptFile);
-      resolve({ exitCode, completedItems, timedOut });
+      resolve({
+        exitCode,
+        completedItems,
+        timedOut,
+        ...isClaude ? streamStats.stats : {}
+      });
     }
     __name(finish, "finish");
     proc.on("exit", (code) => {
@@ -867,22 +942,27 @@ function spawnAgent(opts) {
       }
       rl.close();
       rlErr.close();
-      logStream.end();
+      const msg = "agent process error: " + formatErrorMessage(err);
+      logStream.write(`nightralph: ${msg}
+`);
       if (promptFile) cleanupPromptFile(promptFile);
-      console.error(
-        "Agent process error:",
-        formatErrorMessage(err)
-      );
-      resolve({
-        exitCode: 1,
-        completedItems,
-        timedOut
+      if (opts.onLine) {
+        opts.onLine(`${prefix}${msg}`);
+      } else {
+        console.error(`${prefix}${msg}`);
+      }
+      logStream.end(() => {
+        resolve({
+          exitCode: 1,
+          completedItems,
+          timedOut
+        });
       });
     });
   });
 }
 __name(spawnAgent, "spawnAgent");
-function dryRun(tickets, specBody, testCmd) {
+function dryRun(tickets, specBody, testCmd, preferSubagent) {
   listTickets(tickets);
   console.log("\nSimulated wave order:");
   for (const { wave, ready } of simulateWaves(tickets)) {
@@ -896,6 +976,9 @@ function dryRun(tickets, specBody, testCmd) {
       "\nDeadlocked tickets: " + stuck.map((t) => t.filename).join(", ")
     );
   }
+  console.log(`
+Test command: ${testCmd || "(none)"}`);
+  console.log(`Prefer subagent: ${preferSubagent || "(none)"}`);
   const firstReady = findReadyTickets(tickets);
   if (firstReady.length > 0) {
     console.log(
@@ -907,7 +990,7 @@ Prompt for first ready ticket (${firstReady[0].filename}):
       renderPrompt(
         specBody,
         firstReady[0],
-        { testCmd }
+        { testCmd, preferSubagent }
       )
     );
   }
@@ -951,18 +1034,28 @@ Prompt for first ready ticket (${firstReady[0].filename}):
       renderPrompt(
         opts.specBody,
         firstReady[0],
-        { testCmd: opts.testCmd }
+        {
+          testCmd: opts.testCmd,
+          installCmd: opts.installCmd,
+          preferSubagent: opts.preferSubagent
+        }
       )
     );
   }
   const strategyDesc = opts.conflictStrategy === "respawn" ? "respawn (re-run agent on conflict)" : "stop (stop merging on conflict)";
   console.log(
     `
-Test command: ${opts.testCmd}`
+Test command: ${opts.testCmd || "(none)"}`
+  );
+  console.log(
+    `Install:      ${opts.installCmd || "(none)"}`
   );
   console.log(
     `Effort:       ${opts.effort ?? "(provider default)"}`
   );
+  console.log(
+    `Prefer subagent: ${opts.preferSubagent || "(none)"}`
+  );
   console.log(
     `Retries:      ${opts.retries ?? DEFAULT_RETRIES}`
   );
@@ -979,7 +1072,34 @@ Merge strategy: ${strategyDesc}`
   console.log(`Progress file: ${opts.progressPath}`);
 }
 __name(dryRunIsolated, "dryRunIsolated");
+async function runInstall(opts) {
+  const result = await runTestCmd({
+    cmd: opts.installCmd,
+    cwd: opts.worktreePath,
+    timeout: opts.timeout,
+    registry: opts.registry
+  });
+  const installLogPath = attemptLogPath(
+    opts.logsDir,
+    opts.ticket,
+    opts.attempt ?? 1,
+    ".install.log"
+  );
+  writeFileSync(installLogPath, result.output);
+  if (result.exitCode !== 0) {
+    opts.log(
+      `  ${opts.ticket.filename}: install failed (exit ${result.exitCode}); see ${installLogPath}`
+    );
+    return false;
+  }
+  return true;
+}
+__name(runInstall, "runInstall");
 async function runTestGate(opts) {
+  if (opts.testCmd === "") {
+    opts.log(`  ${opts.ticket.filename}: no test gate`);
+    return true;
+  }
   const result = await runTestCmd({
     cmd: opts.testCmd,
     cwd: opts.worktreePath,
@@ -1021,9 +1141,25 @@ async function respawnAndRetryMerge(opts) {
   } else {
     console.log(msg1);
   }
+  if (opts.installCmd) {
+    const installed = await runInstall({
+      installCmd: opts.installCmd,
+      ticket: opts.ticket,
+      worktreePath: opts.worktreePath,
+      timeout: opts.timeout,
+      logsDir: opts.logsDir,
+      log,
+      registry: runningAgents
+    });
+    if (!installed) return false;
+  }
   const prompt = renderMergePrompt(
     opts.specBody,
-    opts.ticket
+    opts.ticket,
+    {
+      installCmd: opts.installCmd,
+      preferSubagent: opts.preferSubagent
+    }
   );
   const logPath = join(
     opts.logsDir,
@@ -1042,8 +1178,10 @@ async function respawnAndRetryMerge(opts) {
     cwd: opts.worktreePath,
     label,
     maxTurns: opts.maxTurns,
+    preferSubagent: opts.preferSubagent,
     onLine: opts.onLine
   });
+  opts.onAgentRun?.(result);
   if (result.exitCode !== 0) {
     const msg2 = `  ${opts.ticket.filename}: respawned agent exited ${result.exitCode}`;
     if (opts.onLine) {
@@ -1122,20 +1260,43 @@ async function runPool(items, limit, fn) {
   return results;
 }
 __name(runPool, "runPool");
-function retryDelayFor(base, attempt) {
-  return base * 2 ** (attempt - 2);
-}
-__name(retryDelayFor, "retryDelayFor");
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(sleep, "sleep");
 function attemptLogPath(logsDir, ticket, attempt, ext) {
   const stem = ticket.filename.replace(/\.md$/, "");
   const suffix = attempt > 1 ? `.attempt${attempt}` : "";
   return join(logsDir, `${stem}${suffix}${ext}`);
 }
 __name(attemptLogPath, "attemptLogPath");
+function historyFor(learningsPath, ticket) {
+  const featureDir = dirname(dirname(ticket.filepath));
+  const scratchDir = ticket.feature ? join(featureDir, ...ticket.feature.split("/").map(() => "..")) : dirname(featureDir);
+  const others = new Set(
+    ticket.blockers.map((r) => r.feature).filter((f) => f !== ticket.feature)
+  );
+  const entries = [
+    ...readEntries(learningsPath),
+    ...[...others].flatMap((f) => readEntries(
+      join(scratchDir, f, "learnings.md")
+    ))
+  ];
+  return renderHistory(selectHistory(entries, {
+    key: ticketKey(ticket.feature, ticket.num),
+    blockerKeys: ticket.blockers.map((r) => {
+      return ticketKey(r.feature, r.num);
+    })
+  }));
+}
+__name(historyFor, "historyFor");
+function buildHistory(learningsPath, ticket, d) {
+  try {
+    return historyFor(learningsPath, ticket);
+  } catch (err) {
+    d.log(
+      `  ${ticket.filename}: could not read learnings: ${formatErrorMessage(err)}`
+    );
+    return "";
+  }
+}
+__name(buildHistory, "buildHistory");
 async function runTicketAttempt(opts) {
   const { ticket, d } = opts;
   let worktree;
@@ -1154,6 +1315,38 @@ async function runTicketAttempt(opts) {
     "in-progress",
     ticket.feature
   );
+  if (opts.installCmd) {
+    const installed = await runInstall({
+      installCmd: opts.installCmd,
+      ticket,
+      worktreePath: worktree.worktreePath,
+      timeout: opts.timeout,
+      logsDir: opts.logsDir,
+      attempt: opts.attempt,
+      log: /* @__PURE__ */ __name((msg) => d.log(msg), "log"),
+      registry: runningAgents
+    });
+    if (!installed) {
+      await removeWorktreeQuietly(
+        worktree.worktreePath,
+        d
+      );
+      return {
+        kind: "failed",
+        reason: "install",
+        branchName: worktree.branchName,
+        exitCode: 1,
+        completedItems: []
+      };
+    }
+  }
+  try {
+    ensureNotesIgnored(worktree.worktreePath);
+  } catch (err) {
+    d.log(
+      `  ${ticket.filename}: could not set up the notes directory: ${formatErrorMessage(err)}`
+    );
+  }
   const ticketSpec = lookupSpec(
     opts.specBodies,
     opts.specBody,
@@ -1163,7 +1356,18 @@ async function runTicketAttempt(opts) {
     prompt: renderPrompt(
       ticketSpec,
       ticket,
-      { testCmd: opts.testCmd }
+      {
+        testCmd: opts.testCmd,
+        installCmd: opts.installCmd,
+        // Rebuilt every attempt, so a retry sees the
+        // entry its previous attempt just wrote
+        history: buildHistory(
+          opts.learningsPath,
+          ticket,
+          d
+        ),
+        preferSubagent: opts.preferSubagent
+      }
     ),
     agentCmd: opts.agentCmd,
     model: opts.model,
@@ -1178,8 +1382,27 @@ async function runTicketAttempt(opts) {
     label: ticket.filename.replace(/\.md$/, ""),
     maxTurns: opts.maxTurns,
     effort: opts.effort,
+    preferSubagent: opts.preferSubagent,
+    onStats: opts.onStats,
     onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
   });
+  opts.onAgentRun?.(agentResult);
+  let notes = null;
+  try {
+    notes = collectNotes(worktree.worktreePath);
+  } catch (err) {
+    d.log(
+      `  ${ticket.filename}: could not collect notes: ${formatErrorMessage(err)}`
+    );
+  }
+  const agentRun = {
+    exitCode: agentResult.exitCode,
+    completedItems: agentResult.completedItems,
+    timedOut: agentResult.timedOut,
+    notes,
+    ...agentResult.subagents === void 0 ? {} : { subagents: agentResult.subagents },
+    ...agentResult.costUsd === void 0 ? {} : { costUsd: agentResult.costUsd }
+  };
   if (agentResult.timedOut) {
     d.log(
       `  ${ticket.filename}: timed out; keeping the work it committed`
@@ -1194,7 +1417,8 @@ async function runTicketAttempt(opts) {
       reason: "exit",
       branchName: worktree.branchName,
       exitCode: agentResult.exitCode,
-      completedItems: agentResult.completedItems
+      completedItems: agentResult.completedItems,
+      agentRun
     };
   }
   if (isDirty(worktree.worktreePath)) {
@@ -1217,7 +1441,8 @@ async function runTicketAttempt(opts) {
     return {
       kind: "no-commits",
       worktreePath: worktree.worktreePath,
-      branchName: worktree.branchName
+      branchName: worktree.branchName,
+      agentRun
     };
   }
   const passed = await runTestGate({
@@ -1240,73 +1465,189 @@ async function runTicketAttempt(opts) {
       reason: "tests",
       branchName: worktree.branchName,
       exitCode: 1,
-      completedItems: agentResult.completedItems
+      completedItems: agentResult.completedItems,
+      agentRun
     };
   }
   return {
     kind: "ready",
     worktreePath: worktree.worktreePath,
     branchName: worktree.branchName,
-    completedItems: agentResult.completedItems
+    completedItems: agentResult.completedItems,
+    agentRun
   };
 }
 __name(runTicketAttempt, "runTicketAttempt");
-async function runTicketAttempts(opts) {
-  const { ticket, d } = opts;
-  const maxAttempts = opts.retries + 1;
-  const providerName = basename(opts.agentCmd);
-  const isKnown = providerName in EFFORT_LADDERS;
-  let effort = opts.effort;
-  let outcome = {
-    kind: "no-commits",
-    worktreePath: "",
-    branchName: ""
+function readLogTail(path) {
+  try {
+    return tailLines(readFileSync(path, "utf8"), LOG_TAIL_LINES);
+  } catch {
+    return "";
+  }
+}
+__name(readLogTail, "readLogTail");
+function attemptEntry(opts) {
+  const { logsDir, ticket, attempt, effort, outcome } = opts;
+  const base = {
+    key: ticketKey(ticket.feature, ticket.num),
+    label: ticketLabel(ticket),
+    attempt,
+    now: /* @__PURE__ */ new Date()
   };
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    if (attempt === 1) {
-      d.log(`  Starting ${ticket.filename}`);
-    } else {
-      if (isKnown) {
-        effort = escalateEffort(
-          providerName,
-          effort
-        );
+  const logFor = /* @__PURE__ */ __name((ext) => {
+    const path = attemptLogPath(logsDir, ticket, attempt, ext);
+    return { logName: basename(path), logTail: readLogTail(path) };
+  }, "logFor");
+  switch (outcome.kind) {
+    case "ready":
+      return {
+        ...base,
+        outcome: "done",
+        run: outcome.agentRun,
+        effort
+      };
+    case "failed":
+      switch (outcome.reason) {
+        case "exit":
+          return {
+            ...base,
+            outcome: "exit",
+            run: outcome.agentRun,
+            effort
+          };
+        case "tests":
+          return {
+            ...base,
+            outcome: "tests",
+            run: outcome.agentRun,
+            effort,
+            ...logFor(".test.log")
+          };
+        case "install":
+          return {
+            ...base,
+            outcome: "install",
+            ...logFor(".install.log")
+          };
+        default: {
+          const _exhaustive = outcome;
+          return _exhaustive;
+        }
       }
-      const delay = retryDelayFor(opts.retryDelay, attempt);
-      d.log(
-        `  ${ticket.filename}: retrying (attempt ${attempt}/${maxAttempts}` + (isKnown && effort ? `, effort ${effort}` : "") + (delay > 0 ? `, waiting ${delay}s` : "") + ")"
-      );
-      if (delay > 0) await sleep(delay * 1e3);
+    case "no-commits":
+      return {
+        ...base,
+        outcome: "no-commits",
+        run: outcome.agentRun,
+        effort
+      };
+    case "error":
+    case "worktree-error":
+      return {
+        ...base,
+        outcome: "error",
+        error: formatErrorMessage(outcome.error)
+      };
+    default: {
+      const _exhaustive = outcome;
+      return _exhaustive;
     }
+  }
+}
+__name(attemptEntry, "attemptEntry");
+function recordAttempt(opts) {
+  try {
+    const entry = attemptEntry(opts);
+    if (!entry) return;
+    appendEntry(opts.learningsPath, renderEntry(entry));
+  } catch (err) {
+    opts.d.log(
+      `  ${opts.ticket.filename}: could not record learnings: ${formatErrorMessage(err)}`
+    );
+  }
+}
+__name(recordAttempt, "recordAttempt");
+async function runTicketAttempts(opts) {
+  const { ticket, d } = opts;
+  let prior = { subagents: 0 };
+  const showStats = /* @__PURE__ */ __name((stats) => {
+    d.setTicketStats(ticket.num, ticket.feature, stats);
+  }, "showStats");
+  return runWithRetries({
+    maxAttempts: opts.retries + 1,
+    retryDelay: opts.retryDelay,
+    agentCmd: opts.agentCmd,
+    effort: opts.effort,
+    label: ticket.filename,
+    log: /* @__PURE__ */ __name((msg) => d.log(msg), "log")
+  }, async (attempt, effort) => {
+    const record = /* @__PURE__ */ __name((o) => {
+      recordAttempt({
+        learningsPath: opts.learningsPath,
+        logsDir: opts.logsDir,
+        ticket,
+        attempt,
+        effort,
+        outcome: o,
+        d
+      });
+    }, "record");
+    let outcome;
     try {
       outcome = await runTicketAttempt({
         ...opts,
         attempt,
-        effort
+        effort,
+        onStats: /* @__PURE__ */ __name((stats) => showStats(addStats(prior, stats)), "onStats"),
+        onAgentRun: /* @__PURE__ */ __name((result) => {
+          prior = addStats(prior, result);
+          opts.onAgentRun?.(result);
+        }, "onAgentRun")
       });
     } catch (error) {
       d.log(
         `  ${ticket.filename}: attempt ${attempt} threw: ${formatErrorMessage(error)}`
       );
-      return { kind: "error", error };
+      const errorOutcome = { kind: "error", error };
+      record(errorOutcome);
+      return { result: errorOutcome, stop: true };
     }
+    record(outcome);
     if (outcome.kind === "ready") {
       d.setTicketStatus(
         ticket.num,
         "awaiting-merge",
         ticket.feature
       );
-      return outcome;
+      return { result: outcome, stop: true };
     }
-    if (outcome.kind === "worktree-error") return outcome;
-  }
-  return outcome;
+    return {
+      result: outcome,
+      stop: outcome.kind === "worktree-error"
+    };
+  });
 }
 __name(runTicketAttempts, "runTicketAttempts");
+function failureNote(reason) {
+  if (reason === "tests") return "tests failed";
+  if (reason === "install") return "install failed";
+  return "failed";
+}
+__name(failureNote, "failureNote");
+function isRegularFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+__name(isRegularFile, "isRegularFile");
 async function saveProgress(repoRoot, progressPath, progress, message, d) {
   writeProgress(progressPath, progress);
+  const learningsPath = learningsPathFor(progressPath);
+  const paths = isRegularFile(learningsPath) ? [progressPath, learningsPath] : progressPath;
   try {
-    await commitProgress(repoRoot, progressPath, message);
+    await commitProgress(repoRoot, paths, message);
   } catch (err) {
     d.log(
       "  Failed to commit progress: " + formatErrorMessage(err)
@@ -1319,15 +1660,77 @@ function indentFilenames(tickets) {
   return tickets.map((t) => `  ${t.filename}`).join("\n");
 }
 __name(indentFilenames, "indentFilenames");
-function renderFinishSummary(tickets, totalCompleted, failedKeys) {
+function explainOpen(tickets, failedKeys, warnings) {
   const remaining = tickets.filter(
     (t) => t.status === "ready-for-agent"
   );
+  const open = remaining.filter(
+    (t) => !failedKeys.has(ticketKey(t.feature, t.num))
+  );
+  const dead = findBlockedTickets(tickets, failedKeys);
+  const deadRefs = /* @__PURE__ */ __name((t) => dead.get(ticketKey(t.feature, t.num)) ?? [], "deadRefs");
+  const lines = [];
   const human = tickets.filter((t) => t.status === HUMAN_STATUS);
-  const humanNums = new Set(human.map((t) => t.num));
-  const blockedByHuman = remaining.filter(
-    (t) => !failedKeys.has(ticketKey(t.feature, t.num)) && t.blockers.some((b) => humanNums.has(b))
+  if (human.length > 0) {
+    const humanKeys = new Set(
+      human.map((t) => ticketKey(t.feature, t.num))
+    );
+    const blockedByHuman = open.filter((t) => deadRefs(t).some(
+      (r) => humanKeys.has(ticketKey(r.feature, r.num))
+    ));
+    const noun = human.length === 1 ? "ticket is" : "tickets are";
+    lines.push(
+      "",
+      (remaining.length === 0 && failedKeys.size === 0 ? `All remaining ${noun} marked ${HUMAN_STATUS}. ` : `${human.length} ${noun} marked ${HUMAN_STATUS}. `) + "nightralph only runs ready-for-agent tickets, so an agent cannot finish these:",
+      indentFilenames(human)
+    );
+    if (blockedByHuman.length > 0) {
+      const n = blockedByHuman.length;
+      lines.push(
+        `${n} ready-for-agent ticket${n === 1 ? " is" : "s are"} blocked until they are done:`,
+        indentFilenames(blockedByHuman)
+      );
+    }
+    lines.push(
+      "Do that work by hand, then set each ticket's **Status:** to done" + (blockedByHuman.length > 0 ? " and run nightralph again." : ".")
+    );
+  }
+  const blockers = [];
+  const outside = open.filter(
+    (t) => deadRefs(t).some((r) => r.where === "pending")
+  );
+  if (outside.length > 0) {
+    const n = outside.length;
+    blockers.push(
+      `${n} ready-for-agent ticket${n === 1 ? " waits" : "s wait"} on tickets outside this run. Select those features too, or finish them first:`,
+      ...outside.map((t) => `  ${ticketLabel(toRef(t))} waits on ` + deadRefs(t).filter((r) => r.where === "pending").map(blockerLabel).join(", "))
+    );
+  }
+  const missing = open.flatMap((t) => t.blockers.filter((r) => r.where === "missing").map((r) => `  ${ticketLabel(toRef(t))}: ${blockerLabel(r)}`));
+  if (missing.length > 0) {
+    const n = missing.length;
+    blockers.push(
+      `${n} blocker reference${n === 1 ? "" : "s"} match no ticket. Fix the **Blocked by:** line:`,
+      ...missing
+    );
+  }
+  const typos = warnings.filter((w) => w.kind === "typo");
+  if (typos.length > 0) {
+    const n = typos.length;
+    blockers.push(
+      `${n} word${n === 1 ? "" : "s"} in a **Blocked by:** line look${n === 1 ? "s" : ""} like a feature name but match no .scratch/<name>/issues directory:`,
+      ...typos.map((w) => `  ${w.ticket}: ${w.text}`)
+    );
+  }
+  if (blockers.length > 0) lines.push("", ...blockers);
+  return lines;
+}
+__name(explainOpen, "explainOpen");
+function renderFinishSummary(tickets, totalCompleted, failedKeys, warnings = []) {
+  const remaining = tickets.filter(
+    (t) => t.status === "ready-for-agent"
   );
+  const human = tickets.filter((t) => t.status === HUMAN_STATUS);
   const counts = `Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "") + (failedKeys.size > 0 ? `, ${failedKeys.size} failed` : "") + (human.length > 0 ? `, ${human.length} need a human` : "");
   const lines = [counts];
   const features = new Set(
@@ -1356,26 +1759,54 @@ function renderFinishSummary(tickets, totalCompleted, failedKeys) {
       lines.push(detail);
     }
   }
-  if (human.length === 0) return lines.join("\n");
-  const noun = human.length === 1 ? "ticket is" : "tickets are";
-  lines.push(
-    "",
-    (remaining.length === 0 && failedKeys.size === 0 ? `All remaining ${noun} marked ${HUMAN_STATUS}. ` : `${human.length} ${noun} marked ${HUMAN_STATUS}. `) + "nightralph only runs ready-for-agent tickets, so an agent cannot finish these:",
-    indentFilenames(human)
+  lines.push(...explainOpen(tickets, failedKeys, warnings));
+  return lines.join("\n");
+}
+__name(renderFinishSummary, "renderFinishSummary");
+function nothingReady(tickets) {
+  return findReadyTickets(tickets).length === 0 && tickets.some((t) => t.status === "ready-for-agent");
+}
+__name(nothingReady, "nothingReady");
+function renderNothingReady(tickets, warnings) {
+  const lines = [
+    "Nothing to run: every ready-for-agent ticket is waiting on a blocker.",
+    ...explainOpen(tickets, /* @__PURE__ */ new Set(), warnings)
+  ];
+  const dead = findBlockedTickets(tickets, /* @__PURE__ */ new Set());
+  const byKey = new Map(
+    tickets.map((t) => [ticketKey(t.feature, t.num), t])
   );
-  if (blockedByHuman.length > 0) {
-    const n = blockedByHuman.length;
+  const other = [];
+  for (const [key, refs] of dead) {
+    const stuck = refs.flatMap((r) => {
+      const b = byKey.get(ticketKey(r.feature, r.num));
+      return b && b.status !== HUMAN_STATUS ? [`${ticketLabel(toRef(b))} (${b.status})`] : [];
+    });
+    const t = byKey.get(key);
+    if (t && stuck.length > 0) {
+      other.push(
+        `  ${ticketLabel(toRef(t))} waits on ` + stuck.join(", ")
+      );
+    }
+  }
+  if (other.length > 0) {
     lines.push(
-      `${n} ready-for-agent ticket${n === 1 ? " is" : "s are"} blocked until they are done:`,
-      indentFilenames(blockedByHuman)
+      "",
+      "These tickets wait on tickets that are not ready-for-agent:",
+      ...other,
+      "Set those tickets to ready-for-agent or done, or fix the **Blocked by:** lines."
+    );
+  }
+  const cycle = detectDeadlocks(tickets).filter((t) => !dead.has(ticketKey(t.feature, t.num)));
+  if (cycle.length > 0) {
+    lines.push(
+      "",
+      "Deadlocked tickets (waiting on each other): " + cycle.map((t) => ticketLabel(toRef(t))).join(", ") + ". Fix their **Blocked by:** lines."
     );
   }
-  lines.push(
-    "Do that work by hand, then set each ticket's **Status:** to done" + (blockedByHuman.length > 0 ? " and run nightralph again." : ".")
-  );
   return lines.join("\n");
 }
-__name(renderFinishSummary, "renderFinishSummary");
+__name(renderNothingReady, "renderNothingReady");
 function sessionTickets(tickets) {
   return [...tickets].filter((t) => t.status === "ready-for-agent").sort((a, b) => a.feature.localeCompare(b.feature) || a.num - b.num);
 }
@@ -1394,7 +1825,10 @@ function reportBlocked(d, tickets, failedKeys) {
   )) {
     const ticket = byKey.get(key);
     if (!ticket) continue;
-    const labels = dead.map((k) => byKey.get(k)).filter((t) => t !== void 0).map((t) => ticketLabel(toRef(t)));
+    const labels = dead.map((ref) => {
+      const t = byKey.get(ticketKey(ref.feature, ref.num));
+      return t ? ticketLabel(toRef(t)) : blockerLabel(ref);
+    });
     d.setBlocked(ticket.num, ticket.feature, labels);
   }
 }
@@ -1406,7 +1840,7 @@ function runProgress(tickets) {
   };
 }
 __name(runProgress, "runProgress");
-async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, testCmd, display, maxTurns, effort, retries, retryDelay, concurrency) {
+async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, testCmd, display, maxTurns, effort, retries, retryDelay, concurrency, warnings = [], preferSubagent) {
   mkdirSync(logsDir, { recursive: true });
   const d = display ?? createDisplay();
   const maxAttempts = (retries ?? DEFAULT_RETRIES) + 1;
@@ -1420,6 +1854,7 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, te
   let waveNum = 0;
   const failedKeys = /* @__PURE__ */ new Set();
   const session = sessionTickets(tickets);
+  let runStats = emptyRunStats();
   while (true) {
     if (waveNum > 0) reportBlocked(d, tickets, failedKeys);
     const ready = findReadyTickets(tickets).filter(
@@ -1450,7 +1885,7 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, te
         const prompt = renderPrompt(
           specBody,
           t,
-          { testCmd }
+          { testCmd, preferSubagent }
         );
         const label = t.filename.replace(
           /\.md$/,
@@ -1462,6 +1897,18 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, te
           t.feature
         );
         d.log(`  Starting ${t.filename}`);
+        let prior = { subagents: 0 };
+        const onStats = /* @__PURE__ */ __name((stats) => {
+          d.setTicketStats(
+            t.num,
+            t.feature,
+            addStats(prior, stats)
+          );
+        }, "onStats");
+        const tally = /* @__PURE__ */ __name((r) => {
+          prior = addStats(prior, r);
+          runStats = addRun(runStats, r);
+        }, "tally");
         let level = effort;
         let result = await spawnAgent({
           prompt,
@@ -1472,8 +1919,11 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, te
           label,
           maxTurns,
           effort: level,
+          preferSubagent,
+          onStats,
           onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
         });
+        tally(result);
         for (let attempt = 2; result.exitCode !== 0 && !result.timedOut && attempt <= maxAttempts; attempt++) {
           if (isKnown) {
             level = escalateEffort(
@@ -1500,8 +1950,11 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, te
             label,
             maxTurns,
             effort: level,
+            preferSubagent,
+            onStats,
             onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
           });
+          tally(result);
         }
         return { ticket: t, result };
       }
@@ -1560,8 +2013,11 @@ No tickets completed this wave. ${remaining2.length} ready ticket${remaining2.le
   d.log("\n" + renderFinishSummary(
     tickets,
     totalCompleted,
-    failedKeys
+    failedKeys,
+    warnings
   ));
+  const statsLine = renderRunStats(runStats);
+  if (statsLine) d.log(statsLine);
   d.cleanup();
   return { allDone: remaining.length === 0 };
 }
@@ -1582,6 +2038,7 @@ async function runWavesIsolated(opts) {
       "Working tree is dirty; commit or stash changes before running"
     );
   }
+  const launchCommit = headCommit(repoRoot);
   const features = new Set(
     opts.tickets.map((t) => t.feature).filter(Boolean)
   );
@@ -1647,6 +2104,10 @@ async function runWavesIsolated(opts) {
   let waveNum = 0;
   const failedKeys = /* @__PURE__ */ new Set();
   const session = sessionTickets(opts.tickets);
+  let runStats = emptyRunStats();
+  const onAgentRun = /* @__PURE__ */ __name((result) => {
+    runStats = addRun(runStats, result);
+  }, "onAgentRun");
   while (true) {
     if (waveNum > 0) reportBlocked(d, opts.tickets, failedKeys);
     const ready = findReadyTickets(opts.tickets).filter(
@@ -1685,13 +2146,36 @@ async function runWavesIsolated(opts) {
         timeout: opts.timeout,
         logsDir: opts.logsDir,
         testCmd: opts.testCmd,
+        installCmd: opts.installCmd,
         maxTurns: opts.maxTurns,
         effort: opts.effort,
+        preferSubagent: opts.preferSubagent,
+        learningsPath: learningsPathFor(
+          tracker.pathFor(t.feature)
+        ),
         retries,
         retryDelay,
-        d
+        d,
+        onAgentRun
       })
     );
+    const touched = new Set(ready.map((t) => {
+      return learningsPathFor(tracker.pathFor(t.feature));
+    }));
+    for (const path of touched) {
+      if (!isRegularFile(path)) continue;
+      try {
+        await commitProgress(
+          repoRoot,
+          path,
+          "nightralph: record attempt learnings"
+        );
+      } catch (err) {
+        d.log(
+          "  Failed to commit learnings: " + formatErrorMessage(err)
+        );
+      }
+    }
     const outcomes = settled.map(
       (r) => r.status === "fulfilled" ? r.value : { kind: "error", error: r.reason }
     );
@@ -1795,7 +2279,7 @@ async function runWavesIsolated(opts) {
           repoRoot,
           tracker.pathFor(ticket.feature),
           tracker.dataFor(ticket.feature),
-          `nightralph: ${ticket.filename} ` + (outcome.reason === "tests" ? "tests failed" : "failed"),
+          `nightralph: ${ticket.filename} ` + failureNote(outcome.reason),
           d
         );
         continue;
@@ -1831,6 +2315,7 @@ async function runWavesIsolated(opts) {
         branches: successfulBranches,
         strategy: opts.conflictStrategy
       });
+      const doneThisWave = [];
       for (const branchResult of mergeResult.merged) {
         const bk = branchToKey.get(
           branchResult.branch
@@ -1839,6 +2324,7 @@ async function runWavesIsolated(opts) {
         if (!ticket) continue;
         if (branchResult.merged) {
           markDone(ticket);
+          doneThisWave.push(ticket);
           waveCompleted++;
           totalCompleted++;
           d.setTicketStatus(
@@ -1888,11 +2374,15 @@ async function runWavesIsolated(opts) {
             timeout: opts.timeout,
             logsDir: opts.logsDir,
             testCmd: opts.testCmd,
+            installCmd: opts.installCmd,
             maxTurns: opts.maxTurns,
-            onLine: /* @__PURE__ */ __name((msg) => d.log(msg), "onLine")
+            preferSubagent: opts.preferSubagent,
+            onLine: /* @__PURE__ */ __name((msg) => d.log(msg), "onLine"),
+            onAgentRun
           }) : false;
           if (recovered) {
             markDone(ticket);
+            doneThisWave.push(ticket);
             waveCompleted++;
             totalCompleted++;
             d.setTicketStatus(
@@ -1948,6 +2438,28 @@ async function runWavesIsolated(opts) {
               exitCode: 0,
               done: false
             });
+            try {
+              appendEntry(
+                learningsPathFor(
+                  tracker.pathFor(ticket.feature)
+                ),
+                renderEntry({
+                  outcome: "merge",
+                  key: ticketKey(
+                    ticket.feature,
+                    ticket.num
+                  ),
+                  label: ticketLabel(ticket),
+                  attempt: 0,
+                  now: /* @__PURE__ */ new Date(),
+                  stderr: branchResult.stderr ?? ""
+                })
+              );
+            } catch (err) {
+              d.log(
+                `  ${ticket.filename}: could not record learnings: ` + formatErrorMessage(err)
+              );
+            }
             await saveProgress(
               repoRoot,
               tracker.pathFor(ticket.feature),
@@ -1958,6 +2470,7 @@ async function runWavesIsolated(opts) {
           }
         }
       }
+      await commitTicketFiles(repoRoot, doneThisWave, d);
       if (mergeResult.stoppedAt) {
         d.log(
           `
@@ -2000,16 +2513,64 @@ No tickets completed this wave. ${remaining2.length} ready ticket${remaining2.le
     }
   }
   if (waveNum > 0) reportBlocked(d, opts.tickets, failedKeys);
+  let reviewLine = null;
+  if (opts.review) {
+    try {
+      const outcome = await runReviewPass({
+        repoRoot,
+        repoName,
+        baseBranch,
+        reviewPath: opts.review.reviewPath,
+        forkedFrom: opts.review.forkedFrom,
+        launchCommit,
+        specBody: reviewSpecBody(
+          opts.specBody,
+          opts.specBodies
+        ),
+        agentCmd: opts.agentCmd,
+        model: opts.model,
+        timeout: opts.timeout,
+        logsDir: opts.logsDir,
+        testCmd: opts.testCmd,
+        installCmd: opts.installCmd,
+        maxTurns: opts.maxTurns,
+        effort: opts.effort,
+        preferSubagent: opts.preferSubagent,
+        retries,
+        retryDelay,
+        log: /* @__PURE__ */ __name((msg) => d.log(msg), "log")
+      }, {
+        spawnAgent: /* @__PURE__ */ __name(async (spawnOpts) => {
+          const result = await spawnAgent(spawnOpts);
+          onAgentRun(result);
+          return result;
+        }, "spawnAgent"),
+        registry: runningAgents
+      });
+      reviewLine = renderReviewSummary(
+        outcome,
+        relative(repoRoot, opts.review.reviewPath)
+      );
+    } catch (err) {
+      d.log(`
+Review failed: ${formatErrorMessage(err)}`);
+    }
+  }
   const remaining = opts.tickets.filter(
     (t) => t.status === "ready-for-agent"
   );
   d.log("\n" + renderFinishSummary(
     opts.tickets,
     totalCompleted,
-    failedKeys
+    failedKeys,
+    opts.warnings ?? []
   ));
+  const statsLine = renderRunStats(runStats);
+  if (statsLine) d.log(statsLine);
+  if (reviewLine) d.log(reviewLine);
+  d.log(`Work is on ${baseBranch}`);
   d.cleanup();
-  return { allDone: remaining.length === 0 };
+  return { allDone: remaining.length === 0, branch: baseBranch };
 }
 __name(runWavesIsolated, "runWavesIsolated");
 export {
@@ -2018,31 +2579,35 @@ export {
   DEFAULT_CONCURRENCY,
   DEFAULT_RETRIES,
   DEFAULT_RETRY_DELAY,
-  EFFORT_LADDERS,
+  EFFORT_LADDERS2 as EFFORT_LADDERS,
   HUMAN_STATUS,
   TICKET_RE,
   TOOL_USE_RE,
+  blockerLabel,
+  blockerSatisfied,
   checkItems,
   createPiStreamFormatter,
   dryRun,
   dryRunIsolated,
-  escalateEffort,
+  escalateEffort2 as escalateEffort,
   findBlockedTickets,
   findReadyTickets,
   formatErrorMessage,
   formatStreamLine,
   getProviderArgs,
+  historyFor,
   killProcessGroup,
   killRunningAgents,
   lookupSpec,
   markDone,
-  parseBlockers,
+  nothingReady,
   parseStatus,
   parseTicketFilename,
   renderFinishSummary,
   renderMergePrompt,
+  renderNothingReady,
   renderPrompt,
-  retryDelayFor,
+  retryDelayFor2 as retryDelayFor,
   runPool,
   runWaves,
   runWavesIsolated,