@jonit-dev/night-watch-cli 1.8.2 → 1.8.3

package/dist/cli.js

@@ -31,7 +31,7 @@ function resolveProviderBucketKey(provider, providerEnv) {
     return `claude-proxy:${baseUrl}`;
   }
 }
-var DEFAULT_DEFAULT_BRANCH, DEFAULT_PRD_DIR, DEFAULT_MAX_RUNTIME, DEFAULT_REVIEWER_MAX_RUNTIME, DEFAULT_CRON_SCHEDULE, DEFAULT_REVIEWER_SCHEDULE, DEFAULT_CRON_SCHEDULE_OFFSET, DEFAULT_MAX_RETRIES, DEFAULT_REVIEWER_MAX_RETRIES, DEFAULT_REVIEWER_RETRY_DELAY, DEFAULT_REVIEWER_MAX_PRS_PER_RUN, DEFAULT_BRANCH_PREFIX, DEFAULT_BRANCH_PATTERNS, DEFAULT_MIN_REVIEW_SCORE, DEFAULT_MAX_LOG_SIZE, DEFAULT_PROVIDER, DEFAULT_EXECUTOR_ENABLED, DEFAULT_REVIEWER_ENABLED, DEFAULT_PROVIDER_ENV, DEFAULT_FALLBACK_ON_RATE_LIMIT, DEFAULT_CLAUDE_MODEL, DEFAULT_PRIMARY_FALLBACK_MODEL, DEFAULT_SECONDARY_FALLBACK_MODEL, VALID_CLAUDE_MODELS, CLAUDE_MODEL_IDS, DEFAULT_NOTIFICATIONS, DEFAULT_PRD_PRIORITY, DEFAULT_SLICER_SCHEDULE, DEFAULT_SLICER_MAX_RUNTIME, DEFAULT_ROADMAP_SCANNER, DEFAULT_TEMPLATES_DIR, DEFAULT_BOARD_PROVIDER, DEFAULT_LOCAL_BOARD_INFO, DEFAULT_AUTO_MERGE, DEFAULT_AUTO_MERGE_METHOD, VALID_MERGE_METHODS, DEFAULT_QA_ENABLED, DEFAULT_QA_SCHEDULE, DEFAULT_QA_MAX_RUNTIME, DEFAULT_QA_ARTIFACTS, DEFAULT_QA_SKIP_LABEL, DEFAULT_QA_AUTO_INSTALL_PLAYWRIGHT, DEFAULT_QA, QA_LOG_NAME, DEFAULT_AUDIT_ENABLED, DEFAULT_AUDIT_SCHEDULE, DEFAULT_AUDIT_MAX_RUNTIME, DEFAULT_AUDIT, DEFAULT_ANALYTICS_ENABLED, DEFAULT_ANALYTICS_SCHEDULE, DEFAULT_ANALYTICS_MAX_RUNTIME, DEFAULT_ANALYTICS_LOOKBACK_DAYS, DEFAULT_ANALYTICS_TARGET_COLUMN, DEFAULT_ANALYTICS_PROMPT, DEFAULT_ANALYTICS, AUDIT_LOG_NAME, PLANNER_LOG_NAME, ANALYTICS_LOG_NAME, VALID_PROVIDERS, VALID_JOB_TYPES, DEFAULT_JOB_PROVIDERS, BUILT_IN_PRESETS, BUILT_IN_PRESET_IDS, PROVIDER_COMMANDS, CONFIG_FILE_NAME, LOCK_FILE_PREFIX, LOG_DIR, CLAIM_FILE_EXTENSION, EXECUTOR_LOG_NAME, REVIEWER_LOG_NAME, EXECUTOR_LOG_FILE, REVIEWER_LOG_FILE, LOG_FILE_NAMES, GLOBAL_CONFIG_DIR, REGISTRY_FILE_NAME, HISTORY_FILE_NAME, PRD_STATES_FILE_NAME, STATE_DB_FILE_NAME, MAX_HISTORY_RECORDS_PER_PRD, DEFAULT_QUEUE_ENABLED, DEFAULT_QUEUE_MODE, DEFAULT_QUEUE_MAX_CONCURRENCY, DEFAULT_QUEUE_MAX_WAIT_TIME, DEFAULT_QUEUE_PRIORITY, DEFAULT_QUEUE, DEFAULT_SCHEDULING_PRIORITY, QUEUE_LOCK_FILE_NAME;
+var DEFAULT_DEFAULT_BRANCH, DEFAULT_PRD_DIR, DEFAULT_MAX_RUNTIME, DEFAULT_REVIEWER_MAX_RUNTIME, DEFAULT_CRON_SCHEDULE, DEFAULT_REVIEWER_SCHEDULE, DEFAULT_CRON_SCHEDULE_OFFSET, DEFAULT_MAX_RETRIES, DEFAULT_REVIEWER_MAX_RETRIES, DEFAULT_REVIEWER_RETRY_DELAY, DEFAULT_REVIEWER_MAX_PRS_PER_RUN, DEFAULT_BRANCH_PREFIX, DEFAULT_BRANCH_PATTERNS, DEFAULT_MIN_REVIEW_SCORE, DEFAULT_MAX_LOG_SIZE, DEFAULT_PROVIDER, DEFAULT_EXECUTOR_ENABLED, DEFAULT_REVIEWER_ENABLED, DEFAULT_PROVIDER_ENV, DEFAULT_FALLBACK_ON_RATE_LIMIT, DEFAULT_CLAUDE_MODEL, DEFAULT_PRIMARY_FALLBACK_MODEL, DEFAULT_SECONDARY_FALLBACK_MODEL, VALID_CLAUDE_MODELS, CLAUDE_MODEL_IDS, DEFAULT_NOTIFICATIONS, DEFAULT_PRD_PRIORITY, DEFAULT_SLICER_SCHEDULE, DEFAULT_SLICER_MAX_RUNTIME, DEFAULT_ROADMAP_SCANNER, DEFAULT_TEMPLATES_DIR, DEFAULT_BOARD_PROVIDER, DEFAULT_LOCAL_BOARD_INFO, DEFAULT_AUTO_MERGE, DEFAULT_AUTO_MERGE_METHOD, VALID_MERGE_METHODS, DEFAULT_QA_ENABLED, DEFAULT_QA_SCHEDULE, DEFAULT_QA_MAX_RUNTIME, DEFAULT_QA_ARTIFACTS, DEFAULT_QA_SKIP_LABEL, DEFAULT_QA_AUTO_INSTALL_PLAYWRIGHT, DEFAULT_QA, QA_LOG_NAME, DEFAULT_AUDIT_ENABLED, DEFAULT_AUDIT_SCHEDULE, DEFAULT_AUDIT_MAX_RUNTIME, DEFAULT_AUDIT, DEFAULT_ANALYTICS_ENABLED, DEFAULT_ANALYTICS_SCHEDULE, DEFAULT_ANALYTICS_MAX_RUNTIME, DEFAULT_ANALYTICS_LOOKBACK_DAYS, DEFAULT_ANALYTICS_TARGET_COLUMN, DEFAULT_ANALYTICS_PROMPT, DEFAULT_ANALYTICS, AUDIT_LOG_NAME, PLANNER_LOG_NAME, ANALYTICS_LOG_NAME, VALID_PROVIDERS, VALID_JOB_TYPES, DEFAULT_JOB_PROVIDERS, BUILT_IN_PRESETS, BUILT_IN_PRESET_IDS, PROVIDER_COMMANDS, CONFIG_FILE_NAME, LOCK_FILE_PREFIX, LOG_DIR, CLAIM_FILE_EXTENSION, EXECUTOR_LOG_NAME, REVIEWER_LOG_NAME, EXECUTOR_LOG_FILE, REVIEWER_LOG_FILE, LOG_FILE_NAMES, GLOBAL_CONFIG_DIR, REGISTRY_FILE_NAME, HISTORY_FILE_NAME, PRD_STATES_FILE_NAME, STATE_DB_FILE_NAME, GLOBAL_NOTIFICATIONS_FILE_NAME, MAX_HISTORY_RECORDS_PER_PRD, DEFAULT_QUEUE_ENABLED, DEFAULT_QUEUE_MODE, DEFAULT_QUEUE_MAX_CONCURRENCY, DEFAULT_QUEUE_MAX_WAIT_TIME, DEFAULT_QUEUE_PRIORITY, DEFAULT_QUEUE, DEFAULT_SCHEDULING_PRIORITY, QUEUE_LOCK_FILE_NAME;
 var init_constants = __esm({
   "../core/dist/constants.js"() {
     "use strict";
@@ -225,6 +225,7 @@ If no issues are warranted, output an empty array: []`;
     HISTORY_FILE_NAME = "history.json";
     PRD_STATES_FILE_NAME = "prd-states.json";
     STATE_DB_FILE_NAME = "state.db";
+    GLOBAL_NOTIFICATIONS_FILE_NAME = "global-notifications.json";
     MAX_HISTORY_RECORDS_PER_PRD = 10;
     DEFAULT_QUEUE_ENABLED = true;
     DEFAULT_QUEUE_MODE = "conservative";
@@ -2029,11 +2030,18 @@ var init_github_projects = __esm({
           await this.ensureStatusColumns(existing.id);
           return { id: existing.id, number: existing.number, title: existing.title, url: existing.url };
         }
-        const createData = await graphql(`mutation CreateProject($ownerId: ID!, $title: String!) {
-        createProjectV2(input: { ownerId: $ownerId, title: $title }) {
-          projectV2 { id number url title }
+        const createData = await graphql(`
+        mutation CreateProject($ownerId: ID!, $title: String!) {
+          createProjectV2(input: { ownerId: $ownerId, title: $title }) {
+            projectV2 {
+              id
+              number
+              url
+              title
+            }
+          }
         }
-      }`, { ownerId: owner.id, title }, this.cwd);
+      `, { ownerId: owner.id, title }, this.cwd);
         const project = createData.createProjectV2.projectV2;
         this.cachedProjectId = project.id;
         await this.linkProjectToRepository(project.id);
@@ -2049,24 +2057,34 @@ var init_github_projects = __esm({
           const message = err instanceof Error ? err.message : String(err);
           if (!message.includes("Status field not found"))
             throw err;
-          const createFieldData = await graphql(`mutation CreateStatusField($projectId: ID!) {
-          createProjectV2Field(input: {
-            projectId: $projectId
-            dataType: SINGLE_SELECT
-            name: "Status"
-            singleSelectOptions: [
-              { name: "Draft",       color: GRAY,   description: "" }
-              { name: "Ready",       color: BLUE,   description: "" }
-              { name: "In Progress", color: YELLOW, description: "" }
-              { name: "Review",      color: ORANGE, description: "" }
-              { name: "Done",        color: GREEN,  description: "" }
-            ]
-          }) {
-            projectV2Field {
-              ... on ProjectV2SingleSelectField { id options { id name } }
+          const createFieldData = await graphql(`
+          mutation CreateStatusField($projectId: ID!) {
+            createProjectV2Field(
+              input: {
+                projectId: $projectId
+                dataType: SINGLE_SELECT
+                name: "Status"
+                singleSelectOptions: [
+                  { name: "Draft", color: GRAY, description: "" }
+                  { name: "Ready", color: BLUE, description: "" }
+                  { name: "In Progress", color: YELLOW, description: "" }
+                  { name: "Review", color: ORANGE, description: "" }
+                  { name: "Done", color: GREEN, description: "" }
+                ]
+              }
+            ) {
+              projectV2Field {
+                ... on ProjectV2SingleSelectField {
+                  id
+                  options {
+                    id
+                    name
+                  }
+                }
+              }
             }
           }
-        }`, { projectId: project.id }, this.cwd);
+        `, { projectId: project.id }, this.cwd);
           const field = createFieldData.createProjectV2Field.projectV2Field;
           this.cachedFieldId = field.id;
           this.cachedOptionIds = new Map(field.options.map((o) => [o.name, o.id]));
@@ -2093,11 +2111,23 @@ var init_github_projects = __esm({
       async createIssue(input) {
         const repo = await this.getRepo();
         const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
-        const issueArgs = ["issue", "create", "--title", input.title, "--body", input.body, "--repo", repo];
+        const issueArgs = [
+          "issue",
+          "create",
+          "--title",
+          input.title,
+          "--body",
+          input.body,
+          "--repo",
+          repo
+        ];
         if (input.labels && input.labels.length > 0) {
           issueArgs.push("--label", input.labels.join(","));
         }
-        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, { cwd: this.cwd, encoding: "utf-8" });
+        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, {
+          cwd: this.cwd,
+          encoding: "utf-8"
+        });
         const issueUrl = issueUrlRaw.trim();
         const issueNumber = parseInt(issueUrl.split("/").pop() ?? "", 10);
         if (!issueNumber)
@@ -2105,11 +2135,15 @@ var init_github_projects = __esm({
         const [owner, repoName] = repo.split("/");
         const { stdout: nodeIdRaw } = await execFileAsync2("gh", ["api", `repos/${owner}/${repoName}/issues/${issueNumber}`, "--jq", ".node_id"], { cwd: this.cwd, encoding: "utf-8" });
         const issueJson = { number: issueNumber, id: nodeIdRaw.trim(), url: issueUrl };
-        const addData = await graphql(`mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
-        addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
-          item { id }
+        const addData = await graphql(`
+        mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
+          addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+            item {
+              id
+            }
+          }
         }
-      }`, { projectId, contentId: issueJson.id }, this.cwd);
+      `, { projectId, contentId: issueJson.id }, this.cwd);
         const itemId = addData.addProjectV2ItemById.item.id;
         const targetColumn = input.column ?? "Draft";
         const optionId = optionIds.get(targetColumn);
@@ -2129,11 +2163,45 @@ var init_github_projects = __esm({
           assignees: []
         };
       }
+      async addIssue(issueNumber, column = "Ready") {
+        const repo = await this.getRepo();
+        const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
+        const [owner, repoName] = repo.split("/");
+        const { stdout: nodeIdRaw } = await execFileAsync2("gh", ["api", `repos/${owner}/${repoName}/issues/${issueNumber}`, "--jq", ".node_id"], { cwd: this.cwd, encoding: "utf-8" });
+        const nodeId = nodeIdRaw.trim();
+        if (!nodeId)
+          throw new Error(`Issue #${issueNumber} not found in ${repo}.`);
+        const addData = await graphql(`
+        mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
+          addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+            item {
+              id
+            }
+          }
+        }
+      `, { projectId, contentId: nodeId }, this.cwd);
+        const itemId = addData.addProjectV2ItemById.item.id;
+        const optionId = optionIds.get(column);
+        if (optionId)
+          await this.setItemStatus(projectId, itemId, fieldId, optionId);
+        const full = await this.getIssue(issueNumber);
+        if (full)
+          return { ...full, column };
+        throw new Error(`Added issue #${issueNumber} to project but failed to fetch it back.`);
+      }
       async getIssue(issueNumber) {
         const repo = await this.getRepo();
         let rawIssue;
         try {
-          const { stdout: output } = await execFileAsync2("gh", ["issue", "view", String(issueNumber), "--repo", repo, "--json", "number,title,body,url,id,labels,assignees"], { cwd: this.cwd, encoding: "utf-8" });
+          const { stdout: output } = await execFileAsync2("gh", [
+            "issue",
+            "view",
+            String(issueNumber),
+            "--repo",
+            repo,
+            "--json",
+            "number,title,body,url,id,labels,assignees"
+          ], { cwd: this.cwd, encoding: "utf-8" });
           rawIssue = JSON.parse(output);
         } catch {
           return null;
@@ -2238,6 +2306,9 @@ var init_local_kanban = __esm({
         });
         return toIBoardIssue(row);
       }
+      async addIssue(_issueNumber, _column) {
+        throw new Error("addIssue is not supported by the local Kanban provider.");
+      }
       async getIssue(issueNumber) {
         const row = this.repo.getByNumber(issueNumber);
         return row ? toIBoardIssue(row) : null;
@@ -4275,6 +4346,36 @@ var init_log_utils = __esm({
   }
 });
 
+// ../core/dist/utils/global-config.js
+import * as fs11 from "fs";
+import * as os5 from "os";
+import * as path10 from "path";
+function getGlobalNotificationsPath() {
+  return path10.join(os5.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_NOTIFICATIONS_FILE_NAME);
+}
+function loadGlobalNotificationsConfig() {
+  const filePath = getGlobalNotificationsPath();
+  try {
+    if (!fs11.existsSync(filePath))
+      return { webhook: null };
+    const raw = fs11.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { webhook: null };
+  }
+}
+function saveGlobalNotificationsConfig(config) {
+  const filePath = getGlobalNotificationsPath();
+  fs11.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs11.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+var init_global_config = __esm({
+  "../core/dist/utils/global-config.js"() {
+    "use strict";
+    init_constants();
+  }
+});
+
 // ../core/dist/utils/ui.js
 import chalk from "chalk";
 import ora from "ora";
@@ -4631,24 +4732,33 @@ async function sendWebhook(webhook, ctx) {
     warn(`Notification failed (${webhook.type}): ${message}`);
   }
 }
+function webhookIdentity(wh) {
+  if (wh.type === "telegram")
+    return `telegram:${wh.botToken}:${wh.chatId}`;
+  return `${wh.type}:${wh.url}`;
+}
 async function sendNotifications(config, ctx) {
-  const webhooks = config.notifications?.webhooks ?? [];
-  const tasks = [];
-  for (const wh of webhooks) {
-    tasks.push(sendWebhook(wh, ctx));
+  const projectWebhooks = config.notifications?.webhooks ?? [];
+  const globalConfig = loadGlobalNotificationsConfig();
+  const allWebhooks = [...projectWebhooks];
+  if (globalConfig.webhook) {
+    const projectIds = new Set(projectWebhooks.map(webhookIdentity));
+    if (!projectIds.has(webhookIdentity(globalConfig.webhook))) {
+      allWebhooks.push(globalConfig.webhook);
+    }
   }
-  if (tasks.length === 0) {
+  if (allWebhooks.length === 0) {
     return;
   }
-  const results = await Promise.allSettled(tasks);
+  const results = await Promise.allSettled(allWebhooks.map((wh) => sendWebhook(wh, ctx)));
   const sent = results.filter((r) => r.status === "fulfilled").length;
-  const total = results.length;
-  info(`Sent ${sent}/${total} notifications`);
+  info(`Sent ${sent}/${allWebhooks.length} notifications`);
 }
 var MAX_QA_SCREENSHOTS_IN_NOTIFICATION;
 var init_notify = __esm({
   "../core/dist/utils/notify.js"() {
     "use strict";
+    init_global_config();
     init_ui();
     init_github();
     MAX_QA_SCREENSHOTS_IN_NOTIFICATION = 3;
@@ -4685,15 +4795,15 @@ var init_prd_discovery = __esm({
 });
 
 // ../core/dist/utils/prd-utils.js
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber(prdDir) {
-  if (!fs11.existsSync(prdDir))
+  if (!fs12.existsSync(prdDir))
     return 1;
-  const files = fs11.readdirSync(prdDir).filter((f) => f.endsWith(".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;
@@ -4701,16 +4811,16 @@ function getNextPrdNumber(prdDir) {
   return Math.max(0, ...numbers) + 1;
 }
 function markPrdDone(prdDir, prdFile) {
-  const sourcePath = path10.join(prdDir, prdFile);
-  if (!fs11.existsSync(sourcePath)) {
+  const sourcePath = path11.join(prdDir, prdFile);
+  if (!fs12.existsSync(sourcePath)) {
     return false;
   }
-  const doneDir = path10.join(prdDir, "done");
-  if (!fs11.existsSync(doneDir)) {
-    fs11.mkdirSync(doneDir, { recursive: true });
+  const doneDir = path11.join(prdDir, "done");
+  if (!fs12.existsSync(doneDir)) {
+    fs12.mkdirSync(doneDir, { recursive: true });
   }
-  const destPath = path10.join(doneDir, prdFile);
-  fs11.renameSync(sourcePath, destPath);
+  const destPath = path11.join(doneDir, prdFile);
+  fs12.renameSync(sourcePath, destPath);
   return true;
 }
 var init_prd_utils = __esm({
@@ -4720,16 +4830,16 @@ var init_prd_utils = __esm({
 });
 
 // ../core/dist/utils/registry.js
-import * as fs12 from "fs";
-import * as os5 from "os";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as os6 from "os";
+import * as path12 from "path";
 function readLegacyRegistryEntries() {
   const registryPath = getRegistryPath();
-  if (!fs12.existsSync(registryPath)) {
+  if (!fs13.existsSync(registryPath)) {
     return [];
   }
   try {
-    const raw = fs12.readFileSync(registryPath, "utf-8");
+    const raw = fs13.readFileSync(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       return [];
@@ -4764,8 +4874,8 @@ function loadRegistryEntriesWithLegacyFallback() {
   return projectRegistry.getAll();
 }
 function getRegistryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path11.join(os5.homedir(), GLOBAL_CONFIG_DIR);
-  return path11.join(base, REGISTRY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path12.join(os6.homedir(), GLOBAL_CONFIG_DIR);
+  return path12.join(base, REGISTRY_FILE_NAME);
 }
 function loadRegistry() {
   return loadRegistryEntriesWithLegacyFallback();
@@ -4778,7 +4888,7 @@ function saveRegistry(entries) {
   }
 }
 function registerProject(projectDir) {
-  const resolvedPath = path11.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   const { projectRegistry } = getRepositories();
   const entries = loadRegistryEntriesWithLegacyFallback();
   const existing = entries.find((e) => e.path === resolvedPath);
@@ -4787,13 +4897,13 @@ function registerProject(projectDir) {
   }
   const name = getProjectName(resolvedPath);
   const nameExists = entries.some((e) => e.name === name);
-  const finalName = nameExists ? `${name}-${path11.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 = path11.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   loadRegistryEntriesWithLegacyFallback();
   const { projectRegistry } = getRepositories();
   return projectRegistry.remove(resolvedPath);
@@ -4803,7 +4913,7 @@ function validateRegistry() {
   const valid = [];
   const invalid = [];
   for (const entry of entries) {
-    if (fs12.existsSync(entry.path) && fs12.existsSync(path11.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);
@@ -4991,18 +5101,18 @@ var init_roadmap_parser = __esm({
 });
 
 // ../core/dist/utils/roadmap-state.js
-import * as fs13 from "fs";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 function getStateFilePath(prdDir) {
-  return path12.join(prdDir, STATE_FILE_NAME);
+  return path13.join(prdDir, STATE_FILE_NAME);
 }
 function readJsonState(prdDir) {
   const statePath = getStateFilePath(prdDir);
-  if (!fs13.existsSync(statePath)) {
+  if (!fs14.existsSync(statePath)) {
     return null;
   }
   try {
-    const content = fs13.readFileSync(statePath, "utf-8");
+    const content = fs14.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null) {
       return null;
@@ -5040,11 +5150,11 @@ function saveRoadmapState(prdDir, state) {
   const { roadmapState } = getRepositories();
   roadmapState.save(prdDir, state);
   const statePath = getStateFilePath(prdDir);
-  const dir = path12.dirname(statePath);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(statePath);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs13.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  fs14.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 function createEmptyState() {
   return {
@@ -5084,15 +5194,15 @@ var init_roadmap_state = __esm({
 });
 
 // ../core/dist/templates/slicer-prompt.js
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 function loadSlicerTemplate(templateDir) {
   if (cachedTemplate) {
     return cachedTemplate;
   }
-  const templatePath = templateDir ? path13.join(templateDir, "slicer.md") : path13.resolve(__dirname, "..", "..", "templates", "slicer.md");
+  const templatePath = templateDir ? path14.join(templateDir, "slicer.md") : path14.resolve(__dirname, "..", "..", "templates", "slicer.md");
   try {
-    cachedTemplate = fs14.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));
@@ -5117,7 +5227,7 @@ function createSlicerPromptVars(title, section, description, prdDir, prdFilename
     title,
     section,
     description: description || "(No description provided)",
-    outputFilePath: path13.join(prdDir, prdFilename),
+    outputFilePath: path14.join(prdDir, prdFilename),
     prdDir
   };
 }
@@ -5211,8 +5321,8 @@ DO NOT forget to write the file.
 });
 
 // ../core/dist/utils/roadmap-scanner.js
-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";
 function normalizeAuditSeverity(raw) {
@@ -5313,11 +5423,11 @@ function auditFindingToRoadmapItem(finding) {
   };
 }
 function collectAuditPlannerItems(projectDir) {
-  const reportPath = path14.join(projectDir, "logs", "audit-report.md");
-  if (!fs15.existsSync(reportPath)) {
+  const reportPath = path15.join(projectDir, "logs", "audit-report.md");
+  if (!fs16.existsSync(reportPath)) {
     return [];
   }
-  const reportContent = fs15.readFileSync(reportPath, "utf-8");
+  const reportContent = fs16.readFileSync(reportPath, "utf-8");
   if (!reportContent.trim() || /\bNO_ISSUES_FOUND\b/.test(reportContent)) {
     return [];
   }
@@ -5326,9 +5436,9 @@ function collectAuditPlannerItems(projectDir) {
   return findings.map(auditFindingToRoadmapItem);
 }
 function getRoadmapStatus(projectDir, config) {
-  const roadmapPath = path14.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const scannerEnabled = config.roadmapScanner.enabled;
-  if (!fs15.existsSync(roadmapPath)) {
+  if (!fs16.existsSync(roadmapPath)) {
     return {
       found: false,
       enabled: scannerEnabled,
@@ -5339,9 +5449,9 @@ function getRoadmapStatus(projectDir, config) {
       items: []
     };
   }
-  const content = fs15.readFileSync(roadmapPath, "utf-8");
+  const content = fs16.readFileSync(roadmapPath, "utf-8");
   const items = parseRoadmap(content);
-  const prdDir = path14.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const statusItems = items.map((item) => {
@@ -5378,10 +5488,10 @@ function getRoadmapStatus(projectDir, config) {
 }
 function scanExistingPrdSlugs(prdDir) {
   const slugs = /* @__PURE__ */ new Set();
-  if (!fs15.existsSync(prdDir)) {
+  if (!fs16.existsSync(prdDir)) {
     return slugs;
   }
-  const files = fs15.readdirSync(prdDir);
+  const files = fs16.readdirSync(prdDir);
   for (const file of files) {
     if (!file.endsWith(".md")) {
       continue;
@@ -5417,20 +5527,20 @@ 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 = path14.join(prdDir, filename);
-  if (!fs15.existsSync(prdDir)) {
-    fs15.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 provider = resolveJobProvider(config, "slicer");
   const providerArgs = buildProviderArgs(provider, prompt2, projectDir);
-  const logDir = path14.join(projectDir, "logs");
-  if (!fs15.existsSync(logDir)) {
-    fs15.mkdirSync(logDir, { recursive: true });
+  const logDir = path15.join(projectDir, "logs");
+  if (!fs16.existsSync(logDir)) {
+    fs16.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path14.join(logDir, `slicer-${itemSlug}.log`);
-  const logStream = fs15.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((resolve10) => {
@@ -5467,7 +5577,7 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
         });
         return;
       }
-      if (!fs15.existsSync(filePath)) {
+      if (!fs16.existsSync(filePath)) {
         resolve10({
           sliced: false,
           error: `Provider did not create expected file: ${filePath}`,
@@ -5490,23 +5600,23 @@ async function sliceNextItem(projectDir, config) {
       error: "Roadmap scanner is disabled"
     };
   }
-  const roadmapPath = path14.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const auditItems = collectAuditPlannerItems(projectDir);
-  const roadmapExists = fs15.existsSync(roadmapPath);
+  const roadmapExists = fs16.existsSync(roadmapPath);
   if (!roadmapExists && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No pending items to process"
     };
   }
-  const roadmapItems = roadmapExists ? parseRoadmap(fs15.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 = path14.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const pickEligibleItem = (items) => {
@@ -5677,8 +5787,8 @@ var init_shell = __esm({
 });
 
 // ../core/dist/utils/scheduling.js
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 function normalizeSchedulingPriority(priority) {
   if (!Number.isFinite(priority)) {
     return DEFAULT_SCHEDULING_PRIORITY;
@@ -5704,7 +5814,7 @@ function isJobTypeEnabled(config, jobType) {
   }
 }
 function loadPeerConfig(projectPath) {
-  if (!fs16.existsSync(projectPath) || !fs16.existsSync(path15.join(projectPath, CONFIG_FILE_NAME))) {
+  if (!fs17.existsSync(projectPath) || !fs17.existsSync(path16.join(projectPath, CONFIG_FILE_NAME))) {
     return null;
   }
   try {
@@ -5715,9 +5825,9 @@ function loadPeerConfig(projectPath) {
 }
 function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
   const peers = /* @__PURE__ */ new Map();
-  const currentPath = path15.resolve(currentProjectDir);
+  const currentPath = path16.resolve(currentProjectDir);
   const addPeer = (projectPath, config) => {
-    const resolvedPath = path15.resolve(projectPath);
+    const resolvedPath = path16.resolve(projectPath);
     if (!isJobTypeEnabled(config, jobType)) {
       return;
     }
@@ -5725,12 +5835,12 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
       path: resolvedPath,
       config,
       schedulingPriority: normalizeSchedulingPriority(config.schedulingPriority),
-      sortKey: `${path15.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
+      sortKey: `${path16.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
     });
   };
   addPeer(currentPath, currentConfig);
   for (const entry of loadRegistry()) {
-    const resolvedPath = path15.resolve(entry.path);
+    const resolvedPath = path16.resolve(entry.path);
     if (resolvedPath === currentPath || peers.has(resolvedPath)) {
       continue;
     }
@@ -5748,7 +5858,7 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
 }
 function getSchedulingPlan(projectDir, config, jobType) {
   const peers = collectSchedulingPeers(projectDir, config, jobType);
-  const currentPath = path15.resolve(projectDir);
+  const currentPath = path16.resolve(projectDir);
   const slotIndex = Math.max(0, peers.findIndex((peer) => peer.path === currentPath));
   const peerCount = Math.max(1, peers.length);
   const balancedDelayMinutes = peerCount <= 1 ? 0 : Math.floor(slotIndex * 60 / peerCount);
@@ -5840,8 +5950,8 @@ var init_webhook_validator = __esm({
 
 // ../core/dist/utils/worktree-manager.js
 import { execFileSync as execFileSync4 } from "child_process";
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 function gitExec(args, cwd, logFile) {
   try {
     const result = execFileSync4("git", args, {
@@ -5851,7 +5961,7 @@ function gitExec(args, cwd, logFile) {
     });
     if (logFile && result) {
       try {
-        fs17.appendFileSync(logFile, result);
+        fs18.appendFileSync(logFile, result);
       } catch {
       }
     }
@@ -5860,7 +5970,7 @@ function gitExec(args, cwd, logFile) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     if (logFile) {
       try {
-        fs17.appendFileSync(logFile, errorMessage + "\n");
+        fs18.appendFileSync(logFile, errorMessage + "\n");
       } catch {
       }
     }
@@ -5885,11 +5995,11 @@ function branchExistsRemotely(projectDir, branchName) {
 }
 function prepareBranchWorktree(options) {
   const { projectDir, worktreeDir, branchName, defaultBranch, logFile } = options;
-  if (fs17.existsSync(worktreeDir)) {
+  if (fs18.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs17.rmSync(worktreeDir, { recursive: true, force: true });
+        fs18.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5928,11 +6038,11 @@ function prepareBranchWorktree(options) {
 }
 function prepareDetachedWorktree(options) {
   const { projectDir, worktreeDir, defaultBranch, logFile } = options;
-  if (fs17.existsSync(worktreeDir)) {
+  if (fs18.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs17.rmSync(worktreeDir, { recursive: true, force: true });
+        fs18.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5974,7 +6084,7 @@ function isWorktreeRegistered(projectDir, worktreePath) {
   }
 }
 function cleanupWorktrees(projectDir, scope) {
-  const projectName = path16.basename(projectDir);
+  const projectName = path17.basename(projectDir);
   const matchToken = scope ? scope : `${projectName}-nw`;
   const removed = [];
   try {
@@ -6009,16 +6119,16 @@ var init_worktree_manager = __esm({
 });
 
 // ../core/dist/utils/job-queue.js
-import * as os6 from "os";
-import * as path17 from "path";
+import * as os7 from "os";
+import * as path18 from "path";
 import Database7 from "better-sqlite3";
 function getStateDbPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path17.join(os6.homedir(), GLOBAL_CONFIG_DIR);
-  return path17.join(base, STATE_DB_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path18.join(os7.homedir(), GLOBAL_CONFIG_DIR);
+  return path18.join(base, STATE_DB_FILE_NAME);
 }
 function getQueueLockPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path17.join(os6.homedir(), GLOBAL_CONFIG_DIR);
-  return path17.join(base, QUEUE_LOCK_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path18.join(os7.homedir(), GLOBAL_CONFIG_DIR);
+  return path18.join(base, QUEUE_LOCK_FILE_NAME);
 }
 function openDb() {
   const dbPath = getStateDbPath();
@@ -6586,9 +6696,9 @@ var init_amplitude_client = __esm({
 });
 
 // ../core/dist/analytics/analytics-runner.js
-import * as fs18 from "fs";
-import * as os7 from "os";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as os8 from "os";
+import * as path19 from "path";
 function parseIssuesFromResponse(text) {
   const start = text.indexOf("[");
   const end = text.lastIndexOf("]");
@@ -6617,9 +6727,9 @@ async function runAnalytics(config, projectDir) {
 
 --- AMPLITUDE DATA ---
 ${JSON.stringify(data, null, 2)}`;
-  const tmpDir = fs18.mkdtempSync(path18.join(os7.tmpdir(), "nw-analytics-"));
-  const promptFile = path18.join(tmpDir, "analytics-prompt.md");
-  fs18.writeFileSync(promptFile, prompt2, "utf-8");
+  const tmpDir = fs19.mkdtempSync(path19.join(os8.tmpdir(), "nw-analytics-"));
+  const promptFile = path19.join(tmpDir, "analytics-prompt.md");
+  fs19.writeFileSync(promptFile, prompt2, "utf-8");
   try {
     const provider = resolveJobProvider(config, "analytics");
     const providerCmd = PROVIDER_COMMANDS[provider];
@@ -6636,8 +6746,8 @@ set -euo pipefail
 ${providerCmd} exec --yolo "$(cat ${promptFile})" 2>&1
 `;
     }
-    const scriptFile = path18.join(tmpDir, "run-analytics.sh");
-    fs18.writeFileSync(scriptFile, scriptContent, { mode: 493 });
+    const scriptFile = path19.join(tmpDir, "run-analytics.sh");
+    fs19.writeFileSync(scriptFile, scriptContent, { mode: 493 });
     const { exitCode, stdout, stderr } = await executeScriptWithOutput(scriptFile, [], config.providerEnv ?? {});
     if (exitCode !== 0) {
       throw new Error(`AI provider exited with code ${exitCode}: ${stderr || stdout}`);
@@ -6675,7 +6785,7 @@ ${stderr}`;
     };
   } finally {
     try {
-      fs18.rmSync(tmpDir, { recursive: true, force: true });
+      fs19.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -6953,6 +7063,7 @@ __export(dist_exports, {
   EXECUTOR_LOG_FILE: () => EXECUTOR_LOG_FILE,
   EXECUTOR_LOG_NAME: () => EXECUTOR_LOG_NAME,
   GLOBAL_CONFIG_DIR: () => GLOBAL_CONFIG_DIR,
+  GLOBAL_NOTIFICATIONS_FILE_NAME: () => GLOBAL_NOTIFICATIONS_FILE_NAME,
   HISTORY_FILE_NAME: () => HISTORY_FILE_NAME,
   HORIZON_LABELS: () => HORIZON_LABELS,
   HORIZON_LABEL_INFO: () => HORIZON_LABEL_INFO,
@@ -7106,6 +7217,7 @@ __export(dist_exports, {
   label: () => label,
   listPrdStatesByStatus: () => listPrdStatesByStatus,
   loadConfig: () => loadConfig,
+  loadGlobalNotificationsConfig: () => loadGlobalNotificationsConfig,
   loadHistory: () => loadHistory,
   loadRegistry: () => loadRegistry,
   loadRoadmapState: () => loadRoadmapState,
@@ -7146,6 +7258,7 @@ __export(dist_exports, {
   runAnalytics: () => runAnalytics,
   runMigrations: () => runMigrations,
   saveConfig: () => saveConfig,
+  saveGlobalNotificationsConfig: () => saveGlobalNotificationsConfig,
   saveHistory: () => saveHistory,
   saveRegistry: () => saveRegistry,
   saveRoadmapState: () => saveRoadmapState,
@@ -7195,6 +7308,7 @@ var init_dist = __esm({
     init_git_utils();
     init_github();
     init_log_utils();
+    init_global_config();
     init_notify();
     init_prd_discovery();
     init_prd_states();
@@ -7221,39 +7335,39 @@ var init_dist = __esm({
 // src/cli.ts
 import "reflect-metadata";
 import { Command as Command3 } from "commander";
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync19 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname8, join as join35 } from "path";
+import { dirname as dirname9, join as join36 } from "path";
 
 // src/commands/init.ts
 init_dist();
-import fs19 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path20 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join17 } from "path";
+import { dirname as dirname5, join as join18 } from "path";
 import * as readline from "readline";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname4(__filename);
+var __dirname2 = dirname5(__filename);
 function findTemplatesDir(startDir) {
   let d = startDir;
   for (let i = 0; i < 8; i++) {
-    const candidate = join17(d, "templates");
-    if (fs19.existsSync(candidate) && fs19.statSync(candidate).isDirectory()) {
+    const candidate = join18(d, "templates");
+    if (fs20.existsSync(candidate) && fs20.statSync(candidate).isDirectory()) {
       return candidate;
     }
-    d = dirname4(d);
+    d = dirname5(d);
   }
-  return join17(startDir, "templates");
+  return join18(startDir, "templates");
 }
 var TEMPLATES_DIR = findTemplatesDir(__dirname2);
 function hasPlaywrightDependency(cwd) {
-  const packageJsonPath = path19.join(cwd, "package.json");
-  if (!fs19.existsSync(packageJsonPath)) {
+  const packageJsonPath = path20.join(cwd, "package.json");
+  if (!fs20.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson2 = JSON.parse(fs19.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson2 = JSON.parse(fs20.readFileSync(packageJsonPath, "utf-8"));
     return Boolean(
       packageJson2.dependencies?.["@playwright/test"] || packageJson2.dependencies?.playwright || packageJson2.devDependencies?.["@playwright/test"] || packageJson2.devDependencies?.playwright
     );
@@ -7265,7 +7379,7 @@ function detectPlaywright(cwd) {
   if (hasPlaywrightDependency(cwd)) {
     return true;
   }
-  if (fs19.existsSync(path19.join(cwd, "node_modules", ".bin", "playwright"))) {
+  if (fs20.existsSync(path20.join(cwd, "node_modules", ".bin", "playwright"))) {
     return true;
   }
   try {
@@ -7281,10 +7395,10 @@ function detectPlaywright(cwd) {
   }
 }
 function resolvePlaywrightInstallCommand(cwd) {
-  if (fs19.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs20.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm add -D @playwright/test";
   }
-  if (fs19.existsSync(path19.join(cwd, "yarn.lock"))) {
+  if (fs20.existsSync(path20.join(cwd, "yarn.lock"))) {
     return "yarn add -D @playwright/test";
   }
   return "npm install -D @playwright/test";
@@ -7430,8 +7544,8 @@ function promptProviderSelection(providers) {
   });
 }
 function ensureDir(dirPath) {
-  if (!fs19.existsSync(dirPath)) {
-    fs19.mkdirSync(dirPath, { recursive: true });
+  if (!fs20.existsSync(dirPath)) {
+    fs20.mkdirSync(dirPath, { recursive: true });
   }
 }
 function buildInitConfig(params) {
@@ -7488,30 +7602,30 @@ function buildInitConfig(params) {
 }
 function resolveTemplatePath(templateName, customTemplatesDir, bundledTemplatesDir) {
   if (customTemplatesDir !== null) {
-    const customPath = join17(customTemplatesDir, templateName);
-    if (fs19.existsSync(customPath)) {
+    const customPath = join18(customTemplatesDir, templateName);
+    if (fs20.existsSync(customPath)) {
       return { path: customPath, source: "custom" };
     }
   }
-  return { path: join17(bundledTemplatesDir, templateName), source: "bundled" };
+  return { path: join18(bundledTemplatesDir, templateName), source: "bundled" };
 }
 function processTemplate(templateName, targetPath, replacements, force, sourcePath, source) {
-  if (fs19.existsSync(targetPath) && !force) {
+  if (fs20.existsSync(targetPath) && !force) {
     console.log(`  Skipped (exists): ${targetPath}`);
     return { created: false, source: source ?? "bundled" };
   }
-  const templatePath = sourcePath ?? join17(TEMPLATES_DIR, templateName);
+  const templatePath = sourcePath ?? join18(TEMPLATES_DIR, templateName);
   const resolvedSource = source ?? "bundled";
-  let content = fs19.readFileSync(templatePath, "utf-8");
+  let content = fs20.readFileSync(templatePath, "utf-8");
   for (const [key, value] of Object.entries(replacements)) {
     content = content.replaceAll(key, value);
   }
-  fs19.writeFileSync(targetPath, content);
+  fs20.writeFileSync(targetPath, content);
   console.log(`  Created: ${targetPath} (${resolvedSource})`);
   return { created: true, source: resolvedSource };
 }
 function addToGitignore(cwd) {
-  const gitignorePath = path19.join(cwd, ".gitignore");
+  const gitignorePath = path20.join(cwd, ".gitignore");
   const entries = [
     {
       pattern: "/logs/",
@@ -7525,13 +7639,13 @@ function addToGitignore(cwd) {
     },
     { pattern: "*.claim", label: "*.claim", check: (c) => c.includes("*.claim") }
   ];
-  if (!fs19.existsSync(gitignorePath)) {
+  if (!fs20.existsSync(gitignorePath)) {
     const lines = ["# Night Watch", ...entries.map((e) => e.pattern), ""];
-    fs19.writeFileSync(gitignorePath, lines.join("\n"));
+    fs20.writeFileSync(gitignorePath, lines.join("\n"));
     console.log(`  Created: ${gitignorePath} (with Night Watch entries)`);
     return;
   }
-  const content = fs19.readFileSync(gitignorePath, "utf-8");
+  const content = fs20.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`);
@@ -7539,7 +7653,7 @@ function addToGitignore(cwd) {
   }
   const additions = missing.map((e) => e.pattern).join("\n");
   const newContent = content.trimEnd() + "\n\n# Night Watch\n" + additions + "\n";
-  fs19.writeFileSync(gitignorePath, newContent);
+  fs20.writeFileSync(gitignorePath, newContent);
   console.log(`  Updated: ${gitignorePath} (added ${missing.map((e) => e.label).join(", ")})`);
 }
 function initCommand(program2) {
@@ -7660,28 +7774,28 @@ function initCommand(program2) {
       "${DEFAULT_BRANCH}": defaultBranch
     };
     step(6, totalSteps, "Creating PRD directory structure...");
-    const prdDirPath = path19.join(cwd, prdDir);
-    const doneDirPath = path19.join(prdDirPath, "done");
+    const prdDirPath = path20.join(cwd, prdDir);
+    const doneDirPath = path20.join(prdDirPath, "done");
     ensureDir(doneDirPath);
     success(`Created ${prdDirPath}/`);
     success(`Created ${doneDirPath}/`);
     step(7, totalSteps, "Creating logs directory...");
-    const logsPath = path19.join(cwd, LOG_DIR);
+    const logsPath = path20.join(cwd, LOG_DIR);
     ensureDir(logsPath);
     success(`Created ${logsPath}/`);
     addToGitignore(cwd);
     step(8, totalSteps, "Creating instructions directory...");
-    const instructionsDir = path19.join(cwd, "instructions");
+    const instructionsDir = path20.join(cwd, "instructions");
     ensureDir(instructionsDir);
     success(`Created ${instructionsDir}/`);
     const existingConfig = loadConfig(cwd);
-    const customTemplatesDirPath = path19.join(cwd, existingConfig.templatesDir);
-    const customTemplatesDir = fs19.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
+    const customTemplatesDirPath = path20.join(cwd, existingConfig.templatesDir);
+    const customTemplatesDir = fs20.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
     const templateSources = [];
     const nwResolution = resolveTemplatePath("executor.md", customTemplatesDir, TEMPLATES_DIR);
     const nwResult = processTemplate(
       "executor.md",
-      path19.join(instructionsDir, "executor.md"),
+      path20.join(instructionsDir, "executor.md"),
       replacements,
       force,
       nwResolution.path,
@@ -7695,7 +7809,7 @@ function initCommand(program2) {
     );
     const peResult = processTemplate(
       "prd-executor.md",
-      path19.join(instructionsDir, "prd-executor.md"),
+      path20.join(instructionsDir, "prd-executor.md"),
       replacements,
       force,
       peResolution.path,
@@ -7705,7 +7819,7 @@ function initCommand(program2) {
     const prResolution = resolveTemplatePath("pr-reviewer.md", customTemplatesDir, TEMPLATES_DIR);
     const prResult = processTemplate(
       "pr-reviewer.md",
-      path19.join(instructionsDir, "pr-reviewer.md"),
+      path20.join(instructionsDir, "pr-reviewer.md"),
       replacements,
       force,
       prResolution.path,
@@ -7715,7 +7829,7 @@ function initCommand(program2) {
     const qaResolution = resolveTemplatePath("qa.md", customTemplatesDir, TEMPLATES_DIR);
     const qaResult = processTemplate(
       "qa.md",
-      path19.join(instructionsDir, "qa.md"),
+      path20.join(instructionsDir, "qa.md"),
       replacements,
       force,
       qaResolution.path,
@@ -7725,7 +7839,7 @@ function initCommand(program2) {
     const auditResolution = resolveTemplatePath("audit.md", customTemplatesDir, TEMPLATES_DIR);
     const auditResult = processTemplate(
       "audit.md",
-      path19.join(instructionsDir, "audit.md"),
+      path20.join(instructionsDir, "audit.md"),
       replacements,
       force,
       auditResolution.path,
@@ -7733,8 +7847,8 @@ function initCommand(program2) {
     );
     templateSources.push({ name: "audit.md", source: auditResult.source });
     step(9, totalSteps, "Creating configuration file...");
-    const configPath = path19.join(cwd, CONFIG_FILE_NAME);
-    if (fs19.existsSync(configPath) && !force) {
+    const configPath = path20.join(cwd, CONFIG_FILE_NAME);
+    if (fs20.existsSync(configPath) && !force) {
       console.log(`  Skipped (exists): ${configPath}`);
     } else {
       const config = buildInitConfig({
@@ -7744,11 +7858,11 @@ function initCommand(program2) {
         reviewerEnabled,
         prdDir
       });
-      fs19.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      fs20.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
       success(`Created ${configPath}`);
     }
     step(10, totalSteps, "Setting up GitHub Project board...");
-    const existingRaw = JSON.parse(fs19.readFileSync(configPath, "utf-8"));
+    const existingRaw = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
     const existingBoard = existingRaw.boardProvider;
     let boardSetupStatus = "Skipped";
     if (existingBoard?.projectNumber && !force) {
@@ -7770,13 +7884,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(fs19.readFileSync(configPath, "utf-8"));
+          const rawConfig = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
           rawConfig.boardProvider = {
             enabled: true,
             provider: "github",
             projectNumber: board.number
           };
-          fs19.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+          fs20.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
           boardSetupStatus = `Created (#${board.number})`;
           success(`GitHub Project board "${boardTitle}" ready (#${board.number})`);
         } catch (boardErr) {
@@ -7900,8 +8014,8 @@ function getTelegramStatusWebhooks(config) {
 }
 
 // src/commands/run.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
+import * as fs21 from "fs";
+import * as path21 from "path";
 function resolveRunNotificationEvent(exitCode, scriptStatus) {
   if (exitCode === 124) {
     return "run_timeout";
@@ -7933,12 +8047,12 @@ function shouldAttemptCrossProjectFallback(options, scriptStatus) {
   return scriptStatus === "skip_no_eligible_prd";
 }
 function getCrossProjectFallbackCandidates(currentProjectDir) {
-  const current = path20.resolve(currentProjectDir);
+  const current = path21.resolve(currentProjectDir);
   const { valid, invalid } = validateRegistry();
   for (const entry of invalid) {
     warn(`Skipping invalid registry entry: ${entry.path}`);
   }
-  return valid.filter((entry) => path20.resolve(entry.path) !== current);
+  return valid.filter((entry) => path21.resolve(entry.path) !== current);
 }
 async function sendRunCompletionNotifications(config, projectDir, options, exitCode, scriptResult) {
   if (isRateLimitFallbackTriggered(scriptResult?.data)) {
@@ -7948,7 +8062,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     if (nonTelegramWebhooks.length > 0) {
       const _rateLimitCtx = {
         event: "rate_limit_fallback",
-        projectName: path20.basename(projectDir),
+        projectName: path21.basename(projectDir),
         exitCode,
         provider: config.provider
       };
@@ -7976,7 +8090,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     const timeoutDuration = event === "run_timeout" ? config.maxRuntime : void 0;
     const _ctx = {
       event,
-      projectName: path20.basename(projectDir),
+      projectName: path21.basename(projectDir),
       exitCode,
       provider: config.provider,
       prdName: scriptResult?.data.prd,
@@ -8138,20 +8252,20 @@ function applyCliOverrides(config, options) {
   return overridden;
 }
 function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
-  const absolutePrdDir = path20.join(projectDir, prdDir);
-  const doneDir = path20.join(absolutePrdDir, "done");
+  const absolutePrdDir = path21.join(projectDir, prdDir);
+  const doneDir = path21.join(absolutePrdDir, "done");
   const pending = [];
   const completed = [];
-  if (fs20.existsSync(absolutePrdDir)) {
-    const entries = fs20.readdirSync(absolutePrdDir, { withFileTypes: true });
+  if (fs21.existsSync(absolutePrdDir)) {
+    const entries = fs21.readdirSync(absolutePrdDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        const claimPath = path20.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
+        const claimPath = path21.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
         let claimed = false;
         let claimInfo = null;
-        if (fs20.existsSync(claimPath)) {
+        if (fs21.existsSync(claimPath)) {
           try {
-            const content = fs20.readFileSync(claimPath, "utf-8");
+            const content = fs21.readFileSync(claimPath, "utf-8");
             const data = JSON.parse(content);
             const age = Math.floor(Date.now() / 1e3) - data.timestamp;
             if (age < maxRuntime) {
@@ -8165,8 +8279,8 @@ function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
       }
     }
   }
-  if (fs20.existsSync(doneDir)) {
-    const entries = fs20.readdirSync(doneDir, { withFileTypes: true });
+  if (fs21.existsSync(doneDir)) {
+    const entries = fs21.readdirSync(doneDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
         completed.push(entry.name);
@@ -8326,7 +8440,7 @@ ${stderr}`);
 // src/commands/review.ts
 init_dist();
 import { execFileSync as execFileSync5 } from "child_process";
-import * as path21 from "path";
+import * as path22 from "path";
 function shouldSendReviewNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -8566,7 +8680,7 @@ ${stderr}`);
           const finalScore = parseFinalReviewScore(scriptResult?.data.final_score);
           const _reviewCtx = {
             event: "review_completed",
-            projectName: path21.basename(projectDir),
+            projectName: path22.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prUrl: prDetails?.url,
@@ -8587,7 +8701,7 @@ ${stderr}`);
           const autoMergedPrDetails = fetchPrDetailsByNumber(autoMergedPrNumber, projectDir);
           const _mergeCtx = {
             event: "pr_auto_merged",
-            projectName: path21.basename(projectDir),
+            projectName: path22.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: autoMergedPrDetails?.number ?? autoMergedPrNumber,
@@ -8612,7 +8726,7 @@ ${stderr}`);
 
 // src/commands/qa.ts
 init_dist();
-import * as path22 from "path";
+import * as path23 from "path";
 function shouldSendQaNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -8746,7 +8860,7 @@ ${stderr}`);
           const qaScreenshotUrls = primaryQaPr !== void 0 ? fetchQaScreenshotUrlsForPr(primaryQaPr, projectDir, repo) : [];
           const _qaCtx = {
             event: "qa_completed",
-            projectName: path22.basename(projectDir),
+            projectName: path23.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: prDetails?.number ?? primaryQaPr,
@@ -8772,8 +8886,8 @@ ${stderr}`);
 
 // src/commands/audit.ts
 init_dist();
-import * as fs21 from "fs";
-import * as path23 from "path";
+import * as fs22 from "fs";
+import * as path24 from "path";
 function buildEnvVars4(config, options) {
   const env = buildBaseEnvVars(config, "audit", options.dryRun);
   env.NW_AUDIT_MAX_RUNTIME = String(config.audit.maxRuntime);
@@ -8816,7 +8930,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", path23.join(projectDir, "logs", "audit-report.md")]);
+      configTable.push(["Report File", path24.join(projectDir, "logs", "audit-report.md")]);
       console.log(configTable.toString());
       header("Provider Invocation");
       const providerCmd = PROVIDER_COMMANDS[auditProvider];
@@ -8851,8 +8965,8 @@ ${stderr}`);
         } else if (scriptResult?.status?.startsWith("skip_")) {
           spinner.succeed("Code audit skipped");
         } else {
-          const reportPath = path23.join(projectDir, "logs", "audit-report.md");
-          if (!fs21.existsSync(reportPath)) {
+          const reportPath = path24.join(projectDir, "logs", "audit-report.md");
+          if (!fs22.existsSync(reportPath)) {
             spinner.fail("Code audit finished without a report file");
             process.exit(1);
           }
@@ -8863,9 +8977,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 = path23.join(projectDir, "logs", "audit.log");
-        if (fs21.existsSync(logPath)) {
-          const logLines = fs21.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
+        const logPath = path24.join(projectDir, "logs", "audit.log");
+        if (fs22.existsSync(logPath)) {
+          const logLines = fs22.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
           if (logLines.length > 0) {
             process.stderr.write(logLines.join("\n") + "\n");
           }
@@ -8943,16 +9057,16 @@ function analyticsCommand(program2) {
 // src/commands/install.ts
 init_dist();
 import { execSync as execSync4 } from "child_process";
-import * as path24 from "path";
-import * as fs22 from "fs";
+import * as path25 from "path";
+import * as fs23 from "fs";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function getNightWatchBinPath() {
   try {
     const npmBin = execSync4("npm bin -g", { encoding: "utf-8" }).trim();
-    const binPath = path24.join(npmBin, "night-watch");
-    if (fs22.existsSync(binPath)) {
+    const binPath = path25.join(npmBin, "night-watch");
+    if (fs23.existsSync(binPath)) {
       return binPath;
     }
   } catch {
@@ -8965,17 +9079,17 @@ function getNightWatchBinPath() {
 }
 function getNodeBinDir() {
   if (process.execPath && process.execPath !== "node") {
-    return path24.dirname(process.execPath);
+    return path25.dirname(process.execPath);
   }
   try {
     const nodePath = execSync4("which node", { encoding: "utf-8" }).trim();
-    return path24.dirname(nodePath);
+    return path25.dirname(nodePath);
   } catch {
     return "";
   }
 }
 function buildCronPathPrefix(nodeBinDir, nightWatchBin) {
-  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path24.dirname(nightWatchBin) : "";
+  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path25.dirname(nightWatchBin) : "";
   const pathParts = Array.from(
     new Set([nodeBinDir, nightWatchBinDir].filter((part) => part.length > 0))
   );
@@ -8991,12 +9105,12 @@ function performInstall(projectDir, config, options) {
     const nightWatchBin = getNightWatchBinPath();
     const projectName = getProjectName(projectDir);
     const marker = generateMarker(projectName);
-    const logDir = path24.join(projectDir, LOG_DIR);
-    if (!fs22.existsSync(logDir)) {
-      fs22.mkdirSync(logDir, { recursive: true });
+    const logDir = path25.join(projectDir, LOG_DIR);
+    if (!fs23.existsSync(logDir)) {
+      fs23.mkdirSync(logDir, { recursive: true });
     }
-    const executorLog = path24.join(logDir, "executor.log");
-    const reviewerLog = path24.join(logDir, "reviewer.log");
+    const executorLog = path25.join(logDir, "executor.log");
+    const reviewerLog = path25.join(logDir, "reviewer.log");
     if (!options?.force) {
       const existingEntries2 = Array.from(
         /* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)])
@@ -9033,7 +9147,7 @@ function performInstall(projectDir, config, options) {
     const installSlicer = options?.noSlicer === true ? false : config.roadmapScanner.enabled;
     if (installSlicer) {
       const slicerSchedule = config.roadmapScanner.slicerSchedule;
-      const slicerLog = path24.join(logDir, "slicer.log");
+      const slicerLog = path25.join(logDir, "slicer.log");
       const slicerEntry = `${slicerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} planner >> ${shellQuote(slicerLog)} 2>&1  ${marker}`;
       entries.push(slicerEntry);
     }
@@ -9041,7 +9155,7 @@ function performInstall(projectDir, config, options) {
     const installQa = disableQa ? false : config.qa.enabled;
     if (installQa) {
       const qaSchedule = config.qa.schedule;
-      const qaLog = path24.join(logDir, "qa.log");
+      const qaLog = path25.join(logDir, "qa.log");
       const qaEntry = `${qaSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} qa >> ${shellQuote(qaLog)} 2>&1  ${marker}`;
       entries.push(qaEntry);
     }
@@ -9049,7 +9163,7 @@ function performInstall(projectDir, config, options) {
     const installAudit = disableAudit ? false : config.audit.enabled;
     if (installAudit) {
       const auditSchedule = config.audit.schedule;
-      const auditLog = path24.join(logDir, "audit.log");
+      const auditLog = path25.join(logDir, "audit.log");
       const auditEntry = `${auditSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} audit >> ${shellQuote(auditLog)} 2>&1  ${marker}`;
       entries.push(auditEntry);
     }
@@ -9057,7 +9171,7 @@ function performInstall(projectDir, config, options) {
     const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
     if (installAnalytics) {
       const analyticsSchedule = config.analytics.schedule;
-      const analyticsLog = path24.join(logDir, "analytics.log");
+      const analyticsLog = path25.join(logDir, "analytics.log");
       const analyticsEntry = `${analyticsSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} analytics >> ${shellQuote(analyticsLog)} 2>&1  ${marker}`;
       entries.push(analyticsEntry);
     }
@@ -9088,12 +9202,12 @@ function installCommand(program2) {
       const nightWatchBin = getNightWatchBinPath();
       const projectName = getProjectName(projectDir);
       const marker = generateMarker(projectName);
-      const logDir = path24.join(projectDir, LOG_DIR);
-      if (!fs22.existsSync(logDir)) {
-        fs22.mkdirSync(logDir, { recursive: true });
+      const logDir = path25.join(projectDir, LOG_DIR);
+      if (!fs23.existsSync(logDir)) {
+        fs23.mkdirSync(logDir, { recursive: true });
       }
-      const executorLog = path24.join(logDir, "executor.log");
-      const reviewerLog = path24.join(logDir, "reviewer.log");
+      const executorLog = path25.join(logDir, "executor.log");
+      const reviewerLog = path25.join(logDir, "reviewer.log");
       const existingEntries = Array.from(
         /* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)])
       );
@@ -9129,7 +9243,7 @@ function installCommand(program2) {
       const installSlicer = options.noSlicer === true ? false : config.roadmapScanner.enabled;
       let slicerLog;
       if (installSlicer) {
-        slicerLog = path24.join(logDir, "slicer.log");
+        slicerLog = path25.join(logDir, "slicer.log");
         const slicerSchedule = config.roadmapScanner.slicerSchedule;
         const slicerEntry = `${slicerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} planner >> ${shellQuote(slicerLog)} 2>&1  ${marker}`;
         entries.push(slicerEntry);
@@ -9138,7 +9252,7 @@ function installCommand(program2) {
       const installQa = disableQa ? false : config.qa.enabled;
       let qaLog;
       if (installQa) {
-        qaLog = path24.join(logDir, "qa.log");
+        qaLog = path25.join(logDir, "qa.log");
         const qaSchedule = config.qa.schedule;
         const qaEntry = `${qaSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} qa >> ${shellQuote(qaLog)} 2>&1  ${marker}`;
         entries.push(qaEntry);
@@ -9147,7 +9261,7 @@ function installCommand(program2) {
       const installAudit = disableAudit ? false : config.audit.enabled;
       let auditLog;
       if (installAudit) {
-        auditLog = path24.join(logDir, "audit.log");
+        auditLog = path25.join(logDir, "audit.log");
         const auditSchedule = config.audit.schedule;
         const auditEntry = `${auditSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} audit >> ${shellQuote(auditLog)} 2>&1  ${marker}`;
         entries.push(auditEntry);
@@ -9156,7 +9270,7 @@ function installCommand(program2) {
       const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
       let analyticsLog;
       if (installAnalytics) {
-        analyticsLog = path24.join(logDir, "analytics.log");
+        analyticsLog = path25.join(logDir, "analytics.log");
         const analyticsSchedule = config.analytics.schedule;
         const analyticsEntry = `${analyticsSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} analytics >> ${shellQuote(analyticsLog)} 2>&1  ${marker}`;
         entries.push(analyticsEntry);
@@ -9204,8 +9318,8 @@ function installCommand(program2) {
 
 // src/commands/uninstall.ts
 init_dist();
-import * as path25 from "path";
-import * as fs23 from "fs";
+import * as path26 from "path";
+import * as fs24 from "fs";
 function performUninstall(projectDir, options) {
   try {
     const projectName = getProjectName(projectDir);
@@ -9220,19 +9334,19 @@ function performUninstall(projectDir, options) {
     const removedCount = removeEntriesForProject(projectDir, marker);
     unregisterProject(projectDir);
     if (!options?.keepLogs) {
-      const logDir = path25.join(projectDir, "logs");
-      if (fs23.existsSync(logDir)) {
+      const logDir = path26.join(projectDir, "logs");
+      if (fs24.existsSync(logDir)) {
         const logFiles = ["executor.log", "reviewer.log", "slicer.log", "audit.log"];
         logFiles.forEach((logFile) => {
-          const logPath = path25.join(logDir, logFile);
-          if (fs23.existsSync(logPath)) {
-            fs23.unlinkSync(logPath);
+          const logPath = path26.join(logDir, logFile);
+          if (fs24.existsSync(logPath)) {
+            fs24.unlinkSync(logPath);
           }
         });
         try {
-          const remainingFiles = fs23.readdirSync(logDir);
+          const remainingFiles = fs24.readdirSync(logDir);
           if (remainingFiles.length === 0) {
-            fs23.rmdirSync(logDir);
+            fs24.rmdirSync(logDir);
           }
         } catch {
         }
@@ -9265,21 +9379,21 @@ function uninstallCommand(program2) {
       existingEntries.forEach((entry) => dim(`  ${entry}`));
       const removedCount = removeEntriesForProject(projectDir, marker);
       if (!options.keepLogs) {
-        const logDir = path25.join(projectDir, "logs");
-        if (fs23.existsSync(logDir)) {
+        const logDir = path26.join(projectDir, "logs");
+        if (fs24.existsSync(logDir)) {
           const logFiles = ["executor.log", "reviewer.log", "slicer.log", "audit.log"];
           let logsRemoved = 0;
           logFiles.forEach((logFile) => {
-            const logPath = path25.join(logDir, logFile);
-            if (fs23.existsSync(logPath)) {
-              fs23.unlinkSync(logPath);
+            const logPath = path26.join(logDir, logFile);
+            if (fs24.existsSync(logPath)) {
+              fs24.unlinkSync(logPath);
               logsRemoved++;
             }
           });
           try {
-            const remainingFiles = fs23.readdirSync(logDir);
+            const remainingFiles = fs24.readdirSync(logDir);
             if (remainingFiles.length === 0) {
-              fs23.rmdirSync(logDir);
+              fs24.rmdirSync(logDir);
             }
           } catch {
           }
@@ -9515,14 +9629,14 @@ function statusCommand(program2) {
 // src/commands/logs.ts
 init_dist();
 import { spawn as spawn3 } from "child_process";
-import * as path26 from "path";
-import * as fs24 from "fs";
+import * as path27 from "path";
+import * as fs25 from "fs";
 function getLastLines(filePath, lineCount) {
-  if (!fs24.existsSync(filePath)) {
+  if (!fs25.existsSync(filePath)) {
     return `Log file not found: ${filePath}`;
   }
   try {
-    const content = fs24.readFileSync(filePath, "utf-8");
+    const content = fs25.readFileSync(filePath, "utf-8");
     const lines = content.trim().split("\n");
     return lines.slice(-lineCount).join("\n");
   } catch (error2) {
@@ -9530,7 +9644,7 @@ function getLastLines(filePath, lineCount) {
   }
 }
 function followLog(filePath) {
-  if (!fs24.existsSync(filePath)) {
+  if (!fs25.existsSync(filePath)) {
     console.log(`Log file not found: ${filePath}`);
     console.log("The log file will be created when the first execution runs.");
     return;
@@ -9550,13 +9664,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 = path26.join(projectDir, LOG_DIR);
+      const logDir = path27.join(projectDir, LOG_DIR);
       const lineCount = parseInt(options.lines || "50", 10);
-      const executorLog = path26.join(logDir, EXECUTOR_LOG_FILE);
-      const reviewerLog = path26.join(logDir, REVIEWER_LOG_FILE);
-      const qaLog = path26.join(logDir, `${QA_LOG_NAME}.log`);
-      const auditLog = path26.join(logDir, `${AUDIT_LOG_NAME}.log`);
-      const plannerLog = path26.join(logDir, `${PLANNER_LOG_NAME}.log`);
+      const executorLog = path27.join(logDir, EXECUTOR_LOG_FILE);
+      const reviewerLog = path27.join(logDir, REVIEWER_LOG_FILE);
+      const qaLog = path27.join(logDir, `${QA_LOG_NAME}.log`);
+      const auditLog = path27.join(logDir, `${AUDIT_LOG_NAME}.log`);
+      const plannerLog = path27.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";
@@ -9620,15 +9734,15 @@ function logsCommand(program2) {
 
 // src/commands/prd.ts
 init_dist();
-import * as fs25 from "fs";
-import * as path27 from "path";
+import * as fs26 from "fs";
+import * as path28 from "path";
 import * as readline2 from "readline";
 function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber2(prdDir) {
-  if (!fs25.existsSync(prdDir)) return 1;
-  const files = fs25.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+  if (!fs26.existsSync(prdDir)) return 1;
+  const files = fs26.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
@@ -9649,10 +9763,10 @@ function parseDependencies(content) {
 }
 function isClaimActive(claimPath, maxRuntime) {
   try {
-    if (!fs25.existsSync(claimPath)) {
+    if (!fs26.existsSync(claimPath)) {
       return { active: false };
     }
-    const content = fs25.readFileSync(claimPath, "utf-8");
+    const content = fs26.readFileSync(claimPath, "utf-8");
     const claim = JSON.parse(content);
     const age = Math.floor(Date.now() / 1e3) - claim.timestamp;
     if (age < maxRuntime) {
@@ -9668,9 +9782,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 = path27.join(projectDir, config.prdDir);
-    if (!fs25.existsSync(prdDir)) {
-      fs25.mkdirSync(prdDir, { recursive: true });
+    const prdDir = path28.join(projectDir, config.prdDir);
+    if (!fs26.existsSync(prdDir)) {
+      fs26.mkdirSync(prdDir, { recursive: true });
     }
     let complexityScore = 5;
     let dependsOn = [];
@@ -9729,20 +9843,20 @@ function prdCommand(program2) {
     } else {
       filename = `${slug}.md`;
     }
-    const filePath = path27.join(prdDir, filename);
-    if (fs25.existsSync(filePath)) {
+    const filePath = path28.join(prdDir, filename);
+    if (fs26.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 = path27.resolve(options.template);
-      if (!fs25.existsSync(templatePath)) {
+      const templatePath = path28.resolve(options.template);
+      if (!fs26.existsSync(templatePath)) {
         error(`Template file not found: ${templatePath}`);
         process.exit(1);
       }
-      customTemplate = fs25.readFileSync(templatePath, "utf-8");
+      customTemplate = fs26.readFileSync(templatePath, "utf-8");
     }
     const vars = {
       title: name,
@@ -9753,7 +9867,7 @@ function prdCommand(program2) {
       phaseCount
     };
     const content = renderPrdTemplate(vars, customTemplate);
-    fs25.writeFileSync(filePath, content, "utf-8");
+    fs26.writeFileSync(filePath, content, "utf-8");
     header("PRD Created");
     success(`Created: ${filePath}`);
     info(`Title: ${name}`);
@@ -9765,15 +9879,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 = path27.join(projectDir, config.prdDir);
-    const doneDir = path27.join(absolutePrdDir, "done");
+    const absolutePrdDir = path28.join(projectDir, config.prdDir);
+    const doneDir = path28.join(absolutePrdDir, "done");
     const pending = [];
-    if (fs25.existsSync(absolutePrdDir)) {
-      const files = fs25.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md"));
+    if (fs26.existsSync(absolutePrdDir)) {
+      const files = fs26.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs25.readFileSync(path27.join(absolutePrdDir, file), "utf-8");
+        const content = fs26.readFileSync(path28.join(absolutePrdDir, file), "utf-8");
         const deps = parseDependencies(content);
-        const claimPath = path27.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
+        const claimPath = path28.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
         const claimStatus = isClaimActive(claimPath, config.maxRuntime);
         pending.push({
           name: file,
@@ -9784,10 +9898,10 @@ function prdCommand(program2) {
       }
     }
     const done = [];
-    if (fs25.existsSync(doneDir)) {
-      const files = fs25.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+    if (fs26.existsSync(doneDir)) {
+      const files = fs26.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs25.readFileSync(path27.join(doneDir, file), "utf-8");
+        const content = fs26.readFileSync(path28.join(doneDir, file), "utf-8");
         const deps = parseDependencies(content);
         done.push({ name: file, dependencies: deps });
       }
@@ -9826,7 +9940,7 @@ import blessed6 from "blessed";
 // src/commands/dashboard/tab-status.ts
 init_dist();
 import blessed from "blessed";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 function sortPrdsByPriority(prds, priority) {
   if (priority.length === 0) return prds;
   const priorityMap = /* @__PURE__ */ new Map();
@@ -9922,7 +10036,7 @@ function renderLogPane(projectDir, logs) {
   let newestMtime = 0;
   for (const log of existingLogs) {
     try {
-      const stat = fs26.statSync(log.path);
+      const stat = fs27.statSync(log.path);
       if (stat.mtimeMs > newestMtime) {
         newestMtime = stat.mtimeMs;
         newestLog = log;
@@ -11577,8 +11691,8 @@ function createActionsTab() {
 // src/commands/dashboard/tab-logs.ts
 init_dist();
 import blessed5 from "blessed";
-import * as fs27 from "fs";
-import * as path28 from "path";
+import * as fs28 from "fs";
+import * as path29 from "path";
 var LOG_NAMES = ["executor", "reviewer"];
 var LOG_LINES = 200;
 function createLogsTab() {
@@ -11619,7 +11733,7 @@ function createLogsTab() {
   let activeKeyHandlers = [];
   let activeCtx = null;
   function getLogPath(projectDir, logName) {
-    return path28.join(projectDir, "logs", `${logName}.log`);
+    return path29.join(projectDir, "logs", `${logName}.log`);
   }
   function updateSelector() {
     const tabs = LOG_NAMES.map((name, idx) => {
@@ -11633,7 +11747,7 @@ function createLogsTab() {
   function loadLog(ctx) {
     const logName = LOG_NAMES[selectedLogIndex];
     const logPath = getLogPath(ctx.projectDir, logName);
-    if (!fs27.existsSync(logPath)) {
+    if (!fs28.existsSync(logPath)) {
       logContent.setContent(
         `{yellow-fg}No ${logName}.log file found{/yellow-fg}
 
@@ -11643,7 +11757,7 @@ Log will appear here once the ${logName} runs.`
       return;
     }
     try {
-      const stat = fs27.statSync(logPath);
+      const stat = fs28.statSync(logPath);
       const sizeKB = (stat.size / 1024).toFixed(1);
       logContent.setLabel(`[ ${logName}.log - ${sizeKB} KB ]`);
     } catch {
@@ -12149,13 +12263,13 @@ function doctorCommand(program2) {
 
 // src/commands/serve.ts
 init_dist();
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 
 // ../server/dist/index.js
 init_dist();
-import * as fs31 from "fs";
-import * as path34 from "path";
-import { dirname as dirname7 } from "path";
+import * as fs32 from "fs";
+import * as path35 from "path";
+import { dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import cors from "cors";
 import express from "express";
@@ -12239,8 +12353,8 @@ function setupGracefulShutdown(server, beforeClose) {
 
 // ../server/dist/middleware/project-resolver.middleware.js
 init_dist();
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 function resolveProject(req, res, next) {
   const projectId = req.params.projectId;
   const decodedId = decodeURIComponent(projectId).replace(/~/g, "/");
@@ -12250,7 +12364,7 @@ function resolveProject(req, res, next) {
     res.status(404).json({ error: `Project not found: ${decodedId}` });
     return;
   }
-  if (!fs28.existsSync(entry.path) || !fs28.existsSync(path29.join(entry.path, CONFIG_FILE_NAME))) {
+  if (!fs29.existsSync(entry.path) || !fs29.existsSync(path30.join(entry.path, CONFIG_FILE_NAME))) {
     res.status(404).json({ error: `Project path invalid or missing config: ${entry.path}` });
     return;
   }
@@ -12295,8 +12409,8 @@ function startSseStatusWatcher(clients, projectDir, getConfig) {
 
 // ../server/dist/routes/action.routes.js
 init_dist();
-import * as fs29 from "fs";
-import * as path30 from "path";
+import * as fs30 from "fs";
+import * as path31 from "path";
 import { execSync as execSync5, spawn as spawn5 } from "child_process";
 import { Router } from "express";
 
@@ -12334,17 +12448,17 @@ function getBoardProvider(config, projectDir) {
 function cleanOrphanedClaims(dir) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir, { withFileTypes: true });
+    entries = fs30.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path30.join(dir, entry.name);
+    const fullPath = path31.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "done") {
       cleanOrphanedClaims(fullPath);
     } else if (entry.name.endsWith(CLAIM_FILE_EXTENSION)) {
       try {
-        fs29.unlinkSync(fullPath);
+        fs30.unlinkSync(fullPath);
       } catch {
       }
     }
@@ -12501,19 +12615,19 @@ function createActionRouteHandlers(ctx) {
         res.status(400).json({ error: "Invalid PRD name" });
         return;
       }
-      const prdDir = path30.join(projectDir, config.prdDir);
+      const prdDir = path31.join(projectDir, config.prdDir);
       const normalized = prdName.endsWith(".md") ? prdName : `${prdName}.md`;
-      const pendingPath = path30.join(prdDir, normalized);
-      const donePath = path30.join(prdDir, "done", normalized);
-      if (fs29.existsSync(pendingPath)) {
+      const pendingPath = path31.join(prdDir, normalized);
+      const donePath = path31.join(prdDir, "done", normalized);
+      if (fs30.existsSync(pendingPath)) {
         res.json({ message: `"${normalized}" is already pending` });
         return;
       }
-      if (!fs29.existsSync(donePath)) {
+      if (!fs30.existsSync(donePath)) {
         res.status(404).json({ error: `PRD "${normalized}" not found in done/` });
         return;
       }
-      fs29.renameSync(donePath, pendingPath);
+      fs30.renameSync(donePath, pendingPath);
       res.json({ message: `Moved "${normalized}" back to pending` });
     } catch (error2) {
       res.status(500).json({
@@ -12531,11 +12645,11 @@ function createActionRouteHandlers(ctx) {
         res.status(409).json({ error: "Executor is actively running \u2014 use Stop instead" });
         return;
       }
-      if (fs29.existsSync(lockPath)) {
-        fs29.unlinkSync(lockPath);
+      if (fs30.existsSync(lockPath)) {
+        fs30.unlinkSync(lockPath);
       }
-      const prdDir = path30.join(projectDir, config.prdDir);
-      if (fs29.existsSync(prdDir)) {
+      const prdDir = path31.join(projectDir, config.prdDir);
+      if (fs30.existsSync(prdDir)) {
         cleanOrphanedClaims(prdDir);
       }
       broadcastSSE(ctx.getSseClients(req), "status_changed", await fetchStatusSnapshot(projectDir, config));
@@ -13194,6 +13308,26 @@ function createConfigRoutes(deps) {
   });
   return router;
 }
+function createGlobalNotificationsRoutes() {
+  const router = Router3();
+  router.get("/", (_req, res) => {
+    res.json(loadGlobalNotificationsConfig());
+  });
+  router.put("/", (req, res) => {
+    const { webhook } = req.body;
+    if (webhook !== null && webhook !== void 0) {
+      const issues = validateWebhook(webhook);
+      if (issues.length > 0) {
+        res.status(400).json({ error: `Invalid webhook: ${issues.join(", ")}` });
+        return;
+      }
+    }
+    const config = { webhook: webhook ?? null };
+    saveGlobalNotificationsConfig(config);
+    res.json(loadGlobalNotificationsConfig());
+  });
+  return router;
+}
 function createProjectConfigRoutes() {
   const router = Router3({ mergeParams: true });
   router.get("/config", (req, res) => {
@@ -13227,8 +13361,8 @@ function createProjectConfigRoutes() {
 
 // ../server/dist/routes/doctor.routes.js
 init_dist();
-import * as fs30 from "fs";
-import * as path31 from "path";
+import * as fs31 from "fs";
+import * as path32 from "path";
 import { execSync as execSync6 } from "child_process";
 import { Router as Router4 } from "express";
 function runDoctorChecks(projectDir, config) {
@@ -13261,7 +13395,7 @@ function runDoctorChecks(projectDir, config) {
     });
   }
   try {
-    const projectName = path31.basename(projectDir);
+    const projectName = path32.basename(projectDir);
     const marker = generateMarker(projectName);
     const crontabEntries = [...getEntries(marker), ...getProjectEntries(projectDir)];
     if (crontabEntries.length > 0) {
@@ -13284,8 +13418,8 @@ function runDoctorChecks(projectDir, config) {
       detail: "Failed to check crontab"
     });
   }
-  const configPath = path31.join(projectDir, CONFIG_FILE_NAME);
-  if (fs30.existsSync(configPath)) {
+  const configPath = path32.join(projectDir, CONFIG_FILE_NAME);
+  if (fs31.existsSync(configPath)) {
     checks.push({ name: "config", status: "pass", detail: "Config file exists" });
   } else {
     checks.push({
@@ -13294,9 +13428,9 @@ function runDoctorChecks(projectDir, config) {
       detail: "Config file not found (using defaults)"
     });
   }
-  const prdDir = path31.join(projectDir, config.prdDir);
-  if (fs30.existsSync(prdDir)) {
-    const prds = fs30.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+  const prdDir = path32.join(projectDir, config.prdDir);
+  if (fs31.existsSync(prdDir)) {
+    const prds = fs31.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
     checks.push({
       name: "prdDir",
       status: "pass",
@@ -13339,7 +13473,7 @@ function createProjectDoctorRoutes() {
 
 // ../server/dist/routes/log.routes.js
 init_dist();
-import * as path32 from "path";
+import * as path33 from "path";
 import { Router as Router5 } from "express";
 function createLogRoutes(deps) {
   const { projectDir } = deps;
@@ -13358,7 +13492,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 = path32.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path33.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -13384,7 +13518,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 = path32.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path33.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -13419,7 +13553,7 @@ function createProjectPrdRoutes() {
 
 // ../server/dist/routes/roadmap.routes.js
 init_dist();
-import * as path33 from "path";
+import * as path34 from "path";
 import { Router as Router7 } from "express";
 function createRoadmapRouteHandlers(ctx) {
   const router = Router7({ mergeParams: true });
@@ -13429,7 +13563,7 @@ function createRoadmapRouteHandlers(ctx) {
       const config = ctx.getConfig(req);
       const projectDir = ctx.getProjectDir(req);
       const status = getRoadmapStatus(projectDir, config);
-      const prdDir = path33.join(projectDir, config.prdDir);
+      const prdDir = path34.join(projectDir, config.prdDir);
       const state = loadRoadmapState(prdDir);
       res.json({
         ...status,
@@ -13761,26 +13895,26 @@ function createQueueRoutes(deps) {
 
 // ../server/dist/index.js
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname7(__filename2);
+var __dirname3 = dirname8(__filename2);
 function resolveWebDistPath() {
-  const bundled = path34.join(__dirname3, "web");
-  if (fs31.existsSync(path34.join(bundled, "index.html")))
+  const bundled = path35.join(__dirname3, "web");
+  if (fs32.existsSync(path35.join(bundled, "index.html")))
     return bundled;
   let d = __dirname3;
   for (let i = 0; i < 8; i++) {
-    if (fs31.existsSync(path34.join(d, "turbo.json"))) {
-      const dev = path34.join(d, "web/dist");
-      if (fs31.existsSync(path34.join(dev, "index.html")))
+    if (fs32.existsSync(path35.join(d, "turbo.json"))) {
+      const dev = path35.join(d, "web/dist");
+      if (fs32.existsSync(path35.join(dev, "index.html")))
         return dev;
       break;
     }
-    d = dirname7(d);
+    d = dirname8(d);
   }
   return bundled;
 }
 function setupStaticFiles(app) {
   const webDistPath = resolveWebDistPath();
-  if (fs31.existsSync(webDistPath)) {
+  if (fs32.existsSync(webDistPath)) {
     app.use(express.static(webDistPath));
   }
   app.use((req, res, next) => {
@@ -13788,8 +13922,8 @@ function setupStaticFiles(app) {
       next();
       return;
     }
-    const indexPath = path34.resolve(webDistPath, "index.html");
-    if (fs31.existsSync(indexPath)) {
+    const indexPath = path35.resolve(webDistPath, "index.html");
+    if (fs32.existsSync(indexPath)) {
       res.sendFile(indexPath, (err) => {
         if (err)
           next();
@@ -13827,6 +13961,7 @@ function createApp(projectDir) {
   app.use("/api/logs", createLogRoutes({ projectDir }));
   app.use("/api/doctor", createDoctorRoutes({ projectDir, getConfig: () => config }));
   app.use("/api/queue", createQueueRoutes({ getConfig: () => config }));
+  app.use("/api/global-notifications", createGlobalNotificationsRoutes());
   app.get("/api/prs", async (_req, res) => {
     try {
       res.json(await collectPrInfo(projectDir, config.branchPatterns));
@@ -13899,13 +14034,14 @@ function createGlobalApp() {
     }
   });
   app.use("/api/queue", createGlobalQueueRoutes());
+  app.use("/api/global-notifications", createGlobalNotificationsRoutes());
   app.use("/api/projects/:projectId", resolveProject, createProjectRouter());
   setupStaticFiles(app);
   app.use(errorHandler);
   return app;
 }
 function bootContainer() {
-  initContainer(path34.dirname(getDbPath()));
+  initContainer(path35.dirname(getDbPath()));
 }
 function startServer(projectDir, port) {
   bootContainer();
@@ -13958,8 +14094,8 @@ function isProcessRunning2(pid) {
 }
 function readPid(lockPath) {
   try {
-    if (!fs32.existsSync(lockPath)) return null;
-    const raw = fs32.readFileSync(lockPath, "utf-8").trim();
+    if (!fs33.existsSync(lockPath)) return null;
+    const raw = fs33.readFileSync(lockPath, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -13971,10 +14107,10 @@ function acquireServeLock(mode, port) {
   let stalePidCleaned;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs32.openSync(lockPath, "wx");
-      fs32.writeFileSync(fd, `${process.pid}
+      const fd = fs33.openSync(lockPath, "wx");
+      fs33.writeFileSync(fd, `${process.pid}
 `);
-      fs32.closeSync(fd);
+      fs33.closeSync(fd);
       return { acquired: true, lockPath, stalePidCleaned };
     } catch (error2) {
       const err = error2;
@@ -13995,7 +14131,7 @@ function acquireServeLock(mode, port) {
         };
       }
       try {
-        fs32.unlinkSync(lockPath);
+        fs33.unlinkSync(lockPath);
         if (existingPid) {
           stalePidCleaned = existingPid;
         }
@@ -14018,10 +14154,10 @@ function acquireServeLock(mode, port) {
 }
 function releaseServeLock(lockPath) {
   try {
-    if (!fs32.existsSync(lockPath)) return;
+    if (!fs33.existsSync(lockPath)) return;
     const lockPid = readPid(lockPath);
     if (lockPid !== null && lockPid !== process.pid) return;
-    fs32.unlinkSync(lockPath);
+    fs33.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -14117,14 +14253,14 @@ function historyCommand(program2) {
 // src/commands/update.ts
 init_dist();
 import { spawnSync } from "child_process";
-import * as fs33 from "fs";
-import * as path35 from "path";
+import * as fs34 from "fs";
+import * as path36 from "path";
 var DEFAULT_GLOBAL_SPEC = "@jonit-dev/night-watch-cli@latest";
 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) => path35.resolve(cwd, entry));
+  const dirs = projects.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => path36.resolve(cwd, entry));
   return Array.from(new Set(dirs));
 }
 function shouldInstallGlobal(options) {
@@ -14166,7 +14302,7 @@ function updateCommand(program2) {
       }
       const nightWatchBin = resolveNightWatchBin();
       for (const projectDir of projectDirs) {
-        if (!fs33.existsSync(projectDir) || !fs33.statSync(projectDir).isDirectory()) {
+        if (!fs34.existsSync(projectDir) || !fs34.statSync(projectDir).isDirectory()) {
           warn(`Skipping invalid project directory: ${projectDir}`);
           continue;
         }
@@ -14210,8 +14346,8 @@ function prdStateCommand(program2) {
 
 // src/commands/retry.ts
 init_dist();
-import * as fs34 from "fs";
-import * as path36 from "path";
+import * as fs35 from "fs";
+import * as path37 from "path";
 function normalizePrdName(name) {
   if (!name.endsWith(".md")) {
     return `${name}.md`;
@@ -14219,26 +14355,26 @@ function normalizePrdName(name) {
   return name;
 }
 function getDonePrds(doneDir) {
-  if (!fs34.existsSync(doneDir)) {
+  if (!fs35.existsSync(doneDir)) {
     return [];
   }
-  return fs34.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+  return fs35.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 = path36.join(projectDir, config.prdDir);
-    const doneDir = path36.join(prdDir, "done");
+    const prdDir = path37.join(projectDir, config.prdDir);
+    const doneDir = path37.join(prdDir, "done");
     const normalizedPrdName = normalizePrdName(prdName);
-    const pendingPath = path36.join(prdDir, normalizedPrdName);
-    if (fs34.existsSync(pendingPath)) {
+    const pendingPath = path37.join(prdDir, normalizedPrdName);
+    if (fs35.existsSync(pendingPath)) {
       info(`"${normalizedPrdName}" is already pending, nothing to retry.`);
       return;
     }
-    const donePath = path36.join(doneDir, normalizedPrdName);
-    if (fs34.existsSync(donePath)) {
-      fs34.renameSync(donePath, pendingPath);
+    const donePath = path37.join(doneDir, normalizedPrdName);
+    if (fs35.existsSync(donePath)) {
+      fs35.renameSync(donePath, pendingPath);
       success(`Moved "${normalizedPrdName}" back to pending.`);
       dim(`From: ${donePath}`);
       dim(`To:   ${pendingPath}`);
@@ -14490,7 +14626,7 @@ function prdsCommand(program2) {
 
 // src/commands/cancel.ts
 init_dist();
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as readline3 from "readline";
 function getLockFilePaths2(projectDir) {
   const runtimeKey = projectRuntimeKey(projectDir);
@@ -14537,7 +14673,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   const pid = lockStatus.pid;
   if (!lockStatus.running) {
     try {
-      fs35.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
       return {
         success: true,
         message: `${processType} is not running (cleaned up stale lock file for PID ${pid})`,
@@ -14575,7 +14711,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(3e3);
   if (!isProcessRunning3(pid)) {
     try {
-      fs35.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -14610,7 +14746,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(500);
   if (!isProcessRunning3(pid)) {
     try {
-      fs35.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -14671,31 +14807,31 @@ function cancelCommand(program2) {
 
 // src/commands/slice.ts
 init_dist();
-import * as fs36 from "fs";
-import * as path37 from "path";
+import * as fs37 from "fs";
+import * as path38 from "path";
 function plannerLockPath2(projectDir) {
   return `${LOCK_FILE_PREFIX}slicer-${projectRuntimeKey(projectDir)}.lock`;
 }
 function acquirePlannerLock(projectDir) {
   const lockFile = plannerLockPath2(projectDir);
-  if (fs36.existsSync(lockFile)) {
-    const pidRaw = fs36.readFileSync(lockFile, "utf-8").trim();
+  if (fs37.existsSync(lockFile)) {
+    const pidRaw = fs37.readFileSync(lockFile, "utf-8").trim();
     const pid = parseInt(pidRaw, 10);
     if (!Number.isNaN(pid) && isProcessRunning(pid)) {
       return { acquired: false, lockFile, pid };
     }
     try {
-      fs36.unlinkSync(lockFile);
+      fs37.unlinkSync(lockFile);
     } catch {
     }
   }
-  fs36.writeFileSync(lockFile, String(process.pid));
+  fs37.writeFileSync(lockFile, String(process.pid));
   return { acquired: true, lockFile };
 }
 function releasePlannerLock(lockFile) {
   try {
-    if (fs36.existsSync(lockFile)) {
-      fs36.unlinkSync(lockFile);
+    if (fs37.existsSync(lockFile)) {
+      fs37.unlinkSync(lockFile);
     }
   } catch {
   }
@@ -14704,12 +14840,12 @@ function resolvePlannerIssueColumn(config) {
   return config.roadmapScanner.issueColumn === "Ready" ? "Ready" : "Draft";
 }
 function buildPlannerIssueBody(projectDir, config, result) {
-  const relativePrdPath = path37.join(config.prdDir, result.file ?? "").replace(/\\/g, "/");
-  const absolutePrdPath = path37.join(projectDir, config.prdDir, result.file ?? "");
+  const relativePrdPath = path38.join(config.prdDir, result.file ?? "").replace(/\\/g, "/");
+  const absolutePrdPath = path38.join(projectDir, config.prdDir, result.file ?? "");
   const sourceItem = result.item;
   let prdContent;
   try {
-    prdContent = fs36.readFileSync(absolutePrdPath, "utf-8");
+    prdContent = fs37.readFileSync(absolutePrdPath, "utf-8");
   } catch {
     prdContent = `Unable to read generated PRD file at \`${relativePrdPath}\`.`;
   }
@@ -14885,7 +15021,7 @@ function sliceCommand(program2) {
       if (!options.dryRun) {
         await sendNotifications(config, {
           event: "run_started",
-          projectName: path37.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode: 0,
           provider: config.provider
         });
@@ -14920,7 +15056,7 @@ function sliceCommand(program2) {
       if (!options.dryRun && result.sliced) {
         await sendNotifications(config, {
           event: "run_succeeded",
-          projectName: path37.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode,
           provider: config.provider,
           prTitle: result.item?.title
@@ -14928,7 +15064,7 @@ function sliceCommand(program2) {
       } else if (!options.dryRun && !nothingPending) {
         await sendNotifications(config, {
           event: "run_failed",
-          projectName: path37.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode,
           provider: config.provider
         });
@@ -14944,21 +15080,21 @@ function sliceCommand(program2) {
 
 // src/commands/state.ts
 init_dist();
-import * as os8 from "os";
-import * as path38 from "path";
+import * as os9 from "os";
+import * as path39 from "path";
 import chalk5 from "chalk";
 import { Command } from "commander";
 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 || path38.join(os8.homedir(), GLOBAL_CONFIG_DIR);
+    const nightWatchHome = process.env.NIGHT_WATCH_HOME || path39.join(os9.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(`  ${path38.join(nightWatchHome, "projects.json")}`);
-      console.log(`  ${path38.join(nightWatchHome, "history.json")}`);
-      console.log(`  ${path38.join(nightWatchHome, "prd-states.json")}`);
+      console.log(`  ${path39.join(nightWatchHome, "projects.json")}`);
+      console.log(`  ${path39.join(nightWatchHome, "history.json")}`);
+      console.log(`  ${path39.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;
@@ -14996,8 +15132,8 @@ function createStateCommand() {
 init_dist();
 init_dist();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs37 from "fs";
-import * as path39 from "path";
+import * as fs38 from "fs";
+import * as path40 from "path";
 import * as readline4 from "readline";
 import chalk6 from "chalk";
 async function run(fn) {
@@ -15019,7 +15155,7 @@ function getProvider(config, cwd) {
   return createBoardProvider(bp, cwd);
 }
 function defaultBoardTitle(cwd) {
-  return `${path39.basename(cwd)} Night Watch`;
+  return `${path40.basename(cwd)} Night Watch`;
 }
 async function ensureBoardConfigured(config, cwd, provider, options) {
   if (config.boardProvider?.projectNumber) {
@@ -15218,11 +15354,11 @@ function boardCommand(program2) {
       let body = options.body ?? "";
       if (options.bodyFile) {
         const filePath = options.bodyFile;
-        if (!fs37.existsSync(filePath)) {
+        if (!fs38.existsSync(filePath)) {
           console.error(`File not found: ${filePath}`);
           process.exit(1);
         }
-        body = fs37.readFileSync(filePath, "utf-8");
+        body = fs38.readFileSync(filePath, "utf-8");
       }
       const labels = [];
       if (options.label) {
@@ -15250,6 +15386,25 @@ function boardCommand(program2) {
       }
     })
   );
+  board.command("add-issue").description("Add an existing GitHub issue to the board").argument("<number>", "Issue number").option("--column <name>", "Target column (default: Ready)", "Ready").action(
+    async (number, options) => run(async () => {
+      const cwd = process.cwd();
+      const config = loadConfig(cwd);
+      const provider = getProvider(config, cwd);
+      await ensureBoardConfigured(config, cwd, provider);
+      if (!BOARD_COLUMNS.includes(options.column)) {
+        console.error(
+          `Invalid column "${options.column}". Valid columns: ${BOARD_COLUMNS.join(", ")}`
+        );
+        process.exit(1);
+      }
+      const issue = await provider.addIssue(
+        parseInt(number, 10),
+        options.column
+      );
+      success(`Added issue #${issue.number} "${issue.title}" to ${options.column}`);
+    })
+  );
   board.command("status").description("Show the current state of all issues grouped by column").option("--json", "Output raw JSON").option("--group-by <field>", "Group by: priority, category, or column (default: column)").action(
     async (options) => run(async () => {
       const cwd = process.cwd();
@@ -15444,12 +15599,12 @@ function boardCommand(program2) {
       const config = loadConfig(cwd);
       const provider = getProvider(config, cwd);
       await ensureBoardConfigured(config, cwd, provider);
-      const roadmapPath = options.roadmap ?? path39.join(cwd, "ROADMAP.md");
-      if (!fs37.existsSync(roadmapPath)) {
+      const roadmapPath = options.roadmap ?? path40.join(cwd, "ROADMAP.md");
+      if (!fs38.existsSync(roadmapPath)) {
         console.error(`Roadmap file not found: ${roadmapPath}`);
         process.exit(1);
       }
-      const roadmapContent = fs37.readFileSync(roadmapPath, "utf-8");
+      const roadmapContent = fs38.readFileSync(roadmapPath, "utf-8");
       const items = parseRoadmap(roadmapContent);
       const uncheckedItems = getUncheckedItems(items);
       if (uncheckedItems.length === 0) {
@@ -15573,7 +15728,7 @@ function boardCommand(program2) {
 // src/commands/queue.ts
 init_dist();
 init_dist();
-import * as path40 from "path";
+import * as path41 from "path";
 import { spawn as spawn6 } from "child_process";
 import chalk7 from "chalk";
 import { Command as Command2 } from "commander";
@@ -15693,7 +15848,7 @@ function createQueueCommand() {
         process.exit(1);
       }
     }
-    const projectName = path40.basename(projectDir);
+    const projectName = path41.basename(projectDir);
     const queueConfig = loadConfig(projectDir).queue;
     const id = enqueueJob(projectDir, projectName, jobType, envVars, queueConfig);
     console.log(chalk7.green(`Enqueued ${jobType} for ${projectName} (ID: ${id})`));
@@ -15849,17 +16004,17 @@ function notifyCommand(program2) {
 
 // src/cli.ts
 var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname8(__filename3);
+var __dirname4 = dirname9(__filename3);
 function findPackageRoot(dir) {
   let d = dir;
   for (let i = 0; i < 5; i++) {
-    if (existsSync29(join35(d, "package.json"))) return d;
-    d = dirname8(d);
+    if (existsSync30(join36(d, "package.json"))) return d;
+    d = dirname9(d);
   }
   return dir;
 }
 var packageRoot = findPackageRoot(__dirname4);
-var packageJson = JSON.parse(readFileSync18(join35(packageRoot, "package.json"), "utf-8"));
+var packageJson = JSON.parse(readFileSync19(join36(packageRoot, "package.json"), "utf-8"));
 var program = new Command3();
 program.name("night-watch").description("Autonomous PRD execution using Claude CLI + cron").version(packageJson.version);
 initCommand(program);