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

package/dist/cli.js

@@ -31,7 +31,7 @@ function resolveProviderBucketKey(provider, providerEnv) {
     return `claude-proxy:${baseUrl}`;
   }
 }
-var DEFAULT_DEFAULT_BRANCH, DEFAULT_PRD_DIR, DEFAULT_MAX_RUNTIME, DEFAULT_REVIEWER_MAX_RUNTIME, DEFAULT_CRON_SCHEDULE, DEFAULT_REVIEWER_SCHEDULE, DEFAULT_CRON_SCHEDULE_OFFSET, DEFAULT_MAX_RETRIES, DEFAULT_REVIEWER_MAX_RETRIES, DEFAULT_REVIEWER_RETRY_DELAY, DEFAULT_REVIEWER_MAX_PRS_PER_RUN, DEFAULT_BRANCH_PREFIX, DEFAULT_BRANCH_PATTERNS, DEFAULT_MIN_REVIEW_SCORE, DEFAULT_MAX_LOG_SIZE, DEFAULT_PROVIDER, DEFAULT_EXECUTOR_ENABLED, DEFAULT_REVIEWER_ENABLED, DEFAULT_PROVIDER_ENV, DEFAULT_FALLBACK_ON_RATE_LIMIT, DEFAULT_CLAUDE_MODEL, DEFAULT_PRIMARY_FALLBACK_MODEL, DEFAULT_SECONDARY_FALLBACK_MODEL, VALID_CLAUDE_MODELS, CLAUDE_MODEL_IDS, DEFAULT_NOTIFICATIONS, DEFAULT_PRD_PRIORITY, DEFAULT_SLICER_SCHEDULE, DEFAULT_SLICER_MAX_RUNTIME, DEFAULT_ROADMAP_SCANNER, DEFAULT_TEMPLATES_DIR, DEFAULT_BOARD_PROVIDER, DEFAULT_LOCAL_BOARD_INFO, DEFAULT_AUTO_MERGE, DEFAULT_AUTO_MERGE_METHOD, VALID_MERGE_METHODS, DEFAULT_QA_ENABLED, DEFAULT_QA_SCHEDULE, DEFAULT_QA_MAX_RUNTIME, DEFAULT_QA_ARTIFACTS, DEFAULT_QA_SKIP_LABEL, DEFAULT_QA_AUTO_INSTALL_PLAYWRIGHT, DEFAULT_QA, QA_LOG_NAME, DEFAULT_AUDIT_ENABLED, DEFAULT_AUDIT_SCHEDULE, DEFAULT_AUDIT_MAX_RUNTIME, DEFAULT_AUDIT, AUDIT_LOG_NAME, PLANNER_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";
@@ -109,10 +109,36 @@ var init_constants = __esm({
       schedule: DEFAULT_AUDIT_SCHEDULE,
       maxRuntime: DEFAULT_AUDIT_MAX_RUNTIME
     };
+    DEFAULT_ANALYTICS_ENABLED = false;
+    DEFAULT_ANALYTICS_SCHEDULE = "0 6 * * 1";
+    DEFAULT_ANALYTICS_MAX_RUNTIME = 900;
+    DEFAULT_ANALYTICS_LOOKBACK_DAYS = 7;
+    DEFAULT_ANALYTICS_TARGET_COLUMN = "Draft";
+    DEFAULT_ANALYTICS_PROMPT = `You are an analytics reviewer. Analyze the following Amplitude product analytics data.
+Identify significant trends, anomalies, or drops that warrant engineering attention.
+For each actionable finding, output a JSON array of issues:
+[{ "title": "...", "body": "...", "labels": ["analytics"] }]
+If no issues are warranted, output an empty array: []`;
+    DEFAULT_ANALYTICS = {
+      enabled: DEFAULT_ANALYTICS_ENABLED,
+      schedule: DEFAULT_ANALYTICS_SCHEDULE,
+      maxRuntime: DEFAULT_ANALYTICS_MAX_RUNTIME,
+      lookbackDays: DEFAULT_ANALYTICS_LOOKBACK_DAYS,
+      targetColumn: DEFAULT_ANALYTICS_TARGET_COLUMN,
+      analysisPrompt: DEFAULT_ANALYTICS_PROMPT
+    };
     AUDIT_LOG_NAME = "audit";
     PLANNER_LOG_NAME = "slicer";
+    ANALYTICS_LOG_NAME = "analytics";
     VALID_PROVIDERS = ["claude", "codex"];
-    VALID_JOB_TYPES = ["executor", "reviewer", "qa", "audit", "slicer"];
+    VALID_JOB_TYPES = [
+      "executor",
+      "reviewer",
+      "qa",
+      "audit",
+      "slicer",
+      "analytics"
+    ];
     DEFAULT_JOB_PROVIDERS = {};
     BUILT_IN_PRESETS = {
       claude: {
@@ -191,13 +217,15 @@ var init_constants = __esm({
       reviewer: REVIEWER_LOG_NAME,
       qa: QA_LOG_NAME,
       audit: AUDIT_LOG_NAME,
-      planner: PLANNER_LOG_NAME
+      planner: PLANNER_LOG_NAME,
+      analytics: ANALYTICS_LOG_NAME
     };
     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";
@@ -208,7 +236,8 @@ var init_constants = __esm({
       reviewer: 40,
       slicer: 30,
       qa: 20,
-      audit: 10
+      audit: 10,
+      analytics: 10
     };
     DEFAULT_QUEUE = {
       enabled: DEFAULT_QUEUE_ENABLED,
@@ -223,6 +252,15 @@ var init_constants = __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/config-normalize.js
 function validateProvider(value) {
   const trimmed = value.trim();
@@ -418,6 +456,20 @@ function normalizeConfig(rawConfig) {
     };
     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;
+  }
   const rawJobProviders = readObject(rawConfig.jobProviders);
   if (rawJobProviders) {
     const jobProviders = {};
@@ -477,6 +529,7 @@ function normalizeConfig(rawConfig) {
 var init_config_normalize = __esm({
   "../core/dist/config-normalize.js"() {
     "use strict";
+    init_types2();
     init_constants();
   }
 });
@@ -700,6 +753,25 @@ function buildEnvOverrideConfig(fileConfig) {
     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()}`];
@@ -792,6 +864,7 @@ function getDefaultConfig() {
     claudeModel: DEFAULT_CLAUDE_MODEL,
     qa: { ...DEFAULT_QA },
     audit: { ...DEFAULT_AUDIT },
+    analytics: { ...DEFAULT_ANALYTICS },
     jobProviders: { ...DEFAULT_JOB_PROVIDERS },
     queue: { ...DEFAULT_QUEUE }
   };
@@ -858,7 +931,7 @@ function mergeConfigLayer(base, layer) {
         ...layerQueue,
         providerBuckets: { ...baseQueue.providerBuckets, ...layerQueue.providerBuckets }
       };
-    } else if (_key === "providerEnv" || _key === "boardProvider" || _key === "qa" || _key === "audit") {
+    } else if (_key === "providerEnv" || _key === "boardProvider" || _key === "qa" || _key === "audit" || _key === "analytics") {
       base[_key] = {
         ...base[_key],
         ...value
@@ -943,15 +1016,6 @@ 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";
@@ -1966,11 +2030,18 @@ var init_github_projects = __esm({
           await this.ensureStatusColumns(existing.id);
           return { id: existing.id, number: existing.number, title: existing.title, url: existing.url };
         }
-        const createData = await graphql(`mutation CreateProject($ownerId: ID!, $title: String!) {
-        createProjectV2(input: { ownerId: $ownerId, title: $title }) {
-          projectV2 { id number url title }
+        const createData = await graphql(`
+        mutation CreateProject($ownerId: ID!, $title: String!) {
+          createProjectV2(input: { ownerId: $ownerId, title: $title }) {
+            projectV2 {
+              id
+              number
+              url
+              title
+            }
+          }
         }
-      }`, { ownerId: owner.id, title }, this.cwd);
+      `, { ownerId: owner.id, title }, this.cwd);
         const project = createData.createProjectV2.projectV2;
         this.cachedProjectId = project.id;
         await this.linkProjectToRepository(project.id);
@@ -1986,24 +2057,34 @@ var init_github_projects = __esm({
           const message = err instanceof Error ? err.message : String(err);
           if (!message.includes("Status field not found"))
             throw err;
-          const createFieldData = await graphql(`mutation CreateStatusField($projectId: ID!) {
-          createProjectV2Field(input: {
-            projectId: $projectId
-            dataType: SINGLE_SELECT
-            name: "Status"
-            singleSelectOptions: [
-              { name: "Draft",       color: GRAY,   description: "" }
-              { name: "Ready",       color: BLUE,   description: "" }
-              { name: "In Progress", color: YELLOW, description: "" }
-              { name: "Review",      color: ORANGE, description: "" }
-              { name: "Done",        color: GREEN,  description: "" }
-            ]
-          }) {
-            projectV2Field {
-              ... on ProjectV2SingleSelectField { id options { id name } }
+          const createFieldData = await graphql(`
+          mutation CreateStatusField($projectId: ID!) {
+            createProjectV2Field(
+              input: {
+                projectId: $projectId
+                dataType: SINGLE_SELECT
+                name: "Status"
+                singleSelectOptions: [
+                  { name: "Draft", color: GRAY, description: "" }
+                  { name: "Ready", color: BLUE, description: "" }
+                  { name: "In Progress", color: YELLOW, description: "" }
+                  { name: "Review", color: ORANGE, description: "" }
+                  { name: "Done", color: GREEN, description: "" }
+                ]
+              }
+            ) {
+              projectV2Field {
+                ... on ProjectV2SingleSelectField {
+                  id
+                  options {
+                    id
+                    name
+                  }
+                }
+              }
             }
           }
-        }`, { projectId: project.id }, this.cwd);
+        `, { projectId: project.id }, this.cwd);
           const field = createFieldData.createProjectV2Field.projectV2Field;
           this.cachedFieldId = field.id;
           this.cachedOptionIds = new Map(field.options.map((o) => [o.name, o.id]));
@@ -2030,11 +2111,23 @@ var init_github_projects = __esm({
       async createIssue(input) {
         const repo = await this.getRepo();
         const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
-        const issueArgs = ["issue", "create", "--title", input.title, "--body", input.body, "--repo", repo];
+        const issueArgs = [
+          "issue",
+          "create",
+          "--title",
+          input.title,
+          "--body",
+          input.body,
+          "--repo",
+          repo
+        ];
         if (input.labels && input.labels.length > 0) {
           issueArgs.push("--label", input.labels.join(","));
         }
-        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, { cwd: this.cwd, encoding: "utf-8" });
+        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, {
+          cwd: this.cwd,
+          encoding: "utf-8"
+        });
         const issueUrl = issueUrlRaw.trim();
         const issueNumber = parseInt(issueUrl.split("/").pop() ?? "", 10);
         if (!issueNumber)
@@ -2042,11 +2135,15 @@ var init_github_projects = __esm({
         const [owner, repoName] = repo.split("/");
         const { stdout: nodeIdRaw } = await execFileAsync2("gh", ["api", `repos/${owner}/${repoName}/issues/${issueNumber}`, "--jq", ".node_id"], { cwd: this.cwd, encoding: "utf-8" });
         const issueJson = { number: issueNumber, id: nodeIdRaw.trim(), url: issueUrl };
-        const addData = await graphql(`mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
-        addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
-          item { id }
+        const addData = await graphql(`
+        mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
+          addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+            item {
+              id
+            }
+          }
         }
-      }`, { projectId, contentId: issueJson.id }, this.cwd);
+      `, { projectId, contentId: issueJson.id }, this.cwd);
         const itemId = addData.addProjectV2ItemById.item.id;
         const targetColumn = input.column ?? "Draft";
         const optionId = optionIds.get(targetColumn);
@@ -2066,11 +2163,45 @@ var init_github_projects = __esm({
           assignees: []
         };
       }
+      async addIssue(issueNumber, column = "Ready") {
+        const repo = await this.getRepo();
+        const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
+        const [owner, repoName] = repo.split("/");
+        const { stdout: nodeIdRaw } = await execFileAsync2("gh", ["api", `repos/${owner}/${repoName}/issues/${issueNumber}`, "--jq", ".node_id"], { cwd: this.cwd, encoding: "utf-8" });
+        const nodeId = nodeIdRaw.trim();
+        if (!nodeId)
+          throw new Error(`Issue #${issueNumber} not found in ${repo}.`);
+        const addData = await graphql(`
+        mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
+          addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+            item {
+              id
+            }
+          }
+        }
+      `, { projectId, contentId: nodeId }, this.cwd);
+        const itemId = addData.addProjectV2ItemById.item.id;
+        const optionId = optionIds.get(column);
+        if (optionId)
+          await this.setItemStatus(projectId, itemId, fieldId, optionId);
+        const full = await this.getIssue(issueNumber);
+        if (full)
+          return { ...full, column };
+        throw new Error(`Added issue #${issueNumber} to project but failed to fetch it back.`);
+      }
       async getIssue(issueNumber) {
         const repo = await this.getRepo();
         let rawIssue;
         try {
-          const { stdout: output } = await execFileAsync2("gh", ["issue", "view", String(issueNumber), "--repo", repo, "--json", "number,title,body,url,id,labels,assignees"], { cwd: this.cwd, encoding: "utf-8" });
+          const { stdout: output } = await execFileAsync2("gh", [
+            "issue",
+            "view",
+            String(issueNumber),
+            "--repo",
+            repo,
+            "--json",
+            "number,title,body,url,id,labels,assignees"
+          ], { cwd: this.cwd, encoding: "utf-8" });
           rawIssue = JSON.parse(output);
         } catch {
           return null;
@@ -2175,6 +2306,9 @@ var init_local_kanban = __esm({
         });
         return toIBoardIssue(row);
       }
+      async addIssue(_issueNumber, _column) {
+        throw new Error("addIssue is not supported by the local Kanban provider.");
+      }
       async getIssue(issueNumber) {
         const row = this.repo.getByNumber(issueNumber);
         return row ? toIBoardIssue(row) : null;
@@ -3046,6 +3180,9 @@ function auditLockPath(projectDir) {
 function plannerLockPath(projectDir) {
   return `${LOCK_FILE_PREFIX}slicer-${projectRuntimeKey(projectDir)}.lock`;
 }
+function analyticsLockPath(projectDir) {
+  return `${LOCK_FILE_PREFIX}analytics-${projectRuntimeKey(projectDir)}.lock`;
+}
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -3404,7 +3541,8 @@ function collectLogInfo(projectDir) {
     { name: "reviewer", fileName: "reviewer.log" },
     { name: "qa", fileName: `${QA_LOG_NAME}.log` },
     { name: "audit", fileName: `${AUDIT_LOG_NAME}.log` },
-    { name: "planner", fileName: `${PLANNER_LOG_NAME}.log` }
+    { name: "planner", fileName: `${PLANNER_LOG_NAME}.log` },
+    { name: "analytics", fileName: `${ANALYTICS_LOG_NAME}.log` }
   ];
   return logEntries.map(({ name, fileName }) => {
     const logPath = path6.join(projectDir, LOG_DIR, fileName);
@@ -3433,12 +3571,14 @@ async function fetchStatusSnapshot(projectDir, config) {
   const qaLock = checkLockFile(qaLockPath(projectDir));
   const auditLock = checkLockFile(auditLockPath(projectDir));
   const plannerLock = checkLockFile(plannerLockPath(projectDir));
+  const analyticsLock = checkLockFile(analyticsLockPath(projectDir));
   const processes = [
     { name: "executor", running: executorLock.running, pid: executorLock.pid },
     { name: "reviewer", running: reviewerLock.running, pid: reviewerLock.pid },
     { name: "qa", running: qaLock.running, pid: qaLock.pid },
     { name: "audit", running: auditLock.running, pid: auditLock.pid },
-    { name: "planner", running: plannerLock.running, pid: plannerLock.pid }
+    { name: "planner", running: plannerLock.running, pid: plannerLock.pid },
+    { name: "analytics", running: analyticsLock.running, pid: analyticsLock.pid }
   ];
   const prds = collectPrdInfo(projectDir, config.prdDir, config.maxRuntime);
   const prs = await collectPrInfo(projectDir, config.branchPatterns);
@@ -4206,6 +4346,36 @@ var init_log_utils = __esm({
   }
 });
 
+// ../core/dist/utils/global-config.js
+import * as fs11 from "fs";
+import * as os5 from "os";
+import * as path10 from "path";
+function getGlobalNotificationsPath() {
+  return path10.join(os5.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_NOTIFICATIONS_FILE_NAME);
+}
+function loadGlobalNotificationsConfig() {
+  const filePath = getGlobalNotificationsPath();
+  try {
+    if (!fs11.existsSync(filePath))
+      return { webhook: null };
+    const raw = fs11.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { webhook: null };
+  }
+}
+function saveGlobalNotificationsConfig(config) {
+  const filePath = getGlobalNotificationsPath();
+  fs11.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs11.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+var init_global_config = __esm({
+  "../core/dist/utils/global-config.js"() {
+    "use strict";
+    init_constants();
+  }
+});
+
 // ../core/dist/utils/ui.js
 import chalk from "chalk";
 import ora from "ora";
@@ -4562,24 +4732,33 @@ async function sendWebhook(webhook, ctx) {
     warn(`Notification failed (${webhook.type}): ${message}`);
   }
 }
+function webhookIdentity(wh) {
+  if (wh.type === "telegram")
+    return `telegram:${wh.botToken}:${wh.chatId}`;
+  return `${wh.type}:${wh.url}`;
+}
 async function sendNotifications(config, ctx) {
-  const webhooks = config.notifications?.webhooks ?? [];
-  const tasks = [];
-  for (const wh of webhooks) {
-    tasks.push(sendWebhook(wh, ctx));
+  const projectWebhooks = config.notifications?.webhooks ?? [];
+  const globalConfig = loadGlobalNotificationsConfig();
+  const allWebhooks = [...projectWebhooks];
+  if (globalConfig.webhook) {
+    const projectIds = new Set(projectWebhooks.map(webhookIdentity));
+    if (!projectIds.has(webhookIdentity(globalConfig.webhook))) {
+      allWebhooks.push(globalConfig.webhook);
+    }
   }
-  if (tasks.length === 0) {
+  if (allWebhooks.length === 0) {
     return;
   }
-  const results = await Promise.allSettled(tasks);
+  const results = await Promise.allSettled(allWebhooks.map((wh) => sendWebhook(wh, ctx)));
   const sent = results.filter((r) => r.status === "fulfilled").length;
-  const total = results.length;
-  info(`Sent ${sent}/${total} notifications`);
+  info(`Sent ${sent}/${allWebhooks.length} notifications`);
 }
 var MAX_QA_SCREENSHOTS_IN_NOTIFICATION;
 var init_notify = __esm({
   "../core/dist/utils/notify.js"() {
     "use strict";
+    init_global_config();
     init_ui();
     init_github();
     MAX_QA_SCREENSHOTS_IN_NOTIFICATION = 3;
@@ -4616,15 +4795,15 @@ var init_prd_discovery = __esm({
 });
 
 // ../core/dist/utils/prd-utils.js
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber(prdDir) {
-  if (!fs11.existsSync(prdDir))
+  if (!fs12.existsSync(prdDir))
     return 1;
-  const files = fs11.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+  const files = fs12.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
@@ -4632,16 +4811,16 @@ function getNextPrdNumber(prdDir) {
   return Math.max(0, ...numbers) + 1;
 }
 function markPrdDone(prdDir, prdFile) {
-  const sourcePath = path10.join(prdDir, prdFile);
-  if (!fs11.existsSync(sourcePath)) {
+  const sourcePath = path11.join(prdDir, prdFile);
+  if (!fs12.existsSync(sourcePath)) {
     return false;
   }
-  const doneDir = path10.join(prdDir, "done");
-  if (!fs11.existsSync(doneDir)) {
-    fs11.mkdirSync(doneDir, { recursive: true });
+  const doneDir = path11.join(prdDir, "done");
+  if (!fs12.existsSync(doneDir)) {
+    fs12.mkdirSync(doneDir, { recursive: true });
   }
-  const destPath = path10.join(doneDir, prdFile);
-  fs11.renameSync(sourcePath, destPath);
+  const destPath = path11.join(doneDir, prdFile);
+  fs12.renameSync(sourcePath, destPath);
   return true;
 }
 var init_prd_utils = __esm({
@@ -4651,16 +4830,16 @@ var init_prd_utils = __esm({
 });
 
 // ../core/dist/utils/registry.js
-import * as fs12 from "fs";
-import * as os5 from "os";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as os6 from "os";
+import * as path12 from "path";
 function readLegacyRegistryEntries() {
   const registryPath = getRegistryPath();
-  if (!fs12.existsSync(registryPath)) {
+  if (!fs13.existsSync(registryPath)) {
     return [];
   }
   try {
-    const raw = fs12.readFileSync(registryPath, "utf-8");
+    const raw = fs13.readFileSync(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       return [];
@@ -4695,8 +4874,8 @@ function loadRegistryEntriesWithLegacyFallback() {
   return projectRegistry.getAll();
 }
 function getRegistryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path11.join(os5.homedir(), GLOBAL_CONFIG_DIR);
-  return path11.join(base, REGISTRY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path12.join(os6.homedir(), GLOBAL_CONFIG_DIR);
+  return path12.join(base, REGISTRY_FILE_NAME);
 }
 function loadRegistry() {
   return loadRegistryEntriesWithLegacyFallback();
@@ -4709,7 +4888,7 @@ function saveRegistry(entries) {
   }
 }
 function registerProject(projectDir) {
-  const resolvedPath = path11.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   const { projectRegistry } = getRepositories();
   const entries = loadRegistryEntriesWithLegacyFallback();
   const existing = entries.find((e) => e.path === resolvedPath);
@@ -4718,13 +4897,13 @@ function registerProject(projectDir) {
   }
   const name = getProjectName(resolvedPath);
   const nameExists = entries.some((e) => e.name === name);
-  const finalName = nameExists ? `${name}-${path11.basename(resolvedPath)}` : name;
+  const finalName = nameExists ? `${name}-${path12.basename(resolvedPath)}` : name;
   const entry = { name: finalName, path: resolvedPath };
   projectRegistry.upsert(entry);
   return entry;
 }
 function unregisterProject(projectDir) {
-  const resolvedPath = path11.resolve(projectDir);
+  const resolvedPath = path12.resolve(projectDir);
   loadRegistryEntriesWithLegacyFallback();
   const { projectRegistry } = getRepositories();
   return projectRegistry.remove(resolvedPath);
@@ -4734,7 +4913,7 @@ function validateRegistry() {
   const valid = [];
   const invalid = [];
   for (const entry of entries) {
-    if (fs12.existsSync(entry.path) && fs12.existsSync(path11.join(entry.path, CONFIG_FILE_NAME))) {
+    if (fs13.existsSync(entry.path) && fs13.existsSync(path12.join(entry.path, CONFIG_FILE_NAME))) {
       valid.push(entry);
     } else {
       invalid.push(entry);
@@ -4922,18 +5101,18 @@ var init_roadmap_parser = __esm({
 });
 
 // ../core/dist/utils/roadmap-state.js
-import * as fs13 from "fs";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 function getStateFilePath(prdDir) {
-  return path12.join(prdDir, STATE_FILE_NAME);
+  return path13.join(prdDir, STATE_FILE_NAME);
 }
 function readJsonState(prdDir) {
   const statePath = getStateFilePath(prdDir);
-  if (!fs13.existsSync(statePath)) {
+  if (!fs14.existsSync(statePath)) {
     return null;
   }
   try {
-    const content = fs13.readFileSync(statePath, "utf-8");
+    const content = fs14.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null) {
       return null;
@@ -4971,11 +5150,11 @@ function saveRoadmapState(prdDir, state) {
   const { roadmapState } = getRepositories();
   roadmapState.save(prdDir, state);
   const statePath = getStateFilePath(prdDir);
-  const dir = path12.dirname(statePath);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(statePath);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs13.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  fs14.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 function createEmptyState() {
   return {
@@ -5015,15 +5194,15 @@ var init_roadmap_state = __esm({
 });
 
 // ../core/dist/templates/slicer-prompt.js
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 function loadSlicerTemplate(templateDir) {
   if (cachedTemplate) {
     return cachedTemplate;
   }
-  const templatePath = templateDir ? path13.join(templateDir, "slicer.md") : path13.resolve(__dirname, "..", "..", "templates", "slicer.md");
+  const templatePath = templateDir ? path14.join(templateDir, "slicer.md") : path14.resolve(__dirname, "..", "..", "templates", "slicer.md");
   try {
-    cachedTemplate = fs14.readFileSync(templatePath, "utf-8");
+    cachedTemplate = fs15.readFileSync(templatePath, "utf-8");
     return cachedTemplate;
   } catch (error2) {
     console.warn(`Warning: Could not load slicer template from ${templatePath}, using default:`, error2 instanceof Error ? error2.message : String(error2));
@@ -5048,7 +5227,7 @@ function createSlicerPromptVars(title, section, description, prdDir, prdFilename
     title,
     section,
     description: description || "(No description provided)",
-    outputFilePath: path13.join(prdDir, prdFilename),
+    outputFilePath: path14.join(prdDir, prdFilename),
     prdDir
   };
 }
@@ -5142,8 +5321,8 @@ DO NOT forget to write the file.
 });
 
 // ../core/dist/utils/roadmap-scanner.js
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
 function normalizeAuditSeverity(raw) {
@@ -5244,11 +5423,11 @@ function auditFindingToRoadmapItem(finding) {
   };
 }
 function collectAuditPlannerItems(projectDir) {
-  const reportPath = path14.join(projectDir, "logs", "audit-report.md");
-  if (!fs15.existsSync(reportPath)) {
+  const reportPath = path15.join(projectDir, "logs", "audit-report.md");
+  if (!fs16.existsSync(reportPath)) {
     return [];
   }
-  const reportContent = fs15.readFileSync(reportPath, "utf-8");
+  const reportContent = fs16.readFileSync(reportPath, "utf-8");
   if (!reportContent.trim() || /\bNO_ISSUES_FOUND\b/.test(reportContent)) {
     return [];
   }
@@ -5257,9 +5436,9 @@ function collectAuditPlannerItems(projectDir) {
   return findings.map(auditFindingToRoadmapItem);
 }
 function getRoadmapStatus(projectDir, config) {
-  const roadmapPath = path14.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const scannerEnabled = config.roadmapScanner.enabled;
-  if (!fs15.existsSync(roadmapPath)) {
+  if (!fs16.existsSync(roadmapPath)) {
     return {
       found: false,
       enabled: scannerEnabled,
@@ -5270,9 +5449,9 @@ function getRoadmapStatus(projectDir, config) {
       items: []
     };
   }
-  const content = fs15.readFileSync(roadmapPath, "utf-8");
+  const content = fs16.readFileSync(roadmapPath, "utf-8");
   const items = parseRoadmap(content);
-  const prdDir = path14.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const statusItems = items.map((item) => {
@@ -5309,10 +5488,10 @@ function getRoadmapStatus(projectDir, config) {
 }
 function scanExistingPrdSlugs(prdDir) {
   const slugs = /* @__PURE__ */ new Set();
-  if (!fs15.existsSync(prdDir)) {
+  if (!fs16.existsSync(prdDir)) {
     return slugs;
   }
-  const files = fs15.readdirSync(prdDir);
+  const files = fs16.readdirSync(prdDir);
   for (const file of files) {
     if (!file.endsWith(".md")) {
       continue;
@@ -5348,20 +5527,20 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
   const nextNum = getNextPrdNumber(prdDir);
   const padded = String(nextNum).padStart(2, "0");
   const filename = `${padded}-${itemSlug}.md`;
-  const filePath = path14.join(prdDir, filename);
-  if (!fs15.existsSync(prdDir)) {
-    fs15.mkdirSync(prdDir, { recursive: true });
+  const filePath = path15.join(prdDir, filename);
+  if (!fs16.existsSync(prdDir)) {
+    fs16.mkdirSync(prdDir, { recursive: true });
   }
   const promptVars = createSlicerPromptVars(item.title, item.section, item.description, prdDir, filename);
   const prompt2 = renderSlicerPrompt(promptVars);
   const provider = resolveJobProvider(config, "slicer");
   const providerArgs = buildProviderArgs(provider, prompt2, projectDir);
-  const logDir = path14.join(projectDir, "logs");
-  if (!fs15.existsSync(logDir)) {
-    fs15.mkdirSync(logDir, { recursive: true });
+  const logDir = path15.join(projectDir, "logs");
+  if (!fs16.existsSync(logDir)) {
+    fs16.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path14.join(logDir, `slicer-${itemSlug}.log`);
-  const logStream = fs15.createWriteStream(logFile, { flags: "w" });
+  const logFile = path15.join(logDir, `slicer-${itemSlug}.log`);
+  const logStream = fs16.createWriteStream(logFile, { flags: "w" });
   logStream.on("error", () => {
   });
   return new Promise((resolve10) => {
@@ -5398,7 +5577,7 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
         });
         return;
       }
-      if (!fs15.existsSync(filePath)) {
+      if (!fs16.existsSync(filePath)) {
         resolve10({
           sliced: false,
           error: `Provider did not create expected file: ${filePath}`,
@@ -5421,23 +5600,23 @@ async function sliceNextItem(projectDir, config) {
       error: "Roadmap scanner is disabled"
     };
   }
-  const roadmapPath = path14.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path15.join(projectDir, config.roadmapScanner.roadmapPath);
   const auditItems = collectAuditPlannerItems(projectDir);
-  const roadmapExists = fs15.existsSync(roadmapPath);
+  const roadmapExists = fs16.existsSync(roadmapPath);
   if (!roadmapExists && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No pending items to process"
     };
   }
-  const roadmapItems = roadmapExists ? parseRoadmap(fs15.readFileSync(roadmapPath, "utf-8")) : [];
+  const roadmapItems = roadmapExists ? parseRoadmap(fs16.readFileSync(roadmapPath, "utf-8")) : [];
   if (roadmapExists && roadmapItems.length === 0 && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No items in roadmap"
     };
   }
-  const prdDir = path14.join(projectDir, config.prdDir);
+  const prdDir = path15.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const pickEligibleItem = (items) => {
@@ -5608,8 +5787,8 @@ var init_shell = __esm({
 });
 
 // ../core/dist/utils/scheduling.js
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 function normalizeSchedulingPriority(priority) {
   if (!Number.isFinite(priority)) {
     return DEFAULT_SCHEDULING_PRIORITY;
@@ -5628,12 +5807,14 @@ function isJobTypeEnabled(config, jobType) {
       return config.audit.enabled;
     case "slicer":
       return config.roadmapScanner.enabled;
+    case "analytics":
+      return config.analytics.enabled;
     default:
       return true;
   }
 }
 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 {
@@ -5644,9 +5825,9 @@ function loadPeerConfig(projectPath) {
 }
 function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
   const peers = /* @__PURE__ */ new Map();
-  const currentPath = path15.resolve(currentProjectDir);
+  const currentPath = path16.resolve(currentProjectDir);
   const addPeer = (projectPath, config) => {
-    const resolvedPath = path15.resolve(projectPath);
+    const resolvedPath = path16.resolve(projectPath);
     if (!isJobTypeEnabled(config, jobType)) {
       return;
     }
@@ -5654,12 +5835,12 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
       path: resolvedPath,
       config,
       schedulingPriority: normalizeSchedulingPriority(config.schedulingPriority),
-      sortKey: `${path15.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
+      sortKey: `${path16.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
     });
   };
   addPeer(currentPath, currentConfig);
   for (const entry of loadRegistry()) {
-    const resolvedPath = path15.resolve(entry.path);
+    const resolvedPath = path16.resolve(entry.path);
     if (resolvedPath === currentPath || peers.has(resolvedPath)) {
       continue;
     }
@@ -5677,7 +5858,7 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
 }
 function getSchedulingPlan(projectDir, config, jobType) {
   const peers = collectSchedulingPeers(projectDir, config, jobType);
-  const currentPath = path15.resolve(projectDir);
+  const currentPath = path16.resolve(projectDir);
   const slotIndex = Math.max(0, peers.findIndex((peer) => peer.path === currentPath));
   const peerCount = Math.max(1, peers.length);
   const balancedDelayMinutes = peerCount <= 1 ? 0 : Math.floor(slotIndex * 60 / peerCount);
@@ -5769,8 +5950,8 @@ var init_webhook_validator = __esm({
 
 // ../core/dist/utils/worktree-manager.js
 import { execFileSync as execFileSync4 } from "child_process";
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 function gitExec(args, cwd, logFile) {
   try {
     const result = execFileSync4("git", args, {
@@ -5780,7 +5961,7 @@ function gitExec(args, cwd, logFile) {
     });
     if (logFile && result) {
       try {
-        fs17.appendFileSync(logFile, result);
+        fs18.appendFileSync(logFile, result);
       } catch {
       }
     }
@@ -5789,7 +5970,7 @@ function gitExec(args, cwd, logFile) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     if (logFile) {
       try {
-        fs17.appendFileSync(logFile, errorMessage + "\n");
+        fs18.appendFileSync(logFile, errorMessage + "\n");
       } catch {
       }
     }
@@ -5814,11 +5995,11 @@ function branchExistsRemotely(projectDir, branchName) {
 }
 function prepareBranchWorktree(options) {
   const { projectDir, worktreeDir, branchName, defaultBranch, logFile } = options;
-  if (fs17.existsSync(worktreeDir)) {
+  if (fs18.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs17.rmSync(worktreeDir, { recursive: true, force: true });
+        fs18.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5857,11 +6038,11 @@ function prepareBranchWorktree(options) {
 }
 function prepareDetachedWorktree(options) {
   const { projectDir, worktreeDir, defaultBranch, logFile } = options;
-  if (fs17.existsSync(worktreeDir)) {
+  if (fs18.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs17.rmSync(worktreeDir, { recursive: true, force: true });
+        fs18.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5903,7 +6084,7 @@ function isWorktreeRegistered(projectDir, worktreePath) {
   }
 }
 function cleanupWorktrees(projectDir, scope) {
-  const projectName = path16.basename(projectDir);
+  const projectName = path17.basename(projectDir);
   const matchToken = scope ? scope : `${projectName}-nw`;
   const removed = [];
   try {
@@ -5938,16 +6119,16 @@ var init_worktree_manager = __esm({
 });
 
 // ../core/dist/utils/job-queue.js
-import * as os6 from "os";
-import * as path17 from "path";
+import * as os7 from "os";
+import * as path18 from "path";
 import Database7 from "better-sqlite3";
 function getStateDbPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path17.join(os6.homedir(), GLOBAL_CONFIG_DIR);
-  return path17.join(base, STATE_DB_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path18.join(os7.homedir(), GLOBAL_CONFIG_DIR);
+  return path18.join(base, STATE_DB_FILE_NAME);
 }
 function getQueueLockPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path17.join(os6.homedir(), GLOBAL_CONFIG_DIR);
-  return path17.join(base, QUEUE_LOCK_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path18.join(os7.homedir(), GLOBAL_CONFIG_DIR);
+  return path18.join(base, QUEUE_LOCK_FILE_NAME);
 }
 function openDb() {
   const dbPath = getStateDbPath();
@@ -5987,6 +6168,8 @@ function getLockPathForJob(projectPath, jobType) {
       return auditLockPath(projectPath);
     case "slicer":
       return plannerLockPath(projectPath);
+    case "analytics":
+      return analyticsLockPath(projectPath);
   }
 }
 function reconcileStaleRunningJobs(db) {
@@ -6166,7 +6349,10 @@ function fitsProviderCapacity(candidate, config, inFlightByBucket) {
   }
   const bucketConfig = config?.providerBuckets?.[bucketKey];
   if (!bucketConfig) {
-    logger.debug("Capacity check skipped: bucket not configured", { id: candidate.id, bucket: bucketKey });
+    logger.debug("Capacity check skipped: bucket not configured", {
+      id: candidate.id,
+      bucket: bucketKey
+    });
     return true;
   }
   const inFlightCount = inFlightByBucket[bucketKey] ?? 0;
@@ -6197,7 +6383,10 @@ function dispatchNextJob(config) {
     const runningCount = running?.count ?? 0;
     logger.debug("Dispatch attempt", { mode, runningCount, maxConcurrency });
     if (runningCount >= maxConcurrency) {
-      logger.info("Dispatch skipped: global concurrency limit reached", { runningCount, maxConcurrency });
+      logger.info("Dispatch skipped: global concurrency limit reached", {
+        runningCount,
+        maxConcurrency
+      });
       return null;
     }
     const now = Math.floor(Date.now() / 1e3);
@@ -6223,7 +6412,9 @@ function dispatchNextJob(config) {
       logger.debug("Dispatch skipped: no pending jobs");
       return null;
     }
-    logger.debug("Provider-aware dispatch: evaluating candidates", { candidateCount: candidates.length });
+    logger.debug("Provider-aware dispatch: evaluating candidates", {
+      candidateCount: candidates.length
+    });
     const inFlightByBucket = getInFlightCountByBucket(db);
     for (const candidate of candidates) {
       if (fitsProviderCapacity(candidate, config, inFlightByBucket)) {
@@ -6299,7 +6490,11 @@ function clearQueue(filter, force) {
     } else {
       result = db.prepare(`DELETE FROM job_queue WHERE status IN ${statuses}`).run();
     }
-    logger.info("Queue cleared", { count: result.changes, filter: filter ?? "all", force: force ?? false });
+    logger.info("Queue cleared", {
+      count: result.changes,
+      filter: filter ?? "all",
+      force: force ?? false
+    });
     return result.changes;
   } finally {
     db.close();
@@ -6432,6 +6627,192 @@ var init_job_queue = __esm({
   }
 });
 
+// ../core/dist/analytics/amplitude-client.js
+function buildAuthHeader(apiKey, secretKey) {
+  return `Basic ${Buffer.from(`${apiKey}:${secretKey}`).toString("base64")}`;
+}
+function buildDateRange(lookbackDays) {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - lookbackDays);
+  const fmt = (d) => d.toISOString().slice(0, 10).replace(/-/g, "");
+  return { start: fmt(start), end: fmt(end) };
+}
+async function amplitudeFetch(url, authHeader, label2) {
+  logger2.debug(`Fetching ${label2}`, { url });
+  const response = await fetch(url, {
+    headers: { Authorization: authHeader }
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error(`Amplitude authentication failed (401). Check your API Key and Secret Key.`);
+    }
+    if (response.status === 429) {
+      throw new Error(`Amplitude rate limit exceeded (429). Try again later.`);
+    }
+    throw new Error(`Amplitude API error: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+async function fetchAmplitudeData(apiKey, secretKey, lookbackDays) {
+  const authHeader = buildAuthHeader(apiKey, secretKey);
+  const { start, end } = buildDateRange(lookbackDays);
+  logger2.info("Fetching Amplitude data", { lookbackDays, start, end });
+  const baseUrl = "https://amplitude.com/api/2";
+  const allEventsParam = encodeURIComponent('{"event_type":"_all"}');
+  const [activeUsers, eventSegmentation, retention, userSessions] = await Promise.allSettled([
+    amplitudeFetch(`${baseUrl}/users/active?start=${start}&end=${end}`, authHeader, "active users"),
+    amplitudeFetch(`${baseUrl}/events/segmentation?start=${start}&end=${end}&e=${allEventsParam}`, authHeader, "event segmentation"),
+    amplitudeFetch(`${baseUrl}/retention?se=${allEventsParam}&re=${allEventsParam}&start=${start}&end=${end}`, authHeader, "retention"),
+    amplitudeFetch(`${baseUrl}/sessions/average?start=${start}&end=${end}`, authHeader, "user sessions")
+  ]);
+  const settled = [activeUsers, eventSegmentation, retention, userSessions];
+  const labels = ["active users", "event segmentation", "retention", "user sessions"];
+  if (settled.every((r) => r.status === "rejected")) {
+    throw settled[0].reason;
+  }
+  const extract = (result, label2) => {
+    if (result.status === "fulfilled")
+      return result.value;
+    logger2.warn(`Failed to fetch ${label2}`, { error: String(result.reason) });
+    return null;
+  };
+  return {
+    activeUsers: extract(activeUsers, labels[0]),
+    eventSegmentation: extract(eventSegmentation, labels[1]),
+    retention: extract(retention, labels[2]),
+    userSessions: extract(userSessions, labels[3]),
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lookbackDays
+  };
+}
+var logger2;
+var init_amplitude_client = __esm({
+  "../core/dist/analytics/amplitude-client.js"() {
+    "use strict";
+    init_logger();
+    logger2 = createLogger("amplitude-client");
+  }
+});
+
+// ../core/dist/analytics/analytics-runner.js
+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("]");
+  if (start === -1 || end === -1 || end <= start)
+    return [];
+  try {
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.title === "string" && typeof item.body === "string");
+  } catch {
+    logger3.warn("Failed to parse AI response as JSON");
+    return [];
+  }
+}
+async function runAnalytics(config, projectDir) {
+  const apiKey = config.providerEnv?.AMPLITUDE_API_KEY;
+  const secretKey = config.providerEnv?.AMPLITUDE_SECRET_KEY;
+  if (!apiKey || !secretKey) {
+    throw new Error("AMPLITUDE_API_KEY and AMPLITUDE_SECRET_KEY must be set in providerEnv to run analytics");
+  }
+  logger3.info("Fetching Amplitude data", { lookbackDays: config.analytics.lookbackDays });
+  const data = await fetchAmplitudeData(apiKey, secretKey, config.analytics.lookbackDays);
+  const systemPrompt = config.analytics.analysisPrompt?.trim() || DEFAULT_ANALYTICS_PROMPT;
+  const prompt2 = `${systemPrompt}
+
+--- AMPLITUDE DATA ---
+${JSON.stringify(data, null, 2)}`;
+  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];
+    let scriptContent;
+    if (provider === "claude") {
+      const modelId = CLAUDE_MODEL_IDS[config.claudeModel ?? "sonnet"];
+      scriptContent = `#!/usr/bin/env bash
+set -euo pipefail
+${providerCmd} -p "$(cat ${promptFile})" --model ${modelId} --dangerously-skip-permissions 2>&1
+`;
+    } else {
+      scriptContent = `#!/usr/bin/env bash
+set -euo pipefail
+${providerCmd} exec --yolo "$(cat ${promptFile})" 2>&1
+`;
+    }
+    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}`);
+    }
+    const fullOutput = `${stdout}
+${stderr}`;
+    const issues = parseIssuesFromResponse(fullOutput);
+    if (issues.length === 0) {
+      logger3.info("No actionable insights found");
+      return { issuesCreated: 0, summary: "No actionable insights found" };
+    }
+    const boardProvider = createBoardProvider(config.boardProvider, projectDir);
+    const targetColumn = config.analytics.targetColumn;
+    let created = 0;
+    for (const issue of issues) {
+      try {
+        await boardProvider.createIssue({
+          title: issue.title,
+          body: issue.body,
+          column: targetColumn,
+          labels: issue.labels ?? ["analytics"]
+        });
+        created++;
+        logger3.info("Created board issue", { title: issue.title, column: targetColumn });
+      } catch (err) {
+        logger3.error("Failed to create board issue", {
+          title: issue.title,
+          error: String(err)
+        });
+      }
+    }
+    return {
+      issuesCreated: created,
+      summary: `Created ${created} issue(s) from analytics insights`
+    };
+  } finally {
+    try {
+      fs19.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+var logger3;
+var init_analytics_runner = __esm({
+  "../core/dist/analytics/analytics-runner.js"() {
+    "use strict";
+    init_factory();
+    init_config();
+    init_constants();
+    init_shell();
+    init_logger();
+    init_amplitude_client();
+    logger3 = createLogger("analytics");
+  }
+});
+
+// ../core/dist/analytics/index.js
+var init_analytics = __esm({
+  "../core/dist/analytics/index.js"() {
+    "use strict";
+    init_amplitude_client();
+    init_analytics_runner();
+  }
+});
+
 // ../core/dist/templates/prd-template.js
 function renderDependsOn(deps) {
   if (deps.length === 0) {
@@ -6608,6 +6989,7 @@ sequenceDiagram
 // ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  ANALYTICS_LOG_NAME: () => ANALYTICS_LOG_NAME,
   AUDIT_LOG_NAME: () => AUDIT_LOG_NAME,
   BOARD_COLUMNS: () => BOARD_COLUMNS,
   BUILT_IN_PRESETS: () => BUILT_IN_PRESETS,
@@ -6619,6 +7001,13 @@ __export(dist_exports, {
   CONFIG_FILE_NAME: () => CONFIG_FILE_NAME,
   CRONTAB_MARKER_PREFIX: () => CRONTAB_MARKER_PREFIX,
   DATABASE_TOKEN: () => DATABASE_TOKEN,
+  DEFAULT_ANALYTICS: () => DEFAULT_ANALYTICS,
+  DEFAULT_ANALYTICS_ENABLED: () => DEFAULT_ANALYTICS_ENABLED,
+  DEFAULT_ANALYTICS_LOOKBACK_DAYS: () => DEFAULT_ANALYTICS_LOOKBACK_DAYS,
+  DEFAULT_ANALYTICS_MAX_RUNTIME: () => DEFAULT_ANALYTICS_MAX_RUNTIME,
+  DEFAULT_ANALYTICS_PROMPT: () => DEFAULT_ANALYTICS_PROMPT,
+  DEFAULT_ANALYTICS_SCHEDULE: () => DEFAULT_ANALYTICS_SCHEDULE,
+  DEFAULT_ANALYTICS_TARGET_COLUMN: () => DEFAULT_ANALYTICS_TARGET_COLUMN,
   DEFAULT_AUDIT: () => DEFAULT_AUDIT,
   DEFAULT_AUDIT_ENABLED: () => DEFAULT_AUDIT_ENABLED,
   DEFAULT_AUDIT_MAX_RUNTIME: () => DEFAULT_AUDIT_MAX_RUNTIME,
@@ -6674,6 +7063,7 @@ __export(dist_exports, {
   EXECUTOR_LOG_FILE: () => EXECUTOR_LOG_FILE,
   EXECUTOR_LOG_NAME: () => EXECUTOR_LOG_NAME,
   GLOBAL_CONFIG_DIR: () => GLOBAL_CONFIG_DIR,
+  GLOBAL_NOTIFICATIONS_FILE_NAME: () => GLOBAL_NOTIFICATIONS_FILE_NAME,
   HISTORY_FILE_NAME: () => HISTORY_FILE_NAME,
   HORIZON_LABELS: () => HORIZON_LABELS,
   HORIZON_LABEL_INFO: () => HORIZON_LABEL_INFO,
@@ -6705,6 +7095,7 @@ __export(dist_exports, {
   acquireLock: () => acquireLock,
   addDelayToIsoString: () => addDelayToIsoString,
   addEntry: () => addEntry,
+  analyticsLockPath: () => analyticsLockPath,
   auditLockPath: () => auditLockPath,
   buildDescription: () => buildDescription,
   calculateStringSimilarity: () => calculateStringSimilarity,
@@ -6755,6 +7146,7 @@ __export(dist_exports, {
   extractPriority: () => extractPriority,
   extractQaScreenshotUrls: () => extractQaScreenshotUrls,
   extractSummary: () => extractSummary,
+  fetchAmplitudeData: () => fetchAmplitudeData,
   fetchLatestQaCommentBody: () => fetchLatestQaCommentBody,
   fetchPrDetails: () => fetchPrDetails,
   fetchPrDetailsByNumber: () => fetchPrDetailsByNumber,
@@ -6825,6 +7217,7 @@ __export(dist_exports, {
   label: () => label,
   listPrdStatesByStatus: () => listPrdStatesByStatus,
   loadConfig: () => loadConfig,
+  loadGlobalNotificationsConfig: () => loadGlobalNotificationsConfig,
   loadHistory: () => loadHistory,
   loadRegistry: () => loadRegistry,
   loadRoadmapState: () => loadRoadmapState,
@@ -6862,8 +7255,10 @@ __export(dist_exports, {
   reviewerLockPath: () => reviewerLockPath,
   rotateLog: () => rotateLog,
   runAllChecks: () => runAllChecks,
+  runAnalytics: () => runAnalytics,
   runMigrations: () => runMigrations,
   saveConfig: () => saveConfig,
+  saveGlobalNotificationsConfig: () => saveGlobalNotificationsConfig,
   saveHistory: () => saveHistory,
   saveRegistry: () => saveRegistry,
   saveRoadmapState: () => saveRoadmapState,
@@ -6913,6 +7308,7 @@ var init_dist = __esm({
     init_git_utils();
     init_github();
     init_log_utils();
+    init_global_config();
     init_notify();
     init_prd_discovery();
     init_prd_states();
@@ -6930,6 +7326,7 @@ var init_dist = __esm({
     init_webhook_validator();
     init_worktree_manager();
     init_job_queue();
+    init_analytics();
     init_prd_template();
     init_slicer_prompt();
   }
@@ -6938,39 +7335,39 @@ var init_dist = __esm({
 // src/cli.ts
 import "reflect-metadata";
 import { Command as Command3 } from "commander";
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync19 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname8, join as join34 } from "path";
+import { dirname as dirname9, join as join36 } from "path";
 
 // src/commands/init.ts
 init_dist();
-import fs18 from "fs";
-import path18 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 join16 } 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 = join16(d, "templates");
-    if (fs18.existsSync(candidate) && fs18.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 join16(startDir, "templates");
+  return join18(startDir, "templates");
 }
 var TEMPLATES_DIR = findTemplatesDir(__dirname2);
 function hasPlaywrightDependency(cwd) {
-  const packageJsonPath = path18.join(cwd, "package.json");
-  if (!fs18.existsSync(packageJsonPath)) {
+  const packageJsonPath = path20.join(cwd, "package.json");
+  if (!fs20.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson2 = JSON.parse(fs18.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
     );
@@ -6982,7 +7379,7 @@ function detectPlaywright(cwd) {
   if (hasPlaywrightDependency(cwd)) {
     return true;
   }
-  if (fs18.existsSync(path18.join(cwd, "node_modules", ".bin", "playwright"))) {
+  if (fs20.existsSync(path20.join(cwd, "node_modules", ".bin", "playwright"))) {
     return true;
   }
   try {
@@ -6998,10 +7395,10 @@ function detectPlaywright(cwd) {
   }
 }
 function resolvePlaywrightInstallCommand(cwd) {
-  if (fs18.existsSync(path18.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs20.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm add -D @playwright/test";
   }
-  if (fs18.existsSync(path18.join(cwd, "yarn.lock"))) {
+  if (fs20.existsSync(path20.join(cwd, "yarn.lock"))) {
     return "yarn add -D @playwright/test";
   }
   return "npm install -D @playwright/test";
@@ -7147,8 +7544,8 @@ function promptProviderSelection(providers) {
   });
 }
 function ensureDir(dirPath) {
-  if (!fs18.existsSync(dirPath)) {
-    fs18.mkdirSync(dirPath, { recursive: true });
+  if (!fs20.existsSync(dirPath)) {
+    fs20.mkdirSync(dirPath, { recursive: true });
   }
 }
 function buildInitConfig(params) {
@@ -7195,6 +7592,7 @@ function buildInitConfig(params) {
       branchPatterns: [...defaults.qa.branchPatterns]
     },
     audit: { ...defaults.audit },
+    analytics: { ...defaults.analytics },
     jobProviders: { ...defaults.jobProviders },
     queue: {
       ...defaults.queue,
@@ -7204,30 +7602,30 @@ function buildInitConfig(params) {
 }
 function resolveTemplatePath(templateName, customTemplatesDir, bundledTemplatesDir) {
   if (customTemplatesDir !== null) {
-    const customPath = join16(customTemplatesDir, templateName);
-    if (fs18.existsSync(customPath)) {
+    const customPath = join18(customTemplatesDir, templateName);
+    if (fs20.existsSync(customPath)) {
       return { path: customPath, source: "custom" };
     }
   }
-  return { path: join16(bundledTemplatesDir, templateName), source: "bundled" };
+  return { path: join18(bundledTemplatesDir, templateName), source: "bundled" };
 }
 function processTemplate(templateName, targetPath, replacements, force, sourcePath, source) {
-  if (fs18.existsSync(targetPath) && !force) {
+  if (fs20.existsSync(targetPath) && !force) {
     console.log(`  Skipped (exists): ${targetPath}`);
     return { created: false, source: source ?? "bundled" };
   }
-  const templatePath = sourcePath ?? join16(TEMPLATES_DIR, templateName);
+  const templatePath = sourcePath ?? join18(TEMPLATES_DIR, templateName);
   const resolvedSource = source ?? "bundled";
-  let content = fs18.readFileSync(templatePath, "utf-8");
+  let content = fs20.readFileSync(templatePath, "utf-8");
   for (const [key, value] of Object.entries(replacements)) {
     content = content.replaceAll(key, value);
   }
-  fs18.writeFileSync(targetPath, content);
+  fs20.writeFileSync(targetPath, content);
   console.log(`  Created: ${targetPath} (${resolvedSource})`);
   return { created: true, source: resolvedSource };
 }
 function addToGitignore(cwd) {
-  const gitignorePath = path18.join(cwd, ".gitignore");
+  const gitignorePath = path20.join(cwd, ".gitignore");
   const entries = [
     {
       pattern: "/logs/",
@@ -7241,13 +7639,13 @@ function addToGitignore(cwd) {
     },
     { pattern: "*.claim", label: "*.claim", check: (c) => c.includes("*.claim") }
   ];
-  if (!fs18.existsSync(gitignorePath)) {
+  if (!fs20.existsSync(gitignorePath)) {
     const lines = ["# Night Watch", ...entries.map((e) => e.pattern), ""];
-    fs18.writeFileSync(gitignorePath, lines.join("\n"));
+    fs20.writeFileSync(gitignorePath, lines.join("\n"));
     console.log(`  Created: ${gitignorePath} (with Night Watch entries)`);
     return;
   }
-  const content = fs18.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`);
@@ -7255,7 +7653,7 @@ function addToGitignore(cwd) {
   }
   const additions = missing.map((e) => e.pattern).join("\n");
   const newContent = content.trimEnd() + "\n\n# Night Watch\n" + additions + "\n";
-  fs18.writeFileSync(gitignorePath, newContent);
+  fs20.writeFileSync(gitignorePath, newContent);
   console.log(`  Updated: ${gitignorePath} (added ${missing.map((e) => e.label).join(", ")})`);
 }
 function initCommand(program2) {
@@ -7376,28 +7774,28 @@ function initCommand(program2) {
       "${DEFAULT_BRANCH}": defaultBranch
     };
     step(6, totalSteps, "Creating PRD directory structure...");
-    const prdDirPath = path18.join(cwd, prdDir);
-    const doneDirPath = path18.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 = path18.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 = path18.join(cwd, "instructions");
+    const instructionsDir = path20.join(cwd, "instructions");
     ensureDir(instructionsDir);
     success(`Created ${instructionsDir}/`);
     const existingConfig = loadConfig(cwd);
-    const customTemplatesDirPath = path18.join(cwd, existingConfig.templatesDir);
-    const customTemplatesDir = fs18.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",
-      path18.join(instructionsDir, "executor.md"),
+      path20.join(instructionsDir, "executor.md"),
       replacements,
       force,
       nwResolution.path,
@@ -7411,7 +7809,7 @@ function initCommand(program2) {
     );
     const peResult = processTemplate(
       "prd-executor.md",
-      path18.join(instructionsDir, "prd-executor.md"),
+      path20.join(instructionsDir, "prd-executor.md"),
       replacements,
       force,
       peResolution.path,
@@ -7421,7 +7819,7 @@ function initCommand(program2) {
     const prResolution = resolveTemplatePath("pr-reviewer.md", customTemplatesDir, TEMPLATES_DIR);
     const prResult = processTemplate(
       "pr-reviewer.md",
-      path18.join(instructionsDir, "pr-reviewer.md"),
+      path20.join(instructionsDir, "pr-reviewer.md"),
       replacements,
       force,
       prResolution.path,
@@ -7431,7 +7829,7 @@ function initCommand(program2) {
     const qaResolution = resolveTemplatePath("qa.md", customTemplatesDir, TEMPLATES_DIR);
     const qaResult = processTemplate(
       "qa.md",
-      path18.join(instructionsDir, "qa.md"),
+      path20.join(instructionsDir, "qa.md"),
       replacements,
       force,
       qaResolution.path,
@@ -7441,7 +7839,7 @@ function initCommand(program2) {
     const auditResolution = resolveTemplatePath("audit.md", customTemplatesDir, TEMPLATES_DIR);
     const auditResult = processTemplate(
       "audit.md",
-      path18.join(instructionsDir, "audit.md"),
+      path20.join(instructionsDir, "audit.md"),
       replacements,
       force,
       auditResolution.path,
@@ -7449,8 +7847,8 @@ function initCommand(program2) {
     );
     templateSources.push({ name: "audit.md", source: auditResult.source });
     step(9, totalSteps, "Creating configuration file...");
-    const configPath = path18.join(cwd, CONFIG_FILE_NAME);
-    if (fs18.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({
@@ -7460,11 +7858,11 @@ function initCommand(program2) {
         reviewerEnabled,
         prdDir
       });
-      fs18.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(fs18.readFileSync(configPath, "utf-8"));
+    const existingRaw = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
     const existingBoard = existingRaw.boardProvider;
     let boardSetupStatus = "Skipped";
     if (existingBoard?.projectNumber && !force) {
@@ -7486,13 +7884,13 @@ function initCommand(program2) {
           const provider = createBoardProvider({ enabled: true, provider: "github" }, cwd);
           const boardTitle = `${projectName} Night Watch`;
           const board = await provider.setupBoard(boardTitle);
-          const rawConfig = JSON.parse(fs18.readFileSync(configPath, "utf-8"));
+          const rawConfig = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
           rawConfig.boardProvider = {
             enabled: true,
             provider: "github",
             projectNumber: board.number
           };
-          fs18.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) {
@@ -7616,8 +8014,8 @@ function getTelegramStatusWebhooks(config) {
 }
 
 // src/commands/run.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path21 from "path";
 function resolveRunNotificationEvent(exitCode, scriptStatus) {
   if (exitCode === 124) {
     return "run_timeout";
@@ -7649,12 +8047,12 @@ function shouldAttemptCrossProjectFallback(options, scriptStatus) {
   return scriptStatus === "skip_no_eligible_prd";
 }
 function getCrossProjectFallbackCandidates(currentProjectDir) {
-  const current = path19.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) => path19.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)) {
@@ -7664,7 +8062,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     if (nonTelegramWebhooks.length > 0) {
       const _rateLimitCtx = {
         event: "rate_limit_fallback",
-        projectName: path19.basename(projectDir),
+        projectName: path21.basename(projectDir),
         exitCode,
         provider: config.provider
       };
@@ -7692,7 +8090,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     const timeoutDuration = event === "run_timeout" ? config.maxRuntime : void 0;
     const _ctx = {
       event,
-      projectName: path19.basename(projectDir),
+      projectName: path21.basename(projectDir),
       exitCode,
       provider: config.provider,
       prdName: scriptResult?.data.prd,
@@ -7854,20 +8252,20 @@ function applyCliOverrides(config, options) {
   return overridden;
 }
 function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
-  const absolutePrdDir = path19.join(projectDir, prdDir);
-  const doneDir = path19.join(absolutePrdDir, "done");
+  const absolutePrdDir = path21.join(projectDir, prdDir);
+  const doneDir = path21.join(absolutePrdDir, "done");
   const pending = [];
   const completed = [];
-  if (fs19.existsSync(absolutePrdDir)) {
-    const entries = fs19.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 = path19.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
+        const claimPath = path21.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
         let claimed = false;
         let claimInfo = null;
-        if (fs19.existsSync(claimPath)) {
+        if (fs21.existsSync(claimPath)) {
           try {
-            const content = fs19.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) {
@@ -7881,8 +8279,8 @@ function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
       }
     }
   }
-  if (fs19.existsSync(doneDir)) {
-    const entries = fs19.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);
@@ -8042,7 +8440,7 @@ ${stderr}`);
 // src/commands/review.ts
 init_dist();
 import { execFileSync as execFileSync5 } from "child_process";
-import * as path20 from "path";
+import * as path22 from "path";
 function shouldSendReviewNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -8282,7 +8680,7 @@ ${stderr}`);
           const finalScore = parseFinalReviewScore(scriptResult?.data.final_score);
           const _reviewCtx = {
             event: "review_completed",
-            projectName: path20.basename(projectDir),
+            projectName: path22.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prUrl: prDetails?.url,
@@ -8303,7 +8701,7 @@ ${stderr}`);
           const autoMergedPrDetails = fetchPrDetailsByNumber(autoMergedPrNumber, projectDir);
           const _mergeCtx = {
             event: "pr_auto_merged",
-            projectName: path20.basename(projectDir),
+            projectName: path22.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: autoMergedPrDetails?.number ?? autoMergedPrNumber,
@@ -8328,7 +8726,7 @@ ${stderr}`);
 
 // src/commands/qa.ts
 init_dist();
-import * as path21 from "path";
+import * as path23 from "path";
 function shouldSendQaNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -8462,7 +8860,7 @@ ${stderr}`);
           const qaScreenshotUrls = primaryQaPr !== void 0 ? fetchQaScreenshotUrlsForPr(primaryQaPr, projectDir, repo) : [];
           const _qaCtx = {
             event: "qa_completed",
-            projectName: path21.basename(projectDir),
+            projectName: path23.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: prDetails?.number ?? primaryQaPr,
@@ -8488,8 +8886,8 @@ ${stderr}`);
 
 // src/commands/audit.ts
 init_dist();
-import * as fs20 from "fs";
-import * as path22 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);
@@ -8532,7 +8930,7 @@ function auditCommand(program2) {
       configTable.push(["Provider", auditProvider]);
       configTable.push(["Provider CLI", PROVIDER_COMMANDS[auditProvider]]);
       configTable.push(["Max Runtime", `${config.audit.maxRuntime}s`]);
-      configTable.push(["Report File", path22.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];
@@ -8567,8 +8965,8 @@ ${stderr}`);
         } else if (scriptResult?.status?.startsWith("skip_")) {
           spinner.succeed("Code audit skipped");
         } else {
-          const reportPath = path22.join(projectDir, "logs", "audit-report.md");
-          if (!fs20.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);
           }
@@ -8579,9 +8977,9 @@ ${stderr}`);
         const providerExit = scriptResult?.data?.provider_exit;
         const exitDetail = providerExit && providerExit !== String(exitCode) ? `, provider exit ${providerExit}` : "";
         spinner.fail(`Code audit exited with code ${exitCode}${statusSuffix}${exitDetail}`);
-        const logPath = path22.join(projectDir, "logs", "audit.log");
-        if (fs20.existsSync(logPath)) {
-          const logLines = fs20.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");
           }
@@ -8595,19 +8993,80 @@ ${stderr}`);
   });
 }
 
+// src/commands/analytics.ts
+init_dist();
+function analyticsCommand(program2) {
+  program2.command("analytics").description("Run Amplitude analytics job now").option("--dry-run", "Show what would be executed without running").option("--timeout <seconds>", "Override max runtime in seconds").option("--provider <string>", "AI provider to use (claude or codex)").action(async (options) => {
+    const projectDir = process.cwd();
+    let config = loadConfig(projectDir);
+    if (options.timeout) {
+      const timeout = parseInt(options.timeout, 10);
+      if (!isNaN(timeout)) {
+        config = { ...config, analytics: { ...config.analytics, maxRuntime: timeout } };
+      }
+    }
+    if (options.provider) {
+      config = {
+        ...config,
+        _cliProviderOverride: options.provider
+      };
+    }
+    if (!config.analytics.enabled && !options.dryRun) {
+      info("Analytics is disabled in config; skipping run.");
+      process.exit(0);
+    }
+    const apiKey = config.providerEnv?.AMPLITUDE_API_KEY;
+    const secretKey = config.providerEnv?.AMPLITUDE_SECRET_KEY;
+    if (!apiKey || !secretKey) {
+      info(
+        "AMPLITUDE_API_KEY and AMPLITUDE_SECRET_KEY must be set in providerEnv to run analytics."
+      );
+      process.exit(1);
+    }
+    if (options.dryRun) {
+      header("Dry Run: Analytics Job");
+      const analyticsProvider = resolveJobProvider(config, "analytics");
+      header("Configuration");
+      const configTable = createTable({ head: ["Setting", "Value"] });
+      configTable.push(["Provider", analyticsProvider]);
+      configTable.push(["Max Runtime", `${config.analytics.maxRuntime}s`]);
+      configTable.push(["Lookback Days", String(config.analytics.lookbackDays)]);
+      configTable.push(["Target Column", config.analytics.targetColumn]);
+      configTable.push(["Amplitude API Key", apiKey ? "***" + apiKey.slice(-4) : "not set"]);
+      console.log(configTable.toString());
+      console.log();
+      process.exit(0);
+    }
+    const spinner = createSpinner("Running analytics job...");
+    spinner.start();
+    try {
+      await maybeApplyCronSchedulingDelay(config, "analytics", projectDir);
+      const result = await runAnalytics(config, projectDir);
+      if (result.issuesCreated > 0) {
+        spinner.succeed(`Analytics complete \u2014 ${result.summary}`);
+      } else {
+        spinner.succeed("Analytics complete \u2014 no actionable insights found");
+      }
+    } catch (err) {
+      spinner.fail(`Analytics failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/install.ts
 init_dist();
 import { execSync as execSync4 } from "child_process";
-import * as path23 from "path";
-import * as fs21 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 = path23.join(npmBin, "night-watch");
-    if (fs21.existsSync(binPath)) {
+    const binPath = path25.join(npmBin, "night-watch");
+    if (fs23.existsSync(binPath)) {
       return binPath;
     }
   } catch {
@@ -8620,17 +9079,17 @@ function getNightWatchBinPath() {
 }
 function getNodeBinDir() {
   if (process.execPath && process.execPath !== "node") {
-    return path23.dirname(process.execPath);
+    return path25.dirname(process.execPath);
   }
   try {
     const nodePath = execSync4("which node", { encoding: "utf-8" }).trim();
-    return path23.dirname(nodePath);
+    return path25.dirname(nodePath);
   } catch {
     return "";
   }
 }
 function buildCronPathPrefix(nodeBinDir, nightWatchBin) {
-  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path23.dirname(nightWatchBin) : "";
+  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path25.dirname(nightWatchBin) : "";
   const pathParts = Array.from(
     new Set([nodeBinDir, nightWatchBinDir].filter((part) => part.length > 0))
   );
@@ -8646,12 +9105,12 @@ function performInstall(projectDir, config, options) {
     const nightWatchBin = getNightWatchBinPath();
     const projectName = getProjectName(projectDir);
     const marker = generateMarker(projectName);
-    const logDir = path23.join(projectDir, LOG_DIR);
-    if (!fs21.existsSync(logDir)) {
-      fs21.mkdirSync(logDir, { recursive: true });
+    const logDir = path25.join(projectDir, LOG_DIR);
+    if (!fs23.existsSync(logDir)) {
+      fs23.mkdirSync(logDir, { recursive: true });
     }
-    const executorLog = path23.join(logDir, "executor.log");
-    const reviewerLog = path23.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)])
@@ -8688,7 +9147,7 @@ function performInstall(projectDir, config, options) {
     const installSlicer = options?.noSlicer === true ? false : config.roadmapScanner.enabled;
     if (installSlicer) {
       const slicerSchedule = config.roadmapScanner.slicerSchedule;
-      const slicerLog = path23.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);
     }
@@ -8696,7 +9155,7 @@ function performInstall(projectDir, config, options) {
     const installQa = disableQa ? false : config.qa.enabled;
     if (installQa) {
       const qaSchedule = config.qa.schedule;
-      const qaLog = path23.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);
     }
@@ -8704,10 +9163,18 @@ function performInstall(projectDir, config, options) {
     const installAudit = disableAudit ? false : config.audit.enabled;
     if (installAudit) {
       const auditSchedule = config.audit.schedule;
-      const auditLog = path23.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);
     }
+    const disableAnalytics = options?.noAnalytics === true || options?.analytics === false;
+    const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
+    if (installAnalytics) {
+      const analyticsSchedule = config.analytics.schedule;
+      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);
+    }
     const existingEntries = new Set(
       Array.from(/* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)]))
     );
@@ -8726,7 +9193,7 @@ function performInstall(projectDir, config, options) {
   }
 }
 function installCommand(program2) {
-  program2.command("install").description("Add crontab entries for automated execution").option("-s, --schedule <cron>", "Cron schedule for PRD executor").option("--reviewer-schedule <cron>", "Cron schedule for reviewer").option("--no-reviewer", "Skip installing reviewer cron").option("--no-slicer", "Skip installing slicer cron").option("--no-qa", "Skip installing QA cron").option("--no-audit", "Skip installing audit cron").option("-f, --force", "Replace existing cron entries for this project").action(async (options) => {
+  program2.command("install").description("Add crontab entries for automated execution").option("-s, --schedule <cron>", "Cron schedule for PRD executor").option("--reviewer-schedule <cron>", "Cron schedule for reviewer").option("--no-reviewer", "Skip installing reviewer cron").option("--no-slicer", "Skip installing slicer cron").option("--no-qa", "Skip installing QA cron").option("--no-audit", "Skip installing audit cron").option("--no-analytics", "Skip installing analytics cron").option("-f, --force", "Replace existing cron entries for this project").action(async (options) => {
     try {
       const projectDir = process.cwd();
       const config = loadConfig(projectDir);
@@ -8735,12 +9202,12 @@ function installCommand(program2) {
       const nightWatchBin = getNightWatchBinPath();
       const projectName = getProjectName(projectDir);
       const marker = generateMarker(projectName);
-      const logDir = path23.join(projectDir, LOG_DIR);
-      if (!fs21.existsSync(logDir)) {
-        fs21.mkdirSync(logDir, { recursive: true });
+      const logDir = path25.join(projectDir, LOG_DIR);
+      if (!fs23.existsSync(logDir)) {
+        fs23.mkdirSync(logDir, { recursive: true });
       }
-      const executorLog = path23.join(logDir, "executor.log");
-      const reviewerLog = path23.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)])
       );
@@ -8776,7 +9243,7 @@ function installCommand(program2) {
       const installSlicer = options.noSlicer === true ? false : config.roadmapScanner.enabled;
       let slicerLog;
       if (installSlicer) {
-        slicerLog = path23.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);
@@ -8785,7 +9252,7 @@ function installCommand(program2) {
       const installQa = disableQa ? false : config.qa.enabled;
       let qaLog;
       if (installQa) {
-        qaLog = path23.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);
@@ -8794,11 +9261,20 @@ function installCommand(program2) {
       const installAudit = disableAudit ? false : config.audit.enabled;
       let auditLog;
       if (installAudit) {
-        auditLog = path23.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);
       }
+      const disableAnalytics = options.noAnalytics === true || options.analytics === false;
+      const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
+      let analyticsLog;
+      if (installAnalytics) {
+        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);
+      }
       const existingEntrySet = new Set(existingEntries);
       const currentCrontab = readCrontab();
       const baseCrontab = options.force ? currentCrontab.filter((line) => !existingEntrySet.has(line) && !line.includes(marker)) : currentCrontab;
@@ -8825,6 +9301,9 @@ function installCommand(program2) {
       if (installAudit && auditLog) {
         dim(`  Audit: ${auditLog}`);
       }
+      if (installAnalytics && analyticsLog) {
+        dim(`  Analytics: ${analyticsLog}`);
+      }
       console.log();
       dim("To uninstall, run: night-watch uninstall");
       dim("To check status, run: night-watch status");
@@ -8839,8 +9318,8 @@ function installCommand(program2) {
 
 // src/commands/uninstall.ts
 init_dist();
-import * as path24 from "path";
-import * as fs22 from "fs";
+import * as path26 from "path";
+import * as fs24 from "fs";
 function performUninstall(projectDir, options) {
   try {
     const projectName = getProjectName(projectDir);
@@ -8855,19 +9334,19 @@ function performUninstall(projectDir, options) {
     const removedCount = removeEntriesForProject(projectDir, marker);
     unregisterProject(projectDir);
     if (!options?.keepLogs) {
-      const logDir = path24.join(projectDir, "logs");
-      if (fs22.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 = path24.join(logDir, logFile);
-          if (fs22.existsSync(logPath)) {
-            fs22.unlinkSync(logPath);
+          const logPath = path26.join(logDir, logFile);
+          if (fs24.existsSync(logPath)) {
+            fs24.unlinkSync(logPath);
           }
         });
         try {
-          const remainingFiles = fs22.readdirSync(logDir);
+          const remainingFiles = fs24.readdirSync(logDir);
           if (remainingFiles.length === 0) {
-            fs22.rmdirSync(logDir);
+            fs24.rmdirSync(logDir);
           }
         } catch {
         }
@@ -8900,21 +9379,21 @@ function uninstallCommand(program2) {
       existingEntries.forEach((entry) => dim(`  ${entry}`));
       const removedCount = removeEntriesForProject(projectDir, marker);
       if (!options.keepLogs) {
-        const logDir = path24.join(projectDir, "logs");
-        if (fs22.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 = path24.join(logDir, logFile);
-            if (fs22.existsSync(logPath)) {
-              fs22.unlinkSync(logPath);
+            const logPath = path26.join(logDir, logFile);
+            if (fs24.existsSync(logPath)) {
+              fs24.unlinkSync(logPath);
               logsRemoved++;
             }
           });
           try {
-            const remainingFiles = fs22.readdirSync(logDir);
+            const remainingFiles = fs24.readdirSync(logDir);
             if (remainingFiles.length === 0) {
-              fs22.rmdirSync(logDir);
+              fs24.rmdirSync(logDir);
             }
           } catch {
           }
@@ -9150,14 +9629,14 @@ function statusCommand(program2) {
 // src/commands/logs.ts
 init_dist();
 import { spawn as spawn3 } from "child_process";
-import * as path25 from "path";
-import * as fs23 from "fs";
+import * as path27 from "path";
+import * as fs25 from "fs";
 function getLastLines(filePath, lineCount) {
-  if (!fs23.existsSync(filePath)) {
+  if (!fs25.existsSync(filePath)) {
     return `Log file not found: ${filePath}`;
   }
   try {
-    const content = fs23.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) {
@@ -9165,7 +9644,7 @@ function getLastLines(filePath, lineCount) {
   }
 }
 function followLog(filePath) {
-  if (!fs23.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;
@@ -9185,13 +9664,13 @@ function logsCommand(program2) {
   program2.command("logs").description("View night-watch log output").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output (tail -f)").option("-t, --type <type>", "Log type to view (executor|reviewer|qa|audit|planner|all)", "all").action(async (options) => {
     try {
       const projectDir = process.cwd();
-      const logDir = path25.join(projectDir, LOG_DIR);
+      const logDir = path27.join(projectDir, LOG_DIR);
       const lineCount = parseInt(options.lines || "50", 10);
-      const executorLog = path25.join(logDir, EXECUTOR_LOG_FILE);
-      const reviewerLog = path25.join(logDir, REVIEWER_LOG_FILE);
-      const qaLog = path25.join(logDir, `${QA_LOG_NAME}.log`);
-      const auditLog = path25.join(logDir, `${AUDIT_LOG_NAME}.log`);
-      const plannerLog = path25.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";
@@ -9255,15 +9734,15 @@ function logsCommand(program2) {
 
 // src/commands/prd.ts
 init_dist();
-import * as fs24 from "fs";
-import * as path26 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 (!fs24.existsSync(prdDir)) return 1;
-  const files = fs24.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;
@@ -9284,10 +9763,10 @@ function parseDependencies(content) {
 }
 function isClaimActive(claimPath, maxRuntime) {
   try {
-    if (!fs24.existsSync(claimPath)) {
+    if (!fs26.existsSync(claimPath)) {
       return { active: false };
     }
-    const content = fs24.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) {
@@ -9303,9 +9782,9 @@ function prdCommand(program2) {
   prd.command("create").description("Generate a new PRD markdown file from template").argument("<name>", "PRD name (used for title and filename)").option("-i, --interactive", "Prompt for complexity, dependencies, and phase count", false).option("-t, --template <path>", "Path to a custom template file").option("--deps <files>", "Comma-separated dependency filenames").option("--phases <count>", "Number of execution phases", "3").option("--no-number", "Skip auto-numbering prefix").action(async (name, options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const prdDir = path26.join(projectDir, config.prdDir);
-    if (!fs24.existsSync(prdDir)) {
-      fs24.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 = [];
@@ -9364,20 +9843,20 @@ function prdCommand(program2) {
     } else {
       filename = `${slug}.md`;
     }
-    const filePath = path26.join(prdDir, filename);
-    if (fs24.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 = path26.resolve(options.template);
-      if (!fs24.existsSync(templatePath)) {
+      const templatePath = path28.resolve(options.template);
+      if (!fs26.existsSync(templatePath)) {
         error(`Template file not found: ${templatePath}`);
         process.exit(1);
       }
-      customTemplate = fs24.readFileSync(templatePath, "utf-8");
+      customTemplate = fs26.readFileSync(templatePath, "utf-8");
     }
     const vars = {
       title: name,
@@ -9388,7 +9867,7 @@ function prdCommand(program2) {
       phaseCount
     };
     const content = renderPrdTemplate(vars, customTemplate);
-    fs24.writeFileSync(filePath, content, "utf-8");
+    fs26.writeFileSync(filePath, content, "utf-8");
     header("PRD Created");
     success(`Created: ${filePath}`);
     info(`Title: ${name}`);
@@ -9400,15 +9879,15 @@ function prdCommand(program2) {
   prd.command("list").description("List all PRDs with status").option("--json", "Output as JSON").action(async (options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
-    const absolutePrdDir = path26.join(projectDir, config.prdDir);
-    const doneDir = path26.join(absolutePrdDir, "done");
+    const absolutePrdDir = path28.join(projectDir, config.prdDir);
+    const doneDir = path28.join(absolutePrdDir, "done");
     const pending = [];
-    if (fs24.existsSync(absolutePrdDir)) {
-      const files = fs24.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 = fs24.readFileSync(path26.join(absolutePrdDir, file), "utf-8");
+        const content = fs26.readFileSync(path28.join(absolutePrdDir, file), "utf-8");
         const deps = parseDependencies(content);
-        const claimPath = path26.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,
@@ -9419,10 +9898,10 @@ function prdCommand(program2) {
       }
     }
     const done = [];
-    if (fs24.existsSync(doneDir)) {
-      const files = fs24.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 = fs24.readFileSync(path26.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 });
       }
@@ -9461,7 +9940,7 @@ import blessed6 from "blessed";
 // src/commands/dashboard/tab-status.ts
 init_dist();
 import blessed from "blessed";
-import * as fs25 from "fs";
+import * as fs27 from "fs";
 function sortPrdsByPriority(prds, priority) {
   if (priority.length === 0) return prds;
   const priorityMap = /* @__PURE__ */ new Map();
@@ -9557,7 +10036,7 @@ function renderLogPane(projectDir, logs) {
   let newestMtime = 0;
   for (const log of existingLogs) {
     try {
-      const stat = fs25.statSync(log.path);
+      const stat = fs27.statSync(log.path);
       if (stat.mtimeMs > newestMtime) {
         newestMtime = stat.mtimeMs;
         newestLog = log;
@@ -11212,8 +11691,8 @@ function createActionsTab() {
 // src/commands/dashboard/tab-logs.ts
 init_dist();
 import blessed5 from "blessed";
-import * as fs26 from "fs";
-import * as path27 from "path";
+import * as fs28 from "fs";
+import * as path29 from "path";
 var LOG_NAMES = ["executor", "reviewer"];
 var LOG_LINES = 200;
 function createLogsTab() {
@@ -11254,7 +11733,7 @@ function createLogsTab() {
   let activeKeyHandlers = [];
   let activeCtx = null;
   function getLogPath(projectDir, logName) {
-    return path27.join(projectDir, "logs", `${logName}.log`);
+    return path29.join(projectDir, "logs", `${logName}.log`);
   }
   function updateSelector() {
     const tabs = LOG_NAMES.map((name, idx) => {
@@ -11268,7 +11747,7 @@ function createLogsTab() {
   function loadLog(ctx) {
     const logName = LOG_NAMES[selectedLogIndex];
     const logPath = getLogPath(ctx.projectDir, logName);
-    if (!fs26.existsSync(logPath)) {
+    if (!fs28.existsSync(logPath)) {
       logContent.setContent(
         `{yellow-fg}No ${logName}.log file found{/yellow-fg}
 
@@ -11278,7 +11757,7 @@ Log will appear here once the ${logName} runs.`
       return;
     }
     try {
-      const stat = fs26.statSync(logPath);
+      const stat = fs28.statSync(logPath);
       const sizeKB = (stat.size / 1024).toFixed(1);
       logContent.setLabel(`[ ${logName}.log - ${sizeKB} KB ]`);
     } catch {
@@ -11784,13 +12263,13 @@ function doctorCommand(program2) {
 
 // src/commands/serve.ts
 init_dist();
-import * as fs31 from "fs";
+import * as fs33 from "fs";
 
 // ../server/dist/index.js
 init_dist();
-import * as fs30 from "fs";
-import * as path33 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";
@@ -11874,8 +12353,8 @@ function setupGracefulShutdown(server, beforeClose) {
 
 // ../server/dist/middleware/project-resolver.middleware.js
 init_dist();
-import * as fs27 from "fs";
-import * as path28 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, "/");
@@ -11885,7 +12364,7 @@ function resolveProject(req, res, next) {
     res.status(404).json({ error: `Project not found: ${decodedId}` });
     return;
   }
-  if (!fs27.existsSync(entry.path) || !fs27.existsSync(path28.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;
   }
@@ -11930,8 +12409,8 @@ function startSseStatusWatcher(clients, projectDir, getConfig) {
 
 // ../server/dist/routes/action.routes.js
 init_dist();
-import * as fs28 from "fs";
-import * as path29 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";
 
@@ -11969,17 +12448,17 @@ function getBoardProvider(config, projectDir) {
 function cleanOrphanedClaims(dir) {
   let entries;
   try {
-    entries = fs28.readdirSync(dir, { withFileTypes: true });
+    entries = fs30.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path29.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 {
-        fs28.unlinkSync(fullPath);
+        fs30.unlinkSync(fullPath);
       } catch {
       }
     }
@@ -12076,6 +12555,9 @@ function createActionRouteHandlers(ctx) {
   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);
   });
@@ -12133,19 +12615,19 @@ function createActionRouteHandlers(ctx) {
         res.status(400).json({ error: "Invalid PRD name" });
         return;
       }
-      const prdDir = path29.join(projectDir, config.prdDir);
+      const prdDir = path31.join(projectDir, config.prdDir);
       const normalized = prdName.endsWith(".md") ? prdName : `${prdName}.md`;
-      const pendingPath = path29.join(prdDir, normalized);
-      const donePath = path29.join(prdDir, "done", normalized);
-      if (fs28.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 (!fs28.existsSync(donePath)) {
+      if (!fs30.existsSync(donePath)) {
         res.status(404).json({ error: `PRD "${normalized}" not found in done/` });
         return;
       }
-      fs28.renameSync(donePath, pendingPath);
+      fs30.renameSync(donePath, pendingPath);
       res.json({ message: `Moved "${normalized}" back to pending` });
     } catch (error2) {
       res.status(500).json({
@@ -12163,11 +12645,11 @@ function createActionRouteHandlers(ctx) {
         res.status(409).json({ error: "Executor is actively running \u2014 use Stop instead" });
         return;
       }
-      if (fs28.existsSync(lockPath)) {
-        fs28.unlinkSync(lockPath);
+      if (fs30.existsSync(lockPath)) {
+        fs30.unlinkSync(lockPath);
       }
-      const prdDir = path29.join(projectDir, config.prdDir);
-      if (fs28.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));
@@ -12363,6 +12845,7 @@ function createBoardRouteHandlers(ctx) {
         return;
       }
       await provider.closeIssue(issueNumber);
+      await provider.moveIssue(issueNumber, "Done");
       invalidateBoardCache(projectDir);
       res.json({ closed: true });
     } catch (error2) {
@@ -12669,6 +13152,34 @@ function validateConfigChanges(changes, currentConfig) {
       return "audit.maxRuntime must be a number >= 60";
     }
   }
+  if (changes.analytics !== void 0) {
+    if (typeof changes.analytics !== "object" || changes.analytics === null) {
+      return "analytics must be an object";
+    }
+    const analytics = changes.analytics;
+    if (analytics.enabled !== void 0 && typeof analytics.enabled !== "boolean") {
+      return "analytics.enabled must be a boolean";
+    }
+    const analyticsScheduleError = validateCronField("analytics.schedule", analytics.schedule);
+    if (analyticsScheduleError) {
+      return analyticsScheduleError;
+    }
+    if (analytics.maxRuntime !== void 0 && (typeof analytics.maxRuntime !== "number" || analytics.maxRuntime < 60)) {
+      return "analytics.maxRuntime must be a number >= 60";
+    }
+    if (analytics.lookbackDays !== void 0 && (typeof analytics.lookbackDays !== "number" || analytics.lookbackDays < 1 || analytics.lookbackDays > 90)) {
+      return "analytics.lookbackDays must be a number between 1 and 90";
+    }
+    if (analytics.targetColumn !== void 0) {
+      const validColumns = ["Draft", "Ready", "In Progress", "Review", "Done"];
+      if (!validColumns.includes(analytics.targetColumn)) {
+        return `analytics.targetColumn must be one of: ${validColumns.join(", ")}`;
+      }
+    }
+    if (analytics.analysisPrompt !== void 0 && typeof analytics.analysisPrompt !== "string") {
+      return "analytics.analysisPrompt must be a string";
+    }
+  }
   if (changes.queue !== void 0) {
     if (typeof changes.queue !== "object" || changes.queue === null) {
       return "queue must be an object";
@@ -12687,7 +13198,14 @@ function validateConfigChanges(changes, currentConfig) {
       if (typeof queue.priority !== "object" || queue.priority === null) {
         return "queue.priority must be an object";
       }
-      const validQueueJobs = ["executor", "reviewer", "qa", "audit", "slicer"];
+      const validQueueJobs = [
+        "executor",
+        "reviewer",
+        "qa",
+        "audit",
+        "slicer",
+        "analytics"
+      ];
       for (const [jobType, value] of Object.entries(queue.priority)) {
         if (!validQueueJobs.includes(jobType)) {
           return `queue.priority contains invalid job type: ${jobType}`;
@@ -12790,6 +13308,26 @@ function createConfigRoutes(deps) {
   });
   return router;
 }
+function createGlobalNotificationsRoutes() {
+  const router = Router3();
+  router.get("/", (_req, res) => {
+    res.json(loadGlobalNotificationsConfig());
+  });
+  router.put("/", (req, res) => {
+    const { webhook } = req.body;
+    if (webhook !== null && webhook !== void 0) {
+      const issues = validateWebhook(webhook);
+      if (issues.length > 0) {
+        res.status(400).json({ error: `Invalid webhook: ${issues.join(", ")}` });
+        return;
+      }
+    }
+    const config = { webhook: webhook ?? null };
+    saveGlobalNotificationsConfig(config);
+    res.json(loadGlobalNotificationsConfig());
+  });
+  return router;
+}
 function createProjectConfigRoutes() {
   const router = Router3({ mergeParams: true });
   router.get("/config", (req, res) => {
@@ -12823,8 +13361,8 @@ function createProjectConfigRoutes() {
 
 // ../server/dist/routes/doctor.routes.js
 init_dist();
-import * as fs29 from "fs";
-import * as path30 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) {
@@ -12857,7 +13395,7 @@ function runDoctorChecks(projectDir, config) {
     });
   }
   try {
-    const projectName = path30.basename(projectDir);
+    const projectName = path32.basename(projectDir);
     const marker = generateMarker(projectName);
     const crontabEntries = [...getEntries(marker), ...getProjectEntries(projectDir)];
     if (crontabEntries.length > 0) {
@@ -12880,8 +13418,8 @@ function runDoctorChecks(projectDir, config) {
       detail: "Failed to check crontab"
     });
   }
-  const configPath = path30.join(projectDir, CONFIG_FILE_NAME);
-  if (fs29.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({
@@ -12890,9 +13428,9 @@ function runDoctorChecks(projectDir, config) {
       detail: "Config file not found (using defaults)"
     });
   }
-  const prdDir = path30.join(projectDir, config.prdDir);
-  if (fs29.existsSync(prdDir)) {
-    const prds = fs29.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",
@@ -12935,7 +13473,7 @@ function createProjectDoctorRoutes() {
 
 // ../server/dist/routes/log.routes.js
 init_dist();
-import * as path31 from "path";
+import * as path33 from "path";
 import { Router as Router5 } from "express";
 function createLogRoutes(deps) {
   const { projectDir } = deps;
@@ -12943,7 +13481,7 @@ function createLogRoutes(deps) {
   router.get("/:name", (req, res) => {
     try {
       const { name } = req.params;
-      const validNames = ["executor", "reviewer", "qa", "audit", "planner"];
+      const validNames = ["executor", "reviewer", "qa", "audit", "planner", "analytics"];
       if (!validNames.includes(name)) {
         res.status(400).json({
           error: `Invalid log name. Must be one of: ${validNames.join(", ")}`
@@ -12954,7 +13492,7 @@ function createLogRoutes(deps) {
       const lines = typeof linesParam === "string" ? parseInt(linesParam, 10) : 200;
       const linesToRead = isNaN(lines) || lines < 1 ? 200 : Math.min(lines, 1e4);
       const fileName = LOG_FILE_NAMES[name] || name;
-      const logPath = path31.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) {
@@ -12969,7 +13507,7 @@ function createProjectLogRoutes() {
     try {
       const projectDir = req.projectDir;
       const { name } = req.params;
-      const validNames = ["executor", "reviewer", "qa", "audit", "planner"];
+      const validNames = ["executor", "reviewer", "qa", "audit", "planner", "analytics"];
       if (!validNames.includes(name)) {
         res.status(400).json({
           error: `Invalid log name. Must be one of: ${validNames.join(", ")}`
@@ -12980,7 +13518,7 @@ function createProjectLogRoutes() {
       const lines = typeof linesParam === "string" ? parseInt(linesParam, 10) : 200;
       const linesToRead = isNaN(lines) || lines < 1 ? 200 : Math.min(lines, 1e4);
       const fileName = LOG_FILE_NAMES[name] || name;
-      const logPath = path31.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) {
@@ -13015,7 +13553,7 @@ function createProjectPrdRoutes() {
 
 // ../server/dist/routes/roadmap.routes.js
 init_dist();
-import * as path32 from "path";
+import * as path34 from "path";
 import { Router as Router7 } from "express";
 function createRoadmapRouteHandlers(ctx) {
   const router = Router7({ mergeParams: true });
@@ -13025,7 +13563,7 @@ function createRoadmapRouteHandlers(ctx) {
       const config = ctx.getConfig(req);
       const projectDir = ctx.getProjectDir(req);
       const status = getRoadmapStatus(projectDir, config);
-      const prdDir = path32.join(projectDir, config.prdDir);
+      const prdDir = path34.join(projectDir, config.prdDir);
       const state = loadRoadmapState(prdDir);
       res.json({
         ...status,
@@ -13149,11 +13687,13 @@ function buildScheduleInfoResponse(projectDir, config, entries, installed) {
   const qaPlan = getSchedulingPlan(projectDir, config, "qa");
   const auditPlan = getSchedulingPlan(projectDir, config, "audit");
   const plannerPlan = getSchedulingPlan(projectDir, config, "slicer");
+  const analyticsPlan = getSchedulingPlan(projectDir, config, "analytics");
   const executorInstalled = installed && config.executorEnabled !== false && hasScheduledCommand(entries, "run");
   const reviewerInstalled = installed && config.reviewerEnabled && hasScheduledCommand(entries, "review");
   const qaInstalled = installed && config.qa.enabled && hasScheduledCommand(entries, "qa");
   const auditInstalled = installed && config.audit.enabled && hasScheduledCommand(entries, "audit");
   const plannerInstalled = installed && config.roadmapScanner.enabled && (hasScheduledCommand(entries, "planner") || hasScheduledCommand(entries, "slice"));
+  const analyticsInstalled = installed && config.analytics.enabled && hasScheduledCommand(entries, "analytics");
   return {
     executor: {
       schedule: config.cronSchedule,
@@ -13195,6 +13735,14 @@ function buildScheduleInfoResponse(projectDir, config, entries, installed) {
       manualDelayMinutes: plannerPlan.manualDelayMinutes,
       balancedDelayMinutes: plannerPlan.balancedDelayMinutes
     },
+    analytics: {
+      schedule: config.analytics.schedule,
+      installed: analyticsInstalled,
+      nextRun: analyticsInstalled ? addDelayToIsoString(computeNextRun(config.analytics.schedule), analyticsPlan.totalDelayMinutes) : null,
+      delayMinutes: analyticsPlan.totalDelayMinutes,
+      manualDelayMinutes: analyticsPlan.manualDelayMinutes,
+      balancedDelayMinutes: analyticsPlan.balancedDelayMinutes
+    },
     paused: !installed,
     schedulingPriority: config.schedulingPriority,
     entries
@@ -13347,26 +13895,26 @@ function createQueueRoutes(deps) {
 
 // ../server/dist/index.js
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname7(__filename2);
+var __dirname3 = dirname8(__filename2);
 function resolveWebDistPath() {
-  const bundled = path33.join(__dirname3, "web");
-  if (fs30.existsSync(path33.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 (fs30.existsSync(path33.join(d, "turbo.json"))) {
-      const dev = path33.join(d, "web/dist");
-      if (fs30.existsSync(path33.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 (fs30.existsSync(webDistPath)) {
+  if (fs32.existsSync(webDistPath)) {
     app.use(express.static(webDistPath));
   }
   app.use((req, res, next) => {
@@ -13374,8 +13922,8 @@ function setupStaticFiles(app) {
       next();
       return;
     }
-    const indexPath = path33.resolve(webDistPath, "index.html");
-    if (fs30.existsSync(indexPath)) {
+    const indexPath = path35.resolve(webDistPath, "index.html");
+    if (fs32.existsSync(indexPath)) {
       res.sendFile(indexPath, (err) => {
         if (err)
           next();
@@ -13413,6 +13961,7 @@ function createApp(projectDir) {
   app.use("/api/logs", createLogRoutes({ projectDir }));
   app.use("/api/doctor", createDoctorRoutes({ projectDir, getConfig: () => config }));
   app.use("/api/queue", createQueueRoutes({ getConfig: () => config }));
+  app.use("/api/global-notifications", createGlobalNotificationsRoutes());
   app.get("/api/prs", async (_req, res) => {
     try {
       res.json(await collectPrInfo(projectDir, config.branchPatterns));
@@ -13485,13 +14034,14 @@ function createGlobalApp() {
     }
   });
   app.use("/api/queue", createGlobalQueueRoutes());
+  app.use("/api/global-notifications", createGlobalNotificationsRoutes());
   app.use("/api/projects/:projectId", resolveProject, createProjectRouter());
   setupStaticFiles(app);
   app.use(errorHandler);
   return app;
 }
 function bootContainer() {
-  initContainer(path33.dirname(getDbPath()));
+  initContainer(path35.dirname(getDbPath()));
 }
 function startServer(projectDir, port) {
   bootContainer();
@@ -13544,8 +14094,8 @@ function isProcessRunning2(pid) {
 }
 function readPid(lockPath) {
   try {
-    if (!fs31.existsSync(lockPath)) return null;
-    const raw = fs31.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 {
@@ -13557,10 +14107,10 @@ function acquireServeLock(mode, port) {
   let stalePidCleaned;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs31.openSync(lockPath, "wx");
-      fs31.writeFileSync(fd, `${process.pid}
+      const fd = fs33.openSync(lockPath, "wx");
+      fs33.writeFileSync(fd, `${process.pid}
 `);
-      fs31.closeSync(fd);
+      fs33.closeSync(fd);
       return { acquired: true, lockPath, stalePidCleaned };
     } catch (error2) {
       const err = error2;
@@ -13581,7 +14131,7 @@ function acquireServeLock(mode, port) {
         };
       }
       try {
-        fs31.unlinkSync(lockPath);
+        fs33.unlinkSync(lockPath);
         if (existingPid) {
           stalePidCleaned = existingPid;
         }
@@ -13604,10 +14154,10 @@ function acquireServeLock(mode, port) {
 }
 function releaseServeLock(lockPath) {
   try {
-    if (!fs31.existsSync(lockPath)) return;
+    if (!fs33.existsSync(lockPath)) return;
     const lockPid = readPid(lockPath);
     if (lockPid !== null && lockPid !== process.pid) return;
-    fs31.unlinkSync(lockPath);
+    fs33.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -13703,14 +14253,14 @@ function historyCommand(program2) {
 // src/commands/update.ts
 init_dist();
 import { spawnSync } from "child_process";
-import * as fs32 from "fs";
-import * as path34 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) => path34.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) {
@@ -13752,7 +14302,7 @@ function updateCommand(program2) {
       }
       const nightWatchBin = resolveNightWatchBin();
       for (const projectDir of projectDirs) {
-        if (!fs32.existsSync(projectDir) || !fs32.statSync(projectDir).isDirectory()) {
+        if (!fs34.existsSync(projectDir) || !fs34.statSync(projectDir).isDirectory()) {
           warn(`Skipping invalid project directory: ${projectDir}`);
           continue;
         }
@@ -13796,8 +14346,8 @@ function prdStateCommand(program2) {
 
 // src/commands/retry.ts
 init_dist();
-import * as fs33 from "fs";
-import * as path35 from "path";
+import * as fs35 from "fs";
+import * as path37 from "path";
 function normalizePrdName(name) {
   if (!name.endsWith(".md")) {
     return `${name}.md`;
@@ -13805,26 +14355,26 @@ function normalizePrdName(name) {
   return name;
 }
 function getDonePrds(doneDir) {
-  if (!fs33.existsSync(doneDir)) {
+  if (!fs35.existsSync(doneDir)) {
     return [];
   }
-  return fs33.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 = path35.join(projectDir, config.prdDir);
-    const doneDir = path35.join(prdDir, "done");
+    const prdDir = path37.join(projectDir, config.prdDir);
+    const doneDir = path37.join(prdDir, "done");
     const normalizedPrdName = normalizePrdName(prdName);
-    const pendingPath = path35.join(prdDir, normalizedPrdName);
-    if (fs33.existsSync(pendingPath)) {
+    const pendingPath = path37.join(prdDir, normalizedPrdName);
+    if (fs35.existsSync(pendingPath)) {
       info(`"${normalizedPrdName}" is already pending, nothing to retry.`);
       return;
     }
-    const donePath = path35.join(doneDir, normalizedPrdName);
-    if (fs33.existsSync(donePath)) {
-      fs33.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}`);
@@ -14076,7 +14626,7 @@ function prdsCommand(program2) {
 
 // src/commands/cancel.ts
 init_dist();
-import * as fs34 from "fs";
+import * as fs36 from "fs";
 import * as readline3 from "readline";
 function getLockFilePaths2(projectDir) {
   const runtimeKey = projectRuntimeKey(projectDir);
@@ -14123,7 +14673,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   const pid = lockStatus.pid;
   if (!lockStatus.running) {
     try {
-      fs34.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
       return {
         success: true,
         message: `${processType} is not running (cleaned up stale lock file for PID ${pid})`,
@@ -14161,7 +14711,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(3e3);
   if (!isProcessRunning3(pid)) {
     try {
-      fs34.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -14196,7 +14746,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(500);
   if (!isProcessRunning3(pid)) {
     try {
-      fs34.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -14257,31 +14807,31 @@ function cancelCommand(program2) {
 
 // src/commands/slice.ts
 init_dist();
-import * as fs35 from "fs";
-import * as path36 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 (fs35.existsSync(lockFile)) {
-    const pidRaw = fs35.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 {
-      fs35.unlinkSync(lockFile);
+      fs37.unlinkSync(lockFile);
     } catch {
     }
   }
-  fs35.writeFileSync(lockFile, String(process.pid));
+  fs37.writeFileSync(lockFile, String(process.pid));
   return { acquired: true, lockFile };
 }
 function releasePlannerLock(lockFile) {
   try {
-    if (fs35.existsSync(lockFile)) {
-      fs35.unlinkSync(lockFile);
+    if (fs37.existsSync(lockFile)) {
+      fs37.unlinkSync(lockFile);
     }
   } catch {
   }
@@ -14290,12 +14840,12 @@ function resolvePlannerIssueColumn(config) {
   return config.roadmapScanner.issueColumn === "Ready" ? "Ready" : "Draft";
 }
 function buildPlannerIssueBody(projectDir, config, result) {
-  const relativePrdPath = path36.join(config.prdDir, result.file ?? "").replace(/\\/g, "/");
-  const absolutePrdPath = path36.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 = fs35.readFileSync(absolutePrdPath, "utf-8");
+    prdContent = fs37.readFileSync(absolutePrdPath, "utf-8");
   } catch {
     prdContent = `Unable to read generated PRD file at \`${relativePrdPath}\`.`;
   }
@@ -14471,7 +15021,7 @@ function sliceCommand(program2) {
       if (!options.dryRun) {
         await sendNotifications(config, {
           event: "run_started",
-          projectName: path36.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode: 0,
           provider: config.provider
         });
@@ -14506,7 +15056,7 @@ function sliceCommand(program2) {
       if (!options.dryRun && result.sliced) {
         await sendNotifications(config, {
           event: "run_succeeded",
-          projectName: path36.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode,
           provider: config.provider,
           prTitle: result.item?.title
@@ -14514,7 +15064,7 @@ function sliceCommand(program2) {
       } else if (!options.dryRun && !nothingPending) {
         await sendNotifications(config, {
           event: "run_failed",
-          projectName: path36.basename(projectDir),
+          projectName: path38.basename(projectDir),
           exitCode,
           provider: config.provider
         });
@@ -14530,21 +15080,21 @@ function sliceCommand(program2) {
 
 // src/commands/state.ts
 init_dist();
-import * as os7 from "os";
-import * as path37 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 || path37.join(os7.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(`  ${path37.join(nightWatchHome, "projects.json")}`);
-      console.log(`  ${path37.join(nightWatchHome, "history.json")}`);
-      console.log(`  ${path37.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;
@@ -14582,8 +15132,8 @@ function createStateCommand() {
 init_dist();
 init_dist();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs36 from "fs";
-import * as path38 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) {
@@ -14605,7 +15155,7 @@ function getProvider(config, cwd) {
   return createBoardProvider(bp, cwd);
 }
 function defaultBoardTitle(cwd) {
-  return `${path38.basename(cwd)} Night Watch`;
+  return `${path40.basename(cwd)} Night Watch`;
 }
 async function ensureBoardConfigured(config, cwd, provider, options) {
   if (config.boardProvider?.projectNumber) {
@@ -14804,11 +15354,11 @@ function boardCommand(program2) {
       let body = options.body ?? "";
       if (options.bodyFile) {
         const filePath = options.bodyFile;
-        if (!fs36.existsSync(filePath)) {
+        if (!fs38.existsSync(filePath)) {
           console.error(`File not found: ${filePath}`);
           process.exit(1);
         }
-        body = fs36.readFileSync(filePath, "utf-8");
+        body = fs38.readFileSync(filePath, "utf-8");
       }
       const labels = [];
       if (options.label) {
@@ -14836,6 +15386,25 @@ function boardCommand(program2) {
       }
     })
   );
+  board.command("add-issue").description("Add an existing GitHub issue to the board").argument("<number>", "Issue number").option("--column <name>", "Target column (default: Ready)", "Ready").action(
+    async (number, options) => run(async () => {
+      const cwd = process.cwd();
+      const config = loadConfig(cwd);
+      const provider = getProvider(config, cwd);
+      await ensureBoardConfigured(config, cwd, provider);
+      if (!BOARD_COLUMNS.includes(options.column)) {
+        console.error(
+          `Invalid column "${options.column}". Valid columns: ${BOARD_COLUMNS.join(", ")}`
+        );
+        process.exit(1);
+      }
+      const issue = await provider.addIssue(
+        parseInt(number, 10),
+        options.column
+      );
+      success(`Added issue #${issue.number} "${issue.title}" to ${options.column}`);
+    })
+  );
   board.command("status").description("Show the current state of all issues grouped by column").option("--json", "Output raw JSON").option("--group-by <field>", "Group by: priority, category, or column (default: column)").action(
     async (options) => run(async () => {
       const cwd = process.cwd();
@@ -15030,12 +15599,12 @@ function boardCommand(program2) {
       const config = loadConfig(cwd);
       const provider = getProvider(config, cwd);
       await ensureBoardConfigured(config, cwd, provider);
-      const roadmapPath = options.roadmap ?? path38.join(cwd, "ROADMAP.md");
-      if (!fs36.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 = fs36.readFileSync(roadmapPath, "utf-8");
+      const roadmapContent = fs38.readFileSync(roadmapPath, "utf-8");
       const items = parseRoadmap(roadmapContent);
       const uncheckedItems = getUncheckedItems(items);
       if (uncheckedItems.length === 0) {
@@ -15159,11 +15728,11 @@ function boardCommand(program2) {
 // src/commands/queue.ts
 init_dist();
 init_dist();
-import * as path39 from "path";
+import * as path41 from "path";
 import { spawn as spawn6 } from "child_process";
 import chalk7 from "chalk";
 import { Command as Command2 } from "commander";
-var logger2 = createLogger("queue");
+var logger4 = createLogger("queue");
 var VALID_JOB_TYPES2 = ["executor", "reviewer", "qa", "audit", "slicer"];
 function formatTimestamp(unixTs) {
   if (unixTs === null) return "-";
@@ -15279,7 +15848,7 @@ function createQueueCommand() {
         process.exit(1);
       }
     }
-    const projectName = path39.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})`));
@@ -15287,13 +15856,13 @@ function createQueueCommand() {
   queue.command("dispatch").description("Dispatch the next pending job (used by cron scripts)").option("--log <file>", "Log file to write dispatch output").action((_opts) => {
     const entry = dispatchNextJob(loadConfig(process.cwd()).queue);
     if (!entry) {
-      logger2.info("No pending jobs to dispatch");
+      logger4.info("No pending jobs to dispatch");
       return;
     }
-    logger2.info(`Dispatching ${entry.jobType} for ${entry.projectName} (ID: ${entry.id})`);
+    logger4.info(`Dispatching ${entry.jobType} for ${entry.projectName} (ID: ${entry.id})`);
     const scriptName = getScriptNameForJobType(entry.jobType);
     if (!scriptName) {
-      logger2.error(`Unknown job type: ${entry.jobType}`);
+      logger4.error(`Unknown job type: ${entry.jobType}`);
       return;
     }
     let projectEnv;
@@ -15312,7 +15881,7 @@ function createQueueCommand() {
       NW_QUEUE_ENTRY_ID: String(entry.id)
     };
     const scriptPath = getScriptPath(scriptName);
-    logger2.info(`Spawning: ${scriptPath} ${entry.projectPath}`);
+    logger4.info(`Spawning: ${scriptPath} ${entry.projectPath}`);
     try {
       const child = spawn6("bash", [scriptPath, entry.projectPath], {
         detached: true,
@@ -15321,11 +15890,11 @@ function createQueueCommand() {
         cwd: entry.projectPath
       });
       child.unref();
-      logger2.info(`Spawned PID: ${child.pid}`);
+      logger4.info(`Spawned PID: ${child.pid}`);
       markJobRunning(entry.id);
     } catch (error2) {
       updateJobStatus(entry.id, "pending");
-      logger2.error(
+      logger4.error(
         `Failed to dispatch ${entry.jobType} for ${entry.projectName}: ${error2 instanceof Error ? error2.message : String(error2)}`
       );
       process.exit(1);
@@ -15435,17 +16004,17 @@ function notifyCommand(program2) {
 
 // src/cli.ts
 var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname8(__filename3);
+var __dirname4 = dirname9(__filename3);
 function findPackageRoot(dir) {
   let d = dir;
   for (let i = 0; i < 5; i++) {
-    if (existsSync29(join34(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(join34(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);
@@ -15453,6 +16022,7 @@ runCommand(program);
 reviewCommand(program);
 qaCommand(program);
 auditCommand(program);
+analyticsCommand(program);
 installCommand(program);
 uninstallCommand(program);
 statusCommand(program);