nightralph 0.0.10 → 0.0.12

package/dist/index.js

@@ -1,27 +1,1934 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+
+// src/index.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { select } from "@inquirer/prompts";
-import { setup, checkGhAuth } from "./setup.js";
+import { select as select2 } from "@inquirer/prompts";
+
+// src/setup.ts
 import {
-  scanTickets,
-  dryRun,
-  dryRunIsolated,
-  runWaves,
-  runWavesIsolated
-} from "./orchestrator.js";
-import { createDisplay } from "./display.js";
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+var SKILL_DIRS = [
+  "grill",
+  "grilling",
+  "domain-modeling",
+  "to-spec",
+  "to-tickets",
+  "tdd"
+];
+var DOC_TEMPLATES = [
+  "triage-labels.md",
+  "domain.md"
+];
+var START_MARKER = "<!-- nightralph:start -->";
+var END_MARKER = "<!-- nightralph:end -->";
+function writeManagedSection(filePath, content) {
+  const block = [
+    START_MARKER,
+    content,
+    END_MARKER
+  ].join("\n");
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, block + "\n");
+    return;
+  }
+  const existing = readFileSync(filePath, "utf8");
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(
+      endIdx + END_MARKER.length
+    );
+    writeFileSync(filePath, before + block + after);
+  } else {
+    const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+    writeFileSync(filePath, existing + sep + block + "\n");
+  }
+}
+__name(writeManagedSection, "writeManagedSection");
+function checkGhAuth() {
+  try {
+    execSync("gh auth status", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(checkGhAuth, "checkGhAuth");
+var TRACKER_TEMPLATES = {
+  local: "issue-tracker.md",
+  github: "issue-tracker-github.md"
+};
+function setup(opts) {
+  const {
+    bundledSkillsDir,
+    docsTemplatesDir,
+    projectDir,
+    claude,
+    tracker
+  } = opts;
+  const agentsSkillsDir = join(
+    projectDir,
+    ".agents",
+    "skills"
+  );
+  const upstream = JSON.parse(
+    readFileSync(
+      join(bundledSkillsDir, "upstream.json"),
+      "utf8"
+    )
+  );
+  console.log("Installing skills to .agents/skills/\n");
+  for (const skill of SKILL_DIRS) {
+    const src = join(bundledSkillsDir, skill);
+    const dest = join(agentsSkillsDir, skill);
+    mkdirSync(dest, { recursive: true });
+    cpSync(src, dest, { recursive: true });
+    const files = readdirSync(src);
+    console.log(
+      `  ${skill}/ (${files.join(", ")})`
+    );
+  }
+  if (claude) {
+    const claudeSkillsDir = join(
+      projectDir,
+      ".claude",
+      "skills"
+    );
+    mkdirSync(claudeSkillsDir, { recursive: true });
+    for (const skill of SKILL_DIRS) {
+      const linkPath = join(claudeSkillsDir, skill);
+      const target = join(
+        "..",
+        "..",
+        ".agents",
+        "skills",
+        skill
+      );
+      if (existsSync(linkPath)) continue;
+      symlinkSync(target, linkPath);
+    }
+    console.log(
+      "\nCreated symlinks in .claude/skills/"
+    );
+  }
+  const docsAgentsDir = join(
+    projectDir,
+    "docs",
+    "agents"
+  );
+  mkdirSync(docsAgentsDir, { recursive: true });
+  console.log("");
+  for (const tmpl of DOC_TEMPLATES) {
+    const dest = join(docsAgentsDir, tmpl);
+    if (existsSync(dest)) {
+      console.log(
+        `  docs/agents/${tmpl} (already exists)`
+      );
+      continue;
+    }
+    const src = join(docsTemplatesDir, tmpl);
+    writeFileSync(dest, readFileSync(src, "utf8"));
+    console.log(`  docs/agents/${tmpl} (created)`);
+  }
+  const trackerSrc = join(
+    docsTemplatesDir,
+    TRACKER_TEMPLATES[tracker]
+  );
+  const trackerDest = join(docsAgentsDir, "issue-tracker.md");
+  writeFileSync(trackerDest, readFileSync(trackerSrc, "utf8"));
+  console.log(
+    `  docs/agents/issue-tracker.md (${tracker})`
+  );
+  const trackerLine = tracker === "github" ? "Issues are tracked via GitHub Issues using the `gh` CLI." : "Issues are tracked as local markdown files under `.scratch/`.";
+  const managedContent = [
+    "## Agent skills",
+    "",
+    "### Issue tracker",
+    "",
+    `${trackerLine} See \`docs/agents/issue-tracker.md\`.`,
+    "",
+    "### Triage labels",
+    "",
+    "Default label vocabulary. See `docs/agents/triage-labels.md`.",
+    "",
+    "### Domain docs",
+    "",
+    "Single-context layout. See `docs/agents/domain.md`."
+  ].join("\n");
+  const agentsPath = join(projectDir, "AGENTS.md");
+  writeManagedSection(agentsPath, managedContent);
+  console.log("\n  AGENTS.md (updated)");
+  console.log(
+    `
+Source: ${upstream.repo} @ ${upstream.commit}`
+  );
+}
+__name(setup, "setup");
+
+// src/orchestrator.ts
+import { spawn } from "node:child_process";
 import {
-  findFeatureDirs,
-  resolveIssuesDir,
-  getScriptDir
-} from "./resolve.js";
-import { getRepoRoot, getRepoName } from "./worktree.js";
-const scriptDir = getScriptDir(import.meta.url);
+  createWriteStream,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  unlinkSync,
+  readdirSync as readdirSync2
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join3, dirname, basename as basename2 } from "node:path";
+import { createInterface } from "node:readline";
+
+// src/worktree.ts
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { basename, join as join2 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+var execFileAsync = promisify(execFile);
+function getRepoRoot() {
+  const stdout = execFileSync(
+    "git",
+    ["rev-parse", "--show-toplevel"],
+    { encoding: "utf8" }
+  );
+  return stdout.trim();
+}
+__name(getRepoRoot, "getRepoRoot");
+function getRepoName() {
+  return basename(getRepoRoot());
+}
+__name(getRepoName, "getRepoName");
+function getCurrentBranch() {
+  const stdout = execFileSync(
+    "git",
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    { encoding: "utf8" }
+  );
+  return stdout.trim();
+}
+__name(getCurrentBranch, "getCurrentBranch");
+async function branchExists(repoRoot, branchName) {
+  try {
+    await execFileAsync(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      { cwd: repoRoot }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(branchExists, "branchExists");
+async function createWorktree(opts) {
+  const { repoRoot, repoName, baseBranch, ticket } = opts;
+  const branchName = `${repoName}/${String(
+    ticket.num
+  ).padStart(2, "0")}-${ticket.slug}`;
+  const worktreePath = join2(
+    repoRoot,
+    "..",
+    `${repoName}.${String(
+      ticket.num
+    ).padStart(2, "0")}-${ticket.slug}`
+  );
+  if (existsSync2(worktreePath)) {
+    try {
+      await execFileAsync(
+        "git",
+        ["worktree", "remove", "--force", worktreePath],
+        { cwd: repoRoot }
+      );
+    } catch {
+    }
+  }
+  try {
+    await execFileAsync(
+      "git",
+      ["worktree", "prune"],
+      { cwd: repoRoot }
+    );
+  } catch {
+  }
+  if (await branchExists(repoRoot, branchName)) {
+    await execFileAsync(
+      "git",
+      ["branch", "-D", branchName],
+      { cwd: repoRoot }
+    );
+  }
+  await execFileAsync(
+    "git",
+    [
+      "worktree",
+      "add",
+      "-b",
+      branchName,
+      worktreePath,
+      baseBranch
+    ],
+    { cwd: repoRoot }
+  );
+  return { worktreePath, branchName };
+}
+__name(createWorktree, "createWorktree");
+async function removeWorktree(worktreePath) {
+  await execFileAsync(
+    "git",
+    ["-C", worktreePath, "worktree", "remove", worktreePath]
+  );
+}
+__name(removeWorktree, "removeWorktree");
+function hasNewCommits(repoRoot, base, branch) {
+  const stdout = execFileSync(
+    "git",
+    ["rev-list", "--count", `${base}..${branch}`],
+    { cwd: repoRoot, encoding: "utf8" }
+  );
+  return Number(stdout.trim()) > 0;
+}
+__name(hasNewCommits, "hasNewCommits");
+function isDirty(cwd) {
+  const stdout = execFileSync(
+    "git",
+    ["status", "--porcelain"],
+    { cwd, encoding: "utf8" }
+  );
+  return stdout.trim().length > 0;
+}
+__name(isDirty, "isDirty");
+async function commitDirty(cwd, message) {
+  if (!isDirty(cwd)) return false;
+  await execFileAsync(
+    "git",
+    ["add", "-A"],
+    { cwd }
+  );
+  try {
+    await execFileAsync(
+      "git",
+      [
+        "commit",
+        "-m",
+        message ?? "nightralph: auto-commit remaining changes"
+      ],
+      { cwd }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(commitDirty, "commitDirty");
+
+// src/progress.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { promisify as promisify2 } from "node:util";
+var TICKET_FILENAME_RE = /^(\d+)-(.+)\.md$/;
+var execFileAsync2 = promisify2(execFile2);
+function generateProgress(feature, tickets) {
+  return {
+    feature,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tickets: tickets.map((ticket) => ({
+      num: ticket.num,
+      slug: ticket.slug,
+      filename: ticket.filename,
+      done: false,
+      branch: null,
+      exitCode: null,
+      completedAt: null
+    }))
+  };
+}
+__name(generateProgress, "generateProgress");
+function readProgress(progressPath) {
+  let content;
+  try {
+    content = readFileSync2(progressPath, "utf8");
+  } catch {
+    return null;
+  }
+  const featureMatch = content.match(/^# Progress: (.*)$/m);
+  const startedMatch = content.match(/^Started: (.*)$/m);
+  const tickets = [];
+  let current = null;
+  for (const line of content.split("\n")) {
+    const ticketMatch = line.match(/^- \[( |x)\] (.+)$/);
+    if (ticketMatch) {
+      if (current) tickets.push(current);
+      const filename = ticketMatch[2];
+      const parsed = filename.match(TICKET_FILENAME_RE);
+      current = {
+        num: parsed ? Number(parsed[1]) : NaN,
+        slug: parsed ? parsed[2] : "",
+        filename,
+        done: ticketMatch[1] === "x",
+        branch: null,
+        exitCode: null,
+        completedAt: null
+      };
+      continue;
+    }
+    if (!current) continue;
+    const branchMatch = line.match(/^ {2}branch: (.*)$/);
+    if (branchMatch) {
+      current.branch = branchMatch[1];
+      continue;
+    }
+    const exitMatch = line.match(/^ {2}exit: (-?\d+)$/);
+    if (exitMatch) {
+      current.exitCode = Number(exitMatch[1]);
+      continue;
+    }
+    const completedMatch = line.match(/^ {2}completed: (.*)$/);
+    if (completedMatch) {
+      current.completedAt = completedMatch[1];
+      continue;
+    }
+  }
+  if (current) tickets.push(current);
+  return {
+    feature: featureMatch ? featureMatch[1] : "",
+    startedAt: startedMatch ? startedMatch[1] : "",
+    tickets
+  };
+}
+__name(readProgress, "readProgress");
+function mergeProgress(fresh, existing) {
+  if (!existing) return fresh;
+  const existingByFilename = new Map(
+    existing.tickets.map((t) => [t.filename, t])
+  );
+  return {
+    ...fresh,
+    tickets: fresh.tickets.map((ticket) => {
+      const prior = existingByFilename.get(ticket.filename);
+      return prior && prior.done ? { ...prior } : ticket;
+    })
+  };
+}
+__name(mergeProgress, "mergeProgress");
+function renderProgress(data) {
+  const lines = [
+    `# Progress: ${data.feature}`,
+    "",
+    `Started: ${data.startedAt}`,
+    ""
+  ];
+  for (const ticket of data.tickets) {
+    const checkbox = ticket.done ? "[x]" : "[ ]";
+    lines.push(`- ${checkbox} ${ticket.filename}`);
+    if (ticket.done || ticket.exitCode !== null) {
+      if (ticket.branch) {
+        lines.push(
+          `  branch: ${ticket.branch}`
+        );
+      }
+      if (ticket.exitCode !== null) {
+        lines.push(
+          `  exit: ${ticket.exitCode}`
+        );
+      }
+      if (ticket.completedAt) {
+        lines.push(
+          `  completed: ${ticket.completedAt}`
+        );
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+__name(renderProgress, "renderProgress");
+function checkTicket(data, ticketNum, result) {
+  const ticket = data.tickets.find(
+    (t) => t.num === ticketNum
+  );
+  if (!ticket) return;
+  ticket.done = result.done ?? true;
+  ticket.branch = result.branch;
+  ticket.exitCode = result.exitCode;
+  if (ticket.done) {
+    ticket.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+__name(checkTicket, "checkTicket");
+function writeProgress(progressPath, data) {
+  writeFileSync2(
+    progressPath,
+    renderProgress(data)
+  );
+}
+__name(writeProgress, "writeProgress");
+async function commitProgress(repoRoot, progressPath, message) {
+  await execFileAsync2(
+    "git",
+    ["add", "--force", progressPath],
+    { cwd: repoRoot }
+  );
+  await execFileAsync2(
+    "git",
+    ["commit", "-m", message, "--", progressPath],
+    { cwd: repoRoot }
+  );
+}
+__name(commitProgress, "commitProgress");
+
+// src/merge.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
+async function mergeBranch(repoRoot, branch) {
+  if (!repoRoot || typeof repoRoot !== "string") {
+    throw new Error("repoRoot must be a non-empty string");
+  }
+  if (!branch || typeof branch !== "string") {
+    throw new Error("branch must be a non-empty string");
+  }
+  try {
+    await execFileAsync3(
+      "git",
+      ["merge", branch, "--no-edit"],
+      { cwd: repoRoot }
+    );
+    return true;
+  } catch {
+    try {
+      await execFileAsync3(
+        "git",
+        ["merge", "--abort"],
+        { cwd: repoRoot }
+      );
+    } catch {
+    }
+    return false;
+  }
+}
+__name(mergeBranch, "mergeBranch");
+async function rebaseBranch(repoRoot, branch, onto, worktreePath) {
+  if (!repoRoot || typeof repoRoot !== "string") {
+    throw new Error("repoRoot must be a non-empty string");
+  }
+  if (!branch || typeof branch !== "string") {
+    throw new Error("branch must be a non-empty string");
+  }
+  if (!onto || typeof onto !== "string") {
+    throw new Error("onto must be a non-empty string");
+  }
+  if (worktreePath) {
+    try {
+      await execFileAsync3(
+        "git",
+        ["rebase", onto],
+        { cwd: worktreePath }
+      );
+      return true;
+    } catch {
+      try {
+        await execFileAsync3(
+          "git",
+          ["rebase", "--abort"],
+          { cwd: worktreePath }
+        );
+      } catch {
+      }
+      return false;
+    }
+  }
+  try {
+    await execFileAsync3(
+      "git",
+      ["checkout", branch],
+      { cwd: repoRoot }
+    );
+    await execFileAsync3(
+      "git",
+      ["rebase", onto],
+      { cwd: repoRoot }
+    );
+    await execFileAsync3(
+      "git",
+      ["checkout", onto],
+      { cwd: repoRoot }
+    );
+    return true;
+  } catch {
+    try {
+      await execFileAsync3(
+        "git",
+        ["rebase", "--abort"],
+        { cwd: repoRoot }
+      );
+    } catch {
+    }
+    try {
+      await execFileAsync3(
+        "git",
+        ["checkout", onto],
+        { cwd: repoRoot }
+      );
+    } catch {
+    }
+    return false;
+  }
+}
+__name(rebaseBranch, "rebaseBranch");
+async function updateWorktreeFromBase(worktreePath, baseBranch) {
+  try {
+    await execFileAsync3(
+      "git",
+      ["merge", baseBranch, "--no-edit"],
+      { cwd: worktreePath }
+    );
+  } catch {
+  }
+}
+__name(updateWorktreeFromBase, "updateWorktreeFromBase");
+async function mergeWave(opts) {
+  const { repoRoot, baseBranch, branches, strategy } = opts;
+  if (!repoRoot || typeof repoRoot !== "string") {
+    throw new Error("repoRoot must be a non-empty string");
+  }
+  if (!baseBranch || typeof baseBranch !== "string") {
+    throw new Error("baseBranch must be a non-empty string");
+  }
+  const merged = [];
+  let stoppedAt = null;
+  for (let i = 0; i < branches.length; i++) {
+    const { branch, ticketNum, worktreePath } = branches[i];
+    const mergingResult = {
+      branch,
+      ticketNum,
+      merged: false,
+      conflicted: false
+    };
+    if (i === 0) {
+      const success = await mergeBranch(
+        repoRoot,
+        branch
+      );
+      mergingResult.merged = success;
+      mergingResult.conflicted = !success;
+      if (!success) {
+        if (strategy === "stop") {
+          stoppedAt = mergingResult;
+          merged.push(mergingResult);
+          break;
+        }
+        merged.push(mergingResult);
+        continue;
+      }
+    } else {
+      const rebaseSuccess = await rebaseBranch(
+        repoRoot,
+        branch,
+        baseBranch,
+        worktreePath
+      );
+      if (!rebaseSuccess) {
+        mergingResult.conflicted = true;
+        if (strategy === "stop") {
+          stoppedAt = mergingResult;
+          merged.push(mergingResult);
+          break;
+        } else {
+          merged.push(mergingResult);
+          continue;
+        }
+      }
+      const mergeSuccess = await mergeBranch(
+        repoRoot,
+        branch
+      );
+      mergingResult.merged = mergeSuccess;
+      mergingResult.conflicted = !mergeSuccess;
+      if (!mergeSuccess) {
+        if (strategy === "stop") {
+          stoppedAt = mergingResult;
+          merged.push(mergingResult);
+          break;
+        }
+        merged.push(mergingResult);
+        continue;
+      }
+    }
+    merged.push(mergingResult);
+  }
+  return {
+    merged,
+    stoppedAt
+  };
+}
+__name(mergeWave, "mergeWave");
+
+// src/display.ts
+var ESC = "\x1B[";
+var ansi = {
+  cursorUp(n) {
+    return `${ESC}${n}A`;
+  },
+  cursorTo(col) {
+    return `${ESC}${col}G`;
+  },
+  eraseLine() {
+    return `${ESC}2K`;
+  },
+  eraseLines(n) {
+    let out = "";
+    for (let i = 0; i < n; i++) {
+      out += ansi.eraseLine();
+      if (i < n - 1) out += ansi.cursorUp(1);
+    }
+    return out;
+  },
+  cursorHide() {
+    return `${ESC}?25l`;
+  },
+  cursorShow() {
+    return `${ESC}?25h`;
+  }
+};
+var color = {
+  green(text) {
+    return `${ESC}32m${text}${ESC}0m`;
+  },
+  yellow(text) {
+    return `${ESC}33m${text}${ESC}0m`;
+  },
+  red(text) {
+    return `${ESC}31m${text}${ESC}0m`;
+  },
+  dim(text) {
+    return `${ESC}2m${text}${ESC}0m`;
+  }
+};
+var FILLED_DOT = "\u25CF";
+var EMPTY_DOT = "\u25CB";
+function renderDot(status) {
+  switch (status) {
+    case "pending":
+      return color.dim(EMPTY_DOT);
+    case "in-progress":
+      return color.yellow(FILLED_DOT);
+    case "done":
+      return color.green(FILLED_DOT);
+    case "failed":
+      return color.red(FILLED_DOT);
+  }
+}
+__name(renderDot, "renderDot");
+var StatusDisplay = class {
+  static {
+    __name(this, "StatusDisplay");
+  }
+  wave = null;
+  messages = [];
+  renderedLines = 0;
+  config;
+  viewportStart = 0;
+  resizeListener = null;
+  signalHandler = null;
+  constructor(config) {
+    this.config = {
+      messageLines: config?.messageLines ?? 10,
+      stream: config?.stream ?? process.stdout
+    };
+  }
+  getAvailableRows() {
+    const termHeight = this.config.stream.rows ?? 24;
+    const overhead = 2 + this.config.messageLines;
+    const available = termHeight - overhead;
+    return Math.max(1, available);
+  }
+  startWave(waveNum, totalWaves, tickets) {
+    this.wave = {
+      waveNum,
+      totalWaves,
+      tickets: tickets.map((t) => ({
+        ...t,
+        status: "pending"
+      }))
+    };
+    this.messages = [];
+    this.viewportStart = 0;
+    this.config.stream.write(ansi.cursorHide());
+    if (this.config.stream.isTTY) {
+      if (this.resizeListener) {
+        this.config.stream.removeListener(
+          "resize",
+          this.resizeListener
+        );
+      }
+      this.resizeListener = () => this.render();
+      this.config.stream.on(
+        "resize",
+        this.resizeListener
+      );
+    }
+    if (this.signalHandler) {
+      process.removeListener("SIGINT", this.signalHandler);
+      process.removeListener("SIGTERM", this.signalHandler);
+    }
+    this.signalHandler = () => this.cleanup();
+    process.on("SIGINT", this.signalHandler);
+    process.on("SIGTERM", this.signalHandler);
+    this.render();
+  }
+  setTicketStatus(num, status) {
+    if (!this.wave) return;
+    const ticket = this.wave.tickets.find((t) => t.num === num);
+    if (ticket) {
+      ticket.status = status;
+      if (status === "in-progress") {
+        const ticketIndex = this.wave.tickets.indexOf(ticket);
+        const availableRows = this.getAvailableRows();
+        const totalTickets = this.wave.tickets.length;
+        if (ticketIndex < this.viewportStart) {
+          this.viewportStart = ticketIndex;
+        } else if (ticketIndex >= this.viewportStart + availableRows) {
+          this.viewportStart = ticketIndex - availableRows + 3;
+        }
+        this.viewportStart = Math.max(
+          0,
+          Math.min(
+            this.viewportStart,
+            totalTickets - 1
+          )
+        );
+      }
+      this.render();
+    }
+  }
+  log(message) {
+    this.messages.push(message);
+    if (this.messages.length > this.config.messageLines) {
+      this.messages.shift();
+    }
+    this.render();
+  }
+  cleanup() {
+    if (this.resizeListener && this.config.stream.isTTY) {
+      this.config.stream.removeListener("resize", this.resizeListener);
+    }
+    if (this.signalHandler) {
+      process.removeListener("SIGINT", this.signalHandler);
+      process.removeListener("SIGTERM", this.signalHandler);
+    }
+    this.config.stream.write(ansi.cursorShow());
+  }
+  render() {
+    if (!this.wave) return;
+    let output = "";
+    if (this.renderedLines > 0) {
+      output += ansi.eraseLines(this.renderedLines + 1);
+    }
+    const completed = this.wave.tickets.filter(
+      (t) => t.status === "done"
+    ).length;
+    const total = this.wave.tickets.length;
+    const pct = total === 0 ? 0 : Math.round(completed / total * 100);
+    output += `Wave ${this.wave.waveNum}/${this.wave.totalWaves} -- ${pct}% complete
+`;
+    const availableRows = this.getAvailableRows();
+    const tickets = this.wave.tickets;
+    let renderedTicketCount = 0;
+    if (tickets.length <= availableRows) {
+      for (const ticket of tickets) {
+        const dot = renderDot(ticket.status);
+        output += `${dot} ${ticket.filename}
+`;
+      }
+      renderedTicketCount = tickets.length;
+    } else {
+      this.viewportStart = Math.max(
+        0,
+        Math.min(
+          this.viewportStart,
+          tickets.length - 1
+        )
+      );
+      let hasMoreAbove = this.viewportStart > 0;
+      let tentativeCount = availableRows - (hasMoreAbove ? 1 : 0);
+      let hasMoreBelow = this.viewportStart + tentativeCount < tickets.length;
+      let ticketsToShow = Math.max(
+        0,
+        tentativeCount - (hasMoreBelow ? 1 : 0)
+      );
+      const maxStart = Math.max(
+        0,
+        tickets.length - Math.max(1, ticketsToShow)
+      );
+      if (this.viewportStart > maxStart) {
+        this.viewportStart = maxStart;
+        hasMoreAbove = this.viewportStart > 0;
+        tentativeCount = availableRows - (hasMoreAbove ? 1 : 0);
+        hasMoreBelow = this.viewportStart + tentativeCount < tickets.length;
+        ticketsToShow = Math.max(
+          0,
+          tentativeCount - (hasMoreBelow ? 1 : 0)
+        );
+      }
+      if (hasMoreAbove) {
+        const moreCount = this.viewportStart;
+        output += `  ... ${moreCount} more above
+`;
+      }
+      const visibleTickets = tickets.slice(
+        this.viewportStart,
+        this.viewportStart + ticketsToShow
+      );
+      for (const ticket of visibleTickets) {
+        const dot = renderDot(ticket.status);
+        output += `${dot} ${ticket.filename}
+`;
+      }
+      if (hasMoreBelow) {
+        const moreCount = tickets.length - (this.viewportStart + ticketsToShow);
+        output += `  ... ${moreCount} more below
+`;
+      }
+      renderedTicketCount = (hasMoreAbove ? 1 : 0) + visibleTickets.length + (hasMoreBelow ? 1 : 0);
+    }
+    output += "-".repeat(50) + "\n";
+    const msgLines = Math.max(
+      0,
+      this.config.messageLines - this.messages.length
+    );
+    for (const msg of this.messages) {
+      output += `${msg}
+`;
+    }
+    for (let i = 0; i < msgLines; i++) {
+      output += "\n";
+    }
+    this.renderedLines = 2 + renderedTicketCount + this.config.messageLines;
+    this.config.stream.write(output);
+  }
+};
+var PlainDisplay = class {
+  static {
+    __name(this, "PlainDisplay");
+  }
+  startWave(waveNum, _totalWaves, tickets) {
+    console.log(
+      `
+Wave ${waveNum}: ` + tickets.map((t) => t.filename).join(", ")
+    );
+  }
+  setTicketStatus(_num, _status) {
+  }
+  log(message) {
+    console.log(message);
+  }
+  cleanup() {
+  }
+};
+function createDisplay(stream) {
+  const s = stream ?? process.stdout;
+  if (s.isTTY) {
+    return new StatusDisplay({ stream: s });
+  }
+  return new PlainDisplay();
+}
+__name(createDisplay, "createDisplay");
+
+// src/orchestrator.ts
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatErrorMessage, "formatErrorMessage");
+var TICKET_RE = /^(\d+)-(.+)\.md$/;
+function parseTicketFilename(filename) {
+  const m = filename.match(TICKET_RE);
+  if (!m) return null;
+  return { num: Number(m[1]), slug: m[2] };
+}
+__name(parseTicketFilename, "parseTicketFilename");
+function parseStatus(body) {
+  const m = body.match(/\*\*Status:\*\*\s*(.+)/i);
+  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) {
+  const files = readdirSync2(dir).filter((f) => TICKET_RE.test(f)).sort((a, b) => a.localeCompare(
+    b,
+    void 0,
+    { numeric: true, sensitivity: "base" }
+  ));
+  return files.map((filename) => {
+    const parsed = parseTicketFilename(filename);
+    const filepath = join3(dir, filename);
+    const body = readFileSync3(filepath, "utf8");
+    return {
+      num: parsed.num,
+      slug: parsed.slug,
+      filename,
+      filepath,
+      body,
+      status: parseStatus(body),
+      blockers: parseBlockers(body)
+    };
+  });
+}
+__name(scanTickets, "scanTickets");
+function findReadyTickets(tickets) {
+  const doneNums = new Set(
+    tickets.filter((t) => t.status === "done").map((t) => t.num)
+  );
+  return tickets.filter((t) => {
+    if (t.status !== "ready-for-agent") return false;
+    return t.blockers.every((b) => doneNums.has(b));
+  });
+}
+__name(findReadyTickets, "findReadyTickets");
+var COMPLETED_RE = /^\[x\]\s+(.+)$/i;
+function checkItems(ticket, completedItems) {
+  if (completedItems.length === 0) return;
+  let body = ticket.body;
+  for (const item of completedItems) {
+    const escaped = item.replace(
+      /[.*+?^${}()|[\]\\]/g,
+      "\\$&"
+    );
+    body = body.replace(
+      new RegExp(
+        `- \\[ \\] ${escaped}`,
+        "i"
+      ),
+      `- [x] ${item}`
+    );
+  }
+  writeFileSync3(ticket.filepath, body);
+  ticket.body = body;
+}
+__name(checkItems, "checkItems");
+function markDone(ticket) {
+  const updated = ticket.body.replace(
+    /\*\*Status:\*\*\s*.+/i,
+    "**Status:** done"
+  );
+  writeFileSync3(ticket.filepath, updated);
+  ticket.status = "done";
+  ticket.body = updated;
+}
+__name(markDone, "markDone");
+function renderPrompt(specBody, ticket) {
+  return [
+    "---- SPEC CONTEXT ----",
+    specBody,
+    "",
+    "---- TICKET ----",
+    ticket.filename,
+    ticket.body,
+    "",
+    "---- 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.",
+    "- 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.",
+    "- Commit your work when finished.",
+    "- After completing each checklist item in the ticket, print a line: [x] <item text> (matching the checklist text exactly).",
+    ""
+  ].join("\n");
+}
+__name(renderPrompt, "renderPrompt");
+function listTickets(tickets) {
+  console.log("\nTickets:");
+  for (const t of tickets) {
+    const blockerStr = t.blockers.length > 0 ? `blocked by [${t.blockers.join(", ")}]` : "no blockers";
+    console.log(
+      `  ${t.filename} (${t.status}) ${blockerStr}`
+    );
+  }
+}
+__name(listTickets, "listTickets");
+function* simulateWaves(tickets) {
+  const sim = new Map(
+    tickets.map((t) => [t.num, t.status])
+  );
+  let wave = 1;
+  while (true) {
+    const doneNums = new Set(
+      [...sim.entries()].filter(([, s]) => s === "done").map(([n]) => n)
+    );
+    const ready = [...tickets].filter((t) => {
+      if (sim.get(t.num) !== "ready-for-agent") {
+        return false;
+      }
+      return t.blockers.every(
+        (b) => doneNums.has(b)
+      );
+    });
+    if (ready.length === 0) break;
+    yield { wave, ready };
+    for (const t of ready) {
+      sim.set(t.num, "done");
+    }
+    wave++;
+  }
+}
+__name(simulateWaves, "simulateWaves");
+function detectDeadlocks(tickets) {
+  const doneNums = /* @__PURE__ */ new Set();
+  const ready = /* @__PURE__ */ new Set();
+  for (const t of tickets) {
+    if (t.status === "ready-for-agent") {
+      ready.add(t.num);
+    } else if (t.status === "done") {
+      doneNums.add(t.num);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const num of ready) {
+      const ticket = tickets.find(
+        (t) => t.num === num
+      );
+      if (ticket.blockers.every(
+        (b) => doneNums.has(b)
+      )) {
+        doneNums.add(num);
+        ready.delete(num);
+        changed = true;
+      }
+    }
+  }
+  return [...ready].map(
+    (num) => tickets.find((t) => t.num === num)
+  );
+}
+__name(detectDeadlocks, "detectDeadlocks");
+var PROVIDER_ARGS = {
+  claude: [
+    "--print",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions"
+  ],
+  codex: ["exec", "--full-auto"],
+  pi: [
+    "-p",
+    "--verbose",
+    "--approve",
+    "--no-session",
+    "--mode",
+    "json"
+  ]
+};
+function getProviderArgs(cmd) {
+  const name = basename2(cmd);
+  return PROVIDER_ARGS[name] ?? [];
+}
+__name(getProviderArgs, "getProviderArgs");
+function formatStreamLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return line;
+  }
+  if (obj.type === "assistant") {
+    const msg = obj.message;
+    const content = msg?.content;
+    if (!content) return null;
+    for (const block of content) {
+      if (block.type === "text") {
+        return String(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)})` : "";
+    return `${sub}${costStr}`;
+  }
+  if (obj.type === "system") {
+    const sub = obj.subtype;
+    if (sub === "api_retry") {
+      const error = obj.error;
+      return `retry: ${error ?? "unknown"}`;
+    }
+  }
+  return null;
+}
+__name(formatStreamLine, "formatStreamLine");
+function createPiStreamFormatter() {
+  const calls = /* @__PURE__ */ new Map();
+  return (line) => {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return line;
+    }
+    const evt = obj.assistantMessageEvent;
+    if (!evt) return null;
+    const type = evt.type;
+    const ci = evt.contentIndex ?? -1;
+    if (type === "text_delta") {
+      return evt.delta ?? null;
+    }
+    if (type === "toolcall_start") {
+      calls.set(ci, {
+        name: evt.toolName ?? "?",
+        buf: ""
+      });
+      return null;
+    }
+    if (type === "toolcall_delta" && calls.has(ci)) {
+      calls.get(ci).buf += evt.delta ?? "";
+      return null;
+    }
+    if (type === "toolcall_end" && calls.has(ci)) {
+      const call = calls.get(ci);
+      calls.delete(ci);
+      let label = "";
+      try {
+        const args = JSON.parse(call.buf);
+        label = String(
+          args.command ?? args.file_path ?? args.query ?? ""
+        ).split("\n")[0].slice(0, 72);
+      } catch {
+      }
+      return `[${call.name}] ${label}`;
+    }
+    return null;
+  };
+}
+__name(createPiStreamFormatter, "createPiStreamFormatter");
+function writePromptFile(prompt) {
+  const name = `nightralph-${Date.now()}-${Math.random().toString(36).slice(2)}.md`;
+  const filePath = join3(tmpdir(), name);
+  writeFileSync3(filePath, prompt);
+  return filePath;
+}
+__name(writePromptFile, "writePromptFile");
+function cleanupPromptFile(filePath) {
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+__name(cleanupPromptFile, "cleanupPromptFile");
+function spawnAgent(opts) {
+  const args = [
+    ...getProviderArgs(opts.agentCmd)
+  ];
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+  const providerName = basename2(opts.agentCmd);
+  const isClaude = providerName === "claude";
+  const isPi = providerName === "pi";
+  const prefix = opts.label ? `  [${opts.label}] ` : "  ";
+  let promptFile = null;
+  if (isPi) {
+    promptFile = writePromptFile(opts.prompt);
+    args.push(`@${promptFile}`);
+  }
+  const logStream = createWriteStream(
+    opts.logPath,
+    { flags: "w" }
+  );
+  const proc = spawn(opts.agentCmd, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: opts.cwd
+  });
+  proc.stdout.pipe(logStream);
+  const piFormatter = isPi ? createPiStreamFormatter() : null;
+  const completedItems = [];
+  function collectCompleted(text) {
+    const match = text.match(COMPLETED_RE);
+    if (match) completedItems.push(match[1]);
+  }
+  __name(collectCompleted, "collectCompleted");
+  const rl = createInterface({ input: proc.stdout });
+  rl.on("line", (line) => {
+    if (isClaude) {
+      const formatted = formatStreamLine(line);
+      if (formatted !== null) {
+        collectCompleted(formatted);
+        const output = `${prefix}${formatted}`;
+        if (opts.onLine) {
+          opts.onLine(output);
+        } else {
+          console.log(output);
+        }
+      }
+    } else if (piFormatter) {
+      const formatted = piFormatter(line);
+      if (formatted !== null) {
+        collectCompleted(formatted);
+        const output = `${prefix}${formatted}`;
+        if (opts.onLine) {
+          opts.onLine(output);
+        } else {
+          console.log(output);
+        }
+      }
+    } else {
+      collectCompleted(line);
+      const output = `${prefix}${line}`;
+      if (opts.onLine) {
+        opts.onLine(output);
+      } else {
+        console.log(output);
+      }
+    }
+  });
+  proc.stderr.pipe(logStream);
+  const rlErr = createInterface({ input: proc.stderr });
+  rlErr.on("line", (line) => {
+    const output = `${prefix}${line}`;
+    if (opts.onLine) {
+      opts.onLine(output);
+    } else {
+      console.error(output);
+    }
+  });
+  const timeout = setTimeout(() => {
+    if (!proc.killed) {
+      console.warn(
+        `Agent did not exit in ${opts.timeout}s; killing.`
+      );
+      proc.kill("SIGKILL");
+    }
+  }, opts.timeout * 1e3);
+  if (!promptFile) {
+    proc.stdin.write(opts.prompt);
+  }
+  proc.stdin.end();
+  return new Promise((resolve) => {
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      rl.close();
+      rlErr.close();
+      logStream.end();
+      if (promptFile) cleanupPromptFile(promptFile);
+      resolve({
+        exitCode: code ?? 1,
+        completedItems
+      });
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      rl.close();
+      rlErr.close();
+      logStream.end();
+      if (promptFile) cleanupPromptFile(promptFile);
+      console.error(
+        "Agent process error:",
+        formatErrorMessage(err)
+      );
+      resolve({ exitCode: 1, completedItems });
+    });
+  });
+}
+__name(spawnAgent, "spawnAgent");
+function dryRun(tickets, specBody) {
+  listTickets(tickets);
+  console.log("\nSimulated wave order:");
+  for (const { wave, ready } of simulateWaves(tickets)) {
+    console.log(
+      `  Wave ${wave}: ` + ready.map((t) => t.filename).join(", ")
+    );
+  }
+  const stuck = detectDeadlocks(tickets);
+  if (stuck.length > 0) {
+    console.log(
+      "\nDeadlocked tickets: " + stuck.map((t) => t.filename).join(", ")
+    );
+  }
+  const firstReady = findReadyTickets(tickets);
+  if (firstReady.length > 0) {
+    console.log(
+      `
+Prompt for first ready ticket (${firstReady[0].filename}):
+`
+    );
+    console.log(
+      renderPrompt(specBody, firstReady[0])
+    );
+  }
+}
+__name(dryRun, "dryRun");
+function dryRunIsolated(opts) {
+  listTickets(opts.tickets);
+  console.log("\nSimulated wave order:");
+  for (const { wave, ready } of simulateWaves(
+    opts.tickets
+  )) {
+    console.log(
+      `  Wave ${wave}: ` + ready.map((t) => t.filename).join(", ")
+    );
+    for (const t of ready) {
+      const num = String(t.num).padStart(2, "0");
+      const branchName = `${opts.repoName}/${num}-${t.slug}`;
+      const worktreePath = `../${opts.repoName}.${num}-${t.slug}`;
+      console.log(`    worktree: ${worktreePath}`);
+      console.log(`    branch:   ${branchName}`);
+    }
+  }
+  const stuck = detectDeadlocks(opts.tickets);
+  if (stuck.length > 0) {
+    console.log(
+      "\nDeadlocked tickets: " + stuck.map((t) => t.filename).join(", ")
+    );
+  }
+  const firstReady = findReadyTickets(opts.tickets);
+  if (firstReady.length > 0) {
+    console.log(
+      `
+Prompt for first ready ticket (${firstReady[0].filename}):
+`
+    );
+    console.log(
+      renderPrompt(opts.specBody, firstReady[0])
+    );
+  }
+  const strategyDesc = opts.conflictStrategy === "respawn" ? "respawn (re-run agent on conflict)" : "stop (stop merging on conflict)";
+  console.log(
+    `
+Merge strategy: ${strategyDesc}`
+  );
+  console.log(`Progress file: ${opts.progressPath}`);
+}
+__name(dryRunIsolated, "dryRunIsolated");
+async function respawnAndRetryMerge(opts) {
+  await updateWorktreeFromBase(
+    opts.worktreePath,
+    opts.baseBranch
+  );
+  const msg1 = `  ${opts.ticket.filename}: respawning agent to resolve merge conflict`;
+  if (opts.onLine) {
+    opts.onLine(msg1);
+  } else {
+    console.log(msg1);
+  }
+  const prompt = renderPrompt(opts.specBody, opts.ticket);
+  const logPath = join3(
+    opts.logsDir,
+    opts.ticket.filename.replace(/\.md$/, ".respawn.log")
+  );
+  const label = opts.ticket.filename.replace(
+    /\.md$/,
+    ""
+  );
+  const result = await spawnAgent({
+    prompt,
+    agentCmd: opts.agentCmd,
+    model: opts.model,
+    timeout: opts.timeout,
+    logPath,
+    cwd: opts.worktreePath,
+    label,
+    onLine: opts.onLine
+  });
+  if (result.exitCode !== 0) {
+    const msg2 = `  ${opts.ticket.filename}: respawned agent exited ${result.exitCode}`;
+    if (opts.onLine) {
+      opts.onLine(msg2);
+    } else {
+      console.log(msg2);
+    }
+    return false;
+  }
+  const merged = await mergeBranch(
+    opts.repoRoot,
+    opts.branch
+  );
+  if (!merged) {
+    const msg3 = `  ${opts.ticket.filename}: merge still conflicted after respawn`;
+    if (opts.onLine) {
+      opts.onLine(msg3);
+    } else {
+      console.log(msg3);
+    }
+  }
+  return merged;
+}
+__name(respawnAndRetryMerge, "respawnAndRetryMerge");
+async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir, display) {
+  mkdirSync2(logsDir, { recursive: true });
+  const d = display ?? createDisplay();
+  let totalWaves = 0;
+  for (const _ of simulateWaves(tickets)) totalWaves++;
+  let totalCompleted = 0;
+  let waveNum = 0;
+  while (true) {
+    const ready = findReadyTickets(tickets);
+    if (ready.length === 0) break;
+    waveNum++;
+    d.startWave(
+      waveNum,
+      totalWaves,
+      ready.map((t) => ({
+        num: t.num,
+        filename: t.filename
+      }))
+    );
+    const results = await Promise.allSettled(
+      ready.map(async (t) => {
+        const prompt = renderPrompt(specBody, t);
+        const logPath = join3(
+          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({
+          prompt,
+          agentCmd,
+          model,
+          timeout,
+          logPath,
+          label,
+          onLine: /* @__PURE__ */ __name((line) => d.log(line), "onLine")
+        });
+        return { ticket: t, result };
+      })
+    );
+    let waveCompleted = 0;
+    for (const r of results) {
+      if (r.status === "rejected") continue;
+      const { ticket, result } = r.value;
+      if (result.exitCode !== 0) {
+        d.setTicketStatus(ticket.num, "failed");
+        d.log(
+          `  ${ticket.filename}: agent exited ${result.exitCode}`
+        );
+        continue;
+      }
+      checkItems(ticket, result.completedItems);
+      markDone(ticket);
+      waveCompleted++;
+      totalCompleted++;
+      d.setTicketStatus(ticket.num, "done");
+      d.log(
+        `  ${ticket.filename}: done`
+      );
+    }
+    if (waveCompleted === 0) {
+      d.log(
+        "\nNo tickets completed this wave. Stopping."
+      );
+      break;
+    }
+  }
+  const remaining = tickets.filter(
+    (t) => t.status === "ready-for-agent"
+  );
+  d.log(
+    `
+Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
+  );
+  d.cleanup();
+  return { allDone: remaining.length === 0 };
+}
+__name(runWaves, "runWaves");
+async function runWavesIsolated(opts) {
+  mkdirSync2(opts.logsDir, { recursive: true });
+  const d = opts.display ?? createDisplay();
+  let totalWaves = 0;
+  for (const _ of simulateWaves(opts.tickets)) totalWaves++;
+  const repoRoot = getRepoRoot();
+  const repoName = getRepoName();
+  const baseBranch = getCurrentBranch();
+  const progressPath = join3(
+    dirname(opts.logsDir),
+    "progress.md"
+  );
+  const progress = mergeProgress(
+    generateProgress(opts.featureName, opts.tickets),
+    readProgress(progressPath)
+  );
+  writeProgress(progressPath, progress);
+  await commitProgress(
+    repoRoot,
+    progressPath,
+    `nightralph: start ${opts.featureName}`
+  );
+  let totalCompleted = 0;
+  let waveNum = 0;
+  while (true) {
+    const ready = findReadyTickets(opts.tickets);
+    if (ready.length === 0) break;
+    waveNum++;
+    d.startWave(
+      waveNum,
+      totalWaves,
+      ready.map((t) => ({
+        num: t.num,
+        filename: t.filename
+      }))
+    );
+    const worktreeSettled = await Promise.allSettled(
+      ready.map((t) => createWorktree({
+        repoRoot,
+        repoName,
+        baseBranch,
+        ticket: t
+      }))
+    );
+    const activeTickets = [];
+    const worktrees = [];
+    for (let i = 0; i < worktreeSettled.length; i++) {
+      const settled = worktreeSettled[i];
+      const ticket = ready[i];
+      if (settled.status === "rejected") {
+        d.setTicketStatus(ticket.num, "failed");
+        d.log(
+          `  ${ticket.filename}: failed to create worktree: ${formatErrorMessage(settled.reason)}`
+        );
+        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 = join3(
+          opts.logsDir,
+          t.filename.replace(/\.md$/, ".log")
+        );
+        const label = t.filename.replace(
+          /\.md$/,
+          ""
+        );
+        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) {
+        d.setTicketStatus(ticket.num, "failed");
+        d.log(
+          `  ${ticket.filename}: agent exited ${agentResult.exitCode}`
+        );
+        checkItems(ticket, agentResult.completedItems);
+        checkTicket(progress, ticket.num, {
+          branch: worktree.branchName,
+          exitCode: agentResult.exitCode,
+          done: false
+        });
+        writeProgress(progressPath, progress);
+        await commitProgress(
+          repoRoot,
+          progressPath,
+          `nightralph: ${ticket.filename} failed`
+        );
+        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);
+      d.log(
+        `  ${ticket.filename}: agent finished, awaiting merge`
+      );
+      ticketsByNum.set(ticket.num, ticket);
+      worktreePathsByNum.set(
+        ticket.num,
+        worktree.worktreePath
+      );
+      successfulBranches.push({
+        branch: worktree.branchName,
+        ticketNum: ticket.num,
+        worktreePath: worktree.worktreePath
+      });
+    }
+    if (successfulBranches.length > 0) {
+      const mergeResult = await mergeWave({
+        repoRoot,
+        baseBranch,
+        branches: successfulBranches,
+        strategy: opts.conflictStrategy
+      });
+      for (const branchResult of mergeResult.merged) {
+        const ticket = ticketsByNum.get(
+          branchResult.ticketNum
+        );
+        if (!ticket) continue;
+        if (branchResult.merged) {
+          markDone(ticket);
+          waveCompleted++;
+          totalCompleted++;
+          d.setTicketStatus(ticket.num, "done");
+          d.log(
+            `  ${ticket.filename}: done`
+          );
+          checkTicket(progress, ticket.num, {
+            branch: branchResult.branch,
+            exitCode: 0
+          });
+          writeProgress(progressPath, progress);
+          await commitProgress(
+            repoRoot,
+            progressPath,
+            `nightralph: ${ticket.filename} done`
+          );
+          const worktreePath = worktreePathsByNum.get(
+            ticket.num
+          );
+          if (worktreePath) {
+            try {
+              await removeWorktree(worktreePath);
+            } catch (err) {
+              d.log(
+                `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
+              );
+            }
+          }
+        } else {
+          const worktreePath = worktreePathsByNum.get(
+            ticket.num
+          );
+          const recovered = opts.conflictStrategy === "respawn" && worktreePath ? await respawnAndRetryMerge({
+            repoRoot,
+            baseBranch,
+            branch: branchResult.branch,
+            ticket,
+            worktreePath,
+            specBody: opts.specBody,
+            agentCmd: opts.agentCmd,
+            model: opts.model,
+            timeout: opts.timeout,
+            logsDir: opts.logsDir,
+            onLine: /* @__PURE__ */ __name((msg) => d.log(msg), "onLine")
+          }) : false;
+          if (recovered) {
+            markDone(ticket);
+            waveCompleted++;
+            totalCompleted++;
+            d.setTicketStatus(ticket.num, "done");
+            d.log(
+              `  ${ticket.filename}: done (resolved via respawn)`
+            );
+            checkTicket(progress, ticket.num, {
+              branch: branchResult.branch,
+              exitCode: 0
+            });
+            writeProgress(progressPath, progress);
+            await commitProgress(
+              repoRoot,
+              progressPath,
+              `nightralph: ${ticket.filename} done (respawn)`
+            );
+            if (worktreePath) {
+              try {
+                await removeWorktree(worktreePath);
+              } catch (err) {
+                d.log(
+                  `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
+                );
+              }
+            }
+          } else {
+            d.log(
+              `  ${ticket.filename}: merge failed, staying ready-for-agent`
+            );
+          }
+        }
+      }
+      if (mergeResult.stoppedAt) {
+        d.log(
+          `
+Merge stopped at ${mergeResult.stoppedAt.branch}`
+        );
+        for (const sb of successfulBranches) {
+          const ticket = ticketsByNum.get(sb.ticketNum);
+          if (ticket && ticket.status === "done") continue;
+          try {
+            await removeWorktree(sb.worktreePath);
+          } catch (err) {
+            d.log(
+              `  Failed to remove worktree ${sb.worktreePath}: ` + formatErrorMessage(err)
+            );
+          }
+        }
+        break;
+      }
+    }
+    if (waveCompleted === 0) {
+      d.log(
+        "\nNo tickets completed this wave. Stopping."
+      );
+      break;
+    }
+  }
+  const remaining = opts.tickets.filter(
+    (t) => t.status === "ready-for-agent"
+  );
+  d.log(
+    `
+Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
+  );
+  d.cleanup();
+  return { allDone: remaining.length === 0 };
+}
+__name(runWavesIsolated, "runWavesIsolated");
+
+// src/resolve.ts
+import { existsSync as existsSync3, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { select } from "@inquirer/prompts";
+function getScriptDir(metaUrl) {
+  return dirname2(fileURLToPath(metaUrl));
+}
+__name(getScriptDir, "getScriptDir");
+function findFeatureDirs(cwd) {
+  const scratchDir = join4(cwd, ".scratch");
+  if (!existsSync3(scratchDir)) return [];
+  const entries = readdirSync3(
+    scratchDir,
+    { withFileTypes: true }
+  );
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const issuesDir = join4(
+      scratchDir,
+      entry.name,
+      "issues"
+    );
+    const specFile = join4(
+      scratchDir,
+      entry.name,
+      "spec.md"
+    );
+    if (existsSync3(issuesDir)) {
+      results.push({
+        name: entry.name,
+        dir: issuesDir,
+        spec: specFile
+      });
+    }
+  }
+  return results;
+}
+__name(findFeatureDirs, "findFeatureDirs");
+async function resolveIssuesDir(specName, cwd = process.cwd()) {
+  if (specName) {
+    const featureDir = join4(cwd, ".scratch", specName);
+    return {
+      dir: join4(featureDir, "issues"),
+      spec: join4(featureDir, "spec.md")
+    };
+  }
+  const features = findFeatureDirs(cwd);
+  if (features.length === 0) {
+    console.error(
+      "No .scratch/<feature>/issues/ directories found.\nProvide --spec <feature-name>."
+    );
+    process.exit(2);
+  }
+  let chosen;
+  if (features.length === 1) {
+    chosen = features[0];
+    console.log(`Using feature: ${chosen.name}`);
+  } else {
+    const name = await select({
+      message: "Which feature?",
+      choices: features.map((f) => ({
+        name: f.name,
+        value: f.name
+      }))
+    });
+    chosen = features.find((f) => f.name === name);
+  }
+  return { dir: chosen.dir, spec: chosen.spec };
+}
+__name(resolveIssuesDir, "resolveIssuesDir");
+
+// src/index.ts
+var scriptDir = getScriptDir(import.meta.url);
 yargs(hideBin(process.argv)).scriptName("nightralph").usage("$0 <command>").command(
   "setup",
   "Install bundled skills and doc templates",
@@ -31,7 +1938,7 @@ yargs(hideBin(process.argv)).scriptName("nightralph").usage("$0 <command>").comm
     default: false
   }),
   async (argv) => {
-    const tracker = await select({
+    const tracker = await select2({
       message: "Issue tracker format",
       choices: [
         {
@@ -55,8 +1962,8 @@ yargs(hideBin(process.argv)).scriptName("nightralph").usage("$0 <command>").comm
       }
     }
     setup({
-      bundledSkillsDir: join(scriptDir, "skills"),
-      docsTemplatesDir: join(
+      bundledSkillsDir: join5(scriptDir, "skills"),
+      docsTemplatesDir: join5(
         scriptDir,
         "docs-templates"
       ),
@@ -127,15 +2034,15 @@ async function runExecute(argv) {
   const { dir, spec } = await resolveIssuesDir(
     argv.spec
   );
-  if (!existsSync(dir)) {
+  if (!existsSync4(dir)) {
     console.error(`Directory not found: ${dir}`);
     process.exit(2);
   }
-  if (!existsSync(spec)) {
+  if (!existsSync4(spec)) {
     console.error(`Spec file not found: ${spec}`);
     process.exit(2);
   }
-  const specBody = readFileSync(spec, "utf8");
+  const specBody = readFileSync4(spec, "utf8");
   const tickets = scanTickets(dir);
   if (tickets.length === 0) {
     console.log("No ticket files found. Exiting.");
@@ -156,12 +2063,12 @@ async function runExecute(argv) {
       (b) => knownNums.has(b)
     );
   }
-  const logsDir = join(dirname(dir), "logs");
+  const logsDir = join5(dirname3(dir), "logs");
   const timeout = argv.timeout ?? 300;
   const featureName = extractFeatureName(spec);
   const conflictStrategy = argv.stopOnConflict ? "stop" : "respawn";
-  const progressPath = join(
-    dirname(dir),
+  const progressPath = join5(
+    dirname3(dir),
     "progress.md"
   );
   if (argv.dryRun) {