nightralph 0.0.19 → 0.0.21

package/dist/orchestrator.js

@@ -38,10 +38,21 @@ import {
 import {
   createDisplay
 } from "./display.js";
+import { runTestCmd } from "./testcmd.js";
 function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 __name(formatErrorMessage, "formatErrorMessage");
+async function removeWorktreeQuietly(worktreePath, d) {
+  try {
+    await removeWorktree(worktreePath, { force: true });
+  } catch (err) {
+    d.log(
+      `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
+    );
+  }
+}
+__name(removeWorktreeQuietly, "removeWorktreeQuietly");
 const TICKET_RE = /^(\d+)-(.+)\.md$/;
 function parseTicketFilename(filename) {
   const m = filename.match(TICKET_RE);
@@ -132,7 +143,39 @@ function markDone(ticket) {
   ticket.body = updated;
 }
 __name(markDone, "markDone");
-function renderPrompt(specBody, ticket) {
+function stripSpecSection(specBody, heading) {
+  const out = [];
+  let skipping = false;
+  let skipLevel = 0;
+  let inFence = false;
+  for (const line of specBody.split("\n")) {
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+    }
+    if (!inFence) {
+      const m = /^(#{1,6})\s+(.*?)\s*$/.exec(line);
+      if (m) {
+        const level = m[1].length;
+        if (skipping && level <= skipLevel) {
+          skipping = false;
+        }
+        if (!skipping && m[2] === heading) {
+          skipping = true;
+          skipLevel = level;
+          continue;
+        }
+      }
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n");
+}
+__name(stripSpecSection, "stripSpecSection");
+function renderPrompt(specBody, ticket, opts = {}) {
+  const testRules = opts.testCmd ? [
+    "- Work test-first. For each checklist 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.",
+    `- Run \`${opts.testCmd}\` before committing. Do not commit with failing tests. The orchestrator runs the same command after you exit and rejects the ticket if it fails.`
+  ] : [];
   return [
     "---- SPEC CONTEXT ----",
     specBody,
@@ -144,10 +187,12 @@ function renderPrompt(specBody, ticket) {
     "---- AGENT INSTRUCTIONS ----",
     "You are an autonomous coding agent. Implement the ticket.",
     "",
-    "Time is limited. Follow these rules:",
-    "- Spend at most 2 minutes reading existing code. Read only the files directly relevant to the ticket.",
+    "Follow these rules:",
+    "- Read the files directly relevant to the ticket before writing code.",
     "- Do NOT research external APIs or services via web search. Use the spec and ticket body as your sole reference for API shapes.",
-    "- Start writing code as soon as you understand the immediate context. You can read more files as needed while implementing.",
+    ...testRules,
+    "- Do NOT read or modify files outside your current directory (the worktree).",
+    "- Do NOT run git push.",
     "- Commit your work when finished.",
     "- After completing each checklist item in the ticket, print a line: [x] <item text> (matching the checklist text exactly).",
     ""
@@ -173,7 +218,8 @@ function renderMergePrompt(specBody, ticket) {
     "2. Make sure the code compiles and tests pass.",
     "3. Commit the resolved files.",
     "",
-    "Do NOT re-implement the ticket from scratch."
+    "Do NOT re-implement the ticket from scratch.",
+    "Do NOT run git push."
   ].join("\n");
 }
 __name(renderMergePrompt, "renderMergePrompt");
@@ -252,7 +298,11 @@ const PROVIDER_ARGS = {
     "stream-json",
     "--dangerously-skip-permissions"
   ],
-  codex: ["exec", "--full-auto"],
+  // codex removed --full-auto; this is the counterpart
+  // of claude's --dangerously-skip-permissions, and the
+  // workspace-write sandbox would block commits because
+  // a worktree's .git link points outside the tree
+  codex: ["exec", "--dangerously-bypass-approvals-and-sandbox"],
   pi: [
     "-p",
     "--verbose",
@@ -267,6 +317,21 @@ function getProviderArgs(cmd) {
   return PROVIDER_ARGS[name] ?? [];
 }
 __name(getProviderArgs, "getProviderArgs");
+const THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function escalateThinking(level) {
+  if (!level) return "high";
+  const i = THINKING_LEVELS.indexOf(level);
+  return THINKING_LEVELS[Math.min(i + 1, THINKING_LEVELS.length - 1)];
+}
+__name(escalateThinking, "escalateThinking");
 function formatStreamLine(line) {
   let obj;
   try {
@@ -318,7 +383,7 @@ function createPiStreamFormatter() {
     return [out];
   }
   __name(flushBuf, "flushBuf");
-  function process(line) {
+  function process2(line) {
     let obj;
     try {
       obj = JSON.parse(line);
@@ -361,8 +426,8 @@ function createPiStreamFormatter() {
     }
     return [];
   }
-  __name(process, "process");
-  return { process, flush: flushBuf };
+  __name(process2, "process");
+  return { process: process2, flush: flushBuf };
 }
 __name(createPiStreamFormatter, "createPiStreamFormatter");
 function writePromptFile(prompt) {
@@ -379,6 +444,22 @@ function cleanupPromptFile(filePath) {
   }
 }
 __name(cleanupPromptFile, "cleanupPromptFile");
+const CLOSE_GRACE_MS = 2e3;
+function killProcessGroup(pid) {
+  if (pid === void 0) return;
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+  }
+}
+__name(killProcessGroup, "killProcessGroup");
+const runningAgents = /* @__PURE__ */ new Set();
+function killRunningAgents() {
+  for (const pid of runningAgents) {
+    killProcessGroup(pid);
+  }
+}
+__name(killRunningAgents, "killRunningAgents");
 function spawnAgent(opts) {
   const args = [
     ...getProviderArgs(opts.agentCmd)
@@ -386,9 +467,15 @@ function spawnAgent(opts) {
   if (opts.model) {
     args.push("--model", opts.model);
   }
+  if (opts.maxTurns) {
+    args.push("--max-turns", String(opts.maxTurns));
+  }
   const providerName = basename(opts.agentCmd);
   const isClaude = providerName === "claude";
   const isPi = providerName === "pi";
+  if (isPi && opts.thinking) {
+    args.push("--thinking", opts.thinking);
+  }
   const prefix = opts.label ? `  [${opts.label}] ` : "  ";
   let promptFile = null;
   if (isPi) {
@@ -401,8 +488,10 @@ function spawnAgent(opts) {
   );
   const proc = spawn(opts.agentCmd, args, {
     stdio: ["pipe", "pipe", "pipe"],
-    cwd: opts.cwd
+    cwd: opts.cwd,
+    detached: true
   });
+  if (proc.pid !== void 0) runningAgents.add(proc.pid);
   proc.stdout.pipe(logStream);
   const piFormatter = isPi ? createPiStreamFormatter() : null;
   const completedItems = [];
@@ -456,21 +545,41 @@ function spawnAgent(opts) {
       console.error(output);
     }
   });
+  let timedOut = false;
   const timeout = setTimeout(() => {
-    if (!proc.killed) {
-      console.warn(
-        `Agent did not exit in ${opts.timeout}s; killing.`
-      );
-      proc.kill("SIGKILL");
+    if (proc.killed) return;
+    timedOut = true;
+    const msg = `agent timed out after ${opts.timeout}s; killing it`;
+    logStream.write(`nightralph: ${msg}
+`);
+    if (opts.onLine) {
+      opts.onLine(`${prefix}${msg}`);
+    } else {
+      console.warn(`${prefix}${msg}`);
     }
+    killProcessGroup(proc.pid);
   }, opts.timeout * 1e3);
+  proc.stdin.on("error", (err) => {
+    logStream.write(
+      `nightralph: stdin write failed: ${formatErrorMessage(err)}
+`
+    );
+  });
   if (!promptFile) {
     proc.stdin.write(opts.prompt);
   }
   proc.stdin.end();
   return new Promise((resolve) => {
-    proc.on("close", (code) => {
+    let settled = false;
+    let graceTimer;
+    function finish(exitCode) {
+      if (settled) return;
+      settled = true;
       clearTimeout(timeout);
+      if (graceTimer) clearTimeout(graceTimer);
+      if (proc.pid !== void 0) {
+        runningAgents.delete(proc.pid);
+      }
       if (piFormatter) {
         for (const line of piFormatter.flush()) {
           collectCompleted(line);
@@ -486,13 +595,27 @@ function spawnAgent(opts) {
       rlErr.close();
       logStream.end();
       if (promptFile) cleanupPromptFile(promptFile);
-      resolve({
-        exitCode: code ?? 1,
-        completedItems
-      });
+      resolve({ exitCode, completedItems, timedOut });
+    }
+    __name(finish, "finish");
+    proc.on("exit", (code) => {
+      graceTimer = setTimeout(() => {
+        proc.stdout.destroy();
+        proc.stderr.destroy();
+        finish(code ?? 1);
+      }, CLOSE_GRACE_MS);
+    });
+    proc.on("close", (code) => {
+      finish(code ?? 1);
     });
     proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      if (graceTimer) clearTimeout(graceTimer);
       clearTimeout(timeout);
+      if (proc.pid !== void 0) {
+        runningAgents.delete(proc.pid);
+      }
       rl.close();
       rlErr.close();
       logStream.end();
@@ -501,7 +624,11 @@ function spawnAgent(opts) {
         "Agent process error:",
         formatErrorMessage(err)
       );
-      resolve({ exitCode: 1, completedItems });
+      resolve({
+        exitCode: 1,
+        completedItems,
+        timedOut
+      });
     });
   });
 }
@@ -564,18 +691,65 @@ Prompt for first ready ticket (${firstReady[0].filename}):
 `
     );
     console.log(
-      renderPrompt(opts.specBody, firstReady[0])
+      renderPrompt(
+        opts.specBody,
+        firstReady[0],
+        { testCmd: opts.testCmd }
+      )
     );
   }
   const strategyDesc = opts.conflictStrategy === "respawn" ? "respawn (re-run agent on conflict)" : "stop (stop merging on conflict)";
   console.log(
     `
+Test command: ${opts.testCmd ?? "(none)"}`
+  );
+  console.log(
+    `Thinking:     ${opts.thinking ?? "(provider default)"}`
+  );
+  console.log(
+    `Retries:      ${opts.retries ?? DEFAULT_RETRIES}`
+  );
+  console.log(
+    `Retry delay:  ${opts.retryDelay ?? DEFAULT_RETRY_DELAY}s`
+  );
+  console.log(
+    `
 Merge strategy: ${strategyDesc}`
   );
   console.log(`Progress file: ${opts.progressPath}`);
 }
 __name(dryRunIsolated, "dryRunIsolated");
+async function runTestGate(opts) {
+  const result = await runTestCmd({
+    cmd: opts.testCmd,
+    cwd: opts.worktreePath,
+    timeout: opts.timeout
+  });
+  const testLogPath = attemptLogPath(
+    opts.logsDir,
+    opts.ticket,
+    opts.attempt ?? 1,
+    ".test.log"
+  );
+  writeFileSync(testLogPath, result.output);
+  if (result.exitCode !== 0) {
+    opts.log(
+      `  ${opts.ticket.filename}: tests failed (exit ${result.exitCode}); see ${testLogPath}`
+    );
+    return false;
+  }
+  opts.log(`  ${opts.ticket.filename}: tests passed`);
+  return true;
+}
+__name(runTestGate, "runTestGate");
 async function respawnAndRetryMerge(opts) {
+  const log = /* @__PURE__ */ __name((msg) => {
+    if (opts.onLine) {
+      opts.onLine(msg);
+    } else {
+      console.log(msg);
+    }
+  }, "log");
   await updateWorktreeFromBase(
     opts.worktreePath,
     opts.baseBranch
@@ -606,6 +780,7 @@ async function respawnAndRetryMerge(opts) {
     logPath,
     cwd: opts.worktreePath,
     label,
+    maxTurns: opts.maxTurns,
     onLine: opts.onLine
   });
   if (result.exitCode !== 0) {
@@ -617,6 +792,22 @@ async function respawnAndRetryMerge(opts) {
     }
     return false;
   }
+  if (opts.testCmd) {
+    const passed = await runTestGate({
+      testCmd: opts.testCmd,
+      ticket: opts.ticket,
+      worktreePath: opts.worktreePath,
+      timeout: opts.timeout,
+      logsDir: opts.logsDir,
+      log
+    });
+    if (!passed) {
+      log(
+        `  ${opts.ticket.filename}: tests failed after conflict respawn; not merging`
+      );
+      return false;
+    }
+  }
   const mergeResult = await mergeBranch(
     opts.repoRoot,
     opts.branch
@@ -640,6 +831,171 @@ async function respawnAndRetryMerge(opts) {
   return mergeResult.success;
 }
 __name(respawnAndRetryMerge, "respawnAndRetryMerge");
+const DEFAULT_RETRIES = 2;
+const DEFAULT_RETRY_DELAY = 30;
+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");
+async function runTicketAttempt(opts) {
+  const { ticket, d } = opts;
+  let worktree;
+  try {
+    worktree = await createWorktree({
+      repoRoot: opts.repoRoot,
+      repoName: opts.repoName,
+      baseBranch: opts.baseBranch,
+      ticket
+    });
+  } catch (error) {
+    return { kind: "worktree-error", error };
+  }
+  d.setTicketStatus(ticket.num, "in-progress");
+  const agentResult = await spawnAgent({
+    prompt: renderPrompt(
+      opts.specBody,
+      ticket,
+      { testCmd: opts.testCmd }
+    ),
+    agentCmd: opts.agentCmd,
+    model: opts.model,
+    timeout: opts.timeout,
+    logPath: attemptLogPath(
+      opts.logsDir,
+      ticket,
+      opts.attempt,
+      ".log"
+    ),
+    cwd: worktree.worktreePath,
+    label: ticket.filename.replace(/\.md$/, ""),
+    maxTurns: opts.maxTurns,
+    thinking: opts.thinking,
+    onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
+  });
+  if (agentResult.timedOut) {
+    d.log(
+      `  ${ticket.filename}: timed out; keeping the work it committed`
+    );
+  } else if (agentResult.exitCode !== 0) {
+    d.log(
+      `  ${ticket.filename}: agent exited ${agentResult.exitCode}`
+    );
+    await removeWorktreeQuietly(worktree.worktreePath, d);
+    return {
+      kind: "failed",
+      reason: "exit",
+      branchName: worktree.branchName,
+      exitCode: agentResult.exitCode,
+      completedItems: agentResult.completedItems
+    };
+  }
+  if (isDirty(worktree.worktreePath)) {
+    const committed = await commitDirty(
+      worktree.worktreePath,
+      `nightralph: auto-commit ${ticket.filename} remaining changes`
+    );
+    if (committed) {
+      d.log(
+        `  ${ticket.filename}: auto-committed remaining changes`
+      );
+    }
+  }
+  if (!hasNewCommits(
+    opts.repoRoot,
+    opts.baseBranch,
+    worktree.branchName
+  )) {
+    return { kind: "no-commits" };
+  }
+  if (opts.testCmd) {
+    const passed = await runTestGate({
+      testCmd: opts.testCmd,
+      ticket,
+      worktreePath: worktree.worktreePath,
+      timeout: opts.timeout,
+      logsDir: opts.logsDir,
+      attempt: opts.attempt,
+      log: /* @__PURE__ */ __name((msg) => d.log(msg), "log")
+    });
+    if (!passed) {
+      await removeWorktreeQuietly(
+        worktree.worktreePath,
+        d
+      );
+      return {
+        kind: "failed",
+        reason: "tests",
+        branchName: worktree.branchName,
+        exitCode: 1,
+        completedItems: agentResult.completedItems
+      };
+    }
+  }
+  return {
+    kind: "ready",
+    worktreePath: worktree.worktreePath,
+    branchName: worktree.branchName,
+    completedItems: agentResult.completedItems
+  };
+}
+__name(runTicketAttempt, "runTicketAttempt");
+async function runTicketAttempts(opts) {
+  const { ticket, d } = opts;
+  const maxAttempts = opts.retries + 1;
+  const isPi = basename(opts.agentCmd) === "pi";
+  let thinking = opts.thinking;
+  let outcome = { kind: "no-commits" };
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt === 1) {
+      d.log(`  Starting ${ticket.filename}`);
+    } else {
+      thinking = escalateThinking(thinking);
+      const delay = retryDelayFor(opts.retryDelay, attempt);
+      d.log(
+        `  ${ticket.filename}: retrying (attempt ${attempt}/${maxAttempts}` + (isPi ? `, thinking ${thinking}` : "") + (delay > 0 ? `, waiting ${delay}s` : "") + ")"
+      );
+      if (delay > 0) await sleep(delay * 1e3);
+    }
+    try {
+      outcome = await runTicketAttempt({
+        ...opts,
+        attempt,
+        thinking
+      });
+    } catch (error) {
+      d.log(
+        `  ${ticket.filename}: attempt ${attempt} threw: ${formatErrorMessage(error)}`
+      );
+      return { kind: "error", error };
+    }
+    if (outcome.kind === "ready" || outcome.kind === "worktree-error") {
+      return outcome;
+    }
+  }
+  return outcome;
+}
+__name(runTicketAttempts, "runTicketAttempts");
+async function saveProgress(repoRoot, progressPath, progress, message, d) {
+  writeProgress(progressPath, progress);
+  try {
+    await commitProgress(repoRoot, progressPath, message);
+  } catch (err) {
+    d.log(
+      "  Failed to commit progress: " + formatErrorMessage(err)
+    );
+  }
+}
+__name(saveProgress, "saveProgress");
 function runProgress(tickets) {
   return {
     completed: tickets.filter((t) => t.status === "done").length,
@@ -647,15 +1003,21 @@ function runProgress(tickets) {
   };
 }
 __name(runProgress, "runProgress");
-async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, display) {
+async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, display, maxTurns, thinking, retries, retryDelay) {
   mkdirSync(logsDir, { recursive: true });
   const d = display ?? createDisplay();
+  const maxAttempts = (retries ?? DEFAULT_RETRIES) + 1;
+  const delayBase = retryDelay ?? 0;
+  const isPi = basename(agentCmd) === "pi";
   let totalWaves = 0;
   for (const _ of simulateWaves(tickets)) totalWaves++;
   let totalCompleted = 0;
   let waveNum = 0;
+  const failedNums = /* @__PURE__ */ new Set();
   while (true) {
-    const ready = findReadyTickets(tickets);
+    const ready = findReadyTickets(tickets).filter(
+      (t) => !failedNums.has(t.num)
+    );
     if (ready.length === 0) break;
     waveNum++;
     const readyNums = new Set(ready.map((t) => t.num));
@@ -678,25 +1040,48 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, di
     const results = await Promise.allSettled(
       ready.map(async (t) => {
         const prompt = renderPrompt(specBody, t);
-        const logPath = join(
-          logsDir,
-          t.filename.replace(/\.md$/, ".log")
-        );
         const label = t.filename.replace(
           /\.md$/,
           ""
         );
         d.setTicketStatus(t.num, "in-progress");
         d.log(`  Starting ${t.filename}`);
-        const result = await spawnAgent({
+        let level = thinking;
+        let result = await spawnAgent({
           prompt,
           agentCmd,
           model,
           timeout,
-          logPath,
+          logPath: attemptLogPath(logsDir, t, 1, ".log"),
           label,
+          maxTurns,
+          thinking: level,
           onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
         });
+        for (let attempt = 2; result.exitCode !== 0 && !result.timedOut && attempt <= maxAttempts; attempt++) {
+          level = escalateThinking(level);
+          const delay = retryDelayFor(delayBase, attempt);
+          d.log(
+            `  ${t.filename}: agent exited ${result.exitCode}; retrying (attempt ${attempt}/${maxAttempts}` + (isPi ? `, thinking ${level}` : "") + (delay > 0 ? `, waiting ${delay}s` : "") + ")"
+          );
+          if (delay > 0) await sleep(delay * 1e3);
+          result = await spawnAgent({
+            prompt,
+            agentCmd,
+            model,
+            timeout,
+            logPath: attemptLogPath(
+              logsDir,
+              t,
+              attempt,
+              ".log"
+            ),
+            label,
+            maxTurns,
+            thinking: level,
+            onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
+          });
+        }
         return { ticket: t, result };
       })
     );
@@ -705,6 +1090,7 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, di
       if (r.status === "rejected") continue;
       const { ticket, result } = r.value;
       if (result.exitCode !== 0) {
+        failedNums.add(ticket.num);
         d.setTicketStatus(ticket.num, "failed");
         d.log(
           `  ${ticket.filename}: agent exited ${result.exitCode}`
@@ -732,7 +1118,7 @@ async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, di
   );
   d.log(
     `
-Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
+Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "") + (failedNums.size > 0 ? `, ${failedNums.size} failed` : "")
   );
   d.cleanup();
   return { allDone: remaining.length === 0 };
@@ -741,6 +1127,8 @@ __name(runWaves, "runWaves");
 async function runWavesIsolated(opts) {
   mkdirSync(opts.logsDir, { recursive: true });
   const d = opts.display ?? createDisplay();
+  const retries = opts.retries ?? DEFAULT_RETRIES;
+  const retryDelay = opts.retryDelay ?? 0;
   let totalWaves = 0;
   for (const _ of simulateWaves(opts.tickets)) totalWaves++;
   const repoRoot = getRepoRoot();
@@ -759,16 +1147,23 @@ async function runWavesIsolated(opts) {
     generateProgress(opts.featureName, opts.tickets),
     readProgress(progressPath)
   );
-  writeProgress(progressPath, progress);
-  await commitProgress(
+  await saveProgress(
     repoRoot,
     progressPath,
-    `nightralph: start ${opts.featureName}`
+    progress,
+    `nightralph: start ${opts.featureName}`,
+    d
   );
+  if (!opts.testCmd) {
+    d.log("  Test gate disabled: no test command");
+  }
   let totalCompleted = 0;
   let waveNum = 0;
+  const failedNums = /* @__PURE__ */ new Set();
   while (true) {
-    const ready = findReadyTickets(opts.tickets);
+    const ready = findReadyTickets(opts.tickets).filter(
+      (t) => !failedNums.has(t.num)
+    );
     if (ready.length === 0) break;
     waveNum++;
     const readyNums = new Set(ready.map((t) => t.num));
@@ -788,125 +1183,89 @@ async function runWavesIsolated(opts) {
         filename: t.filename
       }))
     );
-    const worktreeSettled = await Promise.allSettled(
-      ready.map((t) => createWorktree({
+    const outcomes = await Promise.all(
+      ready.map((t) => runTicketAttempts({
+        ticket: t,
         repoRoot,
         repoName,
         baseBranch,
-        ticket: t
+        specBody: opts.specBody,
+        agentCmd: opts.agentCmd,
+        model: opts.model,
+        timeout: opts.timeout,
+        logsDir: opts.logsDir,
+        testCmd: opts.testCmd,
+        maxTurns: opts.maxTurns,
+        thinking: opts.thinking,
+        retries,
+        retryDelay,
+        d
       }))
     );
-    const activeTickets = [];
-    const worktrees = [];
-    for (let i = 0; i < worktreeSettled.length; i++) {
-      const settled = worktreeSettled[i];
+    let waveCompleted = 0;
+    const successfulBranches = [];
+    const ticketsByNum = /* @__PURE__ */ new Map();
+    const worktreePathsByNum = /* @__PURE__ */ new Map();
+    for (let i = 0; i < outcomes.length; i++) {
+      const outcome = outcomes[i];
       const ticket = ready[i];
-      if (settled.status === "rejected") {
+      if (outcome.kind === "worktree-error") {
+        failedNums.add(ticket.num);
         d.setTicketStatus(ticket.num, "failed");
         d.log(
-          `  ${ticket.filename}: failed to create worktree: ${formatErrorMessage(settled.reason)}`
+          `  ${ticket.filename}: failed to create worktree: ${formatErrorMessage(outcome.error)}`
         );
         continue;
       }
-      activeTickets.push(ticket);
-      worktrees.push(settled.value);
-    }
-    const results = await Promise.allSettled(
-      activeTickets.map((t, i) => {
-        const prompt = renderPrompt(opts.specBody, t);
-        const logPath = join(
-          opts.logsDir,
-          t.filename.replace(/\.md$/, ".log")
-        );
-        const label = t.filename.replace(
-          /\.md$/,
-          ""
+      if (outcome.kind === "error") {
+        failedNums.add(ticket.num);
+        d.setTicketStatus(ticket.num, "failed");
+        d.log(
+          `  ${ticket.filename}: attempt error: ` + formatErrorMessage(outcome.error)
         );
-        d.setTicketStatus(t.num, "in-progress");
-        d.log(`  Starting ${t.filename}`);
-        return spawnAgent({
-          prompt,
-          agentCmd: opts.agentCmd,
-          model: opts.model,
-          timeout: opts.timeout,
-          logPath,
-          cwd: worktrees[i].worktreePath,
-          label,
-          onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
-        });
-      })
-    );
-    let waveCompleted = 0;
-    const successfulBranches = [];
-    const ticketsByNum = /* @__PURE__ */ new Map();
-    const worktreePathsByNum = /* @__PURE__ */ new Map();
-    for (let i = 0; i < results.length; i++) {
-      const r = results[i];
-      if (r.status === "rejected") continue;
-      const agentResult = r.value;
-      const ticket = activeTickets[i];
-      const worktree = worktrees[i];
-      if (agentResult.exitCode !== 0) {
+        continue;
+      }
+      if (outcome.kind === "no-commits") {
+        failedNums.add(ticket.num);
         d.setTicketStatus(ticket.num, "failed");
         d.log(
-          `  ${ticket.filename}: agent exited ${agentResult.exitCode}`
+          `  ${ticket.filename}: agent exited 0 but made no changes; leaving ticket ready-for-agent`
         );
-        checkItems(ticket, agentResult.completedItems);
+        continue;
+      }
+      if (outcome.kind === "failed") {
+        failedNums.add(ticket.num);
+        d.setTicketStatus(ticket.num, "failed");
+        if (outcome.reason === "exit") {
+          checkItems(ticket, outcome.completedItems);
+        }
         checkTicket(progress, ticket.num, {
-          branch: worktree.branchName,
-          exitCode: agentResult.exitCode,
+          branch: outcome.branchName,
+          exitCode: outcome.exitCode,
           done: false
         });
-        writeProgress(progressPath, progress);
-        await commitProgress(
+        await saveProgress(
           repoRoot,
           progressPath,
-          `nightralph: ${ticket.filename} failed`
+          progress,
+          `nightralph: ${ticket.filename} ` + (outcome.reason === "tests" ? "tests failed" : "failed"),
+          d
         );
-        try {
-          await removeWorktree(worktree.worktreePath);
-        } catch (err) {
-          d.log(
-            `  Failed to remove worktree ${worktree.worktreePath}: ` + formatErrorMessage(err)
-          );
-        }
         continue;
       }
-      if (isDirty(worktree.worktreePath)) {
-        const committed = await commitDirty(
-          worktree.worktreePath,
-          `nightralph: auto-commit ${ticket.filename} remaining changes`
-        );
-        if (committed) {
-          d.log(
-            `  ${ticket.filename}: auto-committed remaining changes`
-          );
-        }
-      }
-      if (!hasNewCommits(
-        repoRoot,
-        baseBranch,
-        worktree.branchName
-      )) {
-        d.setTicketStatus(ticket.num, "failed");
-        d.log(
-          `  ${ticket.filename}: agent exited 0 but made no changes; leaving ticket ready-for-agent`
-        );
-        continue;
-      }
-      checkItems(ticket, agentResult.completedItems);
+      checkItems(ticket, outcome.completedItems);
       d.log(
         `  ${ticket.filename}: agent finished, awaiting merge`
       );
       ticketsByNum.set(ticket.num, ticket);
       worktreePathsByNum.set(
         ticket.num,
-        worktree.worktreePath
+        outcome.worktreePath
       );
       successfulBranches.push({
-        branch: worktree.branchName,
+        branch: outcome.branchName,
         ticketNum: ticket.num,
-        worktreePath: worktree.worktreePath
+        worktreePath: outcome.worktreePath
       });
     }
     if (successfulBranches.length > 0) {
@@ -933,23 +1292,21 @@ async function runWavesIsolated(opts) {
             branch: branchResult.branch,
             exitCode: 0
           });
-          writeProgress(progressPath, progress);
-          await commitProgress(
+          await saveProgress(
             repoRoot,
             progressPath,
-            `nightralph: ${ticket.filename} done`
+            progress,
+            `nightralph: ${ticket.filename} done`,
+            d
           );
           const worktreePath = worktreePathsByNum.get(
             ticket.num
           );
           if (worktreePath) {
-            try {
-              await removeWorktree(worktreePath);
-            } catch (err) {
-              d.log(
-                `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
-              );
-            }
+            await removeWorktreeQuietly(
+              worktreePath,
+              d
+            );
           }
         } else {
           const worktreePath = worktreePathsByNum.get(
@@ -966,6 +1323,8 @@ async function runWavesIsolated(opts) {
             model: opts.model,
             timeout: opts.timeout,
             logsDir: opts.logsDir,
+            testCmd: opts.testCmd,
+            maxTurns: opts.maxTurns,
             onLine: /* @__PURE__ */ __name((msg) => d.log(msg), "onLine")
           }) : false;
           if (recovered) {
@@ -980,15 +1339,19 @@ async function runWavesIsolated(opts) {
               branch: branchResult.branch,
               exitCode: 0
             });
-            writeProgress(progressPath, progress);
-            await commitProgress(
+            await saveProgress(
               repoRoot,
               progressPath,
-              `nightralph: ${ticket.filename} done (respawn)`
+              progress,
+              `nightralph: ${ticket.filename} done (respawn)`,
+              d
             );
             if (worktreePath) {
               try {
-                await removeWorktree(worktreePath);
+                await removeWorktree(
+                  worktreePath,
+                  { force: true }
+                );
               } catch (err) {
                 d.log(
                   `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
@@ -1009,11 +1372,12 @@ async function runWavesIsolated(opts) {
               exitCode: 0,
               done: false
             });
-            writeProgress(progressPath, progress);
-            await commitProgress(
+            await saveProgress(
               repoRoot,
               progressPath,
-              `nightralph: ${ticket.filename} merge failed`
+              progress,
+              `nightralph: ${ticket.filename} merge failed`,
+              d
             );
           }
         }
@@ -1027,7 +1391,10 @@ Merge stopped at ${mergeResult.stoppedAt.branch}`
           const ticket = ticketsByNum.get(sb.ticketNum);
           if (ticket && ticket.status === "done") continue;
           try {
-            await removeWorktree(sb.worktreePath);
+            await removeWorktree(
+              sb.worktreePath,
+              { force: true }
+            );
           } catch (err) {
             d.log(
               `  Failed to remove worktree ${sb.worktreePath}: ` + formatErrorMessage(err)
@@ -1049,7 +1416,7 @@ Merge stopped at ${mergeResult.stoppedAt.branch}`
   );
   d.log(
     `
-Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
+Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "") + (failedNums.size > 0 ? `, ${failedNums.size} failed` : "")
   );
   d.cleanup();
   return { allDone: remaining.length === 0 };
@@ -1057,25 +1424,33 @@ Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.
 __name(runWavesIsolated, "runWavesIsolated");
 export {
   COMPLETED_RE,
+  DEFAULT_RETRIES,
+  DEFAULT_RETRY_DELAY,
+  THINKING_LEVELS,
   TICKET_RE,
   TOOL_USE_RE,
   checkItems,
   createPiStreamFormatter,
   dryRun,
   dryRunIsolated,
+  escalateThinking,
   findReadyTickets,
   formatErrorMessage,
   formatStreamLine,
   getProviderArgs,
+  killProcessGroup,
+  killRunningAgents,
   markDone,
   parseBlockers,
   parseStatus,
   parseTicketFilename,
   renderMergePrompt,
   renderPrompt,
+  retryDelayFor,
   runWaves,
   runWavesIsolated,
   scanTickets,
-  spawnAgent
+  spawnAgent,
+  stripSpecSection
 };
 //# sourceMappingURL=orchestrator.js.map