@jonit-dev/night-watch-cli 1.8.2 → 1.8.4-beta.0

package/dist/cli.js

@@ -17,6 +17,283 @@ var init_types = __esm({
   }
 });
 
+// ../core/dist/jobs/job-registry.js
+function getJobDef(id) {
+  return JOB_MAP.get(id);
+}
+function getAllJobDefs() {
+  return [...JOB_REGISTRY];
+}
+function getJobDefByCommand(command) {
+  return JOB_REGISTRY.find((job) => job.cliCommand === command);
+}
+function getJobDefByLogName(logName) {
+  return JOB_REGISTRY.find((job) => job.logName === logName);
+}
+function getValidJobTypes() {
+  return JOB_REGISTRY.map((job) => job.id);
+}
+function getDefaultQueuePriority() {
+  const result = {};
+  for (const job of JOB_REGISTRY) {
+    result[job.id] = job.queuePriority;
+  }
+  return result;
+}
+function getLogFileNames() {
+  const result = {};
+  for (const job of JOB_REGISTRY) {
+    result[job.id] = job.logName;
+    if (job.cliCommand !== job.id) {
+      result[job.cliCommand] = job.logName;
+    }
+  }
+  return result;
+}
+function getLockSuffix(jobId) {
+  return getJobDef(jobId)?.lockSuffix ?? ".lock";
+}
+function normalizeJobConfig(raw, jobDef) {
+  const readBoolean = (v) => typeof v === "boolean" ? v : void 0;
+  const readString = (v) => typeof v === "string" ? v : void 0;
+  const readNumber = (v) => typeof v === "number" && !Number.isNaN(v) ? v : void 0;
+  const readStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === "string") ? v : void 0;
+  const defaults = jobDef.defaultConfig;
+  const result = {
+    enabled: readBoolean(raw.enabled) ?? defaults.enabled,
+    schedule: readString(raw.schedule) ?? defaults.schedule,
+    maxRuntime: readNumber(raw.maxRuntime) ?? defaults.maxRuntime
+  };
+  for (const field of jobDef.extraFields ?? []) {
+    switch (field.type) {
+      case "boolean":
+        result[field.name] = readBoolean(raw[field.name]) ?? field.defaultValue;
+        break;
+      case "string":
+        result[field.name] = readString(raw[field.name]) ?? field.defaultValue;
+        break;
+      case "number":
+        result[field.name] = readNumber(raw[field.name]) ?? field.defaultValue;
+        break;
+      case "string[]":
+        result[field.name] = readStringArray(raw[field.name]) ?? field.defaultValue;
+        break;
+      case "enum": {
+        const val = readString(raw[field.name]);
+        result[field.name] = val && field.enumValues?.includes(val) ? val : field.defaultValue;
+        break;
+      }
+    }
+  }
+  return result;
+}
+function camelToUpperSnake(name) {
+  return name.replace(/([A-Z])/g, "_$1").toUpperCase();
+}
+function buildJobEnvOverrides(envPrefix, currentBase, extraFields) {
+  const parseBoolean2 = (value) => {
+    const v = value.toLowerCase().trim();
+    if (v === "true" || v === "1")
+      return true;
+    if (v === "false" || v === "0")
+      return false;
+    return null;
+  };
+  const result = { ...currentBase };
+  let changed = false;
+  const enabledVal = process.env[`${envPrefix}_ENABLED`];
+  if (enabledVal) {
+    const v = parseBoolean2(enabledVal);
+    if (v !== null) {
+      result.enabled = v;
+      changed = true;
+    }
+  }
+  const scheduleVal = process.env[`${envPrefix}_SCHEDULE`];
+  if (scheduleVal) {
+    result.schedule = scheduleVal;
+    changed = true;
+  }
+  const maxRuntimeVal = process.env[`${envPrefix}_MAX_RUNTIME`];
+  if (maxRuntimeVal) {
+    const v = parseInt(maxRuntimeVal, 10);
+    if (!isNaN(v) && v > 0) {
+      result.maxRuntime = v;
+      changed = true;
+    }
+  }
+  for (const field of extraFields ?? []) {
+    const envKey = `${envPrefix}_${camelToUpperSnake(field.name)}`;
+    const envVal = process.env[envKey];
+    if (!envVal)
+      continue;
+    switch (field.type) {
+      case "boolean": {
+        const v = parseBoolean2(envVal);
+        if (v !== null) {
+          result[field.name] = v;
+          changed = true;
+        }
+        break;
+      }
+      case "string":
+        result[field.name] = envVal;
+        changed = true;
+        break;
+      case "number": {
+        const v = parseInt(envVal, 10);
+        if (!isNaN(v) && v > 0) {
+          result[field.name] = v;
+          changed = true;
+        }
+        break;
+      }
+      case "string[]": {
+        const patterns = envVal.split(",").map((s) => s.trim()).filter(Boolean);
+        if (patterns.length > 0) {
+          result[field.name] = patterns;
+          changed = true;
+        }
+        break;
+      }
+      case "enum":
+        if (field.enumValues?.includes(envVal)) {
+          result[field.name] = envVal;
+          changed = true;
+        }
+        break;
+    }
+  }
+  return changed ? result : null;
+}
+var JOB_REGISTRY, JOB_MAP;
+var init_job_registry = __esm({
+  "../core/dist/jobs/job-registry.js"() {
+    "use strict";
+    JOB_REGISTRY = [
+      {
+        id: "executor",
+        name: "Executor",
+        description: "Creates implementation PRs from PRDs",
+        cliCommand: "run",
+        logName: "executor",
+        lockSuffix: ".lock",
+        queuePriority: 50,
+        envPrefix: "NW_EXECUTOR",
+        defaultConfig: {
+          enabled: true,
+          schedule: "5 */2 * * *",
+          maxRuntime: 7200
+        }
+      },
+      {
+        id: "reviewer",
+        name: "Reviewer",
+        description: "Reviews and improves PRs on night-watch branches",
+        cliCommand: "review",
+        logName: "reviewer",
+        lockSuffix: "-r.lock",
+        queuePriority: 40,
+        envPrefix: "NW_REVIEWER",
+        defaultConfig: {
+          enabled: true,
+          schedule: "25 */3 * * *",
+          maxRuntime: 3600
+        }
+      },
+      {
+        id: "slicer",
+        name: "Slicer",
+        description: "Generates PRDs from roadmap items",
+        cliCommand: "planner",
+        logName: "slicer",
+        lockSuffix: "-slicer.lock",
+        queuePriority: 30,
+        envPrefix: "NW_SLICER",
+        defaultConfig: {
+          enabled: true,
+          schedule: "35 */6 * * *",
+          maxRuntime: 600
+        }
+      },
+      {
+        id: "qa",
+        name: "QA",
+        description: "Runs end-to-end tests on PRs",
+        cliCommand: "qa",
+        logName: "night-watch-qa",
+        lockSuffix: "-qa.lock",
+        queuePriority: 20,
+        envPrefix: "NW_QA",
+        extraFields: [
+          { name: "branchPatterns", type: "string[]", defaultValue: [] },
+          {
+            name: "artifacts",
+            type: "enum",
+            enumValues: ["screenshot", "video", "both"],
+            defaultValue: "both"
+          },
+          { name: "skipLabel", type: "string", defaultValue: "skip-qa" },
+          { name: "autoInstallPlaywright", type: "boolean", defaultValue: true }
+        ],
+        defaultConfig: {
+          enabled: true,
+          schedule: "45 2,10,18 * * *",
+          maxRuntime: 3600,
+          branchPatterns: [],
+          artifacts: "both",
+          skipLabel: "skip-qa",
+          autoInstallPlaywright: true
+        }
+      },
+      {
+        id: "audit",
+        name: "Auditor",
+        description: "Performs code audits and creates issues for findings",
+        cliCommand: "audit",
+        logName: "audit",
+        lockSuffix: "-audit.lock",
+        queuePriority: 10,
+        envPrefix: "NW_AUDIT",
+        defaultConfig: {
+          enabled: true,
+          schedule: "50 3 * * 1",
+          maxRuntime: 1800
+        }
+      },
+      {
+        id: "analytics",
+        name: "Analytics",
+        description: "Analyzes product analytics and creates issues for trends",
+        cliCommand: "analytics",
+        logName: "analytics",
+        lockSuffix: "-analytics.lock",
+        queuePriority: 10,
+        envPrefix: "NW_ANALYTICS",
+        extraFields: [
+          { name: "lookbackDays", type: "number", defaultValue: 7 },
+          {
+            name: "targetColumn",
+            type: "enum",
+            enumValues: ["Draft", "Ready", "In Progress", "Done", "Closed"],
+            defaultValue: "Draft"
+          },
+          { name: "analysisPrompt", type: "string", defaultValue: "" }
+        ],
+        defaultConfig: {
+          enabled: false,
+          schedule: "0 6 * * 1",
+          maxRuntime: 900,
+          lookbackDays: 7,
+          targetColumn: "Draft",
+          analysisPrompt: ""
+        }
+      }
+    ];
+    JOB_MAP = new Map(JOB_REGISTRY.map((job) => [job.id, job]));
+  }
+});
+
 // ../core/dist/constants.js
 function resolveProviderBucketKey(provider, providerEnv) {
   if (provider === "codex")
@@ -31,10 +308,11 @@ 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";
+    init_job_registry();
     DEFAULT_DEFAULT_BRANCH = "";
     DEFAULT_PRD_DIR = "docs/prds";
     DEFAULT_MAX_RUNTIME = 7200;
@@ -131,14 +409,7 @@ If no issues are warranted, output an empty array: []`;
     PLANNER_LOG_NAME = "slicer";
     ANALYTICS_LOG_NAME = "analytics";
     VALID_PROVIDERS = ["claude", "codex"];
-    VALID_JOB_TYPES = [
-      "executor",
-      "reviewer",
-      "qa",
-      "audit",
-      "slicer",
-      "analytics"
-    ];
+    VALID_JOB_TYPES = getValidJobTypes();
     DEFAULT_JOB_PROVIDERS = {};
     BUILT_IN_PRESETS = {
       claude: {
@@ -212,32 +483,19 @@ If no issues are warranted, output an empty array: []`;
     REVIEWER_LOG_NAME = "reviewer";
     EXECUTOR_LOG_FILE = "executor.log";
     REVIEWER_LOG_FILE = "reviewer.log";
-    LOG_FILE_NAMES = {
-      executor: EXECUTOR_LOG_NAME,
-      reviewer: REVIEWER_LOG_NAME,
-      qa: QA_LOG_NAME,
-      audit: AUDIT_LOG_NAME,
-      planner: PLANNER_LOG_NAME,
-      analytics: ANALYTICS_LOG_NAME
-    };
+    LOG_FILE_NAMES = getLogFileNames();
     GLOBAL_CONFIG_DIR = ".night-watch";
     REGISTRY_FILE_NAME = "projects.json";
     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";
     DEFAULT_QUEUE_MAX_CONCURRENCY = 1;
     DEFAULT_QUEUE_MAX_WAIT_TIME = 7200;
-    DEFAULT_QUEUE_PRIORITY = {
-      executor: 50,
-      reviewer: 40,
-      slicer: 30,
-      qa: 20,
-      audit: 10,
-      analytics: 10
-    };
+    DEFAULT_QUEUE_PRIORITY = getDefaultQueuePriority();
     DEFAULT_QUEUE = {
       enabled: DEFAULT_QUEUE_ENABLED,
       mode: DEFAULT_QUEUE_MODE,
@@ -251,15 +509,6 @@ If no issues are warranted, output an empty array: []`;
   }
 });
 
-// ../core/dist/board/types.js
-var BOARD_COLUMNS;
-var init_types2 = __esm({
-  "../core/dist/board/types.js"() {
-    "use strict";
-    BOARD_COLUMNS = ["Draft", "Ready", "In Progress", "Review", "Done"];
-  }
-});
-
 // ../core/dist/config-normalize.js
 function validateProvider(value) {
   const trimmed = value.trim();
@@ -431,43 +680,14 @@ function normalizeConfig(rawConfig) {
   if (mergeMethod && VALID_MERGE_METHODS.includes(mergeMethod)) {
     normalized.autoMergeMethod = mergeMethod;
   }
-  const rawQa = readObject(rawConfig.qa);
-  if (rawQa) {
-    const artifactsValue = readString(rawQa.artifacts);
-    const artifacts = artifactsValue && ["screenshot", "video", "both"].includes(artifactsValue) ? artifactsValue : DEFAULT_QA.artifacts;
-    const qa = {
-      enabled: readBoolean(rawQa.enabled) ?? DEFAULT_QA.enabled,
-      schedule: readString(rawQa.schedule) ?? DEFAULT_QA.schedule,
-      maxRuntime: readNumber(rawQa.maxRuntime) ?? DEFAULT_QA.maxRuntime,
-      branchPatterns: readStringArray(rawQa.branchPatterns) ?? DEFAULT_QA.branchPatterns,
-      artifacts,
-      skipLabel: readString(rawQa.skipLabel) ?? DEFAULT_QA.skipLabel,
-      autoInstallPlaywright: readBoolean(rawQa.autoInstallPlaywright) ?? DEFAULT_QA.autoInstallPlaywright
-    };
-    normalized.qa = qa;
-  }
-  const rawAudit = readObject(rawConfig.audit);
-  if (rawAudit) {
-    const audit = {
-      enabled: readBoolean(rawAudit.enabled) ?? DEFAULT_AUDIT.enabled,
-      schedule: readString(rawAudit.schedule) ?? DEFAULT_AUDIT.schedule,
-      maxRuntime: readNumber(rawAudit.maxRuntime) ?? DEFAULT_AUDIT.maxRuntime
-    };
-    normalized.audit = audit;
-  }
-  const rawAnalytics = readObject(rawConfig.analytics);
-  if (rawAnalytics) {
-    const targetColumnRaw = readString(rawAnalytics.targetColumn);
-    const targetColumn = targetColumnRaw && BOARD_COLUMNS.includes(targetColumnRaw) ? targetColumnRaw : DEFAULT_ANALYTICS.targetColumn;
-    const analytics = {
-      enabled: readBoolean(rawAnalytics.enabled) ?? DEFAULT_ANALYTICS.enabled,
-      schedule: readString(rawAnalytics.schedule) ?? DEFAULT_ANALYTICS.schedule,
-      maxRuntime: readNumber(rawAnalytics.maxRuntime) ?? DEFAULT_ANALYTICS.maxRuntime,
-      lookbackDays: readNumber(rawAnalytics.lookbackDays) ?? DEFAULT_ANALYTICS.lookbackDays,
-      targetColumn,
-      analysisPrompt: readString(rawAnalytics.analysisPrompt) ?? DEFAULT_ANALYTICS.analysisPrompt
-    };
-    normalized.analytics = analytics;
+  for (const jobId of ["qa", "audit", "analytics"]) {
+    const jobDef = getJobDef(jobId);
+    if (!jobDef)
+      continue;
+    const rawJob = readObject(rawConfig[jobId]);
+    if (rawJob) {
+      normalized[jobId] = normalizeJobConfig(rawJob, jobDef);
+    }
   }
   const rawJobProviders = readObject(rawConfig.jobProviders);
   if (rawJobProviders) {
@@ -528,8 +748,8 @@ function normalizeConfig(rawConfig) {
 var init_config_normalize = __esm({
   "../core/dist/config-normalize.js"() {
     "use strict";
-    init_types2();
     init_constants();
+    init_job_registry();
   }
 });
 
@@ -705,72 +925,16 @@ function buildEnvOverrideConfig(fileConfig) {
       env.claudeModel = model;
     }
   }
-  const qaBase = () => env.qa ?? fileConfig?.qa ?? DEFAULT_QA;
-  if (process.env.NW_QA_ENABLED) {
-    const v = parseBoolean(process.env.NW_QA_ENABLED);
-    if (v !== null)
-      env.qa = { ...qaBase(), enabled: v };
-  }
-  if (process.env.NW_QA_SCHEDULE) {
-    env.qa = { ...qaBase(), schedule: process.env.NW_QA_SCHEDULE };
-  }
-  if (process.env.NW_QA_MAX_RUNTIME) {
-    const v = parseInt(process.env.NW_QA_MAX_RUNTIME, 10);
-    if (!isNaN(v) && v > 0)
-      env.qa = { ...qaBase(), maxRuntime: v };
-  }
-  if (process.env.NW_QA_ARTIFACTS) {
-    const a = process.env.NW_QA_ARTIFACTS;
-    if (["screenshot", "video", "both"].includes(a)) {
-      env.qa = { ...qaBase(), artifacts: a };
+  for (const jobId of ["qa", "audit", "analytics"]) {
+    const jobDef = getJobDef(jobId);
+    if (!jobDef)
+      continue;
+    const currentBase = env[jobId] ?? fileConfig?.[jobId] ?? jobDef.defaultConfig;
+    const overrides = buildJobEnvOverrides(jobDef.envPrefix, currentBase, jobDef.extraFields);
+    if (overrides) {
+      env[jobId] = overrides;
     }
   }
-  if (process.env.NW_QA_SKIP_LABEL) {
-    env.qa = { ...qaBase(), skipLabel: process.env.NW_QA_SKIP_LABEL };
-  }
-  if (process.env.NW_QA_AUTO_INSTALL_PLAYWRIGHT) {
-    const v = parseBoolean(process.env.NW_QA_AUTO_INSTALL_PLAYWRIGHT);
-    if (v !== null)
-      env.qa = { ...qaBase(), autoInstallPlaywright: v };
-  }
-  if (process.env.NW_QA_BRANCH_PATTERNS) {
-    const patterns = process.env.NW_QA_BRANCH_PATTERNS.split(",").map((s) => s.trim()).filter(Boolean);
-    if (patterns.length > 0)
-      env.qa = { ...qaBase(), branchPatterns: patterns };
-  }
-  const auditBase = () => env.audit ?? fileConfig?.audit ?? DEFAULT_AUDIT;
-  if (process.env.NW_AUDIT_ENABLED) {
-    const v = parseBoolean(process.env.NW_AUDIT_ENABLED);
-    if (v !== null)
-      env.audit = { ...auditBase(), enabled: v };
-  }
-  if (process.env.NW_AUDIT_SCHEDULE) {
-    env.audit = { ...auditBase(), schedule: process.env.NW_AUDIT_SCHEDULE };
-  }
-  if (process.env.NW_AUDIT_MAX_RUNTIME) {
-    const v = parseInt(process.env.NW_AUDIT_MAX_RUNTIME, 10);
-    if (!isNaN(v) && v > 0)
-      env.audit = { ...auditBase(), maxRuntime: v };
-  }
-  const analyticsBase = () => env.analytics ?? fileConfig?.analytics ?? DEFAULT_ANALYTICS;
-  if (process.env.NW_ANALYTICS_ENABLED) {
-    const v = parseBoolean(process.env.NW_ANALYTICS_ENABLED);
-    if (v !== null)
-      env.analytics = { ...analyticsBase(), enabled: v };
-  }
-  if (process.env.NW_ANALYTICS_SCHEDULE) {
-    env.analytics = { ...analyticsBase(), schedule: process.env.NW_ANALYTICS_SCHEDULE };
-  }
-  if (process.env.NW_ANALYTICS_MAX_RUNTIME) {
-    const v = parseInt(process.env.NW_ANALYTICS_MAX_RUNTIME, 10);
-    if (!isNaN(v) && v > 0)
-      env.analytics = { ...analyticsBase(), maxRuntime: v };
-  }
-  if (process.env.NW_ANALYTICS_LOOKBACK_DAYS) {
-    const v = parseInt(process.env.NW_ANALYTICS_LOOKBACK_DAYS, 10);
-    if (!isNaN(v) && v > 0)
-      env.analytics = { ...analyticsBase(), lookbackDays: v };
-  }
   const jobProvidersEnv = {};
   for (const jobType of VALID_JOB_TYPES) {
     const val = process.env[`NW_JOB_PROVIDER_${jobType.toUpperCase()}`];
@@ -820,6 +984,7 @@ var init_config_env = __esm({
     "use strict";
     init_constants();
     init_config_normalize();
+    init_job_registry();
   }
 });
 
@@ -1015,6 +1180,15 @@ var init_config = __esm({
   }
 });
 
+// ../core/dist/board/types.js
+var BOARD_COLUMNS;
+var init_types2 = __esm({
+  "../core/dist/board/types.js"() {
+    "use strict";
+    BOARD_COLUMNS = ["Draft", "Ready", "In Progress", "Review", "Done"];
+  }
+});
+
 // ../core/dist/storage/repositories/sqlite/execution-history.repository.js
 import Database from "better-sqlite3";
 import { inject, injectable } from "tsyringe";
@@ -2029,11 +2203,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 +2230,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 +2284,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 +2308,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 +2336,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 +2479,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 +4519,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 +4905,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 +4968,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 +4984,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 +5003,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 +5047,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 +5061,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 +5070,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 +5086,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);
@@ -4811,6 +5094,26 @@ function validateRegistry() {
   }
   return { valid, invalid };
 }
+function pruneProjectData(projectDir) {
+  const resolvedPath = path12.resolve(projectDir);
+  const db = getDb();
+  db.transaction(() => {
+    db.prepare("DELETE FROM execution_history WHERE project_path = ?").run(resolvedPath);
+    db.prepare("DELETE FROM prd_states WHERE project_path = ?").run(resolvedPath);
+    db.prepare("DELETE FROM job_queue WHERE project_path = ?").run(resolvedPath);
+    db.prepare("DELETE FROM job_runs WHERE project_path = ?").run(resolvedPath);
+    db.prepare("DELETE FROM roadmap_states WHERE prd_dir LIKE ?").run(`${resolvedPath}%`);
+  })();
+}
+function removeProject(projectDir) {
+  const resolvedPath = path12.resolve(projectDir);
+  const projectName = getProjectName(resolvedPath);
+  const marker = generateMarker(projectName);
+  const cronEntriesRemoved = removeEntriesForProject(resolvedPath, marker);
+  pruneProjectData(resolvedPath);
+  const unregistered = unregisterProject(resolvedPath);
+  return { cronEntriesRemoved, unregistered, dataPruned: true };
+}
 var init_registry = __esm({
   "../core/dist/utils/registry.js"() {
     "use strict";
@@ -4818,6 +5121,7 @@ var init_registry = __esm({
     init_repositories();
     init_client();
     init_client();
+    init_crontab();
     init_status_data();
   }
 });
@@ -4991,18 +5295,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 +5344,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 +5388,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 +5421,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 +5515,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 +5617,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 +5630,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 +5643,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 +5682,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 +5721,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 +5771,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 +5794,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 +5981,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 +6008,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 +6019,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 +6029,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 +6052,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 +6144,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 +6155,7 @@ function gitExec(args, cwd, logFile) {
     });
     if (logFile && result) {
       try {
-        fs17.appendFileSync(logFile, result);
+        fs18.appendFileSync(logFile, result);
       } catch {
       }
     }
@@ -5860,7 +6164,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 +6189,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 +6232,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 +6278,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 +6313,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 +6890,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 +6921,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 +6940,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 +6979,7 @@ ${stderr}`;
     };
   } finally {
     try {
-      fs18.rmSync(tmpDir, { recursive: true, force: true });
+      fs19.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -6876,6 +7180,14 @@ sequenceDiagram
   }
 });
 
+// ../core/dist/jobs/index.js
+var init_jobs = __esm({
+  "../core/dist/jobs/index.js"() {
+    "use strict";
+    init_job_registry();
+  }
+});
+
 // ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -6953,9 +7265,11 @@ __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,
+  JOB_REGISTRY: () => JOB_REGISTRY,
   LOCK_FILE_PREFIX: () => LOCK_FILE_PREFIX,
   LOG_DIR: () => LOG_DIR,
   LOG_FILE_NAMES: () => LOG_FILE_NAMES,
@@ -6987,7 +7301,9 @@ __export(dist_exports, {
   analyticsLockPath: () => analyticsLockPath,
   auditLockPath: () => auditLockPath,
   buildDescription: () => buildDescription,
+  buildJobEnvOverrides: () => buildJobEnvOverrides,
   calculateStringSimilarity: () => calculateStringSimilarity,
+  camelToUpperSnake: () => camelToUpperSnake,
   canStartJob: () => canStartJob,
   cancelProcess: () => cancelProcess,
   checkConfigFile: () => checkConfigFile,
@@ -7052,23 +7368,30 @@ __export(dist_exports, {
   formatTelegramPayload: () => formatTelegramPayload,
   generateItemHash: () => generateItemHash,
   generateMarker: () => generateMarker,
+  getAllJobDefs: () => getAllJobDefs,
   getBranchTipTimestamp: () => getBranchTipTimestamp,
   getCrontabInfo: () => getCrontabInfo,
   getDb: () => getDb,
   getDbPath: () => getDbPath,
   getDefaultConfig: () => getDefaultConfig,
+  getDefaultQueuePriority: () => getDefaultQueuePriority,
   getEntries: () => getEntries,
   getEventColor: () => getEventColor,
   getEventEmoji: () => getEventEmoji,
   getEventTitle: () => getEventTitle,
   getHistoryPath: () => getHistoryPath,
   getInFlightCount: () => getInFlightCount,
+  getJobDef: () => getJobDef,
+  getJobDefByCommand: () => getJobDefByCommand,
+  getJobDefByLogName: () => getJobDefByLogName,
   getJobPriority: () => getJobPriority,
   getJobRunsAnalytics: () => getJobRunsAnalytics,
   getLabelsForSection: () => getLabelsForSection,
   getLastExecution: () => getLastExecution,
   getLastLogLines: () => getLastLogLines,
   getLockFilePaths: () => getLockFilePaths,
+  getLockSuffix: () => getLockSuffix,
+  getLogFileNames: () => getLogFileNames,
   getLogInfo: () => getLogInfo,
   getNextPendingJob: () => getNextPendingJob,
   getNextPrdNumber: () => getNextPrdNumber,
@@ -7089,6 +7412,7 @@ __export(dist_exports, {
   getStateFilePath: () => getStateFilePath,
   getStateItem: () => getStateItem,
   getUncheckedItems: () => getUncheckedItems,
+  getValidJobTypes: () => getValidJobTypes,
   groupBySection: () => groupBySection2,
   hasEntry: () => hasEntry,
   hasNewItems: () => hasNewItems,
@@ -7106,6 +7430,7 @@ __export(dist_exports, {
   label: () => label,
   listPrdStatesByStatus: () => listPrdStatesByStatus,
   loadConfig: () => loadConfig,
+  loadGlobalNotificationsConfig: () => loadGlobalNotificationsConfig,
   loadHistory: () => loadHistory,
   loadRegistry: () => loadRegistry,
   loadRoadmapState: () => loadRoadmapState,
@@ -7114,6 +7439,7 @@ __export(dist_exports, {
   markJobRunning: () => markJobRunning,
   markPrdDone: () => markPrdDone,
   migrateJsonToSqlite: () => migrateJsonToSqlite,
+  normalizeJobConfig: () => normalizeJobConfig,
   normalizeSchedulingPriority: () => normalizeSchedulingPriority,
   parsePrdDependencies: () => parsePrdDependencies,
   parseRoadmap: () => parseRoadmap,
@@ -7123,6 +7449,7 @@ __export(dist_exports, {
   prepareBranchWorktree: () => prepareBranchWorktree,
   prepareDetachedWorktree: () => prepareDetachedWorktree,
   projectRuntimeKey: () => projectRuntimeKey,
+  pruneProjectData: () => pruneProjectData,
   qaLockPath: () => qaLockPath,
   readCrontab: () => readCrontab,
   readPrdStates: () => readPrdStates,
@@ -7133,6 +7460,7 @@ __export(dist_exports, {
   removeEntries: () => removeEntries,
   removeEntriesForProject: () => removeEntriesForProject,
   removeJob: () => removeJob,
+  removeProject: () => removeProject,
   renderPrdTemplate: () => renderPrdTemplate,
   renderSlicerPrompt: () => renderSlicerPrompt,
   resetRepositories: () => resetRepositories,
@@ -7146,6 +7474,7 @@ __export(dist_exports, {
   runAnalytics: () => runAnalytics,
   runMigrations: () => runMigrations,
   saveConfig: () => saveConfig,
+  saveGlobalNotificationsConfig: () => saveGlobalNotificationsConfig,
   saveHistory: () => saveHistory,
   saveRegistry: () => saveRegistry,
   saveRoadmapState: () => saveRoadmapState,
@@ -7195,6 +7524,7 @@ var init_dist = __esm({
     init_git_utils();
     init_github();
     init_log_utils();
+    init_global_config();
     init_notify();
     init_prd_discovery();
     init_prd_states();
@@ -7215,45 +7545,54 @@ var init_dist = __esm({
     init_analytics();
     init_prd_template();
     init_slicer_prompt();
+    init_jobs();
   }
 });
 
 // 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);
+var NW_SKILLS = [
+  "nw-create-prd",
+  "nw-add-issue",
+  "nw-run",
+  "nw-slice",
+  "nw-board-sync",
+  "nw-review"
+];
 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 +7604,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 +7620,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 +7769,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 +7827,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 +7864,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,15 +7878,70 @@ 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 installSkills(cwd, provider, force, templatesDir) {
+  const skillsTemplatesDir = path20.join(templatesDir, "skills");
+  if (!fs20.existsSync(skillsTemplatesDir)) {
+    return { location: "", installed: 0, skipped: 0, type: "none" };
+  }
+  const isClaudeProvider = provider === "claude" || provider.startsWith("claude");
+  const isCodexProvider = provider === "codex";
+  const claudeDir = path20.join(cwd, ".claude");
+  if (isClaudeProvider || fs20.existsSync(claudeDir)) {
+    ensureDir(claudeDir);
+    const skillsDir = path20.join(claudeDir, "skills");
+    ensureDir(skillsDir);
+    let installed = 0;
+    let skipped = 0;
+    for (const skillName of NW_SKILLS) {
+      const templateFile = path20.join(skillsTemplatesDir, `${skillName}.md`);
+      if (!fs20.existsSync(templateFile)) continue;
+      const skillDir = path20.join(skillsDir, skillName);
+      ensureDir(skillDir);
+      const target = path20.join(skillDir, "SKILL.md");
+      if (fs20.existsSync(target) && !force) {
+        skipped++;
+        continue;
+      }
+      fs20.copyFileSync(templateFile, target);
+      installed++;
+    }
+    return { location: ".claude/skills/", installed, skipped, type: "claude" };
+  }
+  if (isCodexProvider) {
+    const agentsFile = path20.join(cwd, "AGENTS.md");
+    const blockFile = path20.join(skillsTemplatesDir, "_codex-block.md");
+    if (!fs20.existsSync(blockFile)) {
+      return { location: "", installed: 0, skipped: 0, type: "none" };
+    }
+    const block = fs20.readFileSync(blockFile, "utf-8");
+    const marker = "## Night Watch Skills";
+    if (!fs20.existsSync(agentsFile)) {
+      fs20.writeFileSync(agentsFile, block);
+      return { location: "AGENTS.md", installed: NW_SKILLS.length, skipped: 0, type: "codex" };
+    }
+    const existing = fs20.readFileSync(agentsFile, "utf-8");
+    if (existing.includes(marker)) {
+      if (!force) {
+        return { location: "AGENTS.md", installed: 0, skipped: NW_SKILLS.length, type: "codex" };
+      }
+      const withoutSection = existing.replace(/\n\n## Night Watch Skills[\s\S]*$/, "");
+      fs20.writeFileSync(agentsFile, withoutSection + "\n\n" + block);
+    } else {
+      fs20.appendFileSync(agentsFile, "\n\n" + block);
+    }
+    return { location: "AGENTS.md", installed: NW_SKILLS.length, skipped: 0, type: "codex" };
+  }
+  return { location: "", installed: 0, skipped: 0, type: "none" };
+}
 function initCommand(program2) {
   program2.command("init").description("Initialize night-watch in the current project").option("-f, --force", "Overwrite existing configuration").option("-d, --prd-dir <path>", "Path to PRD directory").option("-p, --provider <name>", "AI provider to use (claude or codex)").option("--no-reviewer", "Disable reviewer cron job").action(async (options) => {
     const cwd = process.cwd();
     const force = options.force || false;
     const prdDir = options.prdDir || DEFAULT_PRD_DIR;
-    const totalSteps = 12;
+    const totalSteps = 13;
     const interactive = isInteractiveInitSession();
     console.log();
     header("Night Watch CLI - Initializing");
@@ -7660,28 +8054,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 +8089,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 +8099,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 +8109,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 +8119,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 +8127,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 +8138,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 +8164,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) {
@@ -7798,7 +8192,19 @@ function initCommand(program2) {
         `  Warning: Could not register in global registry: ${regErr instanceof Error ? regErr.message : String(regErr)}`
       );
     }
-    step(12, totalSteps, "Initialization complete!");
+    step(12, totalSteps, "Installing Night Watch skills...");
+    const skillsResult = installSkills(cwd, selectedProvider, force, TEMPLATES_DIR);
+    if (skillsResult.installed > 0) {
+      success(`Installed ${skillsResult.installed} skills to ${skillsResult.location}`);
+      for (const skillName of NW_SKILLS) {
+        console.log(`  /${skillName}`);
+      }
+    } else if (skillsResult.skipped > 0) {
+      info(`Skills already installed (use --force to overwrite)`);
+    } else if (skillsResult.type === "none") {
+      info("No compatible AI skills directory detected \u2014 skipping.");
+    }
+    step(13, totalSteps, "Initialization complete!");
     header("Initialization Complete");
     const filesTable = createTable({ head: ["Created Files", ""] });
     filesTable.push(["PRD Directory", `${prdDir}/done/`]);
@@ -7811,6 +8217,15 @@ function initCommand(program2) {
     filesTable.push(["Config File", CONFIG_FILE_NAME]);
     filesTable.push(["Board Setup", boardSetupStatus]);
     filesTable.push(["Global Registry", "~/.night-watch/projects.json"]);
+    let skillsSummary;
+    if (skillsResult.installed > 0) {
+      skillsSummary = `${skillsResult.installed} skills \u2192 ${skillsResult.location}`;
+    } else if (skillsResult.skipped > 0) {
+      skillsSummary = `Already installed (${skillsResult.location})`;
+    } else {
+      skillsSummary = "Skipped";
+    }
+    filesTable.push(["Skills", skillsSummary]);
     console.log(filesTable.toString());
     header("Configuration");
     label("Provider", selectedProvider);
@@ -7822,6 +8237,9 @@ function initCommand(program2) {
     info("2. Run `night-watch install` to set up cron jobs");
     info("3. Run `night-watch doctor` to verify the full setup");
     info("4. Or run `night-watch run` to execute PRDs manually");
+    if (skillsResult.installed > 0) {
+      info(`5. Use /nw-create-prd, /nw-run, /nw-add-issue and more in your AI assistant`);
+    }
     console.log();
   });
 }
@@ -7900,8 +8318,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 +8351,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 +8366,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 +8394,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 +8556,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 +8583,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 +8744,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 +8984,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 +9005,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 +9030,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 +9164,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 +9190,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 +9234,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 +9269,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 +9281,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 +9361,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 +9383,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 +9409,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 +9451,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 +9459,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 +9467,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 +9475,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 +9506,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 +9547,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 +9556,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 +9565,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 +9574,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 +9622,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 +9638,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 +9683,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 +9933,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 +9948,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 +9968,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 +10038,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 +10067,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 +10086,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 +10147,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 +10171,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 +10183,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 +10202,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 +10244,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 +10340,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 +11995,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 +12037,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 +12051,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 +12061,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 {
@@ -12045,7 +12463,7 @@ function doctorCommand(program2) {
   program2.command("doctor").description("Check Night Watch configuration and system health").option("--fix", "Automatically fix fixable issues").action(async (options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const totalChecks = 8;
+    const totalChecks = 7;
     let checkNum = 1;
     let passedChecks = 0;
     let fixedChecks = 0;
@@ -12071,11 +12489,12 @@ function doctorCommand(program2) {
     const ghResult = runCheck(checkNum++, totalChecks, "GitHub CLI", () => checkGhCli(), options);
     if (ghResult.passed) passedChecks++;
     if (ghResult.fixed) fixedChecks++;
+    const resolvedProviderCli = BUILT_IN_PRESETS[config.provider]?.command ?? config.provider;
     const providerResult = runCheck(
       checkNum++,
       totalChecks,
       "provider CLI",
-      () => checkProviderCli(config.provider),
+      () => checkProviderCli(resolvedProviderCli),
       options
     );
     if (providerResult.passed) passedChecks++;
@@ -12089,15 +12508,6 @@ function doctorCommand(program2) {
     );
     if (configResult.passed) passedChecks++;
     if (configResult.fixed) fixedChecks++;
-    const prdResult = runCheck(
-      checkNum++,
-      totalChecks,
-      "PRD directory",
-      () => checkPrdDirectory(projectDir, config.prdDir),
-      options
-    );
-    if (prdResult.passed) passedChecks++;
-    if (prdResult.fixed) fixedChecks++;
     const logsResult = runCheck(
       checkNum++,
       totalChecks,
@@ -12149,13 +12559,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 +12649,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 +12660,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 +12705,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 +12744,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 {
       }
     }
@@ -12435,18 +12845,16 @@ function createActionRouteHandlers(ctx) {
   router.post(`/${p}review`, (req, res) => {
     spawnAction2(ctx.getProjectDir(req), ["review"], req, res);
   });
-  router.post(`/${p}qa`, (req, res) => {
-    spawnAction2(ctx.getProjectDir(req), ["qa"], req, res);
-  });
-  router.post(`/${p}audit`, (req, res) => {
-    spawnAction2(ctx.getProjectDir(req), ["audit"], req, res);
-  });
-  router.post(`/${p}analytics`, (req, res) => {
-    spawnAction2(ctx.getProjectDir(req), ["analytics"], req, res);
-  });
-  router.post(`/${p}planner`, (req, res) => {
-    spawnAction2(ctx.getProjectDir(req), ["planner"], req, res);
-  });
+  for (const jobDef of JOB_REGISTRY) {
+    if (jobDef.id === "executor")
+      continue;
+    if (jobDef.id === "reviewer")
+      continue;
+    const cmd = jobDef.cliCommand;
+    router.post(`/${p}${cmd}`, (req, res) => {
+      spawnAction2(ctx.getProjectDir(req), [cmd], req, res);
+    });
+  }
   router.post(`/${p}install-cron`, (req, res) => {
     const projectDir = ctx.getProjectDir(req);
     try {
@@ -12501,19 +12909,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 +12939,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 +13602,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 +13655,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 +13689,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 +13712,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 +13722,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 +13767,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 +13786,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 +13812,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 +13847,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 +13857,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 +14189,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 +14216,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 +14255,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));
@@ -13898,14 +14327,30 @@ function createGlobalApp() {
       res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
     }
   });
+  app.delete("/api/projects/:projectId", (req, res) => {
+    try {
+      const rawId = decodeURIComponent(String(req.params.projectId)).replace(/~/g, "/");
+      const entries = loadRegistry();
+      const entry = entries.find((e) => e.name === rawId);
+      if (!entry) {
+        res.status(404).json({ error: "Project not found" });
+        return;
+      }
+      const result = removeProject(entry.path);
+      res.json(result);
+    } catch (error2) {
+      res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
+    }
+  });
   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 +14403,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 +14416,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 +14440,7 @@ function acquireServeLock(mode, port) {
         };
       }
       try {
-        fs32.unlinkSync(lockPath);
+        fs33.unlinkSync(lockPath);
         if (existingPid) {
           stalePidCleaned = existingPid;
         }
@@ -14018,10 +14463,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 +14562,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 +14611,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 +14655,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 +14664,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 +14935,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 +14982,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 +15020,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 +15055,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 +15116,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 +15149,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 +15330,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 +15365,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 +15373,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 +15389,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 +15441,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 +15464,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 +15663,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 +15695,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 +15908,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 +16037,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 +16157,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 +16313,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);