@jonit-dev/night-watch-cli 1.7.48 → 1.7.50

package/dist/cli.js

@@ -46,115 +46,127 @@ import * as fs6 from "fs";
 import * as fs7 from "fs";
 import * as path6 from "path";
 import { execSync as execSync2 } from "child_process";
-import * as fs8 from "fs";
-import * as path7 from "path";
 import * as os3 from "os";
+import * as path7 from "path";
+import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path8 from "path";
+import * as os4 from "os";
+import * as path9 from "path";
 import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs10 from "fs";
 import chalk from "chalk";
 import ora from "ora";
 import Table from "cli-table3";
-import * as fs9 from "fs";
-import * as fs10 from "fs";
-import * as os4 from "os";
-import * as path9 from "path";
-import * as crypto from "crypto";
+import { execFileSync as execFileSync3 } from "child_process";
 import * as fs11 from "fs";
 import * as path10 from "path";
 import * as fs12 from "fs";
 import * as path11 from "path";
 import * as fs13 from "fs";
+import * as os5 from "os";
 import * as path12 from "path";
+import * as crypto from "crypto";
+import * as fs14 from "fs";
+import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
+import * as fs17 from "fs";
+import * as path16 from "path";
 import "reflect-metadata";
 import { Command as Command2 } from "commander";
-import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync18 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname8, join as join30 } from "path";
-import fs14 from "fs";
-import path13 from "path";
+import { dirname as dirname8, join as join33 } from "path";
+import fs18 from "fs";
+import path17 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join13 } from "path";
+import { dirname as dirname4, join as join16 } from "path";
 import * as readline from "readline";
-import * as fs15 from "fs";
-import * as path14 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-import * as path15 from "path";
-import * as path16 from "path";
-import * as fs16 from "fs";
-import * as path17 from "path";
-import { execSync as execSync4 } from "child_process";
+import * as fs19 from "fs";
 import * as path18 from "path";
-import * as fs17 from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
 import * as path19 from "path";
-import * as fs18 from "fs";
-import chalk2 from "chalk";
-import { spawn as spawn3 } from "child_process";
 import * as path20 from "path";
-import * as fs19 from "fs";
 import * as fs20 from "fs";
 import * as path21 from "path";
+import { execSync as execSync4 } from "child_process";
+import * as path22 from "path";
+import * as fs21 from "fs";
+import * as path23 from "path";
+import * as fs22 from "fs";
+import chalk2 from "chalk";
+import { spawn as spawn3 } from "child_process";
+import * as path24 from "path";
+import * as fs23 from "fs";
+import * as fs24 from "fs";
+import * as path25 from "path";
 import * as readline2 from "readline";
 import blessed6 from "blessed";
 import blessed from "blessed";
-import * as fs21 from "fs";
+import * as fs25 from "fs";
 import blessed2 from "blessed";
 import blessed3 from "blessed";
 import cronstrue from "cronstrue";
 import blessed4 from "blessed";
 import { spawn as spawn4 } from "child_process";
 import blessed5 from "blessed";
-import * as fs22 from "fs";
-import * as path22 from "path";
-import * as fs27 from "fs";
 import * as fs26 from "fs";
-import * as path28 from "path";
+import * as path26 from "path";
+import * as fs31 from "fs";
+import * as fs30 from "fs";
+import * as path32 from "path";
 import { dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import cors from "cors";
 import express from "express";
-import * as fs23 from "fs";
-import * as path23 from "path";
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path27 from "path";
+import * as fs28 from "fs";
+import * as path28 from "path";
 import { spawn as spawn5 } from "child_process";
 import { Router } from "express";
 import { Router as Router2 } from "express";
 import { Router as Router3 } from "express";
 import { Router as Router4 } from "express";
-import * as fs25 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path29 from "path";
 import { execSync as execSync5 } from "child_process";
 import { Router as Router5 } from "express";
-import * as path26 from "path";
+import * as path30 from "path";
 import { Router as Router6 } from "express";
 import { Router as Router7 } from "express";
-import * as path27 from "path";
+import * as path31 from "path";
 import { Router as Router8 } from "express";
 import { Router as Router9 } from "express";
 import { CronExpressionParser } from "cron-parser";
 import { spawnSync } from "child_process";
-import * as fs28 from "fs";
-import * as path29 from "path";
-import * as fs29 from "fs";
-import * as path30 from "path";
+import * as fs32 from "fs";
+import * as path33 from "path";
+import * as fs33 from "fs";
+import * as path34 from "path";
 import chalk3 from "chalk";
 import chalk4 from "chalk";
 import { execSync as execSync6 } from "child_process";
-import * as fs30 from "fs";
+import * as fs34 from "fs";
 import * as readline3 from "readline";
-import * as fs31 from "fs";
-import * as path31 from "path";
-import * as os5 from "os";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path35 from "path";
+import * as os6 from "os";
+import * as path36 from "path";
 import chalk5 from "chalk";
 import { Command } from "commander";
-import { execFileSync as execFileSync3 } from "child_process";
-import * as fs32 from "fs";
-import * as path33 from "path";
+import { execFileSync as execFileSync6 } from "child_process";
+import * as fs36 from "fs";
+import * as path37 from "path";
 import * as readline4 from "readline";
 import chalk6 from "chalk";
 var __defProp = Object.defineProperty;
@@ -3453,101 +3465,107 @@ function findMatchingIssue(targetTitle, issues, threshold = 0.8) {
   }
   return bestMatch;
 }
+var HORIZON_SHORT_TERM;
+var HORIZON_MEDIUM_TERM;
+var HORIZON_LONG_TERM;
 var ROADMAP_SECTION_MAPPINGS;
 var init_roadmap_mapping = __esm({
   "../core/dist/board/roadmap-mapping.js"() {
     "use strict";
+    HORIZON_SHORT_TERM = "short-term";
+    HORIZON_MEDIUM_TERM = "medium-term";
+    HORIZON_LONG_TERM = "long-term";
     ROADMAP_SECTION_MAPPINGS = [
       {
         sectionPattern: /§1.*Reliability.*correctness/i,
         category: "reliability",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /§2.*Quality.*developer/i,
         category: "quality",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /§3.*Product.*operators/i,
         category: "product",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /§4.*Unified.*operations/i,
         category: "ux",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /§5.*Provider.*execution/i,
         category: "provider",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /§6.*Team.*multi-project/i,
         category: "team",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /§7.*Platformization.*enterprise/i,
         category: "platform",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       },
       {
         sectionPattern: /§8.*Intelligence.*autonomous/i,
         category: "intelligence",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       },
       {
         sectionPattern: /§9.*Ecosystem.*adoption/i,
         category: "ecosystem",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       },
       // Fallback patterns without section numbers
       {
         sectionPattern: /Reliability.*correctness/i,
         category: "reliability",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /Quality.*developer.*workflow/i,
         category: "quality",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /Product.*completeness/i,
         category: "product",
-        horizon: "short-term"
+        horizon: HORIZON_SHORT_TERM
       },
       {
         sectionPattern: /Unified.*operations/i,
         category: "ux",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /Provider.*execution/i,
         category: "provider",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /Team.*multi-project/i,
         category: "team",
-        horizon: "medium-term"
+        horizon: HORIZON_MEDIUM_TERM
       },
       {
         sectionPattern: /Platformization.*enterprise/i,
         category: "platform",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       },
       {
         sectionPattern: /Intelligence.*autonomous/i,
         category: "intelligence",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       },
       {
         sectionPattern: /Ecosystem.*adoption/i,
         category: "ecosystem",
-        horizon: "long-term"
+        horizon: HORIZON_LONG_TERM
       }
     ];
   }
@@ -4286,6 +4304,34 @@ function checkLockFile(lockPath) {
     return { running: false, pid: null };
   }
 }
+function acquireLock(lockPath, pid) {
+  const effectivePid = pid ?? process.pid;
+  if (fs5.existsSync(lockPath)) {
+    const lockInfo = checkLockFile(lockPath);
+    if (lockInfo.running) {
+      return false;
+    }
+    try {
+      fs5.unlinkSync(lockPath);
+    } catch {
+      return false;
+    }
+  }
+  try {
+    fs5.writeFileSync(lockPath, String(effectivePid), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(lockPath) {
+  try {
+    if (fs5.existsSync(lockPath)) {
+      fs5.unlinkSync(lockPath);
+    }
+  } catch {
+  }
+}
 function countPRDs(projectDir, prdDir, maxRuntime) {
   const fullPrdPath = path5.join(projectDir, prdDir);
   if (!fs5.existsSync(fullPrdPath)) {
@@ -4877,7 +4923,7 @@ function checkPrdDirectory(projectDir, prdDir) {
       }
     };
   }
-  const prds = fs7.readdirSync(prdPath).filter((f) => f.endsWith(".md") && f !== "NIGHT-WATCH-SUMMARY.md");
+  const prds = fs7.readdirSync(prdPath).filter((f) => f.endsWith(".md"));
   return {
     passed: true,
     message: `PRD directory found: ${prdDir} (${prds.length} PRDs)`,
@@ -4950,12 +4996,90 @@ var init_checks = __esm({
     init_constants();
   }
 });
+function claimPrd(prdDir, prdFile, pid) {
+  const claimPath = path7.join(prdDir, prdFile + CLAIM_FILE_EXTENSION);
+  const claimData = {
+    timestamp: Math.floor(Date.now() / 1e3),
+    hostname: os3.hostname(),
+    pid: pid ?? process.pid
+  };
+  fs8.writeFileSync(claimPath, JSON.stringify(claimData), "utf-8");
+}
+function releaseClaim(prdDir, prdFile) {
+  const claimPath = path7.join(prdDir, prdFile + CLAIM_FILE_EXTENSION);
+  try {
+    if (fs8.existsSync(claimPath)) {
+      fs8.unlinkSync(claimPath);
+    }
+  } catch {
+  }
+}
+function isClaimed(prdDir, prdFile, maxRuntime) {
+  const claimPath = path7.join(prdDir, prdFile + CLAIM_FILE_EXTENSION);
+  if (!fs8.existsSync(claimPath)) {
+    return false;
+  }
+  try {
+    const content = fs8.readFileSync(claimPath, "utf-8");
+    const claimData = JSON.parse(content);
+    if (typeof claimData.timestamp !== "number") {
+      fs8.unlinkSync(claimPath);
+      return false;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const age = now - claimData.timestamp;
+    if (age >= maxRuntime) {
+      fs8.unlinkSync(claimPath);
+      return false;
+    }
+    return true;
+  } catch {
+    try {
+      fs8.unlinkSync(claimPath);
+    } catch {
+    }
+    return false;
+  }
+}
+function readClaimInfo(prdDir, prdFile, maxRuntime) {
+  const claimPath = path7.join(prdDir, prdFile + CLAIM_FILE_EXTENSION);
+  if (!fs8.existsSync(claimPath)) {
+    return null;
+  }
+  try {
+    const content = fs8.readFileSync(claimPath, "utf-8");
+    const claimData = JSON.parse(content);
+    if (typeof claimData.timestamp !== "number") {
+      fs8.unlinkSync(claimPath);
+      return null;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const age = now - claimData.timestamp;
+    if (age >= maxRuntime) {
+      fs8.unlinkSync(claimPath);
+      return null;
+    }
+    return claimData;
+  } catch {
+    try {
+      fs8.unlinkSync(claimPath);
+    } catch {
+    }
+    return null;
+  }
+}
+var init_claim_manager = __esm({
+  "../core/dist/utils/claim-manager.js"() {
+    "use strict";
+    init_constants();
+  }
+});
 function saveConfig(projectDir, changes) {
-  const configPath = path7.join(projectDir, CONFIG_FILE_NAME);
+  const configPath = path8.join(projectDir, CONFIG_FILE_NAME);
   try {
     let existing = {};
-    if (fs8.existsSync(configPath)) {
-      const content = fs8.readFileSync(configPath, "utf-8");
+    if (fs9.existsSync(configPath)) {
+      const content = fs9.readFileSync(configPath, "utf-8");
       existing = JSON.parse(content);
     }
     const merged = { ...existing };
@@ -4968,7 +5092,7 @@ function saveConfig(projectDir, changes) {
         }
       }
     }
-    fs8.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
+    fs9.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
     return { success: true };
   } catch (err) {
     return {
@@ -4984,8 +5108,8 @@ var init_config_writer = __esm({
   }
 });
 function getHistoryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path8.join(os3.homedir(), GLOBAL_CONFIG_DIR);
-  return path8.join(base, HISTORY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path9.join(os4.homedir(), GLOBAL_CONFIG_DIR);
+  return path9.join(base, HISTORY_FILE_NAME);
 }
 function loadHistory() {
   const { executionHistory } = getRepositories();
@@ -4996,7 +5120,7 @@ function saveHistory(history) {
   executionHistory.replaceAll(history);
 }
 function recordExecution(projectDir, prdFile, outcome, exitCode, attempt = 1) {
-  const resolved = path8.resolve(projectDir);
+  const resolved = path9.resolve(projectDir);
   const { executionHistory } = getRepositories();
   const record = {
     timestamp: Math.floor(Date.now() / 1e3),
@@ -5008,7 +5132,7 @@ function recordExecution(projectDir, prdFile, outcome, exitCode, attempt = 1) {
   executionHistory.trimRecords(resolved, prdFile, MAX_HISTORY_RECORDS_PER_PRD);
 }
 function getLastExecution(projectDir, prdFile) {
-  const resolved = path8.resolve(projectDir);
+  const resolved = path9.resolve(projectDir);
   const { executionHistory } = getRepositories();
   const records = executionHistory.getRecords(resolved, prdFile);
   return records.length > 0 ? records[0] : null;
@@ -5033,6 +5157,94 @@ var init_execution_history = __esm({
     init_client();
   }
 });
+function getBranchTipTimestamp(projectDir, branch) {
+  let remoteTs = null;
+  let localTs = null;
+  try {
+    const output = execFileSync("git", ["-C", projectDir, "log", "-1", "--format=%ct", `refs/remotes/origin/${branch}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (output) {
+      remoteTs = parseInt(output, 10);
+    }
+  } catch {
+  }
+  try {
+    const output = execFileSync("git", ["-C", projectDir, "log", "-1", "--format=%ct", `refs/heads/${branch}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (output) {
+      localTs = parseInt(output, 10);
+    }
+  } catch {
+  }
+  if (remoteTs !== null && localTs !== null) {
+    return localTs > remoteTs ? localTs : remoteTs;
+  }
+  if (remoteTs !== null) {
+    return remoteTs;
+  }
+  if (localTs !== null) {
+    return localTs;
+  }
+  return null;
+}
+function detectDefaultBranch(projectDir) {
+  const mainTs = getBranchTipTimestamp(projectDir, "main");
+  const masterTs = getBranchTipTimestamp(projectDir, "master");
+  if (mainTs !== null && masterTs !== null) {
+    return mainTs >= masterTs ? "main" : "master";
+  }
+  if (mainTs !== null) {
+    return "main";
+  }
+  if (masterTs !== null) {
+    return "master";
+  }
+  try {
+    const output = execFileSync("git", ["-C", projectDir, "symbolic-ref", "refs/remotes/origin/HEAD"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const match = output.match(/^refs\/remotes\/origin\/(.+)$/);
+    if (match) {
+      return match[1];
+    }
+  } catch {
+  }
+  return "main";
+}
+function resolveWorktreeBaseRef(projectDir, defaultBranch) {
+  try {
+    execFileSync("git", [
+      "-C",
+      projectDir,
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/remotes/origin/${defaultBranch}`
+    ], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return `origin/${defaultBranch}`;
+  } catch {
+  }
+  try {
+    execFileSync("git", ["-C", projectDir, "rev-parse", "--verify", "--quiet", `refs/heads/${defaultBranch}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return defaultBranch;
+  } catch {
+  }
+  try {
+    execFileSync("git", ["-C", projectDir, "rev-parse", "--verify", "--quiet", "refs/remotes/origin/HEAD"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return "origin/HEAD";
+  } catch {
+  }
+  try {
+    execFileSync("git", ["-C", projectDir, "rev-parse", "--verify", "--quiet", "HEAD"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return "HEAD";
+  } catch {
+  }
+  return null;
+}
+var init_git_utils = __esm({
+  "../core/dist/utils/git-utils.js"() {
+    "use strict";
+  }
+});
 function parsePrDetails(raw) {
   try {
     const details = JSON.parse(raw);
@@ -5054,7 +5266,7 @@ function parsePrDetails(raw) {
 }
 function fetchPrBySelector(selector, cwd) {
   try {
-    const output = execFileSync("gh", ["pr", "view", selector, "--json", "number,title,url,body,additions,deletions,changedFiles"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const output = execFileSync2("gh", ["pr", "view", selector, "--json", "number,title,url,body,additions,deletions,changedFiles"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     return parsePrDetails(output);
   } catch {
     return null;
@@ -5068,7 +5280,7 @@ function fetchPrDetailsByNumber(prNumber, cwd) {
 }
 function fetchPrDetails(branchPrefix, cwd) {
   try {
-    const listOutput = execFileSync("gh", ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "20"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const listOutput = execFileSync2("gh", ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "20"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const prs = JSON.parse(listOutput);
     const matching = prs.filter((pr) => pr.headRefName.startsWith(branchPrefix + "/"));
     if (matching.length === 0) {
@@ -5082,7 +5294,7 @@ function fetchPrDetails(branchPrefix, cwd) {
 }
 function fetchReviewedPrDetails(branchPatterns, cwd) {
   try {
-    const listOutput = execFileSync("gh", ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "20"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const listOutput = execFileSync2("gh", ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "20"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const prs = JSON.parse(listOutput);
     const matching = prs.filter((pr) => branchPatterns.some((pattern) => pr.headRefName.startsWith(pattern)));
     if (matching.length === 0) {
@@ -5123,6 +5335,45 @@ var init_github = __esm({
     "use strict";
   }
 });
+function rotateLog(logFile, maxSize = DEFAULT_MAX_LOG_SIZE) {
+  if (!fs10.existsSync(logFile)) {
+    return false;
+  }
+  try {
+    const stats = fs10.statSync(logFile);
+    if (stats.size > maxSize) {
+      const oldPath = `${logFile}.old`;
+      fs10.renameSync(logFile, oldPath);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function checkRateLimited(logFile, startLine) {
+  if (!fs10.existsSync(logFile)) {
+    return false;
+  }
+  try {
+    const content = fs10.readFileSync(logFile, "utf-8");
+    const lines = content.split("\n");
+    let linesToCheck;
+    if (startLine !== void 0 && startLine > 0) {
+      linesToCheck = lines.slice(startLine);
+    } else {
+      linesToCheck = lines.slice(-20);
+    }
+    return linesToCheck.some((line) => line.includes("429"));
+  } catch {
+    return false;
+  }
+}
+var init_log_utils = __esm({
+  "../core/dist/utils/log-utils.js"() {
+    "use strict";
+    init_constants();
+  }
+});
 function success(msg) {
   console.log(chalk.green("\u2714"), msg);
 }
@@ -5282,6 +5533,11 @@ function buildDescription(ctx) {
   if (ctx.duration !== void 0) {
     lines.push(`Duration: ${ctx.duration}s`);
   }
+  if (ctx.event === "run_timeout") {
+    lines.push("Cause: Execution hit the max runtime limit and was terminated.");
+    lines.push("Resume: Progress is checkpointed on timeout, and the next run resumes from that branch state.");
+    lines.push("Recommendation: Avoid huge PRDs; slice large work into smaller PRDs/phases.");
+  }
   if (ctx.event === "review_completed" && ctx.attempts !== void 0 && ctx.attempts > 1) {
     const retryInfo = `Attempts: ${ctx.attempts}`;
     if (ctx.finalScore !== void 0) {
@@ -5453,27 +5709,145 @@ var init_notify = __esm({
     init_github();
   }
 });
+function getOpenBranches(projectDir) {
+  try {
+    const output = execFileSync3("gh", ["pr", "list", "--state", "open", "--json", "headRefName", "--jq", ".[].headRefName"], { cwd: projectDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return output.trim().split("\n").filter((b) => b.length > 0);
+  } catch {
+    return [];
+  }
+}
+function sortPrdsByPriority(files, priorityList) {
+  if (!priorityList.length) {
+    return files;
+  }
+  const prioritySet = new Set(priorityList);
+  const prioritized = [];
+  const remaining = [];
+  for (const priorityName of priorityList) {
+    const match = files.find((f) => f === `${priorityName}.md`);
+    if (match) {
+      prioritized.push(match);
+    }
+  }
+  for (const file of files) {
+    if (!prioritySet.has(file.replace(/\.md$/, ""))) {
+      remaining.push(file);
+    }
+  }
+  return [...prioritized, ...remaining];
+}
+function findEligiblePrd(options) {
+  const { prdDir, projectDir, maxRuntime, prdPriority } = options;
+  const doneDir = path10.join(prdDir, "done");
+  if (!fs11.existsSync(prdDir)) {
+    return null;
+  }
+  let prdFiles = fs11.readdirSync(prdDir).filter((f) => f.endsWith(".md") && fs11.statSync(path10.join(prdDir, f)).isFile()).sort();
+  if (prdFiles.length === 0) {
+    return null;
+  }
+  if (prdPriority) {
+    const priorityList = prdPriority.split(":").filter((p) => p.length > 0);
+    prdFiles = sortPrdsByPriority(prdFiles, priorityList);
+  }
+  const openBranches = getOpenBranches(projectDir);
+  for (const prdFile of prdFiles) {
+    const prdName = prdFile.replace(/\.md$/, "");
+    const prdPath = path10.join(prdDir, prdFile);
+    if (isClaimed(prdDir, prdFile, maxRuntime)) {
+      continue;
+    }
+    if (isInCooldown(projectDir, prdFile, maxRuntime)) {
+      continue;
+    }
+    if (openBranches.some((branch) => branch.includes(prdName))) {
+      continue;
+    }
+    const dependencies = parsePrdDependencies(prdPath);
+    let allDepsMet = true;
+    for (const dep of dependencies) {
+      const depFile = dep.endsWith(".md") ? dep : `${dep}.md`;
+      const depPath = path10.join(doneDir, depFile);
+      if (!fs11.existsSync(depPath)) {
+        allDepsMet = false;
+        break;
+      }
+    }
+    if (!allDepsMet) {
+      continue;
+    }
+    return prdFile;
+  }
+  return null;
+}
+function findEligibleBoardIssue(options) {
+  const { projectDir, maxRuntime } = options;
+  try {
+    const output = execFileSync3("gh", ["issue", "list", "--state", "open", "--json", "number,title,body", "--jq", ".[]"], { cwd: projectDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const issues = output.trim().split("\n").filter((line) => line.length > 0);
+    for (const issueLine of issues) {
+      try {
+        const issue = JSON.parse(issueLine);
+        const claimFile = `issue-${issue.number}`;
+        if (isClaimed(projectDir, claimFile, maxRuntime)) {
+          continue;
+        }
+        return {
+          number: issue.number,
+          title: issue.title,
+          body: issue.body || ""
+        };
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+var init_prd_discovery = __esm({
+  "../core/dist/utils/prd-discovery.js"() {
+    "use strict";
+    init_claim_manager();
+    init_execution_history();
+    init_status_data();
+  }
+});
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber(prdDir) {
-  if (!fs9.existsSync(prdDir))
+  if (!fs12.existsSync(prdDir))
     return 1;
-  const files = fs9.readdirSync(prdDir).filter((f) => f.endsWith(".md") && f !== "NIGHT-WATCH-SUMMARY.md");
+  const files = fs12.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
   });
   return Math.max(0, ...numbers) + 1;
 }
+function markPrdDone(prdDir, prdFile) {
+  const sourcePath = path11.join(prdDir, prdFile);
+  if (!fs12.existsSync(sourcePath)) {
+    return false;
+  }
+  const doneDir = path11.join(prdDir, "done");
+  if (!fs12.existsSync(doneDir)) {
+    fs12.mkdirSync(doneDir, { recursive: true });
+  }
+  const destPath = path11.join(doneDir, prdFile);
+  fs12.renameSync(sourcePath, destPath);
+  return true;
+}
 var init_prd_utils = __esm({
   "../core/dist/utils/prd-utils.js"() {
     "use strict";
   }
 });
 function getRegistryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path9.join(os4.homedir(), GLOBAL_CONFIG_DIR);
-  return path9.join(base, REGISTRY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path12.join(os5.homedir(), GLOBAL_CONFIG_DIR);
+  return path12.join(base, REGISTRY_FILE_NAME);
 }
 function loadRegistry() {
   const { projectRegistry } = getRepositories();
@@ -5487,7 +5861,7 @@ function saveRegistry(entries) {
   }
 }
 function registerProject(projectDir) {
-  const resolvedPath = path9.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   const { projectRegistry } = getRepositories();
   const entries = projectRegistry.getAll();
   const existing = entries.find((e) => e.path === resolvedPath);
@@ -5496,13 +5870,13 @@ function registerProject(projectDir) {
   }
   const name = getProjectName(resolvedPath);
   const nameExists = entries.some((e) => e.name === name);
-  const finalName = nameExists ? `${name}-${path9.basename(resolvedPath)}` : name;
+  const finalName = nameExists ? `${name}-${path12.basename(resolvedPath)}` : name;
   const entry = { name: finalName, path: resolvedPath };
   projectRegistry.upsert(entry);
   return entry;
 }
 function unregisterProject(projectDir) {
-  const resolvedPath = path9.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   const { projectRegistry } = getRepositories();
   return projectRegistry.remove(resolvedPath);
 }
@@ -5511,7 +5885,7 @@ function validateRegistry() {
   const valid = [];
   const invalid = [];
   for (const entry of entries) {
-    if (fs10.existsSync(entry.path) && fs10.existsSync(path9.join(entry.path, CONFIG_FILE_NAME))) {
+    if (fs13.existsSync(entry.path) && fs13.existsSync(path12.join(entry.path, CONFIG_FILE_NAME))) {
       valid.push(entry);
     } else {
       invalid.push(entry);
@@ -5704,15 +6078,15 @@ var init_roadmap_parser = __esm({
   }
 });
 function getStateFilePath(prdDir) {
-  return path10.join(prdDir, STATE_FILE_NAME);
+  return path13.join(prdDir, STATE_FILE_NAME);
 }
 function readJsonState(prdDir) {
   const statePath = getStateFilePath(prdDir);
-  if (!fs11.existsSync(statePath)) {
+  if (!fs14.existsSync(statePath)) {
     return null;
   }
   try {
-    const content = fs11.readFileSync(statePath, "utf-8");
+    const content = fs14.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null) {
       return null;
@@ -5750,11 +6124,11 @@ function saveRoadmapState(prdDir, state) {
   const { roadmapState } = getRepositories();
   roadmapState.save(prdDir, state);
   const statePath = getStateFilePath(prdDir);
-  const dir = path10.dirname(statePath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(statePath);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs11.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  fs14.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 function createEmptyState() {
   return {
@@ -5797,9 +6171,9 @@ function loadSlicerTemplate(templateDir) {
   if (cachedTemplate) {
     return cachedTemplate;
   }
-  const templatePath = templateDir ? path11.join(templateDir, "night-watch-slicer.md") : path11.resolve(__dirname, "..", "..", "templates", "night-watch-slicer.md");
+  const templatePath = templateDir ? path14.join(templateDir, "night-watch-slicer.md") : path14.resolve(__dirname, "..", "..", "templates", "night-watch-slicer.md");
   try {
-    cachedTemplate = fs12.readFileSync(templatePath, "utf-8");
+    cachedTemplate = fs15.readFileSync(templatePath, "utf-8");
     return cachedTemplate;
   } catch (error2) {
     console.warn(`Warning: Could not load slicer template from ${templatePath}, using default:`, error2 instanceof Error ? error2.message : String(error2));
@@ -5824,7 +6198,7 @@ function createSlicerPromptVars(title, section, description, prdDir, prdFilename
     title,
     section,
     description: description || "(No description provided)",
-    outputFilePath: path11.join(prdDir, prdFilename),
+    outputFilePath: path14.join(prdDir, prdFilename),
     prdDir
   };
 }
@@ -6015,11 +6389,11 @@ function auditFindingToRoadmapItem(finding) {
   };
 }
 function collectAuditPlannerItems(projectDir) {
-  const reportPath = path12.join(projectDir, "logs", "audit-report.md");
-  if (!fs13.existsSync(reportPath)) {
+  const reportPath = path15.join(projectDir, "logs", "audit-report.md");
+  if (!fs16.existsSync(reportPath)) {
     return [];
   }
-  const reportContent = fs13.readFileSync(reportPath, "utf-8");
+  const reportContent = fs16.readFileSync(reportPath, "utf-8");
   if (!reportContent.trim() || /\bNO_ISSUES_FOUND\b/.test(reportContent)) {
     return [];
   }
@@ -6028,9 +6402,9 @@ function collectAuditPlannerItems(projectDir) {
   return findings.map(auditFindingToRoadmapItem);
 }
 function getRoadmapStatus(projectDir, config) {
-  const roadmapPath = path12.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const scannerEnabled = config.roadmapScanner.enabled;
-  if (!fs13.existsSync(roadmapPath)) {
+  if (!fs16.existsSync(roadmapPath)) {
     return {
       found: false,
       enabled: scannerEnabled,
@@ -6041,9 +6415,9 @@ function getRoadmapStatus(projectDir, config) {
       items: []
     };
   }
-  const content = fs13.readFileSync(roadmapPath, "utf-8");
+  const content = fs16.readFileSync(roadmapPath, "utf-8");
   const items = parseRoadmap(content);
-  const prdDir = path12.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const statusItems = items.map((item) => {
@@ -6080,12 +6454,12 @@ function getRoadmapStatus(projectDir, config) {
 }
 function scanExistingPrdSlugs(prdDir) {
   const slugs = /* @__PURE__ */ new Set();
-  if (!fs13.existsSync(prdDir)) {
+  if (!fs16.existsSync(prdDir)) {
     return slugs;
   }
-  const files = fs13.readdirSync(prdDir);
+  const files = fs16.readdirSync(prdDir);
   for (const file of files) {
-    if (!file.endsWith(".md") || file === "NIGHT-WATCH-SUMMARY.md") {
+    if (!file.endsWith(".md")) {
       continue;
     }
     const match = file.match(/^\d+-(.+)\.md$/);
@@ -6119,19 +6493,19 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
   const nextNum = getNextPrdNumber(prdDir);
   const padded = String(nextNum).padStart(2, "0");
   const filename = `${padded}-${itemSlug}.md`;
-  const filePath = path12.join(prdDir, filename);
-  if (!fs13.existsSync(prdDir)) {
-    fs13.mkdirSync(prdDir, { recursive: true });
+  const filePath = path15.join(prdDir, filename);
+  if (!fs16.existsSync(prdDir)) {
+    fs16.mkdirSync(prdDir, { recursive: true });
   }
   const promptVars = createSlicerPromptVars(item.title, item.section, item.description, prdDir, filename);
   const prompt2 = renderSlicerPrompt(promptVars);
   const providerArgs = buildProviderArgs(config.provider, prompt2);
-  const logDir = path12.join(projectDir, "logs");
-  if (!fs13.existsSync(logDir)) {
-    fs13.mkdirSync(logDir, { recursive: true });
+  const logDir = path15.join(projectDir, "logs");
+  if (!fs16.existsSync(logDir)) {
+    fs16.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path12.join(logDir, `slicer-${itemSlug}.log`);
-  const logStream = fs13.createWriteStream(logFile, { flags: "w" });
+  const logFile = path15.join(logDir, `slicer-${itemSlug}.log`);
+  const logStream = fs16.createWriteStream(logFile, { flags: "w" });
   logStream.on("error", () => {
   });
   return new Promise((resolve9) => {
@@ -6168,7 +6542,7 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
         });
         return;
       }
-      if (!fs13.existsSync(filePath)) {
+      if (!fs16.existsSync(filePath)) {
         resolve9({
           sliced: false,
           error: `Provider did not create expected file: ${filePath}`,
@@ -6191,23 +6565,23 @@ async function sliceNextItem(projectDir, config) {
       error: "Roadmap scanner is disabled"
     };
   }
-  const roadmapPath = path12.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const auditItems = collectAuditPlannerItems(projectDir);
-  const roadmapExists = fs13.existsSync(roadmapPath);
+  const roadmapExists = fs16.existsSync(roadmapPath);
   if (!roadmapExists && auditItems.length === 0) {
     return {
       sliced: false,
       error: "ROADMAP.md not found"
     };
   }
-  const roadmapItems = roadmapExists ? parseRoadmap(fs13.readFileSync(roadmapPath, "utf-8")) : [];
+  const roadmapItems = roadmapExists ? parseRoadmap(fs16.readFileSync(roadmapPath, "utf-8")) : [];
   if (roadmapExists && roadmapItems.length === 0 && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No items in roadmap"
     };
   }
-  const prdDir = path12.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const pickEligibleItem = (items) => {
@@ -6423,6 +6797,162 @@ var init_webhook_validator = __esm({
     "use strict";
   }
 });
+function gitExec(args, cwd, logFile) {
+  try {
+    const result = execFileSync4("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (logFile && result) {
+      try {
+        fs17.appendFileSync(logFile, result);
+      } catch {
+      }
+    }
+    return { success: true };
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    if (logFile) {
+      try {
+        fs17.appendFileSync(logFile, errorMessage + "\n");
+      } catch {
+      }
+    }
+    return { success: false, error: errorMessage };
+  }
+}
+function branchExistsLocally(projectDir, branchName) {
+  try {
+    execFileSync4("git", ["-C", projectDir, "rev-parse", "--verify", "--quiet", `refs/heads/${branchName}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function branchExistsRemotely(projectDir, branchName) {
+  try {
+    execFileSync4("git", ["-C", projectDir, "rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branchName}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function prepareBranchWorktree(options) {
+  const { projectDir, worktreeDir, branchName, defaultBranch, logFile } = options;
+  gitExec(["fetch", "origin", defaultBranch], projectDir, logFile);
+  const baseRef = resolveWorktreeBaseRef(projectDir, defaultBranch);
+  if (!baseRef) {
+    return {
+      success: false,
+      worktreePath: worktreeDir,
+      error: "No valid base ref found for worktree"
+    };
+  }
+  if (branchExistsLocally(projectDir, branchName)) {
+    const result2 = gitExec(["worktree", "add", worktreeDir, branchName], projectDir, logFile);
+    return {
+      success: result2.success,
+      worktreePath: worktreeDir,
+      error: result2.error
+    };
+  }
+  if (branchExistsRemotely(projectDir, branchName)) {
+    const result2 = gitExec(["worktree", "add", "-b", branchName, worktreeDir, `origin/${branchName}`], projectDir, logFile);
+    return {
+      success: result2.success,
+      worktreePath: worktreeDir,
+      error: result2.error
+    };
+  }
+  const result = gitExec(["worktree", "add", "-b", branchName, worktreeDir, baseRef], projectDir, logFile);
+  return {
+    success: result.success,
+    worktreePath: worktreeDir,
+    error: result.error
+  };
+}
+function prepareDetachedWorktree(options) {
+  const { projectDir, worktreeDir, defaultBranch, logFile } = options;
+  if (fs17.existsSync(worktreeDir)) {
+    const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
+    if (!isRegistered) {
+      try {
+        fs17.rmSync(worktreeDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  gitExec(["fetch", "origin", defaultBranch], projectDir, logFile);
+  const baseRef = resolveWorktreeBaseRef(projectDir, defaultBranch);
+  if (!baseRef) {
+    return {
+      success: false,
+      worktreePath: worktreeDir,
+      error: "No valid base ref found for worktree"
+    };
+  }
+  const result = gitExec(["worktree", "add", "--detach", worktreeDir, baseRef], projectDir, logFile);
+  return {
+    success: result.success,
+    worktreePath: worktreeDir,
+    error: result.error
+  };
+}
+function isWorktreeRegistered(projectDir, worktreePath) {
+  try {
+    const output = execFileSync4("git", ["-C", projectDir, "worktree", "list", "--porcelain"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = output.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        const wtPath = line.substring("worktree ".length);
+        if (wtPath === worktreePath) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function cleanupWorktrees(projectDir, scope) {
+  const projectName = path16.basename(projectDir);
+  const matchToken = scope ? scope : `${projectName}-nw`;
+  const removed = [];
+  try {
+    const output = execFileSync4("git", ["-C", projectDir, "worktree", "list", "--porcelain"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = output.split("\n");
+    const worktreePaths = [];
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        worktreePaths.push(line.substring("worktree ".length));
+      }
+    }
+    for (const wtPath of worktreePaths) {
+      if (wtPath.includes(matchToken)) {
+        const result = gitExec(["worktree", "remove", "--force", wtPath], projectDir);
+        if (result.success) {
+          removed.push(wtPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return removed;
+}
+var init_worktree_manager = __esm({
+  "../core/dist/utils/worktree-manager.js"() {
+    "use strict";
+    init_git_utils();
+  }
+});
 function renderDependsOn(deps) {
   if (deps.length === 0) {
     return "";
@@ -6678,6 +7208,7 @@ __export(dist_exports, {
   VALID_JOB_TYPES: () => VALID_JOB_TYPES,
   VALID_MERGE_METHODS: () => VALID_MERGE_METHODS,
   VALID_PROVIDERS: () => VALID_PROVIDERS,
+  acquireLock: () => acquireLock,
   addEntry: () => addEntry,
   auditLockPath: () => auditLockPath,
   buildDescription: () => buildDescription,
@@ -6692,6 +7223,9 @@ __export(dist_exports, {
   checkNodeVersion: () => checkNodeVersion,
   checkPrdDirectory: () => checkPrdDirectory,
   checkProviderCli: () => checkProviderCli,
+  checkRateLimited: () => checkRateLimited,
+  claimPrd: () => claimPrd,
+  cleanupWorktrees: () => cleanupWorktrees,
   clearPrdState: () => clearPrdState,
   clearTemplateCache: () => clearTemplateCache,
   closeDb: () => closeDb,
@@ -6711,6 +7245,7 @@ __export(dist_exports, {
   createSlicerPromptVars: () => createSlicerPromptVars,
   createSpinner: () => createSpinner,
   createTable: () => createTable,
+  detectDefaultBranch: () => detectDefaultBranch,
   detectProviders: () => detectProviders,
   dim: () => dim,
   error: () => error,
@@ -6726,6 +7261,8 @@ __export(dist_exports, {
   fetchPrDetailsForBranch: () => fetchPrDetailsForBranch,
   fetchReviewedPrDetails: () => fetchReviewedPrDetails,
   fetchStatusSnapshot: () => fetchStatusSnapshot,
+  findEligibleBoardIssue: () => findEligibleBoardIssue,
+  findEligiblePrd: () => findEligiblePrd,
   findMatchingIssue: () => findMatchingIssue,
   formatDiscordPayload: () => formatDiscordPayload,
   formatInstalledStatus: () => formatInstalledStatus,
@@ -6735,6 +7272,7 @@ __export(dist_exports, {
   generateItemHash: () => generateItemHash,
   generateMarker: () => generateMarker,
   generatePersonaAvatar: () => generatePersonaAvatar,
+  getBranchTipTimestamp: () => getBranchTipTimestamp,
   getCrontabInfo: () => getCrontabInfo,
   getDb: () => getDb,
   getDbPath: () => getDbPath,
@@ -6768,6 +7306,7 @@ __export(dist_exports, {
   header: () => header,
   info: () => info,
   initContainer: () => initContainer,
+  isClaimed: () => isClaimed,
   isContainerInitialized: () => isContainerInitialized,
   isInCooldown: () => isInCooldown,
   isItemProcessed: () => isItemProcessed,
@@ -6784,25 +7323,33 @@ __export(dist_exports, {
   loadRoadmapState: () => loadRoadmapState,
   loadSlicerTemplate: () => loadSlicerTemplate,
   markItemProcessed: () => markItemProcessed,
+  markPrdDone: () => markPrdDone,
   migrateJsonToSqlite: () => migrateJsonToSqlite,
   parsePrdDependencies: () => parsePrdDependencies,
   parseRoadmap: () => parseRoadmap,
   parseScriptResult: () => parseScriptResult,
   performCancel: () => performCancel,
   plannerLockPath: () => plannerLockPath,
+  prepareBranchWorktree: () => prepareBranchWorktree,
+  prepareDetachedWorktree: () => prepareDetachedWorktree,
   projectRuntimeKey: () => projectRuntimeKey,
   qaLockPath: () => qaLockPath,
+  readClaimInfo: () => readClaimInfo,
   readCrontab: () => readCrontab,
   readPrdStates: () => readPrdStates,
   recordExecution: () => recordExecution,
   registerProject: () => registerProject,
+  releaseClaim: () => releaseClaim,
+  releaseLock: () => releaseLock,
   removeEntries: () => removeEntries,
   removeEntriesForProject: () => removeEntriesForProject,
   renderPrdTemplate: () => renderPrdTemplate,
   renderSlicerPrompt: () => renderSlicerPrompt,
   resetRepositories: () => resetRepositories,
   resolveJobProvider: () => resolveJobProvider,
+  resolveWorktreeBaseRef: () => resolveWorktreeBaseRef,
   reviewerLockPath: () => reviewerLockPath,
+  rotateLog: () => rotateLog,
   runAllChecks: () => runAllChecks,
   runMigrations: () => runMigrations,
   saveConfig: () => saveConfig,
@@ -6817,6 +7364,7 @@ __export(dist_exports, {
   sliceRoadmapItem: () => sliceRoadmapItem,
   slugify: () => slugify,
   sortByPriority: () => sortByPriority,
+  sortPrdsByPriority: () => sortPrdsByPriority,
   step: () => step,
   success: () => success,
   unmarkItemProcessed: () => unmarkItemProcessed,
@@ -6850,11 +7398,15 @@ var init_dist = __esm({
     init_logger();
     init_cancel();
     init_checks();
+    init_claim_manager();
     init_config_writer();
     init_crontab();
     init_execution_history();
+    init_git_utils();
     init_github();
+    init_log_utils();
     init_notify();
+    init_prd_discovery();
     init_prd_states();
     init_prd_utils();
     init_registry();
@@ -6867,6 +7419,7 @@ var init_dist = __esm({
     init_status_data();
     init_ui();
     init_webhook_validator();
+    init_worktree_manager();
     init_prd_template();
     init_slicer_prompt();
   }
@@ -6877,22 +7430,22 @@ var __dirname2 = dirname4(__filename);
 function findTemplatesDir(startDir) {
   let d = startDir;
   for (let i = 0; i < 8; i++) {
-    const candidate = join13(d, "templates");
-    if (fs14.existsSync(candidate) && fs14.statSync(candidate).isDirectory()) {
+    const candidate = join16(d, "templates");
+    if (fs18.existsSync(candidate) && fs18.statSync(candidate).isDirectory()) {
       return candidate;
     }
     d = dirname4(d);
   }
-  return join13(startDir, "templates");
+  return join16(startDir, "templates");
 }
 var TEMPLATES_DIR = findTemplatesDir(__dirname2);
 function hasPlaywrightDependency(cwd) {
-  const packageJsonPath = path13.join(cwd, "package.json");
-  if (!fs14.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(cwd, "package.json");
+  if (!fs18.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson2 = JSON.parse(fs14.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson2 = JSON.parse(fs18.readFileSync(packageJsonPath, "utf-8"));
     return Boolean(packageJson2.dependencies?.["@playwright/test"] || packageJson2.dependencies?.playwright || packageJson2.devDependencies?.["@playwright/test"] || packageJson2.devDependencies?.playwright);
   } catch {
     return false;
@@ -6902,7 +7455,7 @@ function detectPlaywright(cwd) {
   if (hasPlaywrightDependency(cwd)) {
     return true;
   }
-  if (fs14.existsSync(path13.join(cwd, "node_modules", ".bin", "playwright"))) {
+  if (fs18.existsSync(path17.join(cwd, "node_modules", ".bin", "playwright"))) {
     return true;
   }
   try {
@@ -6918,10 +7471,10 @@ function detectPlaywright(cwd) {
   }
 }
 function resolvePlaywrightInstallCommand(cwd) {
-  if (fs14.existsSync(path13.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs18.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm add -D @playwright/test";
   }
-  if (fs14.existsSync(path13.join(cwd, "yarn.lock"))) {
+  if (fs18.existsSync(path17.join(cwd, "yarn.lock"))) {
     return "yarn add -D @playwright/test";
   }
   return "npm install -D @playwright/test";
@@ -7040,36 +7593,36 @@ function promptProviderSelection(providers) {
   });
 }
 function ensureDir(dirPath) {
-  if (!fs14.existsSync(dirPath)) {
-    fs14.mkdirSync(dirPath, { recursive: true });
+  if (!fs18.existsSync(dirPath)) {
+    fs18.mkdirSync(dirPath, { recursive: true });
   }
 }
 function resolveTemplatePath(templateName, customTemplatesDir, bundledTemplatesDir) {
   if (customTemplatesDir !== null) {
-    const customPath = join13(customTemplatesDir, templateName);
-    if (fs14.existsSync(customPath)) {
+    const customPath = join16(customTemplatesDir, templateName);
+    if (fs18.existsSync(customPath)) {
       return { path: customPath, source: "custom" };
     }
   }
-  return { path: join13(bundledTemplatesDir, templateName), source: "bundled" };
+  return { path: join16(bundledTemplatesDir, templateName), source: "bundled" };
 }
 function processTemplate(templateName, targetPath, replacements, force, sourcePath, source) {
-  if (fs14.existsSync(targetPath) && !force) {
+  if (fs18.existsSync(targetPath) && !force) {
     console.log(`  Skipped (exists): ${targetPath}`);
     return { created: false, source: source ?? "bundled" };
   }
-  const templatePath = sourcePath ?? join13(TEMPLATES_DIR, templateName);
+  const templatePath = sourcePath ?? join16(TEMPLATES_DIR, templateName);
   const resolvedSource = source ?? "bundled";
-  let content = fs14.readFileSync(templatePath, "utf-8");
+  let content = fs18.readFileSync(templatePath, "utf-8");
   for (const [key, value] of Object.entries(replacements)) {
     content = content.replaceAll(key, value);
   }
-  fs14.writeFileSync(targetPath, content);
+  fs18.writeFileSync(targetPath, content);
   console.log(`  Created: ${targetPath} (${resolvedSource})`);
   return { created: true, source: resolvedSource };
 }
 function addToGitignore(cwd) {
-  const gitignorePath = path13.join(cwd, ".gitignore");
+  const gitignorePath = path17.join(cwd, ".gitignore");
   const entries = [
     {
       pattern: "/logs/",
@@ -7083,13 +7636,13 @@ function addToGitignore(cwd) {
     },
     { pattern: "*.claim", label: "*.claim", check: (c) => c.includes("*.claim") }
   ];
-  if (!fs14.existsSync(gitignorePath)) {
+  if (!fs18.existsSync(gitignorePath)) {
     const lines = ["# Night Watch", ...entries.map((e) => e.pattern), ""];
-    fs14.writeFileSync(gitignorePath, lines.join("\n"));
+    fs18.writeFileSync(gitignorePath, lines.join("\n"));
     console.log(`  Created: ${gitignorePath} (with Night Watch entries)`);
     return;
   }
-  const content = fs14.readFileSync(gitignorePath, "utf-8");
+  const content = fs18.readFileSync(gitignorePath, "utf-8");
   const missing = entries.filter((e) => !e.check(content));
   if (missing.length === 0) {
     console.log(`  Skipped (exists): Night Watch entries in .gitignore`);
@@ -7097,30 +7650,15 @@ function addToGitignore(cwd) {
   }
   const additions = missing.map((e) => e.pattern).join("\n");
   const newContent = content.trimEnd() + "\n\n# Night Watch\n" + additions + "\n";
-  fs14.writeFileSync(gitignorePath, newContent);
+  fs18.writeFileSync(gitignorePath, newContent);
   console.log(`  Updated: ${gitignorePath} (added ${missing.map((e) => e.label).join(", ")})`);
 }
-function createSummaryFile(summaryPath, force) {
-  if (fs14.existsSync(summaryPath) && !force) {
-    console.log(`  Skipped (exists): ${summaryPath}`);
-    return;
-  }
-  const content = `# Night Watch Summary
-
-This file tracks the progress of PRDs executed by Night Watch.
-
----
-
-`;
-  fs14.writeFileSync(summaryPath, content);
-  console.log(`  Created: ${summaryPath}`);
-}
 function initCommand(program2) {
   program2.command("init").description("Initialize night-watch in the current project").option("-f, --force", "Overwrite existing configuration").option("-d, --prd-dir <path>", "Path to PRD directory").option("-p, --provider <name>", "AI provider to use (claude or codex)").option("--no-reviewer", "Disable reviewer cron job").action(async (options) => {
     const cwd = process.cwd();
     const force = options.force || false;
     const prdDir = options.prdDir || DEFAULT_PRD_DIR;
-    const totalSteps = 12;
+    const totalSteps = 11;
     console.log();
     header("Night Watch CLI - Initializing");
     step(1, totalSteps, "Checking git repository...");
@@ -7201,57 +7739,54 @@ function initCommand(program2) {
       "${DEFAULT_BRANCH}": defaultBranch
     };
     step(5, totalSteps, "Creating PRD directory structure...");
-    const prdDirPath = path13.join(cwd, prdDir);
-    const doneDirPath = path13.join(prdDirPath, "done");
+    const prdDirPath = path17.join(cwd, prdDir);
+    const doneDirPath = path17.join(prdDirPath, "done");
     ensureDir(doneDirPath);
     success(`Created ${prdDirPath}/`);
     success(`Created ${doneDirPath}/`);
-    step(6, totalSteps, "Creating NIGHT-WATCH-SUMMARY.md...");
-    const summaryPath = path13.join(prdDirPath, "NIGHT-WATCH-SUMMARY.md");
-    createSummaryFile(summaryPath, force);
-    step(7, totalSteps, "Creating logs directory...");
-    const logsPath = path13.join(cwd, LOG_DIR);
+    step(6, totalSteps, "Creating logs directory...");
+    const logsPath = path17.join(cwd, LOG_DIR);
     ensureDir(logsPath);
     success(`Created ${logsPath}/`);
     addToGitignore(cwd);
-    step(8, totalSteps, "Creating Claude slash commands...");
-    const commandsDir = path13.join(cwd, ".claude", "commands");
-    ensureDir(commandsDir);
-    success(`Created ${commandsDir}/`);
+    step(7, totalSteps, "Creating instructions directory...");
+    const instructionsDir = path17.join(cwd, "instructions");
+    ensureDir(instructionsDir);
+    success(`Created ${instructionsDir}/`);
     const existingConfig = loadConfig(cwd);
-    const customTemplatesDirPath = path13.join(cwd, existingConfig.templatesDir);
-    const customTemplatesDir = fs14.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
+    const customTemplatesDirPath = path17.join(cwd, existingConfig.templatesDir);
+    const customTemplatesDir = fs18.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
     const templateSources = [];
     const nwResolution = resolveTemplatePath("night-watch.md", customTemplatesDir, TEMPLATES_DIR);
-    const nwResult = processTemplate("night-watch.md", path13.join(commandsDir, "night-watch.md"), replacements, force, nwResolution.path, nwResolution.source);
+    const nwResult = processTemplate("night-watch.md", path17.join(instructionsDir, "night-watch.md"), replacements, force, nwResolution.path, nwResolution.source);
     templateSources.push({ name: "night-watch.md", source: nwResult.source });
     const peResolution = resolveTemplatePath("prd-executor.md", customTemplatesDir, TEMPLATES_DIR);
-    const peResult = processTemplate("prd-executor.md", path13.join(commandsDir, "prd-executor.md"), replacements, force, peResolution.path, peResolution.source);
+    const peResult = processTemplate("prd-executor.md", path17.join(instructionsDir, "prd-executor.md"), replacements, force, peResolution.path, peResolution.source);
     templateSources.push({ name: "prd-executor.md", source: peResult.source });
     const prResolution = resolveTemplatePath("night-watch-pr-reviewer.md", customTemplatesDir, TEMPLATES_DIR);
-    const prResult = processTemplate("night-watch-pr-reviewer.md", path13.join(commandsDir, "night-watch-pr-reviewer.md"), replacements, force, prResolution.path, prResolution.source);
+    const prResult = processTemplate("night-watch-pr-reviewer.md", path17.join(instructionsDir, "night-watch-pr-reviewer.md"), replacements, force, prResolution.path, prResolution.source);
     templateSources.push({ name: "night-watch-pr-reviewer.md", source: prResult.source });
     const qaResolution = resolveTemplatePath("night-watch-qa.md", customTemplatesDir, TEMPLATES_DIR);
-    const qaResult = processTemplate("night-watch-qa.md", path13.join(commandsDir, "night-watch-qa.md"), replacements, force, qaResolution.path, qaResolution.source);
+    const qaResult = processTemplate("night-watch-qa.md", path17.join(instructionsDir, "night-watch-qa.md"), replacements, force, qaResolution.path, qaResolution.source);
     templateSources.push({ name: "night-watch-qa.md", source: qaResult.source });
     const auditResolution = resolveTemplatePath("night-watch-audit.md", customTemplatesDir, TEMPLATES_DIR);
-    const auditResult = processTemplate("night-watch-audit.md", path13.join(commandsDir, "night-watch-audit.md"), replacements, force, auditResolution.path, auditResolution.source);
+    const auditResult = processTemplate("night-watch-audit.md", path17.join(instructionsDir, "night-watch-audit.md"), replacements, force, auditResolution.path, auditResolution.source);
     templateSources.push({ name: "night-watch-audit.md", source: auditResult.source });
-    step(9, totalSteps, "Creating configuration file...");
-    const configPath = path13.join(cwd, CONFIG_FILE_NAME);
-    if (fs14.existsSync(configPath) && !force) {
+    step(8, totalSteps, "Creating configuration file...");
+    const configPath = path17.join(cwd, CONFIG_FILE_NAME);
+    if (fs18.existsSync(configPath) && !force) {
       console.log(`  Skipped (exists): ${configPath}`);
     } else {
-      let configContent = fs14.readFileSync(join13(TEMPLATES_DIR, "night-watch.config.json"), "utf-8");
+      let configContent = fs18.readFileSync(join16(TEMPLATES_DIR, "night-watch.config.json"), "utf-8");
       configContent = configContent.replace('"projectName": ""', `"projectName": "${projectName}"`);
       configContent = configContent.replace('"defaultBranch": ""', `"defaultBranch": "${defaultBranch}"`);
       configContent = configContent.replace(/"provider":\s*"[^"]*"/, `"provider": "${selectedProvider}"`);
       configContent = configContent.replace(/"reviewerEnabled":\s*(true|false)/, `"reviewerEnabled": ${reviewerEnabled}`);
-      fs14.writeFileSync(configPath, configContent);
+      fs18.writeFileSync(configPath, configContent);
       success(`Created ${configPath}`);
     }
-    step(10, totalSteps, "Setting up GitHub Project board...");
-    const existingRaw = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+    step(9, totalSteps, "Setting up GitHub Project board...");
+    const existingRaw = JSON.parse(fs18.readFileSync(configPath, "utf-8"));
     const existingBoard = existingRaw.boardProvider;
     if (existingBoard?.projectNumber && !force) {
       info(`Board already configured (#${existingBoard.projectNumber}), skipping.`);
@@ -7273,13 +7808,13 @@ function initCommand(program2) {
           const provider = createBoardProvider({ enabled: true, provider: "github" }, cwd);
           const boardTitle = `${projectName} Night Watch`;
           const board = await provider.setupBoard(boardTitle);
-          const rawConfig = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+          const rawConfig = JSON.parse(fs18.readFileSync(configPath, "utf-8"));
           rawConfig.boardProvider = {
             enabled: true,
             provider: "github",
             projectNumber: board.number
           };
-          fs14.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+          fs18.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
           success(`GitHub Project board "${boardTitle}" ready (#${board.number})`);
         } catch (boardErr) {
           console.warn(`  Warning: Could not set up GitHub Project board: ${boardErr instanceof Error ? boardErr.message : String(boardErr)}`);
@@ -7287,7 +7822,7 @@ function initCommand(program2) {
         }
       }
     }
-    step(11, totalSteps, "Registering project in global registry...");
+    step(10, totalSteps, "Registering project in global registry...");
     try {
       const { registerProject: registerProject2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
       const entry = registerProject2(cwd);
@@ -7295,23 +7830,22 @@ function initCommand(program2) {
     } catch (regErr) {
       console.warn(`  Warning: Could not register in global registry: ${regErr instanceof Error ? regErr.message : String(regErr)}`);
     }
-    step(12, totalSteps, "Initialization complete!");
+    step(11, totalSteps, "Initialization complete!");
     header("Initialization Complete");
     const filesTable = createTable({ head: ["Created Files", ""] });
     filesTable.push(["PRD Directory", `${prdDir}/done/`]);
-    filesTable.push(["Summary File", `${prdDir}/NIGHT-WATCH-SUMMARY.md`]);
     filesTable.push(["Logs Directory", `${LOG_DIR}/`]);
     filesTable.push([
-      "Slash Commands",
-      `.claude/commands/night-watch.md (${templateSources[0].source})`
+      "Instructions",
+      `instructions/night-watch.md (${templateSources[0].source})`
     ]);
-    filesTable.push(["", `.claude/commands/prd-executor.md (${templateSources[1].source})`]);
+    filesTable.push(["", `instructions/prd-executor.md (${templateSources[1].source})`]);
     filesTable.push([
       "",
-      `.claude/commands/night-watch-pr-reviewer.md (${templateSources[2].source})`
+      `instructions/night-watch-pr-reviewer.md (${templateSources[2].source})`
     ]);
-    filesTable.push(["", `.claude/commands/night-watch-qa.md (${templateSources[3].source})`]);
-    filesTable.push(["", `.claude/commands/night-watch-audit.md (${templateSources[4].source})`]);
+    filesTable.push(["", `instructions/night-watch-qa.md (${templateSources[3].source})`]);
+    filesTable.push(["", `instructions/night-watch-audit.md (${templateSources[4].source})`]);
     filesTable.push(["Config File", CONFIG_FILE_NAME]);
     filesTable.push(["Global Registry", "~/.night-watch/projects.json"]);
     console.log(filesTable.toString());
@@ -7352,12 +7886,12 @@ function shouldAttemptCrossProjectFallback(options, scriptStatus) {
   return scriptStatus === "skip_no_eligible_prd";
 }
 function getCrossProjectFallbackCandidates(currentProjectDir) {
-  const current = path14.resolve(currentProjectDir);
+  const current = path18.resolve(currentProjectDir);
   const { valid, invalid } = validateRegistry();
   for (const entry of invalid) {
     warn(`Skipping invalid registry entry: ${entry.path}`);
   }
-  return valid.filter((entry) => path14.resolve(entry.path) !== current);
+  return valid.filter((entry) => path18.resolve(entry.path) !== current);
 }
 async function sendRunCompletionNotifications(config, projectDir, options, exitCode, scriptResult) {
   if (isRateLimitFallbackTriggered(scriptResult?.data)) {
@@ -7365,7 +7899,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     if (nonTelegramWebhooks.length > 0) {
       const _rateLimitCtx = {
         event: "rate_limit_fallback",
-        projectName: path14.basename(projectDir),
+        projectName: path18.basename(projectDir),
         exitCode,
         provider: config.provider
       };
@@ -7387,11 +7921,15 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     }
   }
   if (event) {
+    const timeoutDuration = event === "run_timeout" ? config.maxRuntime : void 0;
     const _ctx = {
       event,
-      projectName: path14.basename(projectDir),
+      projectName: path18.basename(projectDir),
       exitCode,
       provider: config.provider,
+      prdName: scriptResult?.data.prd,
+      branchName: scriptResult?.data.branch,
+      duration: timeoutDuration,
       prUrl: prDetails?.url,
       prTitle: prDetails?.title,
       prBody: prDetails?.body,
@@ -7499,20 +8037,20 @@ function applyCliOverrides(config, options) {
   return overridden;
 }
 function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
-  const absolutePrdDir = path14.join(projectDir, prdDir);
-  const doneDir = path14.join(absolutePrdDir, "done");
+  const absolutePrdDir = path18.join(projectDir, prdDir);
+  const doneDir = path18.join(absolutePrdDir, "done");
   const pending = [];
   const completed = [];
-  if (fs15.existsSync(absolutePrdDir)) {
-    const entries = fs15.readdirSync(absolutePrdDir, { withFileTypes: true });
+  if (fs19.existsSync(absolutePrdDir)) {
+    const entries = fs19.readdirSync(absolutePrdDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "NIGHT-WATCH-SUMMARY.md") {
-        const claimPath = path14.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const claimPath = path18.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
         let claimed = false;
         let claimInfo = null;
-        if (fs15.existsSync(claimPath)) {
+        if (fs19.existsSync(claimPath)) {
           try {
-            const content = fs15.readFileSync(claimPath, "utf-8");
+            const content = fs19.readFileSync(claimPath, "utf-8");
             const data = JSON.parse(content);
             const age = Math.floor(Date.now() / 1e3) - data.timestamp;
             if (age < maxRuntime) {
@@ -7526,8 +8064,8 @@ function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
       }
     }
   }
-  if (fs15.existsSync(doneDir)) {
-    const entries = fs15.readdirSync(doneDir, { withFileTypes: true });
+  if (fs19.existsSync(doneDir)) {
+    const entries = fs19.readdirSync(doneDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
         completed.push(entry.name);
@@ -7736,13 +8274,42 @@ function applyCliOverrides2(config, options) {
   }
   return overridden;
 }
+function isFailingCheck(check) {
+  const bucket = (check.bucket ?? "").toLowerCase();
+  const state = (check.state ?? "").toLowerCase();
+  const conclusion = (check.conclusion ?? "").toLowerCase();
+  return bucket === "fail" || bucket === "cancel" || state === "failure" || state === "error" || state === "cancelled" || conclusion === "failure" || conclusion === "error" || conclusion === "cancelled" || conclusion === "timed_out" || conclusion === "action_required" || conclusion === "startup_failure" || conclusion === "stale";
+}
+function getPrFailingChecks(prNumber) {
+  try {
+    const result = execFileSync5("gh", ["pr", "checks", String(prNumber), "--json", "name,bucket,state,conclusion"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const checks = JSON.parse(result.trim() || "[]");
+    const failing = checks.filter((check) => isFailingCheck(check)).map((check) => `${check.name ?? "unknown"} [state=${check.state ?? "unknown"}, conclusion=${check.conclusion ?? "unknown"}]`);
+    if (failing.length > 0) {
+      return failing;
+    }
+  } catch {
+  }
+  try {
+    const result = execFileSync5("gh", ["pr", "checks", String(prNumber)], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => /fail|error|cancel|timed[_ -]?out|action_required|startup_failure|stale/i.test(line));
+  } catch {
+    return [];
+  }
+}
 function getOpenPrsNeedingWork(branchPatterns) {
   try {
     const args = ["pr", "list", "--state", "open", "--json", "number,title,headRefName"];
     for (const pattern of branchPatterns) {
       args.push("--head", pattern);
     }
-    const result = execFileSync2("gh", args, {
+    const result = execFileSync5("gh", args, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -7810,6 +8377,21 @@ function reviewCommand(program2) {
       console.log();
       process.exit(0);
     }
+    const preflightOpenPrs = getOpenPrsNeedingWork(config.branchPatterns);
+    const preflightFailures = preflightOpenPrs.map((pr) => ({
+      prNumber: pr.number,
+      title: pr.title,
+      failingChecks: getPrFailingChecks(pr.number)
+    })).filter((entry) => entry.failingChecks.length > 0);
+    if (preflightFailures.length > 0) {
+      header("Preflight Failing Checks");
+      for (const entry of preflightFailures) {
+        info(`#${entry.prNumber}: ${entry.title}`);
+        for (const check of entry.failingChecks) {
+          dim(`  ${check}`);
+        }
+      }
+    }
     const spinner = createSpinner("Running PR reviewer...");
     spinner.start();
     try {
@@ -7849,7 +8431,7 @@ ${stderr}`);
           const finalScore = parseFinalReviewScore(scriptResult?.data.final_score);
           const _reviewCtx = {
             event: "review_completed",
-            projectName: path15.basename(projectDir),
+            projectName: path19.basename(projectDir),
             exitCode,
             provider: config.provider,
             prUrl: prDetails?.url,
@@ -7870,7 +8452,7 @@ ${stderr}`);
           const autoMergedPrDetails = fetchPrDetailsByNumber(autoMergedPrNumber, projectDir);
           const _mergeCtx = {
             event: "pr_auto_merged",
-            projectName: path15.basename(projectDir),
+            projectName: path19.basename(projectDir),
             exitCode,
             provider: config.provider,
             prNumber: autoMergedPrDetails?.number ?? autoMergedPrNumber,
@@ -8026,7 +8608,7 @@ ${stderr}`);
           const fallbackPrUrl = !prDetails?.url && primaryQaPr && repo ? `https://github.com/${repo}/pull/${primaryQaPr}` : void 0;
           const _qaCtx = {
             event: "qa_completed",
-            projectName: path16.basename(projectDir),
+            projectName: path20.basename(projectDir),
             exitCode,
             provider: config.provider,
             prNumber: prDetails?.number ?? primaryQaPr,
@@ -8105,7 +8687,7 @@ function auditCommand(program2) {
       configTable.push(["Provider", auditProvider]);
       configTable.push(["Provider CLI", PROVIDER_COMMANDS[auditProvider]]);
       configTable.push(["Max Runtime", `${config.audit.maxRuntime}s`]);
-      configTable.push(["Report File", path17.join(projectDir, "logs", "audit-report.md")]);
+      configTable.push(["Report File", path21.join(projectDir, "logs", "audit-report.md")]);
       console.log(configTable.toString());
       header("Provider Invocation");
       const providerCmd = PROVIDER_COMMANDS[auditProvider];
@@ -8131,8 +8713,8 @@ ${stderr}`);
         } else if (scriptResult?.status?.startsWith("skip_")) {
           spinner.succeed("Code audit skipped");
         } else {
-          const reportPath = path17.join(projectDir, "logs", "audit-report.md");
-          if (!fs16.existsSync(reportPath)) {
+          const reportPath = path21.join(projectDir, "logs", "audit-report.md");
+          if (!fs20.existsSync(reportPath)) {
             spinner.fail("Code audit finished without a report file");
             process.exit(1);
           }
@@ -8143,9 +8725,9 @@ ${stderr}`);
         const providerExit = scriptResult?.data?.provider_exit;
         const exitDetail = providerExit && providerExit !== String(exitCode) ? `, provider exit ${providerExit}` : "";
         spinner.fail(`Code audit exited with code ${exitCode}${statusSuffix}${exitDetail}`);
-        const logPath = path17.join(projectDir, "logs", "audit.log");
-        if (fs16.existsSync(logPath)) {
-          const logLines = fs16.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
+        const logPath = path21.join(projectDir, "logs", "audit.log");
+        if (fs20.existsSync(logPath)) {
+          const logLines = fs20.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
           if (logLines.length > 0) {
             process.stderr.write(logLines.join("\n") + "\n");
           }
@@ -8165,8 +8747,8 @@ function shellQuote(value) {
 function getNightWatchBinPath() {
   try {
     const npmBin = execSync4("npm bin -g", { encoding: "utf-8" }).trim();
-    const binPath = path18.join(npmBin, "night-watch");
-    if (fs17.existsSync(binPath)) {
+    const binPath = path22.join(npmBin, "night-watch");
+    if (fs21.existsSync(binPath)) {
       return binPath;
     }
   } catch {
@@ -8180,13 +8762,13 @@ function getNightWatchBinPath() {
 function getNodeBinDir() {
   try {
     const nodePath = execSync4("which node", { encoding: "utf-8" }).trim();
-    return path18.dirname(nodePath);
+    return path22.dirname(nodePath);
   } catch {
     return "";
   }
 }
 function buildCronPathPrefix(nodeBinDir, nightWatchBin) {
-  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path18.dirname(nightWatchBin) : "";
+  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path22.dirname(nightWatchBin) : "";
   const pathParts = Array.from(new Set([nodeBinDir, nightWatchBinDir].filter((part) => part.length > 0)));
   if (pathParts.length === 0) {
     return "";
@@ -8213,12 +8795,12 @@ function performInstall(projectDir, config, options) {
     const nightWatchBin = getNightWatchBinPath();
     const projectName = getProjectName(projectDir);
     const marker = generateMarker(projectName);
-    const logDir = path18.join(projectDir, LOG_DIR);
-    if (!fs17.existsSync(logDir)) {
-      fs17.mkdirSync(logDir, { recursive: true });
+    const logDir = path22.join(projectDir, LOG_DIR);
+    if (!fs21.existsSync(logDir)) {
+      fs21.mkdirSync(logDir, { recursive: true });
     }
-    const executorLog = path18.join(logDir, "executor.log");
-    const reviewerLog = path18.join(logDir, "reviewer.log");
+    const executorLog = path22.join(logDir, "executor.log");
+    const reviewerLog = path22.join(logDir, "reviewer.log");
     if (!options?.force) {
       const existingEntries = Array.from(/* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)]));
       if (existingEntries.length > 0) {
@@ -8251,7 +8833,7 @@ function performInstall(projectDir, config, options) {
     const installSlicer = options?.noSlicer === true ? false : config.roadmapScanner.enabled;
     if (installSlicer) {
       const slicerSchedule = applyScheduleOffset(config.roadmapScanner.slicerSchedule, offset);
-      const slicerLog = path18.join(logDir, "slicer.log");
+      const slicerLog = path22.join(logDir, "slicer.log");
       const slicerEntry = `${slicerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} planner >> ${shellQuote(slicerLog)} 2>&1  ${marker}`;
       entries.push(slicerEntry);
     }
@@ -8259,7 +8841,7 @@ function performInstall(projectDir, config, options) {
     const installQa = disableQa ? false : config.qa.enabled;
     if (installQa) {
       const qaSchedule = applyScheduleOffset(config.qa.schedule, offset);
-      const qaLog = path18.join(logDir, "qa.log");
+      const qaLog = path22.join(logDir, "qa.log");
       const qaEntry = `${qaSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} qa >> ${shellQuote(qaLog)} 2>&1  ${marker}`;
       entries.push(qaEntry);
     }
@@ -8267,7 +8849,7 @@ function performInstall(projectDir, config, options) {
     const installAudit = disableAudit ? false : config.audit.enabled;
     if (installAudit) {
       const auditSchedule = applyScheduleOffset(config.audit.schedule, offset);
-      const auditLog = path18.join(logDir, "audit.log");
+      const auditLog = path22.join(logDir, "audit.log");
       const auditEntry = `${auditSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} audit >> ${shellQuote(auditLog)} 2>&1  ${marker}`;
       entries.push(auditEntry);
     }
@@ -8294,12 +8876,12 @@ function installCommand(program2) {
       const nightWatchBin = getNightWatchBinPath();
       const projectName = getProjectName(projectDir);
       const marker = generateMarker(projectName);
-      const logDir = path18.join(projectDir, LOG_DIR);
-      if (!fs17.existsSync(logDir)) {
-        fs17.mkdirSync(logDir, { recursive: true });
+      const logDir = path22.join(projectDir, LOG_DIR);
+      if (!fs21.existsSync(logDir)) {
+        fs21.mkdirSync(logDir, { recursive: true });
       }
-      const executorLog = path18.join(logDir, "executor.log");
-      const reviewerLog = path18.join(logDir, "reviewer.log");
+      const executorLog = path22.join(logDir, "executor.log");
+      const reviewerLog = path22.join(logDir, "reviewer.log");
       const existingEntries = Array.from(/* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)]));
       if (existingEntries.length > 0) {
         warn(`Night Watch is already installed for ${projectName}.`);
@@ -8332,7 +8914,7 @@ function installCommand(program2) {
       const installSlicer = options.noSlicer === true ? false : config.roadmapScanner.enabled;
       let slicerLog;
       if (installSlicer) {
-        slicerLog = path18.join(logDir, "slicer.log");
+        slicerLog = path22.join(logDir, "slicer.log");
         const slicerSchedule = applyScheduleOffset(config.roadmapScanner.slicerSchedule, offset);
         const slicerEntry = `${slicerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} planner >> ${shellQuote(slicerLog)} 2>&1  ${marker}`;
         entries.push(slicerEntry);
@@ -8341,7 +8923,7 @@ function installCommand(program2) {
       const installQa = disableQa ? false : config.qa.enabled;
       let qaLog;
       if (installQa) {
-        qaLog = path18.join(logDir, "qa.log");
+        qaLog = path22.join(logDir, "qa.log");
         const qaSchedule = applyScheduleOffset(config.qa.schedule, offset);
         const qaEntry = `${qaSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} qa >> ${shellQuote(qaLog)} 2>&1  ${marker}`;
         entries.push(qaEntry);
@@ -8350,7 +8932,7 @@ function installCommand(program2) {
       const installAudit = disableAudit ? false : config.audit.enabled;
       let auditLog;
       if (installAudit) {
-        auditLog = path18.join(logDir, "audit.log");
+        auditLog = path22.join(logDir, "audit.log");
         const auditSchedule = applyScheduleOffset(config.audit.schedule, offset);
         const auditEntry = `${auditSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} audit >> ${shellQuote(auditLog)} 2>&1  ${marker}`;
         entries.push(auditEntry);
@@ -8399,19 +8981,19 @@ function performUninstall(projectDir, options) {
     }
     const removedCount = removeEntriesForProject(projectDir, marker);
     if (!options?.keepLogs) {
-      const logDir = path19.join(projectDir, "logs");
-      if (fs18.existsSync(logDir)) {
+      const logDir = path23.join(projectDir, "logs");
+      if (fs22.existsSync(logDir)) {
         const logFiles = ["executor.log", "reviewer.log", "slicer.log", "audit.log"];
         logFiles.forEach((logFile) => {
-          const logPath = path19.join(logDir, logFile);
-          if (fs18.existsSync(logPath)) {
-            fs18.unlinkSync(logPath);
+          const logPath = path23.join(logDir, logFile);
+          if (fs22.existsSync(logPath)) {
+            fs22.unlinkSync(logPath);
           }
         });
         try {
-          const remainingFiles = fs18.readdirSync(logDir);
+          const remainingFiles = fs22.readdirSync(logDir);
           if (remainingFiles.length === 0) {
-            fs18.rmdirSync(logDir);
+            fs22.rmdirSync(logDir);
           }
         } catch {
         }
@@ -8442,21 +9024,21 @@ function uninstallCommand(program2) {
       existingEntries.forEach((entry) => dim(`  ${entry}`));
       const removedCount = removeEntriesForProject(projectDir, marker);
       if (!options.keepLogs) {
-        const logDir = path19.join(projectDir, "logs");
-        if (fs18.existsSync(logDir)) {
+        const logDir = path23.join(projectDir, "logs");
+        if (fs22.existsSync(logDir)) {
           const logFiles = ["executor.log", "reviewer.log", "slicer.log", "audit.log"];
           let logsRemoved = 0;
           logFiles.forEach((logFile) => {
-            const logPath = path19.join(logDir, logFile);
-            if (fs18.existsSync(logPath)) {
-              fs18.unlinkSync(logPath);
+            const logPath = path23.join(logDir, logFile);
+            if (fs22.existsSync(logPath)) {
+              fs22.unlinkSync(logPath);
               logsRemoved++;
             }
           });
           try {
-            const remainingFiles = fs18.readdirSync(logDir);
+            const remainingFiles = fs22.readdirSync(logDir);
             if (remainingFiles.length === 0) {
-              fs18.rmdirSync(logDir);
+              fs22.rmdirSync(logDir);
             }
           } catch {
           }
@@ -8682,11 +9264,11 @@ function statusCommand(program2) {
 }
 init_dist();
 function getLastLines(filePath, lineCount) {
-  if (!fs19.existsSync(filePath)) {
+  if (!fs23.existsSync(filePath)) {
     return `Log file not found: ${filePath}`;
   }
   try {
-    const content = fs19.readFileSync(filePath, "utf-8");
+    const content = fs23.readFileSync(filePath, "utf-8");
     const lines = content.trim().split("\n");
     return lines.slice(-lineCount).join("\n");
   } catch (error2) {
@@ -8694,7 +9276,7 @@ function getLastLines(filePath, lineCount) {
   }
 }
 function followLog(filePath) {
-  if (!fs19.existsSync(filePath)) {
+  if (!fs23.existsSync(filePath)) {
     console.log(`Log file not found: ${filePath}`);
     console.log("The log file will be created when the first execution runs.");
     return;
@@ -8714,13 +9296,13 @@ function logsCommand(program2) {
   program2.command("logs").description("View night-watch log output").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output (tail -f)").option("-t, --type <type>", "Log type to view (executor|reviewer|qa|audit|planner|all)", "all").action(async (options) => {
     try {
       const projectDir = process.cwd();
-      const logDir = path20.join(projectDir, LOG_DIR);
+      const logDir = path24.join(projectDir, LOG_DIR);
       const lineCount = parseInt(options.lines || "50", 10);
-      const executorLog = path20.join(logDir, EXECUTOR_LOG_FILE);
-      const reviewerLog = path20.join(logDir, REVIEWER_LOG_FILE);
-      const qaLog = path20.join(logDir, `${QA_LOG_NAME}.log`);
-      const auditLog = path20.join(logDir, `${AUDIT_LOG_NAME}.log`);
-      const plannerLog = path20.join(logDir, `${PLANNER_LOG_NAME}.log`);
+      const executorLog = path24.join(logDir, EXECUTOR_LOG_FILE);
+      const reviewerLog = path24.join(logDir, REVIEWER_LOG_FILE);
+      const qaLog = path24.join(logDir, `${QA_LOG_NAME}.log`);
+      const auditLog = path24.join(logDir, `${AUDIT_LOG_NAME}.log`);
+      const plannerLog = path24.join(logDir, `${PLANNER_LOG_NAME}.log`);
       const logType = options.type?.toLowerCase() || "all";
       const showExecutor = logType === "all" || logType === "run" || logType === "executor";
       const showReviewer = logType === "all" || logType === "review" || logType === "reviewer";
@@ -8790,9 +9372,9 @@ function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber2(prdDir) {
-  if (!fs20.existsSync(prdDir))
+  if (!fs24.existsSync(prdDir))
     return 1;
-  const files = fs20.readdirSync(prdDir).filter((f) => f.endsWith(".md") && f !== "NIGHT-WATCH-SUMMARY.md");
+  const files = fs24.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
@@ -8814,10 +9396,10 @@ function parseDependencies(content) {
 }
 function isClaimActive(claimPath, maxRuntime) {
   try {
-    if (!fs20.existsSync(claimPath)) {
+    if (!fs24.existsSync(claimPath)) {
       return { active: false };
     }
-    const content = fs20.readFileSync(claimPath, "utf-8");
+    const content = fs24.readFileSync(claimPath, "utf-8");
     const claim = JSON.parse(content);
     const age = Math.floor(Date.now() / 1e3) - claim.timestamp;
     if (age < maxRuntime) {
@@ -8833,9 +9415,9 @@ function prdCommand(program2) {
   prd.command("create").description("Generate a new PRD markdown file from template").argument("<name>", "PRD name (used for title and filename)").option("-i, --interactive", "Prompt for complexity, dependencies, and phase count", false).option("-t, --template <path>", "Path to a custom template file").option("--deps <files>", "Comma-separated dependency filenames").option("--phases <count>", "Number of execution phases", "3").option("--no-number", "Skip auto-numbering prefix").action(async (name, options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const prdDir = path21.join(projectDir, config.prdDir);
-    if (!fs20.existsSync(prdDir)) {
-      fs20.mkdirSync(prdDir, { recursive: true });
+    const prdDir = path25.join(projectDir, config.prdDir);
+    if (!fs24.existsSync(prdDir)) {
+      fs24.mkdirSync(prdDir, { recursive: true });
     }
     let complexityScore = 5;
     let dependsOn = [];
@@ -8891,20 +9473,20 @@ function prdCommand(program2) {
     } else {
       filename = `${slug}.md`;
     }
-    const filePath = path21.join(prdDir, filename);
-    if (fs20.existsSync(filePath)) {
+    const filePath = path25.join(prdDir, filename);
+    if (fs24.existsSync(filePath)) {
       error(`File already exists: ${filePath}`);
       dim("Use a different name or remove the existing file.");
       process.exit(1);
     }
     let customTemplate;
     if (options.template) {
-      const templatePath = path21.resolve(options.template);
-      if (!fs20.existsSync(templatePath)) {
+      const templatePath = path25.resolve(options.template);
+      if (!fs24.existsSync(templatePath)) {
         error(`Template file not found: ${templatePath}`);
         process.exit(1);
       }
-      customTemplate = fs20.readFileSync(templatePath, "utf-8");
+      customTemplate = fs24.readFileSync(templatePath, "utf-8");
     }
     const vars = {
       title: name,
@@ -8915,7 +9497,7 @@ function prdCommand(program2) {
       phaseCount
     };
     const content = renderPrdTemplate(vars, customTemplate);
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs24.writeFileSync(filePath, content, "utf-8");
     header("PRD Created");
     success(`Created: ${filePath}`);
     info(`Title: ${name}`);
@@ -8927,15 +9509,15 @@ function prdCommand(program2) {
   prd.command("list").description("List all PRDs with status").option("--json", "Output as JSON").action(async (options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const absolutePrdDir = path21.join(projectDir, config.prdDir);
-    const doneDir = path21.join(absolutePrdDir, "done");
+    const absolutePrdDir = path25.join(projectDir, config.prdDir);
+    const doneDir = path25.join(absolutePrdDir, "done");
     const pending = [];
-    if (fs20.existsSync(absolutePrdDir)) {
-      const files = fs20.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md") && f !== "NIGHT-WATCH-SUMMARY.md");
+    if (fs24.existsSync(absolutePrdDir)) {
+      const files = fs24.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs20.readFileSync(path21.join(absolutePrdDir, file), "utf-8");
+        const content = fs24.readFileSync(path25.join(absolutePrdDir, file), "utf-8");
         const deps = parseDependencies(content);
-        const claimPath = path21.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
+        const claimPath = path25.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
         const claimStatus = isClaimActive(claimPath, config.maxRuntime);
         pending.push({
           name: file,
@@ -8946,10 +9528,10 @@ function prdCommand(program2) {
       }
     }
     const done = [];
-    if (fs20.existsSync(doneDir)) {
-      const files = fs20.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+    if (fs24.existsSync(doneDir)) {
+      const files = fs24.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs20.readFileSync(path21.join(doneDir, file), "utf-8");
+        const content = fs24.readFileSync(path25.join(doneDir, file), "utf-8");
         const deps = parseDependencies(content);
         done.push({ name: file, dependencies: deps });
       }
@@ -8982,7 +9564,7 @@ function prdCommand(program2) {
 }
 init_dist();
 init_dist();
-function sortPrdsByPriority(prds, priority) {
+function sortPrdsByPriority2(prds, priority) {
   if (priority.length === 0)
     return prds;
   const priorityMap = /* @__PURE__ */ new Map();
@@ -9001,7 +9583,7 @@ function renderPrdPane(prds, priority) {
   if (prds.length === 0) {
     return "No PRD files found";
   }
-  const sorted = priority ? sortPrdsByPriority(prds, priority) : prds;
+  const sorted = priority ? sortPrdsByPriority2(prds, priority) : prds;
   const lines = [];
   for (const prd of sorted) {
     let indicator;
@@ -9079,7 +9661,7 @@ function renderLogPane(projectDir, logs) {
   let newestMtime = 0;
   for (const log of existingLogs) {
     try {
-      const stat = fs21.statSync(log.path);
+      const stat = fs25.statSync(log.path);
       if (stat.mtimeMs > newestMtime) {
         newestMtime = stat.mtimeMs;
         newestLog = log;
@@ -9204,7 +9786,7 @@ function createStatusTab() {
       ctx.showMessage("No PRDs to reorder", "info");
       return;
     }
-    const sorted = sortPrdsByPriority(nonDone, ctx.config.prdPriority);
+    const sorted = sortPrdsByPriority2(nonDone, ctx.config.prdPriority);
     reorderList = sorted.map((p) => p.name);
     reorderIndex = 0;
     reorderMode = true;
@@ -10760,7 +11342,7 @@ function createLogsTab() {
   let activeKeyHandlers = [];
   let activeCtx = null;
   function getLogPath(projectDir, logName) {
-    return path22.join(projectDir, "logs", `${logName}.log`);
+    return path26.join(projectDir, "logs", `${logName}.log`);
   }
   function updateSelector() {
     const tabs = LOG_NAMES.map((name, idx) => {
@@ -10774,7 +11356,7 @@ function createLogsTab() {
   function loadLog(ctx) {
     const logName = LOG_NAMES[selectedLogIndex];
     const logPath = getLogPath(ctx.projectDir, logName);
-    if (!fs22.existsSync(logPath)) {
+    if (!fs26.existsSync(logPath)) {
       logContent.setContent(`{yellow-fg}No ${logName}.log file found{/yellow-fg}
 
 Log will appear here once the ${logName} runs.`);
@@ -10782,7 +11364,7 @@ Log will appear here once the ${logName} runs.`);
       return;
     }
     try {
-      const stat = fs22.statSync(logPath);
+      const stat = fs26.statSync(logPath);
       const sizeKB = (stat.size / 1024).toFixed(1);
       logContent.setLabel(`[ ${logName}.log - ${sizeKB} KB ]`);
     } catch {
@@ -11347,7 +11929,7 @@ function resolveProject(req, res, next) {
     res.status(404).json({ error: `Project not found: ${decodedId}` });
     return;
   }
-  if (!fs23.existsSync(entry.path) || !fs23.existsSync(path23.join(entry.path, CONFIG_FILE_NAME))) {
+  if (!fs27.existsSync(entry.path) || !fs27.existsSync(path27.join(entry.path, CONFIG_FILE_NAME))) {
     res.status(404).json({ error: `Project path invalid or missing config: ${entry.path}` });
     return;
   }
@@ -11432,17 +12014,17 @@ function getBoardProvider(config, projectDir) {
 function cleanOrphanedClaims(dir) {
   let entries;
   try {
-    entries = fs24.readdirSync(dir, { withFileTypes: true });
+    entries = fs28.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "done") {
       cleanOrphanedClaims(fullPath);
     } else if (entry.name.endsWith(CLAIM_FILE_EXTENSION)) {
       try {
-        fs24.unlinkSync(fullPath);
+        fs28.unlinkSync(fullPath);
       } catch {
       }
     }
@@ -11490,7 +12072,7 @@ function spawnAction2(projectDir, command, req, res, onSpawned) {
         const config = loadConfig(projectDir);
         sendNotifications(config, {
           event: "run_started",
-          projectName: path24.basename(projectDir),
+          projectName: path28.basename(projectDir),
           exitCode: 0,
           provider: config.provider
         }).catch(() => {
@@ -11572,19 +12154,19 @@ function createActionRouteHandlers(ctx) {
         res.status(400).json({ error: "Invalid PRD name" });
         return;
       }
-      const prdDir = path24.join(projectDir, config.prdDir);
+      const prdDir = path28.join(projectDir, config.prdDir);
       const normalized = prdName.endsWith(".md") ? prdName : `${prdName}.md`;
-      const pendingPath = path24.join(prdDir, normalized);
-      const donePath = path24.join(prdDir, "done", normalized);
-      if (fs24.existsSync(pendingPath)) {
+      const pendingPath = path28.join(prdDir, normalized);
+      const donePath = path28.join(prdDir, "done", normalized);
+      if (fs28.existsSync(pendingPath)) {
         res.json({ message: `"${normalized}" is already pending` });
         return;
       }
-      if (!fs24.existsSync(donePath)) {
+      if (!fs28.existsSync(donePath)) {
         res.status(404).json({ error: `PRD "${normalized}" not found in done/` });
         return;
       }
-      fs24.renameSync(donePath, pendingPath);
+      fs28.renameSync(donePath, pendingPath);
       res.json({ message: `Moved "${normalized}" back to pending` });
     } catch (error2) {
       res.status(500).json({
@@ -11602,11 +12184,11 @@ function createActionRouteHandlers(ctx) {
         res.status(409).json({ error: "Executor is actively running \u2014 use Stop instead" });
         return;
       }
-      if (fs24.existsSync(lockPath)) {
-        fs24.unlinkSync(lockPath);
+      if (fs28.existsSync(lockPath)) {
+        fs28.unlinkSync(lockPath);
       }
-      const prdDir = path24.join(projectDir, config.prdDir);
-      if (fs24.existsSync(prdDir)) {
+      const prdDir = path28.join(projectDir, config.prdDir);
+      if (fs28.existsSync(prdDir)) {
         cleanOrphanedClaims(prdDir);
       }
       broadcastSSE(ctx.getSseClients(req), "status_changed", await fetchStatusSnapshot(projectDir, config));
@@ -11743,6 +12325,7 @@ function createAgentRoutes() {
   return router;
 }
 init_dist();
+var ERROR_BOARD_NOT_CONFIGURED = "Board not configured";
 function createBoardRouteHandlers(ctx) {
   const router = Router3({ mergeParams: true });
   const p = ctx.pathPrefix;
@@ -11752,7 +12335,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const cached = getCachedBoardData(projectDir);
@@ -11785,7 +12368,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const issues = await provider.getAllIssues();
@@ -11800,7 +12383,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const { title, body, column } = req.body;
@@ -11831,7 +12414,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const issueNumber = parseInt(req.params.number, 10);
@@ -11861,7 +12444,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const issueNumber = parseInt(req.params.number, 10);
@@ -11889,7 +12472,7 @@ function createBoardRouteHandlers(ctx) {
       const projectDir = ctx.getProjectDir(req);
       const provider = getBoardProvider(config, projectDir);
       if (!provider) {
-        res.status(404).json({ error: "Board not configured" });
+        res.status(404).json({ error: ERROR_BOARD_NOT_CONFIGURED });
         return;
       }
       const issueNumber = parseInt(req.params.number, 10);
@@ -12177,7 +12760,7 @@ function runDoctorChecks(projectDir, config) {
     });
   }
   try {
-    const projectName = path25.basename(projectDir);
+    const projectName = path29.basename(projectDir);
     const marker = generateMarker(projectName);
     const crontabEntries = [...getEntries(marker), ...getProjectEntries(projectDir)];
     if (crontabEntries.length > 0) {
@@ -12200,8 +12783,8 @@ function runDoctorChecks(projectDir, config) {
       detail: "Failed to check crontab"
     });
   }
-  const configPath = path25.join(projectDir, CONFIG_FILE_NAME);
-  if (fs25.existsSync(configPath)) {
+  const configPath = path29.join(projectDir, CONFIG_FILE_NAME);
+  if (fs29.existsSync(configPath)) {
     checks.push({ name: "config", status: "pass", detail: "Config file exists" });
   } else {
     checks.push({
@@ -12210,9 +12793,9 @@ function runDoctorChecks(projectDir, config) {
       detail: "Config file not found (using defaults)"
     });
   }
-  const prdDir = path25.join(projectDir, config.prdDir);
-  if (fs25.existsSync(prdDir)) {
-    const prds = fs25.readdirSync(prdDir).filter((f) => f.endsWith(".md") && f !== "NIGHT-WATCH-SUMMARY.md");
+  const prdDir = path29.join(projectDir, config.prdDir);
+  if (fs29.existsSync(prdDir)) {
+    const prds = fs29.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
     checks.push({
       name: "prdDir",
       status: "pass",
@@ -12270,7 +12853,7 @@ function createLogRoutes(deps) {
       const lines = typeof linesParam === "string" ? parseInt(linesParam, 10) : 200;
       const linesToRead = isNaN(lines) || lines < 1 ? 200 : Math.min(lines, 1e4);
       const fileName = LOG_FILE_NAMES[name] || name;
-      const logPath = path26.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path30.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -12296,7 +12879,7 @@ function createProjectLogRoutes() {
       const lines = typeof linesParam === "string" ? parseInt(linesParam, 10) : 200;
       const linesToRead = isNaN(lines) || lines < 1 ? 200 : Math.min(lines, 1e4);
       const fileName = LOG_FILE_NAMES[name] || name;
-      const logPath = path26.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path30.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -12334,7 +12917,7 @@ function createRoadmapRouteHandlers(ctx) {
       const config = ctx.getConfig(req);
       const projectDir = ctx.getProjectDir(req);
       const status = getRoadmapStatus(projectDir, config);
-      const prdDir = path27.join(projectDir, config.prdDir);
+      const prdDir = path31.join(projectDir, config.prdDir);
       const state = loadRoadmapState(prdDir);
       res.json({
         ...status,
@@ -12591,14 +13174,14 @@ data: ${JSON.stringify(snapshot)}
 var __filename2 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname7(__filename2);
 function resolveWebDistPath() {
-  const bundled = path28.join(__dirname3, "web");
-  if (fs26.existsSync(path28.join(bundled, "index.html")))
+  const bundled = path32.join(__dirname3, "web");
+  if (fs30.existsSync(path32.join(bundled, "index.html")))
     return bundled;
   let d = __dirname3;
   for (let i = 0; i < 8; i++) {
-    if (fs26.existsSync(path28.join(d, "turbo.json"))) {
-      const dev = path28.join(d, "web/dist");
-      if (fs26.existsSync(path28.join(dev, "index.html")))
+    if (fs30.existsSync(path32.join(d, "turbo.json"))) {
+      const dev = path32.join(d, "web/dist");
+      if (fs30.existsSync(path32.join(dev, "index.html")))
         return dev;
       break;
     }
@@ -12608,7 +13191,7 @@ function resolveWebDistPath() {
 }
 function setupStaticFiles(app) {
   const webDistPath = resolveWebDistPath();
-  if (fs26.existsSync(webDistPath)) {
+  if (fs30.existsSync(webDistPath)) {
     app.use(express.static(webDistPath));
   }
   app.use((req, res, next) => {
@@ -12616,8 +13199,8 @@ function setupStaticFiles(app) {
       next();
       return;
     }
-    const indexPath = path28.resolve(webDistPath, "index.html");
-    if (fs26.existsSync(indexPath)) {
+    const indexPath = path32.resolve(webDistPath, "index.html");
+    if (fs30.existsSync(indexPath)) {
       res.sendFile(indexPath, (err) => {
         if (err)
           next();
@@ -12727,7 +13310,7 @@ function createGlobalApp() {
   return app;
 }
 function bootContainer() {
-  initContainer(path28.dirname(getDbPath()));
+  initContainer(path32.dirname(getDbPath()));
   const personaRepo = container.resolve(SqliteAgentPersonaRepository);
   personaRepo.seedDefaultsOnFirstRun();
   personaRepo.patchDefaultAvatarUrls();
@@ -12781,9 +13364,9 @@ function isProcessRunning2(pid) {
 }
 function readPid(lockPath) {
   try {
-    if (!fs27.existsSync(lockPath))
+    if (!fs31.existsSync(lockPath))
       return null;
-    const raw = fs27.readFileSync(lockPath, "utf-8").trim();
+    const raw = fs31.readFileSync(lockPath, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -12795,10 +13378,10 @@ function acquireServeLock(mode, port) {
   let stalePidCleaned;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs27.openSync(lockPath, "wx");
-      fs27.writeFileSync(fd, `${process.pid}
+      const fd = fs31.openSync(lockPath, "wx");
+      fs31.writeFileSync(fd, `${process.pid}
 `);
-      fs27.closeSync(fd);
+      fs31.closeSync(fd);
       return { acquired: true, lockPath, stalePidCleaned };
     } catch (error2) {
       const err = error2;
@@ -12819,7 +13402,7 @@ function acquireServeLock(mode, port) {
         };
       }
       try {
-        fs27.unlinkSync(lockPath);
+        fs31.unlinkSync(lockPath);
         if (existingPid) {
           stalePidCleaned = existingPid;
         }
@@ -12842,12 +13425,12 @@ function acquireServeLock(mode, port) {
 }
 function releaseServeLock(lockPath) {
   try {
-    if (!fs27.existsSync(lockPath))
+    if (!fs31.existsSync(lockPath))
       return;
     const lockPid = readPid(lockPath);
     if (lockPid !== null && lockPid !== process.pid)
       return;
-    fs27.unlinkSync(lockPath);
+    fs31.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -12933,7 +13516,7 @@ function parseProjectDirs(projects, cwd) {
   if (!projects || projects.trim().length === 0) {
     return [cwd];
   }
-  const dirs = projects.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => path29.resolve(cwd, entry));
+  const dirs = projects.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => path33.resolve(cwd, entry));
   return Array.from(new Set(dirs));
 }
 function runCommand2(command, args, cwd) {
@@ -12972,7 +13555,7 @@ function updateCommand(program2) {
       }
       const nightWatchBin = resolveNightWatchBin();
       for (const projectDir of projectDirs) {
-        if (!fs28.existsSync(projectDir) || !fs28.statSync(projectDir).isDirectory()) {
+        if (!fs32.existsSync(projectDir) || !fs32.statSync(projectDir).isDirectory()) {
           warn(`Skipping invalid project directory: ${projectDir}`);
           continue;
         }
@@ -13019,26 +13602,26 @@ function normalizePrdName(name) {
   return name;
 }
 function getDonePrds(doneDir) {
-  if (!fs29.existsSync(doneDir)) {
+  if (!fs33.existsSync(doneDir)) {
     return [];
   }
-  return fs29.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+  return fs33.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
 }
 function retryCommand(program2) {
   program2.command("retry <prdName>").description("Move a completed PRD from done/ back to pending").action((prdName) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const prdDir = path30.join(projectDir, config.prdDir);
-    const doneDir = path30.join(prdDir, "done");
+    const prdDir = path34.join(projectDir, config.prdDir);
+    const doneDir = path34.join(prdDir, "done");
     const normalizedPrdName = normalizePrdName(prdName);
-    const pendingPath = path30.join(prdDir, normalizedPrdName);
-    if (fs29.existsSync(pendingPath)) {
+    const pendingPath = path34.join(prdDir, normalizedPrdName);
+    if (fs33.existsSync(pendingPath)) {
       info(`"${normalizedPrdName}" is already pending, nothing to retry.`);
       return;
     }
-    const donePath = path30.join(doneDir, normalizedPrdName);
-    if (fs29.existsSync(donePath)) {
-      fs29.renameSync(donePath, pendingPath);
+    const donePath = path34.join(doneDir, normalizedPrdName);
+    if (fs33.existsSync(donePath)) {
+      fs33.renameSync(donePath, pendingPath);
       success(`Moved "${normalizedPrdName}" back to pending.`);
       dim(`From: ${donePath}`);
       dim(`To:   ${pendingPath}`);
@@ -13212,7 +13795,7 @@ function prdsCommand(program2) {
       const config = loadConfig(projectDir);
       const prds = collectPrdInfo(projectDir, config.prdDir, config.maxRuntime);
       const openPrBranches = getOpenPrBranches(projectDir);
-      const filteredPrds = prds.filter((prd) => !prd.name.toLowerCase().includes("night-watch-summary"));
+      const filteredPrds = prds;
       for (const prd of filteredPrds) {
         if (prd.status !== "done") {
           const matchingPr = findMatchingPr(prd.name, openPrBranches, config.branchPrefix);
@@ -13320,7 +13903,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   const pid = lockStatus.pid;
   if (!lockStatus.running) {
     try {
-      fs30.unlinkSync(lockPath);
+      fs34.unlinkSync(lockPath);
       return {
         success: true,
         message: `${processType} is not running (cleaned up stale lock file for PID ${pid})`,
@@ -13358,7 +13941,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep3(3e3);
   if (!isProcessRunning3(pid)) {
     try {
-      fs30.unlinkSync(lockPath);
+      fs34.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -13393,7 +13976,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep3(500);
   if (!isProcessRunning3(pid)) {
     try {
-      fs30.unlinkSync(lockPath);
+      fs34.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -13460,24 +14043,24 @@ function plannerLockPath2(projectDir) {
 }
 function acquirePlannerLock(projectDir) {
   const lockFile = plannerLockPath2(projectDir);
-  if (fs31.existsSync(lockFile)) {
-    const pidRaw = fs31.readFileSync(lockFile, "utf-8").trim();
+  if (fs35.existsSync(lockFile)) {
+    const pidRaw = fs35.readFileSync(lockFile, "utf-8").trim();
     const pid = parseInt(pidRaw, 10);
     if (!Number.isNaN(pid) && isProcessRunning(pid)) {
       return { acquired: false, lockFile, pid };
     }
     try {
-      fs31.unlinkSync(lockFile);
+      fs35.unlinkSync(lockFile);
     } catch {
     }
   }
-  fs31.writeFileSync(lockFile, String(process.pid));
+  fs35.writeFileSync(lockFile, String(process.pid));
   return { acquired: true, lockFile };
 }
 function releasePlannerLock(lockFile) {
   try {
-    if (fs31.existsSync(lockFile)) {
-      fs31.unlinkSync(lockFile);
+    if (fs35.existsSync(lockFile)) {
+      fs35.unlinkSync(lockFile);
     }
   } catch {
   }
@@ -13599,7 +14182,7 @@ function sliceCommand(program2) {
       if (!options.dryRun) {
         await sendNotifications(config, {
           event: "run_started",
-          projectName: path31.basename(projectDir),
+          projectName: path35.basename(projectDir),
           exitCode: 0,
           provider: config.provider
         });
@@ -13619,7 +14202,7 @@ function sliceCommand(program2) {
       if (!options.dryRun && result.sliced) {
         await sendNotifications(config, {
           event: "run_succeeded",
-          projectName: path31.basename(projectDir),
+          projectName: path35.basename(projectDir),
           exitCode,
           provider: config.provider,
           prTitle: result.item?.title
@@ -13627,7 +14210,7 @@ function sliceCommand(program2) {
       } else if (!options.dryRun && !nothingPending) {
         await sendNotifications(config, {
           event: "run_failed",
-          projectName: path31.basename(projectDir),
+          projectName: path35.basename(projectDir),
           exitCode,
           provider: config.provider
         });
@@ -13645,13 +14228,13 @@ function createStateCommand() {
   const state = new Command("state");
   state.description("Manage Night Watch state");
   state.command("migrate").description("Migrate legacy JSON state files to SQLite").option("--dry-run", "Show what would be migrated without making changes").action((opts) => {
-    const nightWatchHome = process.env.NIGHT_WATCH_HOME || path32.join(os5.homedir(), GLOBAL_CONFIG_DIR);
+    const nightWatchHome = process.env.NIGHT_WATCH_HOME || path36.join(os6.homedir(), GLOBAL_CONFIG_DIR);
     if (opts.dryRun) {
       console.log(chalk5.cyan("Dry-run mode: no changes will be made.\n"));
       console.log(`Legacy JSON files that would be migrated from: ${chalk5.bold(nightWatchHome)}`);
-      console.log(`  ${path32.join(nightWatchHome, "projects.json")}`);
-      console.log(`  ${path32.join(nightWatchHome, "history.json")}`);
-      console.log(`  ${path32.join(nightWatchHome, "prd-states.json")}`);
+      console.log(`  ${path36.join(nightWatchHome, "projects.json")}`);
+      console.log(`  ${path36.join(nightWatchHome, "history.json")}`);
+      console.log(`  ${path36.join(nightWatchHome, "prd-states.json")}`);
       console.log(`  <project>/<prdDir>/.roadmap-state.json (per project)`);
       console.log(chalk5.dim("\nRun without --dry-run to apply the migration."));
       return;
@@ -13699,7 +14282,7 @@ function getProvider(config, cwd) {
   return createBoardProvider(bp, cwd);
 }
 function defaultBoardTitle(cwd) {
-  return `${path33.basename(cwd)} Night Watch`;
+  return `${path37.basename(cwd)} Night Watch`;
 }
 async function ensureBoardConfigured(config, cwd, provider, options) {
   if (config.boardProvider?.projectNumber) {
@@ -13739,7 +14322,7 @@ async function confirmPrompt(question) {
 }
 async function createGitHubLabel(label2, cwd) {
   try {
-    execFileSync3("gh", ["label", "create", label2.name, "--description", label2.description, "--color", label2.color], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    execFileSync6("gh", ["label", "create", label2.name, "--description", label2.description, "--color", label2.color], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     return { created: true, skipped: false };
   } catch (err) {
     const output = err instanceof Error ? err.message : String(err);
@@ -13879,11 +14462,11 @@ function boardCommand(program2) {
     let body = options.body ?? "";
     if (options.bodyFile) {
       const filePath = options.bodyFile;
-      if (!fs32.existsSync(filePath)) {
+      if (!fs36.existsSync(filePath)) {
         console.error(`File not found: ${filePath}`);
         process.exit(1);
       }
-      body = fs32.readFileSync(filePath, "utf-8");
+      body = fs36.readFileSync(filePath, "utf-8");
     }
     const labels = [];
     if (options.label) {
@@ -14091,12 +14674,12 @@ function boardCommand(program2) {
     const config = loadConfig(cwd);
     const provider = getProvider(config, cwd);
     await ensureBoardConfigured(config, cwd, provider);
-    const roadmapPath = options.roadmap ?? path33.join(cwd, "ROADMAP.md");
-    if (!fs32.existsSync(roadmapPath)) {
+    const roadmapPath = options.roadmap ?? path37.join(cwd, "ROADMAP.md");
+    if (!fs36.existsSync(roadmapPath)) {
       console.error(`Roadmap file not found: ${roadmapPath}`);
       process.exit(1);
     }
-    const roadmapContent = fs32.readFileSync(roadmapPath, "utf-8");
+    const roadmapContent = fs36.readFileSync(roadmapPath, "utf-8");
     const items = parseRoadmap(roadmapContent);
     const uncheckedItems = getUncheckedItems(items);
     if (uncheckedItems.length === 0) {
@@ -14190,7 +14773,7 @@ function boardCommand(program2) {
       try {
         const labelsToAdd = [category, horizon].filter((l) => !issue.labels.includes(l));
         if (labelsToAdd.length > 0) {
-          execFileSync3("gh", ["issue", "edit", String(issue.number), "--add-label", labelsToAdd.join(",")], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+          execFileSync6("gh", ["issue", "edit", String(issue.number), "--add-label", labelsToAdd.join(",")], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
         }
         updated++;
         success(`Updated labels on #${issue.number}: ${item.title}`);
@@ -14214,14 +14797,14 @@ var __dirname4 = dirname8(__filename3);
 function findPackageRoot(dir) {
   let d = dir;
   for (let i = 0; i < 5; i++) {
-    if (existsSync26(join30(d, "package.json")))
+    if (existsSync30(join33(d, "package.json")))
       return d;
     d = dirname8(d);
   }
   return dir;
 }
 var packageRoot = findPackageRoot(__dirname4);
-var packageJson = JSON.parse(readFileSync16(join30(packageRoot, "package.json"), "utf-8"));
+var packageJson = JSON.parse(readFileSync18(join33(packageRoot, "package.json"), "utf-8"));
 var program = new Command2();
 program.name("night-watch").description("Autonomous PRD execution using Claude CLI + cron").version(packageJson.version);
 initCommand(program);