@jonit-dev/night-watch-cli 1.8.12-beta.0 → 1.8.12-beta.3

package/dist/cli.js

@@ -64,13 +64,13 @@ function getLockSuffix(jobId) {
 }
 function normalizeJobConfig(raw, jobDef) {
   const readBoolean = (v) => typeof v === "boolean" ? v : void 0;
-  const readString = (v) => typeof v === "string" ? v : void 0;
+  const readString2 = (v) => typeof v === "string" ? v : void 0;
   const readNumber = (v) => typeof v === "number" && !Number.isNaN(v) ? v : void 0;
-  const readStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === "string") ? v : void 0;
+  const readStringArray2 = (v) => Array.isArray(v) && v.every((s) => typeof s === "string") ? v : void 0;
   const defaults = jobDef.defaultConfig;
   const result = {
     enabled: readBoolean(raw.enabled) ?? defaults.enabled,
-    schedule: readString(raw.schedule) ?? defaults.schedule,
+    schedule: readString2(raw.schedule) ?? defaults.schedule,
     maxRuntime: readNumber(raw.maxRuntime) ?? defaults.maxRuntime
   };
   for (const field of jobDef.extraFields ?? []) {
@@ -79,16 +79,16 @@ function normalizeJobConfig(raw, jobDef) {
         result[field.name] = readBoolean(raw[field.name]) ?? field.defaultValue;
         break;
       case "string":
-        result[field.name] = readString(raw[field.name]) ?? field.defaultValue;
+        result[field.name] = readString2(raw[field.name]) ?? field.defaultValue;
         break;
       case "number":
         result[field.name] = readNumber(raw[field.name]) ?? field.defaultValue;
         break;
       case "string[]":
-        result[field.name] = readStringArray(raw[field.name]) ?? field.defaultValue;
+        result[field.name] = readStringArray2(raw[field.name]) ?? field.defaultValue;
         break;
       case "enum": {
-        const val = readString(raw[field.name]);
+        const val = readString2(raw[field.name]);
         result[field.name] = val && field.enumValues?.includes(val) ? val : field.defaultValue;
         break;
       }
@@ -390,7 +390,7 @@ function resolveProviderBucketKey(provider, providerEnv) {
     return `claude-proxy:${baseUrl}`;
   }
 }
-var DEFAULT_DEFAULT_BRANCH, DEFAULT_PRD_DIR, DEFAULT_SUMMARY_WINDOW_HOURS, 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_VALIDATED_LABEL, DEFAULT_QA, QA_LOG_NAME, DEFAULT_AUDIT_ENABLED, DEFAULT_AUDIT_SCHEDULE, DEFAULT_AUDIT_MAX_RUNTIME, DEFAULT_AUDIT_TARGET_COLUMN, 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, DEFAULT_PR_RESOLVER_ENABLED, DEFAULT_PR_RESOLVER_SCHEDULE, DEFAULT_PR_RESOLVER_MAX_RUNTIME, DEFAULT_PR_RESOLVER_MAX_PRS_PER_RUN, DEFAULT_PR_RESOLVER_PER_PR_TIMEOUT, DEFAULT_PR_RESOLVER_AI_CONFLICT_RESOLUTION, DEFAULT_PR_RESOLVER_AI_REVIEW_RESOLUTION, DEFAULT_PR_RESOLVER_READY_LABEL, DEFAULT_PR_RESOLVER, DEFAULT_MERGER_ENABLED, DEFAULT_MERGER_SCHEDULE, DEFAULT_MERGER_MAX_RUNTIME, DEFAULT_MERGER_MERGE_METHOD, DEFAULT_MERGER_MIN_REVIEW_SCORE, DEFAULT_MERGER_REBASE_BEFORE_MERGE, DEFAULT_MERGER_MAX_PRS_PER_RUN, DEFAULT_MERGER, MERGER_LOG_NAME, AUDIT_LOG_NAME, PLANNER_LOG_NAME, ANALYTICS_LOG_NAME, PR_RESOLVER_LOG_NAME, VALID_PROVIDERS, VALID_JOB_TYPES, DEFAULT_JOB_PROVIDERS, DEFAULT_PROVIDER_SCHEDULE_OVERRIDES, 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;
+var DEFAULT_DEFAULT_BRANCH, DEFAULT_PRD_DIR, DEFAULT_SUMMARY_WINDOW_HOURS, 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_VALIDATED_LABEL, DEFAULT_QA, QA_LOG_NAME, DEFAULT_AUDIT_ENABLED, DEFAULT_AUDIT_SCHEDULE, DEFAULT_AUDIT_MAX_RUNTIME, DEFAULT_AUDIT_TARGET_COLUMN, 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, DEFAULT_PR_RESOLVER_ENABLED, DEFAULT_PR_RESOLVER_SCHEDULE, DEFAULT_PR_RESOLVER_MAX_RUNTIME, DEFAULT_PR_RESOLVER_MAX_PRS_PER_RUN, DEFAULT_PR_RESOLVER_PER_PR_TIMEOUT, DEFAULT_PR_RESOLVER_AI_CONFLICT_RESOLUTION, DEFAULT_PR_RESOLVER_AI_REVIEW_RESOLUTION, DEFAULT_PR_RESOLVER_READY_LABEL, DEFAULT_PR_RESOLVER, DEFAULT_MERGER_ENABLED, DEFAULT_MERGER_SCHEDULE, DEFAULT_MERGER_MAX_RUNTIME, DEFAULT_MERGER_MERGE_METHOD, DEFAULT_MERGER_MIN_REVIEW_SCORE, DEFAULT_MERGER_REBASE_BEFORE_MERGE, DEFAULT_MERGER_MAX_PRS_PER_RUN, DEFAULT_MERGER, MERGER_LOG_NAME, AUDIT_LOG_NAME, PLANNER_LOG_NAME, ANALYTICS_LOG_NAME, PR_RESOLVER_LOG_NAME, VALID_PROVIDERS, VALID_JOB_TYPES, DEFAULT_JOB_PROVIDERS, DEFAULT_PROVIDER_SCHEDULE_OVERRIDES, DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV, DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS, DEFAULT_WEBHOOK_TRIGGERS, 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;
 var init_constants = __esm({
   "../core/dist/constants.js"() {
     "use strict";
@@ -537,6 +537,20 @@ If no issues are warranted, output an empty array: []`;
     VALID_JOB_TYPES = getValidJobTypes();
     DEFAULT_JOB_PROVIDERS = {};
     DEFAULT_PROVIDER_SCHEDULE_OVERRIDES = [];
+    DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV = "NIGHT_WATCH_WEBHOOK_SECRET";
+    DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS = 300;
+    DEFAULT_WEBHOOK_TRIGGERS = {
+      enabled: false,
+      secretEnv: DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV,
+      allowedJobIds: getValidJobTypes(),
+      requireTimestamp: false,
+      maxSkewSeconds: DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS,
+      github: {
+        enabled: false,
+        events: [],
+        rules: []
+      }
+    };
     BUILT_IN_PRESETS = {
       claude: {
         name: "Claude",
@@ -645,26 +659,26 @@ function validateProvider(value) {
 function normalizeConfig(rawConfig) {
   const normalized = {};
   const hasOwn = (key) => Object.prototype.hasOwnProperty.call(rawConfig, key);
-  const readString = (value) => typeof value === "string" ? value : void 0;
+  const readString2 = (value) => typeof value === "string" ? value : void 0;
   const readNumber = (value) => typeof value === "number" && !Number.isNaN(value) ? value : void 0;
   const readBoolean = (value) => typeof value === "boolean" ? value : void 0;
-  const readStringArray = (value) => Array.isArray(value) && value.every((v) => typeof v === "string") ? value : void 0;
-  const readObject = (value) => value !== null && typeof value === "object" ? value : void 0;
-  const cron = readObject(rawConfig.cron);
-  const review = readObject(rawConfig.review);
-  const logging = readObject(rawConfig.logging);
-  normalized.defaultBranch = readString(rawConfig.defaultBranch);
-  normalized.prdDir = readString(rawConfig.prdDir) ?? readString(rawConfig.prdDirectory);
+  const readStringArray2 = (value) => Array.isArray(value) && value.every((v) => typeof v === "string") ? value : void 0;
+  const readObject2 = (value) => value !== null && typeof value === "object" ? value : void 0;
+  const cron = readObject2(rawConfig.cron);
+  const review = readObject2(rawConfig.review);
+  const logging = readObject2(rawConfig.logging);
+  normalized.defaultBranch = readString2(rawConfig.defaultBranch);
+  normalized.prdDir = readString2(rawConfig.prdDir) ?? readString2(rawConfig.prdDirectory);
   normalized.maxRuntime = readNumber(rawConfig.maxRuntime);
   normalized.sessionMaxRuntime = readNumber(rawConfig.sessionMaxRuntime);
   normalized.reviewerMaxRuntime = readNumber(rawConfig.reviewerMaxRuntime);
-  normalized.branchPrefix = readString(rawConfig.branchPrefix);
-  normalized.branchPatterns = readStringArray(rawConfig.branchPatterns) ?? readStringArray(review?.branchPatterns);
+  normalized.branchPrefix = readString2(rawConfig.branchPrefix);
+  normalized.branchPatterns = readStringArray2(rawConfig.branchPatterns) ?? readStringArray2(review?.branchPatterns);
   normalized.minReviewScore = readNumber(rawConfig.minReviewScore) ?? readNumber(review?.minScore);
   normalized.maxLogSize = readNumber(rawConfig.maxLogSize) ?? readNumber(logging?.maxLogSize);
   normalized.gitPushNoVerify = readBoolean(rawConfig.gitPushNoVerify);
-  normalized.cronSchedule = readString(rawConfig.cronSchedule) ?? readString(cron?.executorSchedule);
-  normalized.reviewerSchedule = readString(rawConfig.reviewerSchedule) ?? readString(cron?.reviewerSchedule);
+  normalized.cronSchedule = readString2(rawConfig.cronSchedule) ?? readString2(cron?.executorSchedule);
+  normalized.reviewerSchedule = readString2(rawConfig.reviewerSchedule) ?? readString2(cron?.reviewerSchedule);
   const rawScheduleBundleId = rawConfig.scheduleBundleId;
   if (typeof rawScheduleBundleId === "string") {
     const trimmed = rawScheduleBundleId.trim();
@@ -681,11 +695,11 @@ function normalizeConfig(rawConfig) {
   normalized.provider = validateProvider(String(rawConfig.provider ?? "")) ?? void 0;
   normalized.executorEnabled = readBoolean(rawConfig.executorEnabled);
   normalized.reviewerEnabled = readBoolean(rawConfig.reviewerEnabled);
-  const providerLabelVal = readString(rawConfig.providerLabel);
+  const providerLabelVal = readString2(rawConfig.providerLabel);
   if (providerLabelVal) {
     normalized.providerLabel = providerLabelVal;
   }
-  const rawProviderEnv = readObject(rawConfig.providerEnv);
+  const rawProviderEnv = readObject2(rawConfig.providerEnv);
   if (rawProviderEnv) {
     const env = {};
     for (const [key, value] of Object.entries(rawProviderEnv)) {
@@ -697,26 +711,26 @@ function normalizeConfig(rawConfig) {
       normalized.providerEnv = env;
     }
   }
-  const rawProviderPresets = readObject(rawConfig.providerPresets);
+  const rawProviderPresets = readObject2(rawConfig.providerPresets);
   if (rawProviderPresets) {
     const presets = {};
     for (const [presetId, presetVal] of Object.entries(rawProviderPresets)) {
-      const rawPreset = readObject(presetVal);
+      const rawPreset = readObject2(presetVal);
       if (rawPreset) {
-        const name = readString(rawPreset.name);
-        const command = readString(rawPreset.command);
+        const name = readString2(rawPreset.name);
+        const command = readString2(rawPreset.command);
         if (name && command) {
           const preset = {
             name,
             command,
-            subcommand: readString(rawPreset.subcommand),
-            promptFlag: readString(rawPreset.promptFlag),
-            autoApproveFlag: readString(rawPreset.autoApproveFlag),
-            workdirFlag: readString(rawPreset.workdirFlag),
-            modelFlag: readString(rawPreset.modelFlag),
-            model: readString(rawPreset.model)
+            subcommand: readString2(rawPreset.subcommand),
+            promptFlag: readString2(rawPreset.promptFlag),
+            autoApproveFlag: readString2(rawPreset.autoApproveFlag),
+            workdirFlag: readString2(rawPreset.workdirFlag),
+            modelFlag: readString2(rawPreset.modelFlag),
+            model: readString2(rawPreset.model)
           };
-          const rawEnvVars = readObject(rawPreset.envVars);
+          const rawEnvVars = readObject2(rawPreset.envVars);
           if (rawEnvVars) {
             const envVars = {};
             for (const [envKey, envVal] of Object.entries(rawEnvVars)) {
@@ -736,7 +750,7 @@ function normalizeConfig(rawConfig) {
       normalized.providerPresets = presets;
     }
   }
-  const rawNotifications = readObject(rawConfig.notifications);
+  const rawNotifications = readObject2(rawConfig.notifications);
   if (rawNotifications) {
     const rawWebhooks = Array.isArray(rawNotifications.webhooks) ? rawNotifications.webhooks : [];
     const webhooks = [];
@@ -754,18 +768,18 @@ function normalizeConfig(rawConfig) {
     }
     normalized.notifications = { webhooks };
   }
-  normalized.prdPriority = readStringArray(rawConfig.prdPriority);
-  const rawRoadmapScanner = readObject(rawConfig.roadmapScanner);
+  normalized.prdPriority = readStringArray2(rawConfig.prdPriority);
+  const rawRoadmapScanner = readObject2(rawConfig.roadmapScanner);
   if (rawRoadmapScanner) {
-    const priorityModeRaw = readString(rawRoadmapScanner.priorityMode);
+    const priorityModeRaw = readString2(rawRoadmapScanner.priorityMode);
     const priorityMode = priorityModeRaw === "roadmap-first" || priorityModeRaw === "audit-first" ? priorityModeRaw : DEFAULT_ROADMAP_SCANNER.priorityMode;
-    const issueColumnRaw = readString(rawRoadmapScanner.issueColumn);
+    const issueColumnRaw = readString2(rawRoadmapScanner.issueColumn);
     const issueColumn = issueColumnRaw === "Draft" || issueColumnRaw === "Ready" ? issueColumnRaw : DEFAULT_ROADMAP_SCANNER.issueColumn;
     const roadmapScanner = {
       enabled: readBoolean(rawRoadmapScanner.enabled) ?? DEFAULT_ROADMAP_SCANNER.enabled,
-      roadmapPath: readString(rawRoadmapScanner.roadmapPath) ?? DEFAULT_ROADMAP_SCANNER.roadmapPath,
+      roadmapPath: readString2(rawRoadmapScanner.roadmapPath) ?? DEFAULT_ROADMAP_SCANNER.roadmapPath,
       autoScanInterval: readNumber(rawRoadmapScanner.autoScanInterval) ?? DEFAULT_ROADMAP_SCANNER.autoScanInterval,
-      slicerSchedule: readString(rawRoadmapScanner.slicerSchedule) ?? DEFAULT_ROADMAP_SCANNER.slicerSchedule,
+      slicerSchedule: readString2(rawRoadmapScanner.slicerSchedule) ?? DEFAULT_ROADMAP_SCANNER.slicerSchedule,
       slicerMaxRuntime: readNumber(rawRoadmapScanner.slicerMaxRuntime) ?? DEFAULT_ROADMAP_SCANNER.slicerMaxRuntime,
       priorityMode,
       issueColumn
@@ -775,12 +789,12 @@ function normalizeConfig(rawConfig) {
     }
     normalized.roadmapScanner = roadmapScanner;
   }
-  normalized.templatesDir = readString(rawConfig.templatesDir);
-  const rawBoardProvider = readObject(rawConfig.boardProvider);
+  normalized.templatesDir = readString2(rawConfig.templatesDir);
+  const rawBoardProvider = readObject2(rawConfig.boardProvider);
   if (rawBoardProvider) {
     const bp = {
       enabled: readBoolean(rawBoardProvider.enabled) ?? DEFAULT_BOARD_PROVIDER.enabled,
-      provider: readString(rawBoardProvider.provider) ?? DEFAULT_BOARD_PROVIDER.provider
+      provider: readString2(rawBoardProvider.provider) ?? DEFAULT_BOARD_PROVIDER.provider
     };
     if (typeof rawBoardProvider.projectNumber === "number") {
       bp.projectNumber = rawBoardProvider.projectNumber;
@@ -796,7 +810,7 @@ function normalizeConfig(rawConfig) {
       normalized.primaryFallbackModel = null;
       normalized.claudeModel = null;
     } else {
-      const primaryFallbackModelRaw = readString(rawConfig.primaryFallbackModel);
+      const primaryFallbackModelRaw = readString2(rawConfig.primaryFallbackModel);
       if (primaryFallbackModelRaw && VALID_CLAUDE_MODELS.includes(primaryFallbackModelRaw)) {
         normalized.primaryFallbackModel = primaryFallbackModelRaw;
         normalized.claudeModel = primaryFallbackModelRaw;
@@ -806,7 +820,7 @@ function normalizeConfig(rawConfig) {
     if (rawConfig.claudeModel === null) {
       normalized.claudeModel = null;
     } else {
-      const claudeModelRaw = readString(rawConfig.claudeModel);
+      const claudeModelRaw = readString2(rawConfig.claudeModel);
       if (claudeModelRaw && VALID_CLAUDE_MODELS.includes(claudeModelRaw)) {
         normalized.primaryFallbackModel = claudeModelRaw;
         normalized.claudeModel = claudeModelRaw;
@@ -817,16 +831,16 @@ function normalizeConfig(rawConfig) {
     if (rawConfig.secondaryFallbackModel === null) {
       normalized.secondaryFallbackModel = null;
     } else {
-      const secondaryFallbackModelRaw = readString(rawConfig.secondaryFallbackModel);
+      const secondaryFallbackModelRaw = readString2(rawConfig.secondaryFallbackModel);
       if (secondaryFallbackModelRaw && VALID_CLAUDE_MODELS.includes(secondaryFallbackModelRaw)) {
         normalized.secondaryFallbackModel = secondaryFallbackModelRaw;
       }
     }
   }
-  normalized.primaryFallbackPreset = readString(rawConfig.primaryFallbackPreset);
-  normalized.secondaryFallbackPreset = readString(rawConfig.secondaryFallbackPreset);
+  normalized.primaryFallbackPreset = readString2(rawConfig.primaryFallbackPreset);
+  normalized.secondaryFallbackPreset = readString2(rawConfig.secondaryFallbackPreset);
   normalized.autoMerge = readBoolean(rawConfig.autoMerge);
-  const mergeMethod = readString(rawConfig.autoMergeMethod);
+  const mergeMethod = readString2(rawConfig.autoMergeMethod);
   if (mergeMethod && VALID_MERGE_METHODS.includes(mergeMethod)) {
     normalized.autoMergeMethod = mergeMethod;
   }
@@ -834,23 +848,23 @@ function normalizeConfig(rawConfig) {
     const jobDef = getJobDef(jobId);
     if (!jobDef)
       continue;
-    const rawJob = readObject(rawConfig[jobId]);
+    const rawJob = readObject2(rawConfig[jobId]);
     if (rawJob) {
       normalized[jobId] = normalizeJobConfig(rawJob, jobDef);
     }
   }
   const prResolverDef = getJobDef("pr-resolver");
   if (prResolverDef) {
-    const rawJob = readObject(rawConfig.prResolver);
+    const rawJob = readObject2(rawConfig.prResolver);
     if (rawJob) {
       normalized.prResolver = normalizeJobConfig(rawJob, prResolverDef);
     }
   }
-  const rawJobProviders = readObject(rawConfig.jobProviders);
+  const rawJobProviders = readObject2(rawConfig.jobProviders);
   if (rawJobProviders) {
     const jobProviders = {};
     for (const jobType of VALID_JOB_TYPES) {
-      const providerValue = readString(rawJobProviders[jobType]);
+      const providerValue = readString2(rawJobProviders[jobType]);
       if (providerValue && providerValue.trim().length > 0) {
         jobProviders[jobType] = providerValue.trim();
       }
@@ -859,7 +873,20 @@ function normalizeConfig(rawConfig) {
       normalized.jobProviders = jobProviders;
     }
   }
-  const rawScheduleOverrides = readObject(rawConfig.providerScheduleOverrides);
+  const rawPausedJobs = readObject2(rawConfig.pausedJobs);
+  if (rawPausedJobs) {
+    const pausedJobs = {};
+    for (const jobType of VALID_JOB_TYPES) {
+      const paused = readBoolean(rawPausedJobs[jobType]);
+      if (paused !== void 0) {
+        pausedJobs[jobType] = paused;
+      }
+    }
+    if (Object.keys(pausedJobs).length > 0) {
+      normalized.pausedJobs = pausedJobs;
+    }
+  }
+  const rawScheduleOverrides = readObject2(rawConfig.providerScheduleOverrides);
   if (rawScheduleOverrides) {
     if (Array.isArray(rawScheduleOverrides)) {
       const overrides = [];
@@ -867,10 +894,10 @@ function normalizeConfig(rawConfig) {
       for (const rawOverride of rawScheduleOverrides) {
         if (rawOverride && typeof rawOverride === "object") {
           const overrideObj = rawOverride;
-          const label2 = readString(overrideObj.label);
-          const presetId = readString(overrideObj.presetId);
-          const startTime = readString(overrideObj.startTime);
-          const endTime = readString(overrideObj.endTime);
+          const label2 = readString2(overrideObj.label);
+          const presetId = readString2(overrideObj.presetId);
+          const startTime = readString2(overrideObj.startTime);
+          const endTime = readString2(overrideObj.endTime);
           const rawDays = overrideObj.days;
           const rawJobTypes = overrideObj.jobTypes;
           const enabled = readBoolean(overrideObj.enabled);
@@ -920,9 +947,9 @@ function normalizeConfig(rawConfig) {
       }
     }
   }
-  const rawQueue = readObject(rawConfig.queue);
+  const rawQueue = readObject2(rawConfig.queue);
   if (rawQueue) {
-    const rawMode = readString(rawQueue.mode);
+    const rawMode = readString2(rawQueue.mode);
     const mode = rawMode === "conservative" || rawMode === "provider-aware" || rawMode === "auto" ? rawMode : DEFAULT_QUEUE.mode;
     const queue = {
       enabled: readBoolean(rawQueue.enabled) ?? DEFAULT_QUEUE.enabled,
@@ -932,7 +959,7 @@ function normalizeConfig(rawConfig) {
       priority: { ...DEFAULT_QUEUE.priority },
       providerBuckets: {}
     };
-    const rawPriority = readObject(rawQueue.priority);
+    const rawPriority = readObject2(rawQueue.priority);
     if (rawPriority) {
       for (const jobType of VALID_JOB_TYPES) {
         const prio = readNumber(rawPriority[jobType]);
@@ -941,10 +968,10 @@ function normalizeConfig(rawConfig) {
         }
       }
     }
-    const rawProviderBuckets = readObject(rawQueue.providerBuckets);
+    const rawProviderBuckets = readObject2(rawQueue.providerBuckets);
     if (rawProviderBuckets) {
       for (const [bucketKey, bucketVal] of Object.entries(rawProviderBuckets)) {
-        const rawBucket = readObject(bucketVal);
+        const rawBucket = readObject2(bucketVal);
         if (rawBucket) {
           const maxConcurrency = readNumber(rawBucket.maxConcurrency);
           if (maxConcurrency !== void 0) {
@@ -1274,9 +1301,113 @@ function getDefaultConfig() {
     merger: { ...DEFAULT_MERGER },
     jobProviders: { ...DEFAULT_JOB_PROVIDERS },
     providerScheduleOverrides: [...DEFAULT_PROVIDER_SCHEDULE_OVERRIDES],
-    queue: { ...DEFAULT_QUEUE }
+    queue: { ...DEFAULT_QUEUE },
+    pausedJobs: {},
+    webhookTriggers: cloneWebhookTriggers(DEFAULT_WEBHOOK_TRIGGERS)
+  };
+}
+function cloneWebhookTriggers(config) {
+  return {
+    ...config,
+    allowedJobIds: [...config.allowedJobIds],
+    github: {
+      ...config.github,
+      events: [...config.github.events],
+      rules: config.github.rules.map((rule) => {
+        const cloned = { ...rule };
+        if (rule.branchPatterns) {
+          cloned.branchPatterns = [...rule.branchPatterns];
+        }
+        return cloned;
+      })
+    }
   };
 }
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isValidJobType(value) {
+  return typeof value === "string" && getJobDef(value) !== void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length > 0 ? strings : [];
+}
+function normalizeWebhookGithubRules(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  const rules = [];
+  for (const item of value) {
+    if (!isPlainObject(item))
+      continue;
+    const event = typeof item.event === "string" ? item.event.trim() : "";
+    if (!event || !isValidJobType(item.jobId))
+      continue;
+    const rule = {
+      event,
+      jobId: item.jobId
+    };
+    if (typeof item.action === "string" && item.action.trim()) {
+      rule.action = item.action.trim();
+    }
+    const branchPatterns = readStringArray(item.branchPatterns);
+    if (branchPatterns !== void 0) {
+      rule.branchPatterns = branchPatterns;
+    }
+    if (typeof item.onlyOnFailure === "boolean") {
+      rule.onlyOnFailure = item.onlyOnFailure;
+    }
+    rules.push(rule);
+  }
+  return rules;
+}
+function normalizeWebhookTriggersConfig(value) {
+  if (!isPlainObject(value))
+    return void 0;
+  const config = cloneWebhookTriggers(DEFAULT_WEBHOOK_TRIGGERS);
+  if (typeof value.enabled === "boolean") {
+    config.enabled = value.enabled;
+  }
+  if (typeof value.secretEnv === "string") {
+    config.secretEnv = value.secretEnv.trim();
+  }
+  const allowedJobIds = readStringArray(value.allowedJobIds);
+  if (allowedJobIds !== void 0) {
+    config.allowedJobIds = allowedJobIds.filter(isValidJobType);
+  }
+  if (typeof value.requireTimestamp === "boolean") {
+    config.requireTimestamp = value.requireTimestamp;
+  }
+  if (typeof value.maxSkewSeconds === "number" && Number.isFinite(value.maxSkewSeconds)) {
+    const n = Math.floor(value.maxSkewSeconds);
+    config.maxSkewSeconds = n > 0 ? n : DEFAULT_WEBHOOK_TRIGGERS.maxSkewSeconds;
+  }
+  if (isPlainObject(value.github)) {
+    if (typeof value.github.enabled === "boolean") {
+      config.github.enabled = value.github.enabled;
+    }
+    const events = readStringArray(value.github.events);
+    if (events !== void 0) {
+      config.github.events = events.map((event) => event.trim()).filter(Boolean);
+    }
+    const rules = normalizeWebhookGithubRules(value.github.rules);
+    if (rules !== void 0) {
+      config.github.rules = rules;
+    }
+  }
+  return config;
+}
+function validateWebhookTriggers(config) {
+  const validated = cloneWebhookTriggers(config);
+  validated.allowedJobIds = validated.allowedJobIds.filter(isValidJobType);
+  validated.github.rules = validated.github.rules.filter((rule) => isValidJobType(rule.jobId));
+  if (validated.enabled && validated.secretEnv.trim().length === 0) {
+    throw new Error("webhookTriggers.secretEnv must be non-empty when webhook triggers are enabled");
+  }
+  return validated;
+}
 function loadConfigFile(configPath) {
   try {
     if (!fs.existsSync(configPath)) {
@@ -1284,7 +1415,12 @@ function loadConfigFile(configPath) {
     }
     const content = fs.readFileSync(configPath, "utf-8");
     const rawConfig = JSON.parse(content);
-    return normalizeConfig(rawConfig);
+    const normalized = normalizeConfig(rawConfig);
+    const webhookTriggers = normalizeWebhookTriggersConfig(rawConfig.webhookTriggers);
+    if (webhookTriggers) {
+      normalized.webhookTriggers = webhookTriggers;
+    }
+    return normalized;
   } catch (error2) {
     console.warn(`Warning: Could not parse config file at ${configPath}: ${error2 instanceof Error ? error2.message : String(error2)}`);
     return null;
@@ -1339,6 +1475,26 @@ function mergeConfigLayer(base, layer) {
         ...layerQueue,
         providerBuckets: { ...baseQueue.providerBuckets, ...layerQueue.providerBuckets }
       };
+    } else if (_key === "webhookTriggers") {
+      const baseWebhook = base[_key];
+      const layerWebhook = value;
+      base[_key] = {
+        ...baseWebhook,
+        ...layerWebhook,
+        allowedJobIds: [...layerWebhook.allowedJobIds],
+        github: {
+          ...baseWebhook.github,
+          ...layerWebhook.github,
+          events: [...layerWebhook.github.events],
+          rules: layerWebhook.github.rules.map((rule) => {
+            const cloned = { ...rule };
+            if (rule.branchPatterns) {
+              cloned.branchPatterns = [...rule.branchPatterns];
+            }
+            return cloned;
+          })
+        }
+      };
     } else if (_key === "providerEnv" || _key === "boardProvider" || _key === "qa" || _key === "audit" || _key === "analytics" || _key === "prResolver" || _key === "merger") {
       base[_key] = {
         ...base[_key],
@@ -1379,6 +1535,7 @@ function mergeConfigs(base, fileConfig, envConfig) {
   if (merged.claudeModel === void 0) {
     merged.claudeModel = merged.primaryFallbackModel === void 0 ? DEFAULT_CLAUDE_MODEL : merged.primaryFallbackModel;
   }
+  merged.webhookTriggers = validateWebhookTriggers(merged.webhookTriggers);
   return merged;
 }
 function loadConfig(projectDir) {
@@ -1492,6 +1649,7 @@ var init_config = __esm({
     init_constants();
     init_config_normalize();
     init_config_env();
+    init_job_registry();
     init_config_normalize();
   }
 });
@@ -1895,14 +2053,350 @@ var init_roadmap_state_repository = __esm({
   }
 });
 
+// ../core/src/board/types.ts
+var BOARD_COLUMNS2;
+var init_types3 = __esm({
+  "../core/src/board/types.ts"() {
+    "use strict";
+    BOARD_COLUMNS2 = ["Draft", "Ready", "In Progress", "Review", "Done"];
+  }
+});
+
+// ../core/src/jobs/job-registry.ts
+function getValidJobTypes2() {
+  return JOB_REGISTRY2.map((job) => job.id);
+}
+function getDefaultQueuePriority2() {
+  const result = {};
+  for (const job of JOB_REGISTRY2) {
+    result[job.id] = job.queuePriority;
+  }
+  return result;
+}
+function getLogFileNames2() {
+  const result = {};
+  for (const job of JOB_REGISTRY2) {
+    result[job.id] = job.logName;
+    if (job.cliCommand !== job.id) {
+      result[job.cliCommand] = job.logName;
+    }
+  }
+  return result;
+}
+var JOB_REGISTRY2, JOB_MAP2;
+var init_job_registry2 = __esm({
+  "../core/src/jobs/job-registry.ts"() {
+    "use strict";
+    init_types3();
+    JOB_REGISTRY2 = [
+      {
+        id: "executor",
+        name: "Executor",
+        description: "Creates implementation PRs from PRDs",
+        cliCommand: "run",
+        logName: "executor",
+        lockSuffix: ".lock",
+        queuePriority: 50,
+        envPrefix: "NW_EXECUTOR",
+        defaultConfig: {
+          enabled: true,
+          schedule: "5 */2 * * *",
+          maxRuntime: 7200
+        }
+      },
+      {
+        id: "reviewer",
+        name: "Reviewer",
+        description: "Reviews and improves PRs on night-watch branches",
+        cliCommand: "review",
+        logName: "reviewer",
+        lockSuffix: "-r.lock",
+        queuePriority: 40,
+        envPrefix: "NW_REVIEWER",
+        defaultConfig: {
+          enabled: true,
+          schedule: "25 */3 * * *",
+          maxRuntime: 3600
+        }
+      },
+      {
+        id: "pr-resolver",
+        name: "PR Conflict Solver",
+        description: "Resolves merge conflicts via AI rebase; optionally addresses review comments and labels PRs ready-to-merge",
+        cliCommand: "resolve",
+        logName: "pr-resolver",
+        lockSuffix: "-pr-resolver.lock",
+        queuePriority: 35,
+        envPrefix: "NW_PR_RESOLVER",
+        extraFields: [
+          { name: "branchPatterns", type: "string[]", defaultValue: [] },
+          { name: "maxPrsPerRun", type: "number", defaultValue: 0 },
+          { name: "perPrTimeout", type: "number", defaultValue: 600 },
+          { name: "aiConflictResolution", type: "boolean", defaultValue: true },
+          { name: "aiReviewResolution", type: "boolean", defaultValue: false },
+          { name: "readyLabel", type: "string", defaultValue: "ready-to-merge" }
+        ],
+        defaultConfig: {
+          enabled: true,
+          schedule: "15 6,14,22 * * *",
+          maxRuntime: 3600,
+          branchPatterns: [],
+          maxPrsPerRun: 0,
+          perPrTimeout: 600,
+          aiConflictResolution: true,
+          aiReviewResolution: false,
+          readyLabel: "ready-to-merge"
+        }
+      },
+      {
+        id: "slicer",
+        name: "Slicer",
+        description: "Generates PRDs from roadmap items",
+        cliCommand: "planner",
+        logName: "slicer",
+        lockSuffix: "-slicer.lock",
+        queuePriority: 30,
+        envPrefix: "NW_SLICER",
+        defaultConfig: {
+          enabled: true,
+          schedule: "35 */6 * * *",
+          maxRuntime: 600
+        }
+      },
+      {
+        id: "qa",
+        name: "QA",
+        description: "Runs end-to-end tests on PRs",
+        cliCommand: "qa",
+        logName: "night-watch-qa",
+        lockSuffix: "-qa.lock",
+        queuePriority: 20,
+        envPrefix: "NW_QA",
+        extraFields: [
+          { name: "branchPatterns", type: "string[]", defaultValue: [] },
+          {
+            name: "artifacts",
+            type: "enum",
+            enumValues: ["screenshot", "video", "both"],
+            defaultValue: "both"
+          },
+          { name: "skipLabel", type: "string", defaultValue: "skip-qa" },
+          { name: "autoInstallPlaywright", type: "boolean", defaultValue: true },
+          { name: "validatedLabel", type: "string", defaultValue: "e2e-validated" }
+        ],
+        defaultConfig: {
+          enabled: true,
+          schedule: "45 2,10,18 * * *",
+          maxRuntime: 3600,
+          branchPatterns: [],
+          artifacts: "both",
+          skipLabel: "skip-qa",
+          autoInstallPlaywright: true,
+          validatedLabel: "e2e-validated"
+        }
+      },
+      {
+        id: "audit",
+        name: "Auditor",
+        description: "Performs code audits and creates issues for findings",
+        cliCommand: "audit",
+        logName: "audit",
+        lockSuffix: "-audit.lock",
+        queuePriority: 10,
+        envPrefix: "NW_AUDIT",
+        extraFields: [
+          {
+            name: "targetColumn",
+            type: "enum",
+            enumValues: [...BOARD_COLUMNS2],
+            defaultValue: "Draft"
+          }
+        ],
+        defaultConfig: {
+          enabled: true,
+          schedule: "50 3 * * 1",
+          maxRuntime: 1800,
+          targetColumn: "Draft"
+        }
+      },
+      {
+        id: "analytics",
+        name: "Analytics",
+        description: "Analyzes product analytics and creates issues for trends",
+        cliCommand: "analytics",
+        logName: "analytics",
+        lockSuffix: "-analytics.lock",
+        queuePriority: 10,
+        envPrefix: "NW_ANALYTICS",
+        extraFields: [
+          { name: "lookbackDays", type: "number", defaultValue: 7 },
+          {
+            name: "targetColumn",
+            type: "enum",
+            enumValues: [...BOARD_COLUMNS2],
+            defaultValue: "Draft"
+          },
+          { name: "analysisPrompt", type: "string", defaultValue: "" }
+        ],
+        defaultConfig: {
+          enabled: false,
+          schedule: "0 6 * * 1",
+          maxRuntime: 900,
+          lookbackDays: 7,
+          targetColumn: "Draft",
+          analysisPrompt: ""
+        }
+      },
+      {
+        id: "merger",
+        name: "Merge Orchestrator",
+        description: "Repo-wide PR merge coordinator \u2014 scans, rebases, and merges in FIFO order",
+        cliCommand: "merge",
+        logName: "merger",
+        lockSuffix: "-merger.lock",
+        queuePriority: 45,
+        envPrefix: "NW_MERGER",
+        extraFields: [
+          {
+            name: "mergeMethod",
+            type: "enum",
+            enumValues: ["squash", "merge", "rebase"],
+            defaultValue: "squash"
+          },
+          { name: "minReviewScore", type: "number", defaultValue: 80 },
+          { name: "branchPatterns", type: "string[]", defaultValue: [] },
+          { name: "rebaseBeforeMerge", type: "boolean", defaultValue: true },
+          { name: "maxPrsPerRun", type: "number", defaultValue: 0 }
+        ],
+        defaultConfig: {
+          enabled: false,
+          schedule: "55 */4 * * *",
+          maxRuntime: 1800,
+          mergeMethod: "squash",
+          minReviewScore: 80,
+          branchPatterns: [],
+          rebaseBeforeMerge: true,
+          maxPrsPerRun: 0
+        }
+      }
+    ];
+    JOB_MAP2 = new Map(JOB_REGISTRY2.map((job) => [job.id, job]));
+  }
+});
+
+// ../core/src/constants.ts
+var DEFAULT_LOCAL_BOARD_INFO2, VALID_JOB_TYPES2, DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV2, DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS2, DEFAULT_WEBHOOK_TRIGGERS2, BUILT_IN_PRESETS2, BUILT_IN_PRESET_IDS2, PROVIDER_COMMANDS2, LOG_FILE_NAMES2, GLOBAL_CONFIG_DIR2, STATE_DB_FILE_NAME2, DEFAULT_QUEUE_ENABLED2, DEFAULT_QUEUE_MODE2, DEFAULT_QUEUE_MAX_CONCURRENCY2, DEFAULT_QUEUE_MAX_WAIT_TIME2, DEFAULT_QUEUE_PRIORITY2, DEFAULT_QUEUE2;
+var init_constants2 = __esm({
+  "../core/src/constants.ts"() {
+    "use strict";
+    init_job_registry2();
+    DEFAULT_LOCAL_BOARD_INFO2 = { id: "local", number: 0, title: "Local Kanban", url: "" };
+    VALID_JOB_TYPES2 = getValidJobTypes2();
+    DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV2 = "NIGHT_WATCH_WEBHOOK_SECRET";
+    DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS2 = 300;
+    DEFAULT_WEBHOOK_TRIGGERS2 = {
+      enabled: false,
+      secretEnv: DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV2,
+      allowedJobIds: getValidJobTypes2(),
+      requireTimestamp: false,
+      maxSkewSeconds: DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS2,
+      github: {
+        enabled: false,
+        events: [],
+        rules: []
+      }
+    };
+    BUILT_IN_PRESETS2 = {
+      claude: {
+        name: "Claude",
+        command: "claude",
+        promptFlag: "-p",
+        autoApproveFlag: "--dangerously-skip-permissions"
+      },
+      "claude-sonnet-4-6": {
+        name: "Claude Sonnet 4.6",
+        command: "claude",
+        promptFlag: "-p",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        modelFlag: "--model",
+        model: "claude-sonnet-4-6"
+      },
+      "claude-opus-4-6": {
+        name: "Claude Opus 4.6",
+        command: "claude",
+        promptFlag: "-p",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        modelFlag: "--model",
+        model: "claude-opus-4-6"
+      },
+      codex: {
+        name: "Codex",
+        command: "codex",
+        subcommand: "exec",
+        autoApproveFlag: "--yolo",
+        workdirFlag: "-C"
+      },
+      "glm-47": {
+        name: "GLM-4.7",
+        command: "claude",
+        promptFlag: "-p",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        modelFlag: "--model",
+        model: "glm-4.7",
+        envVars: {
+          ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+          API_TIMEOUT_MS: "3000000",
+          ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-4.7",
+          ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-4.7"
+        }
+      },
+      "glm-5": {
+        name: "GLM-5",
+        command: "claude",
+        promptFlag: "-p",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        modelFlag: "--model",
+        model: "glm-5",
+        envVars: {
+          ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+          API_TIMEOUT_MS: "3000000",
+          ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-5",
+          ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-5"
+        }
+      }
+    };
+    BUILT_IN_PRESET_IDS2 = Object.keys(BUILT_IN_PRESETS2);
+    PROVIDER_COMMANDS2 = {
+      claude: BUILT_IN_PRESETS2.claude.command,
+      codex: BUILT_IN_PRESETS2.codex.command
+    };
+    LOG_FILE_NAMES2 = getLogFileNames2();
+    GLOBAL_CONFIG_DIR2 = ".night-watch";
+    STATE_DB_FILE_NAME2 = "state.db";
+    DEFAULT_QUEUE_ENABLED2 = true;
+    DEFAULT_QUEUE_MODE2 = "auto";
+    DEFAULT_QUEUE_MAX_CONCURRENCY2 = 3;
+    DEFAULT_QUEUE_MAX_WAIT_TIME2 = 7200;
+    DEFAULT_QUEUE_PRIORITY2 = getDefaultQueuePriority2();
+    DEFAULT_QUEUE2 = {
+      enabled: DEFAULT_QUEUE_ENABLED2,
+      mode: DEFAULT_QUEUE_MODE2,
+      maxConcurrency: DEFAULT_QUEUE_MAX_CONCURRENCY2,
+      maxWaitTime: DEFAULT_QUEUE_MAX_WAIT_TIME2,
+      priority: { ...DEFAULT_QUEUE_PRIORITY2 },
+      providerBuckets: {}
+    };
+  }
+});
+
 // ../core/dist/storage/sqlite/client.js
 import * as fs2 from "fs";
 import * as os from "os";
 import * as path2 from "path";
 import Database6 from "better-sqlite3";
 function getDbPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path2.join(os.homedir(), GLOBAL_CONFIG_DIR);
-  return path2.join(base, STATE_DB_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path2.join(os.homedir(), GLOBAL_CONFIG_DIR2);
+  return path2.join(base, STATE_DB_FILE_NAME2);
 }
 function getDb() {
   if (_db) {
@@ -1924,7 +2418,7 @@ function closeDb() {
 }
 function createDbForDir(projectDir) {
   fs2.mkdirSync(projectDir, { recursive: true });
-  const dbPath = path2.join(projectDir, STATE_DB_FILE_NAME);
+  const dbPath = path2.join(projectDir, STATE_DB_FILE_NAME2);
   const db = new Database6(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
@@ -1934,7 +2428,7 @@ var _db;
 var init_client = __esm({
   "../core/dist/storage/sqlite/client.js"() {
     "use strict";
-    init_constants();
+    init_constants2();
     _db = null;
   }
 });
@@ -2896,21 +3390,21 @@ var LocalKanbanProvider;
 var init_local_kanban = __esm({
   "../core/dist/board/providers/local-kanban.js"() {
     "use strict";
-    init_types2();
-    init_constants();
+    init_types3();
+    init_constants2();
     LocalKanbanProvider = class {
       repo;
       constructor(repo) {
         this.repo = repo;
       }
       async setupBoard(title) {
-        return { ...DEFAULT_LOCAL_BOARD_INFO, title };
+        return { ...DEFAULT_LOCAL_BOARD_INFO2, title };
       }
       async getBoard() {
-        return DEFAULT_LOCAL_BOARD_INFO;
+        return DEFAULT_LOCAL_BOARD_INFO2;
       }
       async getColumns() {
-        return BOARD_COLUMNS.map((name, i) => ({ id: String(i), name }));
+        return BOARD_COLUMNS2.map((name, i) => ({ id: String(i), name }));
       }
       async createIssue(input) {
         const row = this.repo.create({
@@ -4491,11 +4985,11 @@ var init_checks = __esm({
 // ../core/dist/utils/config-writer.js
 import * as fs9 from "fs";
 import * as path8 from "path";
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function cleanJobProviders(value) {
-  if (!isPlainObject(value)) {
+  if (!isPlainObject2(value)) {
     return {};
   }
   const entries = [];
@@ -4519,7 +5013,7 @@ function saveConfig(projectDir, changes) {
       if (value !== void 0) {
         if (key === "jobProviders") {
           merged[key] = cleanJobProviders(value);
-        } else if (PARTIAL_MERGE_KEYS.has(key) && isPlainObject(existing[key]) && isPlainObject(value)) {
+        } else if (PARTIAL_MERGE_KEYS.has(key) && isPlainObject2(existing[key]) && isPlainObject2(value)) {
           merged[key] = { ...existing[key], ...value };
         } else {
           merged[key] = value;
@@ -4535,28 +5029,147 @@ function saveConfig(projectDir, changes) {
     };
   }
 }
-var PARTIAL_MERGE_KEYS;
-var init_config_writer = __esm({
-  "../core/dist/utils/config-writer.js"() {
+var PARTIAL_MERGE_KEYS;
+var init_config_writer = __esm({
+  "../core/dist/utils/config-writer.js"() {
+    "use strict";
+    init_constants();
+    PARTIAL_MERGE_KEYS = /* @__PURE__ */ new Set([
+      "notifications",
+      "qa",
+      "audit",
+      "roadmapScanner",
+      "queue",
+      "providerPresets",
+      "pausedJobs"
+    ]);
+  }
+});
+
+// ../core/dist/utils/config-path.js
+import * as fs10 from "fs";
+import * as path9 from "path";
+function isPlainObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function splitConfigPath(dotPath) {
+  const parts = dotPath.split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0 || parts.some((part) => part === "__proto__" || part === "constructor")) {
+    throw new Error(`Invalid config path: ${dotPath}`);
+  }
+  return parts;
+}
+function readRawConfig(projectDir) {
+  const configPath = path9.join(projectDir, CONFIG_FILE_NAME);
+  if (!fs10.existsSync(configPath)) {
+    return {};
+  }
+  return JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+}
+function writeRawConfig(projectDir, rawConfig) {
+  const configPath = path9.join(projectDir, CONFIG_FILE_NAME);
+  fs10.writeFileSync(configPath, `${JSON.stringify(rawConfig, null, 2)}
+`);
+}
+function getValueAtPath(source, parts) {
+  let current = source;
+  for (const part of parts) {
+    if (!isPlainObject3(current) || !(part in current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setValueAtPath(target, parts, value) {
+  let current = target;
+  for (const part of parts.slice(0, -1)) {
+    const next = current[part];
+    if (next === void 0) {
+      current[part] = {};
+    } else if (!isPlainObject3(next)) {
+      throw new Error(`Cannot set ${parts.join(".")}: ${part} is not an object`);
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function hasKnownConfigPath(parts) {
+  if (parts[0] === "pausedJobs" && parts.length === 2) {
+    return getValidJobTypes().includes(parts[1]);
+  }
+  const defaults = getDefaultConfig();
+  let current = defaults;
+  for (const part of parts) {
+    if (!isPlainObject3(current) || !(part in current)) {
+      return false;
+    }
+    current = current[part];
+  }
+  return true;
+}
+function parseConfigValue(rawValue) {
+  const trimmed = rawValue.trim();
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  if (trimmed === "null")
+    return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(trimmed)) {
+    return Number(trimmed);
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return JSON.parse(trimmed);
+  }
+  return rawValue;
+}
+function getConfigValue(projectDir, dotPath) {
+  const parts = splitConfigPath(dotPath);
+  if (!hasKnownConfigPath(parts)) {
+    throw new Error(`Unknown config path: ${dotPath}`);
+  }
+  const config = loadConfig(projectDir);
+  return { path: parts.join("."), value: getValueAtPath(config, parts) };
+}
+function setConfigValue(projectDir, dotPath, value) {
+  const parts = splitConfigPath(dotPath);
+  if (!hasKnownConfigPath(parts)) {
+    throw new Error(`Unknown config path: ${dotPath}`);
+  }
+  const rawConfig = readRawConfig(projectDir);
+  const originalRawConfig = JSON.parse(JSON.stringify(rawConfig));
+  const currentConfig = loadConfig(projectDir);
+  const previousValue = getValueAtPath(currentConfig, parts);
+  setValueAtPath(rawConfig, parts, value);
+  const result = saveConfig(projectDir, rawConfig);
+  if (!result.success) {
+    throw new Error(`Failed to save config: ${result.error}`);
+  }
+  const reloaded = loadConfig(projectDir);
+  const reloadedValue = getValueAtPath(reloaded, parts);
+  if (JSON.stringify(reloadedValue) !== JSON.stringify(value)) {
+    writeRawConfig(projectDir, originalRawConfig);
+    throw new Error(`Invalid value for config path: ${parts.join(".")}`);
+  }
+  return { path: parts.join("."), previousValue, value: reloadedValue };
+}
+var init_config_path = __esm({
+  "../core/dist/utils/config-path.js"() {
     "use strict";
     init_constants();
-    PARTIAL_MERGE_KEYS = /* @__PURE__ */ new Set([
-      "notifications",
-      "qa",
-      "audit",
-      "roadmapScanner",
-      "queue",
-      "providerPresets"
-    ]);
+    init_config();
+    init_job_registry();
+    init_config_writer();
   }
 });
 
 // ../core/dist/utils/execution-history.js
 import * as os4 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 function getHistoryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path9.join(os4.homedir(), GLOBAL_CONFIG_DIR);
-  return path9.join(base, HISTORY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path10.join(os4.homedir(), GLOBAL_CONFIG_DIR);
+  return path10.join(base, HISTORY_FILE_NAME);
 }
 function loadHistory() {
   const { executionHistory } = getRepositories();
@@ -4567,7 +5180,7 @@ function saveHistory(history) {
   executionHistory.replaceAll(history);
 }
 function recordExecution(projectDir, prdFile, outcome, exitCode, attempt = 1) {
-  const resolved = path9.resolve(projectDir);
+  const resolved = path10.resolve(projectDir);
   const { executionHistory } = getRepositories();
   const record = {
     timestamp: Math.floor(Date.now() / 1e3),
@@ -4579,7 +5192,7 @@ function recordExecution(projectDir, prdFile, outcome, exitCode, attempt = 1) {
   executionHistory.trimRecords(resolved, prdFile, MAX_HISTORY_RECORDS_PER_PRD);
 }
 function getLastExecution(projectDir, prdFile) {
-  const resolved = path9.resolve(projectDir);
+  const resolved = path10.resolve(projectDir);
   const { executionHistory } = getRepositories();
   const records = executionHistory.getRecords(resolved, prdFile);
   return records.length > 0 ? records[0] : null;
@@ -4880,16 +5493,16 @@ var init_github = __esm({
 });
 
 // ../core/dist/utils/log-utils.js
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 function rotateLog(logFile, maxSize = DEFAULT_MAX_LOG_SIZE) {
-  if (!fs10.existsSync(logFile)) {
+  if (!fs11.existsSync(logFile)) {
     return false;
   }
   try {
-    const stats = fs10.statSync(logFile);
+    const stats = fs11.statSync(logFile);
     if (stats.size > maxSize) {
       const oldPath = `${logFile}.old`;
-      fs10.renameSync(logFile, oldPath);
+      fs11.renameSync(logFile, oldPath);
       return true;
     }
   } catch {
@@ -4897,11 +5510,11 @@ function rotateLog(logFile, maxSize = DEFAULT_MAX_LOG_SIZE) {
   return false;
 }
 function checkRateLimited(logFile, startLine) {
-  if (!fs10.existsSync(logFile)) {
+  if (!fs11.existsSync(logFile)) {
     return false;
   }
   try {
-    const content = fs10.readFileSync(logFile, "utf-8");
+    const content = fs11.readFileSync(logFile, "utf-8");
     const lines = content.split("\n");
     let linesToCheck;
     if (startLine !== void 0 && startLine > 0) {
@@ -4922,18 +5535,18 @@ var init_log_utils = __esm({
 });
 
 // ../core/dist/utils/global-config.js
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as os5 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 function getGlobalNotificationsPath() {
-  return path10.join(os5.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_NOTIFICATIONS_FILE_NAME);
+  return path11.join(os5.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_NOTIFICATIONS_FILE_NAME);
 }
 function loadGlobalNotificationsConfig() {
   const filePath = getGlobalNotificationsPath();
   try {
-    if (!fs11.existsSync(filePath))
+    if (!fs12.existsSync(filePath))
       return { webhook: null };
-    const raw = fs11.readFileSync(filePath, "utf-8");
+    const raw = fs12.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { webhook: null };
@@ -4941,8 +5554,8 @@ function loadGlobalNotificationsConfig() {
 }
 function saveGlobalNotificationsConfig(config) {
   const filePath = getGlobalNotificationsPath();
-  fs11.mkdirSync(path10.dirname(filePath), { recursive: true });
-  fs11.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs12.mkdirSync(path11.dirname(filePath), { recursive: true });
+  fs12.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 var init_global_config = __esm({
   "../core/dist/utils/global-config.js"() {
@@ -5415,15 +6028,15 @@ var init_prd_discovery = __esm({
 });
 
 // ../core/dist/utils/prd-utils.js
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path12 from "path";
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber(prdDir) {
-  if (!fs12.existsSync(prdDir))
+  if (!fs13.existsSync(prdDir))
     return 1;
-  const files = fs12.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+  const files = fs13.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
@@ -5431,16 +6044,16 @@ function getNextPrdNumber(prdDir) {
   return Math.max(0, ...numbers) + 1;
 }
 function markPrdDone(prdDir, prdFile) {
-  const sourcePath = path11.join(prdDir, prdFile);
-  if (!fs12.existsSync(sourcePath)) {
+  const sourcePath = path12.join(prdDir, prdFile);
+  if (!fs13.existsSync(sourcePath)) {
     return false;
   }
-  const doneDir = path11.join(prdDir, "done");
-  if (!fs12.existsSync(doneDir)) {
-    fs12.mkdirSync(doneDir, { recursive: true });
+  const doneDir = path12.join(prdDir, "done");
+  if (!fs13.existsSync(doneDir)) {
+    fs13.mkdirSync(doneDir, { recursive: true });
   }
-  const destPath = path11.join(doneDir, prdFile);
-  fs12.renameSync(sourcePath, destPath);
+  const destPath = path12.join(doneDir, prdFile);
+  fs13.renameSync(sourcePath, destPath);
   return true;
 }
 var init_prd_utils = __esm({
@@ -5450,16 +6063,16 @@ var init_prd_utils = __esm({
 });
 
 // ../core/dist/utils/registry.js
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os6 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 function readLegacyRegistryEntries() {
   const registryPath = getRegistryPath();
-  if (!fs13.existsSync(registryPath)) {
+  if (!fs14.existsSync(registryPath)) {
     return [];
   }
   try {
-    const raw = fs13.readFileSync(registryPath, "utf-8");
+    const raw = fs14.readFileSync(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       return [];
@@ -5494,8 +6107,8 @@ function loadRegistryEntriesWithLegacyFallback() {
   return projectRegistry.getAll();
 }
 function getRegistryPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path12.join(os6.homedir(), GLOBAL_CONFIG_DIR);
-  return path12.join(base, REGISTRY_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path13.join(os6.homedir(), GLOBAL_CONFIG_DIR);
+  return path13.join(base, REGISTRY_FILE_NAME);
 }
 function loadRegistry() {
   return loadRegistryEntriesWithLegacyFallback();
@@ -5508,7 +6121,7 @@ function saveRegistry(entries) {
   }
 }
 function registerProject(projectDir) {
-  const resolvedPath = path12.resolve(projectDir);
+  const resolvedPath = path13.resolve(projectDir);
   const { projectRegistry } = getRepositories();
   const entries = loadRegistryEntriesWithLegacyFallback();
   const existing = entries.find((e) => e.path === resolvedPath);
@@ -5517,13 +6130,13 @@ function registerProject(projectDir) {
   }
   const name = getProjectName(resolvedPath);
   const nameExists = entries.some((e) => e.name === name);
-  const finalName = nameExists ? `${name}-${path12.basename(resolvedPath)}` : name;
+  const finalName = nameExists ? `${name}-${path13.basename(resolvedPath)}` : name;
   const entry = { name: finalName, path: resolvedPath };
   projectRegistry.upsert(entry);
   return entry;
 }
 function unregisterProject(projectDir) {
-  const resolvedPath = path12.resolve(projectDir);
+  const resolvedPath = path13.resolve(projectDir);
   loadRegistryEntriesWithLegacyFallback();
   const { projectRegistry } = getRepositories();
   return projectRegistry.remove(resolvedPath);
@@ -5533,7 +6146,7 @@ function validateRegistry() {
   const valid = [];
   const invalid = [];
   for (const entry of entries) {
-    if (fs13.existsSync(entry.path) && fs13.existsSync(path12.join(entry.path, CONFIG_FILE_NAME))) {
+    if (fs14.existsSync(entry.path) && fs14.existsSync(path13.join(entry.path, CONFIG_FILE_NAME))) {
       valid.push(entry);
     } else {
       invalid.push(entry);
@@ -5542,7 +6155,7 @@ function validateRegistry() {
   return { valid, invalid };
 }
 function pruneProjectData(projectDir) {
-  const resolvedPath = path12.resolve(projectDir);
+  const resolvedPath = path13.resolve(projectDir);
   const db = getDb();
   db.transaction(() => {
     db.prepare("DELETE FROM execution_history WHERE project_path = ?").run(resolvedPath);
@@ -5553,7 +6166,7 @@ function pruneProjectData(projectDir) {
   })();
 }
 function removeProject(projectDir) {
-  const resolvedPath = path12.resolve(projectDir);
+  const resolvedPath = path13.resolve(projectDir);
   const projectName = getProjectName(resolvedPath);
   const marker = generateMarker(projectName);
   const cronEntriesRemoved = removeEntriesForProject(resolvedPath, marker);
@@ -5742,8 +6355,8 @@ var init_roadmap_parser = __esm({
 });
 
 // ../core/dist/audit/report.js
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 function normalizeAuditSeverity(raw) {
   const normalized = raw.trim().toLowerCase();
   if (normalized === "critical")
@@ -5802,11 +6415,11 @@ function parseAuditFindings(reportContent) {
   return findings;
 }
 function loadAuditFindings(projectDir) {
-  const reportPath = path13.join(projectDir, "logs", "audit-report.md");
-  if (!fs14.existsSync(reportPath)) {
+  const reportPath = path14.join(projectDir, "logs", "audit-report.md");
+  if (!fs15.existsSync(reportPath)) {
     return [];
   }
-  const reportContent = fs14.readFileSync(reportPath, "utf-8");
+  const reportContent = fs15.readFileSync(reportPath, "utf-8");
   if (!reportContent.trim() || /\bNO_ISSUES_FOUND\b/.test(reportContent)) {
     return [];
   }
@@ -5819,18 +6432,18 @@ var init_report = __esm({
 });
 
 // ../core/dist/utils/roadmap-state.js
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 function getStateFilePath(prdDir) {
-  return path14.join(prdDir, STATE_FILE_NAME);
+  return path15.join(prdDir, STATE_FILE_NAME);
 }
 function readJsonState(prdDir) {
   const statePath = getStateFilePath(prdDir);
-  if (!fs15.existsSync(statePath)) {
+  if (!fs16.existsSync(statePath)) {
     return null;
   }
   try {
-    const content = fs15.readFileSync(statePath, "utf-8");
+    const content = fs16.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null) {
       return null;
@@ -5868,11 +6481,11 @@ function saveRoadmapState(prdDir, state) {
   const { roadmapState } = getRepositories();
   roadmapState.save(prdDir, state);
   const statePath = getStateFilePath(prdDir);
-  const dir = path14.dirname(statePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(statePath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs15.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  fs16.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 function createEmptyState() {
   return {
@@ -5912,21 +6525,21 @@ var init_roadmap_state = __esm({
 });
 
 // ../core/dist/templates/slicer-prompt.js
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function loadSlicerTemplate(templateDir) {
   if (cachedTemplate) {
     return cachedTemplate;
   }
-  const candidatePaths = templateDir ? [path15.join(templateDir, "slicer.md")] : [
-    path15.resolve(__dirname, "slicer.md"),
-    path15.resolve(__dirname, "..", "templates", "slicer.md"),
-    path15.resolve(__dirname, "..", "..", "..", "..", "templates", "slicer.md")
+  const candidatePaths = templateDir ? [path16.join(templateDir, "slicer.md")] : [
+    path16.resolve(__dirname, "slicer.md"),
+    path16.resolve(__dirname, "..", "templates", "slicer.md"),
+    path16.resolve(__dirname, "..", "..", "..", "..", "templates", "slicer.md")
   ];
-  const templatePath = candidatePaths.find((candidate) => fs16.existsSync(candidate)) ?? candidatePaths[0];
+  const templatePath = candidatePaths.find((candidate) => fs17.existsSync(candidate)) ?? candidatePaths[0];
   try {
-    cachedTemplate = fs16.readFileSync(templatePath, "utf-8");
+    cachedTemplate = fs17.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));
@@ -5951,7 +6564,7 @@ function createSlicerPromptVars(title, section, description, prdDir, prdFilename
     title,
     section,
     description: description || "(No description provided)",
-    outputFilePath: path15.join(prdDir, prdFilename),
+    outputFilePath: path16.join(prdDir, prdFilename),
     prdDir
   };
 }
@@ -5960,7 +6573,7 @@ var init_slicer_prompt = __esm({
   "../core/dist/templates/slicer-prompt.js"() {
     "use strict";
     __filename = fileURLToPath2(import.meta.url);
-    __dirname = path15.dirname(__filename);
+    __dirname = path16.dirname(__filename);
     DEFAULT_SLICER_TEMPLATE = `You are a **Principal Software Architect**. Your job: analyze the codebase and write a complete Product Requirements Document (PRD) for a feature. The PRD will be used directly as a GitHub issue body, so it must be self-contained and immediately actionable by an engineer.
 
 When this activates: \`Planning Mode: Principal Architect\`
@@ -6093,8 +6706,8 @@ DO NOT forget to write the file.
 });
 
 // ../core/dist/utils/roadmap-scanner.js
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
 function auditSeverityRank(severity) {
@@ -6145,9 +6758,9 @@ function collectAuditPlannerItems(projectDir) {
   return findings.map(auditFindingToRoadmapItem);
 }
 function getRoadmapStatus(projectDir, config) {
-  const roadmapPath = path16.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path17.join(projectDir, config.roadmapScanner.roadmapPath);
   const scannerEnabled = config.roadmapScanner.enabled;
-  if (!fs17.existsSync(roadmapPath)) {
+  if (!fs18.existsSync(roadmapPath)) {
     return {
       found: false,
       enabled: scannerEnabled,
@@ -6158,9 +6771,9 @@ function getRoadmapStatus(projectDir, config) {
       items: []
     };
   }
-  const content = fs17.readFileSync(roadmapPath, "utf-8");
+  const content = fs18.readFileSync(roadmapPath, "utf-8");
   const items = parseRoadmap(content);
-  const prdDir = path16.join(projectDir, config.prdDir);
+  const prdDir = path17.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const statusItems = items.map((item) => {
@@ -6197,10 +6810,10 @@ function getRoadmapStatus(projectDir, config) {
 }
 function scanExistingPrdSlugs(prdDir) {
   const slugs = /* @__PURE__ */ new Set();
-  if (!fs17.existsSync(prdDir)) {
+  if (!fs18.existsSync(prdDir)) {
     return slugs;
   }
-  const files = fs17.readdirSync(prdDir);
+  const files = fs18.readdirSync(prdDir);
   for (const file of files) {
     if (!file.endsWith(".md")) {
       continue;
@@ -6252,21 +6865,21 @@ 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 = path16.join(prdDir, filename);
-  if (!fs17.existsSync(prdDir)) {
-    fs17.mkdirSync(prdDir, { recursive: true });
+  const filePath = path17.join(prdDir, filename);
+  if (!fs18.existsSync(prdDir)) {
+    fs18.mkdirSync(prdDir, { recursive: true });
   }
   const promptVars = createSlicerPromptVars(item.title, item.section, item.description, prdDir, filename);
   const prompt = renderSlicerPrompt(promptVars);
   const providerId = resolveJobProvider(config, "slicer");
   const preset = resolvePreset(config, providerId);
   const providerArgs = buildProviderArgs(preset, prompt, projectDir);
-  const logDir = path16.join(projectDir, "logs");
-  if (!fs17.existsSync(logDir)) {
-    fs17.mkdirSync(logDir, { recursive: true });
+  const logDir = path17.join(projectDir, "logs");
+  if (!fs18.existsSync(logDir)) {
+    fs18.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path16.join(logDir, `slicer-${itemSlug}.log`);
-  const logStream = fs17.createWriteStream(logFile, { flags: "w" });
+  const logFile = path17.join(logDir, `slicer-${itemSlug}.log`);
+  const logStream = fs18.createWriteStream(logFile, { flags: "w" });
   logStream.on("error", () => {
   });
   return new Promise((resolve9) => {
@@ -6304,7 +6917,7 @@ async function sliceRoadmapItem(projectDir, prdDir, item, config) {
         });
         return;
       }
-      if (!fs17.existsSync(filePath)) {
+      if (!fs18.existsSync(filePath)) {
         resolve9({
           sliced: false,
           error: `Provider did not create expected file: ${filePath}`,
@@ -6327,23 +6940,23 @@ async function sliceNextItem(projectDir, config) {
       error: "Roadmap scanner is disabled"
     };
   }
-  const roadmapPath = path16.join(projectDir, config.roadmapScanner.roadmapPath);
+  const roadmapPath = path17.join(projectDir, config.roadmapScanner.roadmapPath);
   const auditItems = collectAuditPlannerItems(projectDir);
-  const roadmapExists = fs17.existsSync(roadmapPath);
+  const roadmapExists = fs18.existsSync(roadmapPath);
   if (!roadmapExists && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No pending items to process"
     };
   }
-  const roadmapItems = roadmapExists ? parseRoadmap(fs17.readFileSync(roadmapPath, "utf-8")) : [];
+  const roadmapItems = roadmapExists ? parseRoadmap(fs18.readFileSync(roadmapPath, "utf-8")) : [];
   if (roadmapExists && roadmapItems.length === 0 && auditItems.length === 0) {
     return {
       sliced: false,
       error: "No items in roadmap"
     };
   }
-  const prdDir = path16.join(projectDir, config.prdDir);
+  const prdDir = path17.join(projectDir, config.prdDir);
   const state = loadRoadmapState(prdDir);
   const existingPrdSlugs = scanExistingPrdSlugs(prdDir);
   const pickEligibleItem = (items) => {
@@ -6515,8 +7128,8 @@ var init_shell = __esm({
 });
 
 // ../core/dist/utils/scheduling.js
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 function normalizeSchedulingPriority(priority) {
   if (!Number.isFinite(priority)) {
     return DEFAULT_SCHEDULING_PRIORITY;
@@ -6551,7 +7164,7 @@ function getJobSchedule(config, jobType) {
   }
 }
 function loadPeerConfig(projectPath) {
-  if (!fs18.existsSync(projectPath) || !fs18.existsSync(path17.join(projectPath, CONFIG_FILE_NAME))) {
+  if (!fs19.existsSync(projectPath) || !fs19.existsSync(path18.join(projectPath, CONFIG_FILE_NAME))) {
     return null;
   }
   try {
@@ -6562,10 +7175,10 @@ function loadPeerConfig(projectPath) {
 }
 function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
   const peers = /* @__PURE__ */ new Map();
-  const currentPath = path17.resolve(currentProjectDir);
+  const currentPath = path18.resolve(currentProjectDir);
   const currentSchedule = getJobSchedule(currentConfig, jobType);
   const addPeer = (projectPath, config) => {
-    const resolvedPath = path17.resolve(projectPath);
+    const resolvedPath = path18.resolve(projectPath);
     if (!isJobTypeEnabled(config, jobType)) {
       return;
     }
@@ -6576,12 +7189,12 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
       path: resolvedPath,
       config,
       schedulingPriority: normalizeSchedulingPriority(config.schedulingPriority),
-      sortKey: `${path17.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
+      sortKey: `${path18.basename(resolvedPath).toLowerCase()}::${resolvedPath.toLowerCase()}`
     });
   };
   addPeer(currentPath, currentConfig);
   for (const entry of loadRegistry()) {
-    const resolvedPath = path17.resolve(entry.path);
+    const resolvedPath = path18.resolve(entry.path);
     if (resolvedPath === currentPath || peers.has(resolvedPath)) {
       continue;
     }
@@ -6599,7 +7212,7 @@ function collectSchedulingPeers(currentProjectDir, currentConfig, jobType) {
 }
 function getSchedulingPlan(projectDir, config, jobType) {
   const peers = collectSchedulingPeers(projectDir, config, jobType);
-  const currentPath = path17.resolve(projectDir);
+  const currentPath = path18.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);
@@ -6691,8 +7304,8 @@ var init_webhook_validator = __esm({
 
 // ../core/dist/utils/worktree-manager.js
 import { execFileSync as execFileSync4 } from "child_process";
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function gitExec(args, cwd, logFile) {
   try {
     const result = execFileSync4("git", args, {
@@ -6702,7 +7315,7 @@ function gitExec(args, cwd, logFile) {
     });
     if (logFile && result) {
       try {
-        fs19.appendFileSync(logFile, result);
+        fs20.appendFileSync(logFile, result);
       } catch {
       }
     }
@@ -6711,7 +7324,7 @@ function gitExec(args, cwd, logFile) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     if (logFile) {
       try {
-        fs19.appendFileSync(logFile, errorMessage + "\n");
+        fs20.appendFileSync(logFile, errorMessage + "\n");
       } catch {
       }
     }
@@ -6736,11 +7349,11 @@ function branchExistsRemotely(projectDir, branchName) {
 }
 function prepareBranchWorktree(options) {
   const { projectDir, worktreeDir, branchName, defaultBranch, logFile } = options;
-  if (fs19.existsSync(worktreeDir)) {
+  if (fs20.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs19.rmSync(worktreeDir, { recursive: true, force: true });
+        fs20.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -6779,11 +7392,11 @@ function prepareBranchWorktree(options) {
 }
 function prepareDetachedWorktree(options) {
   const { projectDir, worktreeDir, defaultBranch, logFile } = options;
-  if (fs19.existsSync(worktreeDir)) {
+  if (fs20.existsSync(worktreeDir)) {
     const isRegistered = isWorktreeRegistered(projectDir, worktreeDir);
     if (!isRegistered) {
       try {
-        fs19.rmSync(worktreeDir, { recursive: true, force: true });
+        fs20.rmSync(worktreeDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -6825,7 +7438,7 @@ function isWorktreeRegistered(projectDir, worktreePath) {
   }
 }
 function cleanupWorktrees(projectDir, scope) {
-  const projectName = path18.basename(projectDir);
+  const projectName = path19.basename(projectDir);
   const matchToken = scope ? scope : `${projectName}-nw`;
   const removed = [];
   try {
@@ -6860,13 +7473,13 @@ var init_worktree_manager = __esm({
 });
 
 // ../core/dist/utils/job-queue.js
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as os7 from "os";
-import * as path19 from "path";
+import * as path20 from "path";
 import Database7 from "better-sqlite3";
 function getStateDbPath() {
-  const base = process.env.NIGHT_WATCH_HOME || path19.join(os7.homedir(), GLOBAL_CONFIG_DIR);
-  return path19.join(base, STATE_DB_FILE_NAME);
+  const base = process.env.NIGHT_WATCH_HOME || path20.join(os7.homedir(), GLOBAL_CONFIG_DIR);
+  return path20.join(base, STATE_DB_FILE_NAME);
 }
 function openDb() {
   const dbPath = getStateDbPath();
@@ -6918,7 +7531,7 @@ function getLockPathForJob(projectPath, jobType) {
 }
 function isRunningEntryStale(entry) {
   const lockPath = getLockPathForJob(entry.projectPath, entry.jobType);
-  if (fs20.existsSync(lockPath)) {
+  if (fs21.existsSync(lockPath)) {
     const lockInfo = checkLockFile(lockPath);
     return { isStale: !lockInfo.running, lockPid: lockInfo.pid };
   }
@@ -7640,9 +8253,9 @@ var init_amplitude_client = __esm({
 });
 
 // ../core/dist/analytics/analytics-runner.js
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as os8 from "os";
-import * as path20 from "path";
+import * as path21 from "path";
 function parseIssuesFromResponse(text) {
   const start = text.indexOf("[");
   const end = text.lastIndexOf("]");
@@ -7671,9 +8284,9 @@ async function runAnalytics(config, projectDir) {
 
 --- AMPLITUDE DATA ---
 ${JSON.stringify(data, null, 2)}`;
-  const tmpDir = fs21.mkdtempSync(path20.join(os8.tmpdir(), "nw-analytics-"));
-  const promptFile = path20.join(tmpDir, "analytics-prompt.md");
-  fs21.writeFileSync(promptFile, prompt, "utf-8");
+  const tmpDir = fs22.mkdtempSync(path21.join(os8.tmpdir(), "nw-analytics-"));
+  const promptFile = path21.join(tmpDir, "analytics-prompt.md");
+  fs22.writeFileSync(promptFile, prompt, "utf-8");
   try {
     const provider = resolveJobProvider(config, "analytics");
     let providerCmd = PROVIDER_COMMANDS[provider];
@@ -7694,8 +8307,8 @@ set -euo pipefail
 ${providerCmd} exec --yolo "$(cat ${promptFile})" 2>&1
 `;
     }
-    const scriptFile = path20.join(tmpDir, "run-analytics.sh");
-    fs21.writeFileSync(scriptFile, scriptContent, { mode: 493 });
+    const scriptFile = path21.join(tmpDir, "run-analytics.sh");
+    fs22.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}`);
@@ -7742,7 +8355,7 @@ ${stderr}`;
     };
   } finally {
     try {
-      fs21.rmSync(tmpDir, { recursive: true, force: true });
+      fs22.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -8200,6 +8813,9 @@ __export(dist_exports, {
   DEFAULT_SLICER_SCHEDULE: () => DEFAULT_SLICER_SCHEDULE,
   DEFAULT_SUMMARY_WINDOW_HOURS: () => DEFAULT_SUMMARY_WINDOW_HOURS,
   DEFAULT_TEMPLATES_DIR: () => DEFAULT_TEMPLATES_DIR,
+  DEFAULT_WEBHOOK_TRIGGERS: () => DEFAULT_WEBHOOK_TRIGGERS,
+  DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS: () => DEFAULT_WEBHOOK_TRIGGER_MAX_SKEW_SECONDS,
+  DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV: () => DEFAULT_WEBHOOK_TRIGGER_SECRET_ENV,
   EXECUTOR_LOG_FILE: () => EXECUTOR_LOG_FILE,
   EXECUTOR_LOG_NAME: () => EXECUTOR_LOG_NAME,
   EXECUTOR_PARTIAL_LABEL: () => EXECUTOR_PARTIAL_LABEL,
@@ -8314,6 +8930,7 @@ __export(dist_exports, {
   generateMarker: () => generateMarker,
   getAllJobDefs: () => getAllJobDefs,
   getBranchTipTimestamp: () => getBranchTipTimestamp,
+  getConfigValue: () => getConfigValue,
   getCrontabInfo: () => getCrontabInfo,
   getDb: () => getDb,
   getDbPath: () => getDbPath,
@@ -8390,6 +9007,7 @@ __export(dist_exports, {
   normalizeJobConfig: () => normalizeJobConfig,
   normalizeSchedulingPriority: () => normalizeSchedulingPriority,
   parseAuditFindings: () => parseAuditFindings,
+  parseConfigValue: () => parseConfigValue,
   parsePrdDependencies: () => parsePrdDependencies,
   parseRoadmap: () => parseRoadmap,
   parseScriptResult: () => parseScriptResult,
@@ -8432,6 +9050,7 @@ __export(dist_exports, {
   scanRoadmap: () => scanRoadmap,
   sendNotifications: () => sendNotifications,
   sendWebhook: () => sendWebhook,
+  setConfigValue: () => setConfigValue,
   sleep: () => sleep,
   sliceNextItem: () => sliceNextItem,
   sliceRoadmapItem: () => sliceRoadmapItem,
@@ -8471,6 +9090,7 @@ var init_dist = __esm({
     init_cancel();
     init_checks();
     init_config_writer();
+    init_config_path();
     init_crontab();
     init_execution_history();
     init_git_utils();
@@ -8506,30 +9126,30 @@ var init_dist = __esm({
 // src/cli.ts
 import "reflect-metadata";
 import { Command as Command3 } from "commander";
-import { existsSync as existsSync33, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync21 } from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname12, join as join37 } from "path";
+import { dirname as dirname12, join as join38 } from "path";
 
 // src/commands/init.ts
 init_dist();
-import fs22 from "fs";
-import path21 from "path";
+import fs23 from "fs";
+import path22 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname6, join as join19 } from "path";
+import { dirname as dirname6, join as join20 } from "path";
 import * as readline from "readline";
 var __filename2 = fileURLToPath3(import.meta.url);
 var __dirname2 = dirname6(__filename2);
 function findTemplatesDir(startDir) {
   let d = startDir;
   for (let i = 0; i < 8; i++) {
-    const candidate = join19(d, "templates");
-    if (fs22.existsSync(candidate) && fs22.statSync(candidate).isDirectory()) {
+    const candidate = join20(d, "templates");
+    if (fs23.existsSync(candidate) && fs23.statSync(candidate).isDirectory()) {
       return candidate;
     }
     d = dirname6(d);
   }
-  return join19(startDir, "templates");
+  return join20(startDir, "templates");
 }
 var TEMPLATES_DIR = findTemplatesDir(__dirname2);
 var NW_SKILLS = [
@@ -8541,12 +9161,12 @@ var NW_SKILLS = [
   "nw-review"
 ];
 function hasPlaywrightDependency(cwd) {
-  const packageJsonPath = path21.join(cwd, "package.json");
-  if (!fs22.existsSync(packageJsonPath)) {
+  const packageJsonPath = path22.join(cwd, "package.json");
+  if (!fs23.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson2 = JSON.parse(fs23.readFileSync(packageJsonPath, "utf-8"));
     return Boolean(
       packageJson2.dependencies?.["@playwright/test"] || packageJson2.dependencies?.playwright || packageJson2.devDependencies?.["@playwright/test"] || packageJson2.devDependencies?.playwright
     );
@@ -8558,7 +9178,7 @@ function detectPlaywright(cwd) {
   if (hasPlaywrightDependency(cwd)) {
     return true;
   }
-  if (fs22.existsSync(path21.join(cwd, "node_modules", ".bin", "playwright"))) {
+  if (fs23.existsSync(path22.join(cwd, "node_modules", ".bin", "playwright"))) {
     return true;
   }
   try {
@@ -8574,10 +9194,10 @@ function detectPlaywright(cwd) {
   }
 }
 function resolvePlaywrightInstallCommand(cwd) {
-  if (fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs23.existsSync(path22.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm add -D @playwright/test";
   }
-  if (fs22.existsSync(path21.join(cwd, "yarn.lock"))) {
+  if (fs23.existsSync(path22.join(cwd, "yarn.lock"))) {
     return "yarn add -D @playwright/test";
   }
   return "npm install -D @playwright/test";
@@ -8723,8 +9343,8 @@ function promptProviderSelection(providers) {
   });
 }
 function ensureDir(dirPath) {
-  if (!fs22.existsSync(dirPath)) {
-    fs22.mkdirSync(dirPath, { recursive: true });
+  if (!fs23.existsSync(dirPath)) {
+    fs23.mkdirSync(dirPath, { recursive: true });
   }
 }
 function buildInitConfig(params) {
@@ -8780,35 +9400,47 @@ function buildInitConfig(params) {
     queue: {
       ...defaults.queue,
       priority: { ...defaults.queue.priority }
+    },
+    webhookTriggers: {
+      ...defaults.webhookTriggers,
+      allowedJobIds: [...defaults.webhookTriggers.allowedJobIds],
+      github: {
+        ...defaults.webhookTriggers.github,
+        events: [...defaults.webhookTriggers.github.events],
+        rules: defaults.webhookTriggers.github.rules.map((rule) => ({
+          ...rule,
+          branchPatterns: rule.branchPatterns ? [...rule.branchPatterns] : void 0
+        }))
+      }
     }
   };
 }
 function resolveTemplatePath(templateName, customTemplatesDir, bundledTemplatesDir) {
   if (customTemplatesDir !== null) {
-    const customPath = join19(customTemplatesDir, templateName);
-    if (fs22.existsSync(customPath)) {
+    const customPath = join20(customTemplatesDir, templateName);
+    if (fs23.existsSync(customPath)) {
       return { path: customPath, source: "custom" };
     }
   }
-  return { path: join19(bundledTemplatesDir, templateName), source: "bundled" };
+  return { path: join20(bundledTemplatesDir, templateName), source: "bundled" };
 }
 function processTemplate(templateName, targetPath, replacements, force, sourcePath, source) {
-  if (fs22.existsSync(targetPath) && !force) {
+  if (fs23.existsSync(targetPath) && !force) {
     console.log(`  Skipped (exists): ${targetPath}`);
     return { created: false, source: source ?? "bundled" };
   }
-  const templatePath = sourcePath ?? join19(TEMPLATES_DIR, templateName);
+  const templatePath = sourcePath ?? join20(TEMPLATES_DIR, templateName);
   const resolvedSource = source ?? "bundled";
-  let content = fs22.readFileSync(templatePath, "utf-8");
+  let content = fs23.readFileSync(templatePath, "utf-8");
   for (const [key, value] of Object.entries(replacements)) {
     content = content.replaceAll(key, value);
   }
-  fs22.writeFileSync(targetPath, content);
+  fs23.writeFileSync(targetPath, content);
   console.log(`  Created: ${targetPath} (${resolvedSource})`);
   return { created: true, source: resolvedSource };
 }
 function addToGitignore(cwd) {
-  const gitignorePath = path21.join(cwd, ".gitignore");
+  const gitignorePath = path22.join(cwd, ".gitignore");
   const entries = [
     {
       pattern: "/logs/",
@@ -8822,13 +9454,13 @@ function addToGitignore(cwd) {
     },
     { pattern: "*.claim", label: "*.claim", check: (c) => c.includes("*.claim") }
   ];
-  if (!fs22.existsSync(gitignorePath)) {
+  if (!fs23.existsSync(gitignorePath)) {
     const lines = ["# Night Watch", ...entries.map((e) => e.pattern), ""];
-    fs22.writeFileSync(gitignorePath, lines.join("\n"));
+    fs23.writeFileSync(gitignorePath, lines.join("\n"));
     console.log(`  Created: ${gitignorePath} (with Night Watch entries)`);
     return;
   }
-  const content = fs22.readFileSync(gitignorePath, "utf-8");
+  const content = fs23.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`);
@@ -8836,59 +9468,59 @@ function addToGitignore(cwd) {
   }
   const additions = missing.map((e) => e.pattern).join("\n");
   const newContent = content.trimEnd() + "\n\n# Night Watch\n" + additions + "\n";
-  fs22.writeFileSync(gitignorePath, newContent);
+  fs23.writeFileSync(gitignorePath, newContent);
   console.log(`  Updated: ${gitignorePath} (added ${missing.map((e) => e.label).join(", ")})`);
 }
 function installSkills(cwd, provider, force, templatesDir) {
-  const skillsTemplatesDir = path21.join(templatesDir, "skills");
-  if (!fs22.existsSync(skillsTemplatesDir)) {
+  const skillsTemplatesDir = path22.join(templatesDir, "skills");
+  if (!fs23.existsSync(skillsTemplatesDir)) {
     return { location: "", installed: 0, skipped: 0, type: "none" };
   }
   const isClaudeProvider = provider === "claude" || provider.startsWith("claude");
   const isCodexProvider = provider === "codex";
-  const claudeDir = path21.join(cwd, ".claude");
-  if (isClaudeProvider || fs22.existsSync(claudeDir)) {
+  const claudeDir = path22.join(cwd, ".claude");
+  if (isClaudeProvider || fs23.existsSync(claudeDir)) {
     ensureDir(claudeDir);
-    const skillsDir = path21.join(claudeDir, "skills");
+    const skillsDir = path22.join(claudeDir, "skills");
     ensureDir(skillsDir);
     let installed = 0;
     let skipped = 0;
     for (const skillName of NW_SKILLS) {
-      const templateFile = path21.join(skillsTemplatesDir, `${skillName}.md`);
-      if (!fs22.existsSync(templateFile)) continue;
-      const skillDir = path21.join(skillsDir, skillName);
+      const templateFile = path22.join(skillsTemplatesDir, `${skillName}.md`);
+      if (!fs23.existsSync(templateFile)) continue;
+      const skillDir = path22.join(skillsDir, skillName);
       ensureDir(skillDir);
-      const target = path21.join(skillDir, "SKILL.md");
-      if (fs22.existsSync(target) && !force) {
+      const target = path22.join(skillDir, "SKILL.md");
+      if (fs23.existsSync(target) && !force) {
         skipped++;
         continue;
       }
-      fs22.copyFileSync(templateFile, target);
+      fs23.copyFileSync(templateFile, target);
       installed++;
     }
     return { location: ".claude/skills/", installed, skipped, type: "claude" };
   }
   if (isCodexProvider) {
-    const agentsFile = path21.join(cwd, "AGENTS.md");
-    const blockFile = path21.join(skillsTemplatesDir, "_codex-block.md");
-    if (!fs22.existsSync(blockFile)) {
+    const agentsFile = path22.join(cwd, "AGENTS.md");
+    const blockFile = path22.join(skillsTemplatesDir, "_codex-block.md");
+    if (!fs23.existsSync(blockFile)) {
       return { location: "", installed: 0, skipped: 0, type: "none" };
     }
-    const block = fs22.readFileSync(blockFile, "utf-8");
+    const block = fs23.readFileSync(blockFile, "utf-8");
     const marker = "## Night Watch Skills";
-    if (!fs22.existsSync(agentsFile)) {
-      fs22.writeFileSync(agentsFile, block);
+    if (!fs23.existsSync(agentsFile)) {
+      fs23.writeFileSync(agentsFile, block);
       return { location: "AGENTS.md", installed: NW_SKILLS.length, skipped: 0, type: "codex" };
     }
-    const existing = fs22.readFileSync(agentsFile, "utf-8");
+    const existing = fs23.readFileSync(agentsFile, "utf-8");
     if (existing.includes(marker)) {
       if (!force) {
         return { location: "AGENTS.md", installed: 0, skipped: NW_SKILLS.length, type: "codex" };
       }
       const withoutSection = existing.replace(/\n\n## Night Watch Skills[\s\S]*$/, "");
-      fs22.writeFileSync(agentsFile, withoutSection + "\n\n" + block);
+      fs23.writeFileSync(agentsFile, withoutSection + "\n\n" + block);
     } else {
-      fs22.appendFileSync(agentsFile, "\n\n" + block);
+      fs23.appendFileSync(agentsFile, "\n\n" + block);
     }
     return { location: "AGENTS.md", installed: NW_SKILLS.length, skipped: 0, type: "codex" };
   }
@@ -9012,28 +9644,28 @@ function initCommand(program2) {
       "${DEFAULT_BRANCH}": defaultBranch
     };
     step(6, totalSteps, "Creating PRD directory structure...");
-    const prdDirPath = path21.join(cwd, prdDir);
-    const doneDirPath = path21.join(prdDirPath, "done");
+    const prdDirPath = path22.join(cwd, prdDir);
+    const doneDirPath = path22.join(prdDirPath, "done");
     ensureDir(doneDirPath);
     success(`Created ${prdDirPath}/`);
     success(`Created ${doneDirPath}/`);
     step(7, totalSteps, "Creating logs directory...");
-    const logsPath = path21.join(cwd, LOG_DIR);
+    const logsPath = path22.join(cwd, LOG_DIR);
     ensureDir(logsPath);
     success(`Created ${logsPath}/`);
     addToGitignore(cwd);
     step(8, totalSteps, "Creating instructions directory...");
-    const instructionsDir = path21.join(cwd, "instructions");
+    const instructionsDir = path22.join(cwd, "instructions");
     ensureDir(instructionsDir);
     success(`Created ${instructionsDir}/`);
     const existingConfig = loadConfig(cwd);
-    const customTemplatesDirPath = path21.join(cwd, existingConfig.templatesDir);
-    const customTemplatesDir = fs22.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
+    const customTemplatesDirPath = path22.join(cwd, existingConfig.templatesDir);
+    const customTemplatesDir = fs23.existsSync(customTemplatesDirPath) ? customTemplatesDirPath : null;
     const templateSources = [];
     const nwResolution = resolveTemplatePath("executor.md", customTemplatesDir, TEMPLATES_DIR);
     const nwResult = processTemplate(
       "executor.md",
-      path21.join(instructionsDir, "executor.md"),
+      path22.join(instructionsDir, "executor.md"),
       replacements,
       force,
       nwResolution.path,
@@ -9047,7 +9679,7 @@ function initCommand(program2) {
     );
     const peResult = processTemplate(
       "prd-executor.md",
-      path21.join(instructionsDir, "prd-executor.md"),
+      path22.join(instructionsDir, "prd-executor.md"),
       replacements,
       force,
       peResolution.path,
@@ -9057,7 +9689,7 @@ function initCommand(program2) {
     const prResolution = resolveTemplatePath("pr-reviewer.md", customTemplatesDir, TEMPLATES_DIR);
     const prResult = processTemplate(
       "pr-reviewer.md",
-      path21.join(instructionsDir, "pr-reviewer.md"),
+      path22.join(instructionsDir, "pr-reviewer.md"),
       replacements,
       force,
       prResolution.path,
@@ -9067,7 +9699,7 @@ function initCommand(program2) {
     const qaResolution = resolveTemplatePath("qa.md", customTemplatesDir, TEMPLATES_DIR);
     const qaResult = processTemplate(
       "qa.md",
-      path21.join(instructionsDir, "qa.md"),
+      path22.join(instructionsDir, "qa.md"),
       replacements,
       force,
       qaResolution.path,
@@ -9077,7 +9709,7 @@ function initCommand(program2) {
     const auditResolution = resolveTemplatePath("audit.md", customTemplatesDir, TEMPLATES_DIR);
     const auditResult = processTemplate(
       "audit.md",
-      path21.join(instructionsDir, "audit.md"),
+      path22.join(instructionsDir, "audit.md"),
       replacements,
       force,
       auditResolution.path,
@@ -9091,7 +9723,7 @@ function initCommand(program2) {
     );
     const plannerResult = processTemplate(
       "prd-creator.md",
-      path21.join(instructionsDir, "prd-creator.md"),
+      path22.join(instructionsDir, "prd-creator.md"),
       replacements,
       force,
       plannerResolution.path,
@@ -9099,8 +9731,8 @@ function initCommand(program2) {
     );
     templateSources.push({ name: "prd-creator.md", source: plannerResult.source });
     step(9, totalSteps, "Creating configuration file...");
-    const configPath = path21.join(cwd, CONFIG_FILE_NAME);
-    if (fs22.existsSync(configPath) && !force) {
+    const configPath = path22.join(cwd, CONFIG_FILE_NAME);
+    if (fs23.existsSync(configPath) && !force) {
       console.log(`  Skipped (exists): ${configPath}`);
     } else {
       const config = buildInitConfig({
@@ -9110,11 +9742,11 @@ function initCommand(program2) {
         reviewerEnabled,
         prdDir
       });
-      fs22.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      fs23.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
       success(`Created ${configPath}`);
     }
     step(10, totalSteps, "Setting up GitHub Project board...");
-    const existingRaw = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
+    const existingRaw = JSON.parse(fs23.readFileSync(configPath, "utf-8"));
     const existingBoard = existingRaw.boardProvider;
     let boardSetupStatus = "Skipped";
     if (existingBoard?.projectNumber && !force) {
@@ -9136,13 +9768,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(fs22.readFileSync(configPath, "utf-8"));
+          const rawConfig = JSON.parse(fs23.readFileSync(configPath, "utf-8"));
           rawConfig.boardProvider = {
             enabled: true,
             provider: "github",
             projectNumber: board.number
           };
-          fs22.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+          fs23.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
           boardSetupStatus = `Created (#${board.number})`;
           success(`GitHub Project board "${boardTitle}" ready (#${board.number})`);
         } catch (boardErr) {
@@ -9278,6 +9910,7 @@ function buildBaseEnvVars(config, jobType, isDryRun) {
   if (config.defaultBranch) {
     env.NW_DEFAULT_BRANCH = config.defaultBranch;
   }
+  env.NW_PR_RESOLVER_READY_LABEL = config.prResolver?.readyLabel ?? "ready-to-merge";
   env.NW_GIT_PUSH_NO_VERIFY = config.gitPushNoVerify ? "1" : "0";
   if (config.providerEnv) {
     Object.assign(env, config.providerEnv);
@@ -9326,8 +9959,8 @@ function getTelegramStatusWebhooks(config) {
 }
 
 // src/commands/run.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 function resolveRunNotificationEvent(exitCode, scriptStatus) {
   if (exitCode === 124) {
     return "run_timeout";
@@ -9359,12 +9992,12 @@ function shouldAttemptCrossProjectFallback(options, scriptStatus) {
   return scriptStatus === "skip_no_eligible_prd";
 }
 function getCrossProjectFallbackCandidates(currentProjectDir) {
-  const current = path22.resolve(currentProjectDir);
+  const current = path23.resolve(currentProjectDir);
   const { valid, invalid } = validateRegistry();
   for (const entry of invalid) {
     warn(`Skipping invalid registry entry: ${entry.path}`);
   }
-  return valid.filter((entry) => path22.resolve(entry.path) !== current);
+  return valid.filter((entry) => path23.resolve(entry.path) !== current);
 }
 async function sendRunCompletionNotifications(config, projectDir, options, exitCode, scriptResult) {
   if (isRateLimitFallbackTriggered(scriptResult?.data)) {
@@ -9374,7 +10007,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     if (nonTelegramWebhooks.length > 0) {
       const _rateLimitCtx = {
         event: "rate_limit_fallback",
-        projectName: path22.basename(projectDir),
+        projectName: path23.basename(projectDir),
         exitCode,
         provider: config.provider
       };
@@ -9406,7 +10039,7 @@ async function sendRunCompletionNotifications(config, projectDir, options, exitC
     const timeoutDuration = event === "run_timeout" ? config.maxRuntime : void 0;
     const _ctx = {
       event,
-      projectName: path22.basename(projectDir),
+      projectName: path23.basename(projectDir),
       exitCode,
       provider: config.provider,
       prdName: scriptResult?.data.prd,
@@ -9570,20 +10203,20 @@ function applyCliOverrides(config, options) {
   return overridden;
 }
 function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
-  const absolutePrdDir = path22.join(projectDir, prdDir);
-  const doneDir = path22.join(absolutePrdDir, "done");
+  const absolutePrdDir = path23.join(projectDir, prdDir);
+  const doneDir = path23.join(absolutePrdDir, "done");
   const pending = [];
   const completed = [];
-  if (fs23.existsSync(absolutePrdDir)) {
-    const entries = fs23.readdirSync(absolutePrdDir, { withFileTypes: true });
+  if (fs24.existsSync(absolutePrdDir)) {
+    const entries = fs24.readdirSync(absolutePrdDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        const claimPath = path22.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
+        const claimPath = path23.join(absolutePrdDir, entry.name + CLAIM_FILE_EXTENSION);
         let claimed = false;
         let claimInfo = null;
-        if (fs23.existsSync(claimPath)) {
+        if (fs24.existsSync(claimPath)) {
           try {
-            const content = fs23.readFileSync(claimPath, "utf-8");
+            const content = fs24.readFileSync(claimPath, "utf-8");
             const data = JSON.parse(content);
             const age = Math.floor(Date.now() / 1e3) - data.timestamp;
             if (age < maxRuntime) {
@@ -9597,8 +10230,8 @@ function scanPrdDirectory(projectDir, prdDir, maxRuntime) {
       }
     }
   }
-  if (fs23.existsSync(doneDir)) {
-    const entries = fs23.readdirSync(doneDir, { withFileTypes: true });
+  if (fs24.existsSync(doneDir)) {
+    const entries = fs24.readdirSync(doneDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
         completed.push(entry.name);
@@ -9758,7 +10391,7 @@ ${stderr}`);
 // src/commands/review.ts
 init_dist();
 import { execFileSync as execFileSync5 } from "child_process";
-import * as path23 from "path";
+import * as path24 from "path";
 function shouldSendReviewNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -9824,76 +10457,6 @@ function parseFinalReviewScore(raw) {
   }
   return parsed;
 }
-function postReadyForHumanReviewComment(prNumber, finalScore, cwd) {
-  const markerName = "night-watch-ready-for-review";
-  let headRefOid = "";
-  try {
-    headRefOid = execFileSync5(
-      "gh",
-      ["pr", "view", String(prNumber), "--json", "headRefOid", "--jq", ".headRefOid"],
-      {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }
-    ).trim();
-  } catch {
-    headRefOid = "";
-  }
-  if (headRefOid) {
-    try {
-      const existingComments = execFileSync5(
-        "gh",
-        ["api", `repos/{owner}/{repo}/issues/${prNumber}/comments`, "--jq", ".[].body"],
-        {
-          cwd,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        }
-      );
-      const marker2 = `<!-- ${markerName} headRefOid:${headRefOid} -->`;
-      if (existingComments.includes(marker2)) {
-        try {
-          execFileSync5("gh", ["pr", "edit", String(prNumber), "--add-label", "ready-for-review"], {
-            cwd,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-        } catch {
-        }
-        return;
-      }
-    } catch {
-    }
-  }
-  const scoreNote = finalScore !== void 0 ? ` (score: ${finalScore}/100)` : "";
-  const shortSha = headRefOid ? headRefOid.slice(0, 12) : "";
-  const marker = headRefOid ? `<!-- ${markerName} headRefOid:${headRefOid} -->
-
-` : "";
-  const shaNote = shortSha ? ` at commit \`${shortSha}\`` : "";
-  const body = `${marker}## \u2705 Ready for Human Review
-
-Night Watch has reviewed this PR${scoreNote}${shaNote} and found no issues requiring automated fixes for the current head.
-
-This PR is ready for human code review and merge.`;
-  try {
-    execFileSync5("gh", ["pr", "comment", String(prNumber), "--body", body], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-  }
-  try {
-    execFileSync5("gh", ["pr", "edit", String(prNumber), "--add-label", "ready-for-review"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-  }
-}
 function buildEnvVars2(config, options) {
   const env = buildBaseEnvVars(config, "reviewer", options.dryRun);
   env.NW_REVIEWER_MAX_RUNTIME = String(config.reviewerMaxRuntime);
@@ -9903,6 +10466,7 @@ function buildEnvVars2(config, options) {
   env.NW_MIN_REVIEW_SCORE = String(config.minReviewScore);
   env.NW_BRANCH_PATTERNS = config.branchPatterns.join(",");
   env.NW_PRD_DIR = config.prdDir;
+  env.NW_PR_RESOLVER_READY_LABEL = config.prResolver.readyLabel;
   env.NW_CLAUDE_MODEL_ID = CLAUDE_MODEL_IDS[config.primaryFallbackModel ?? config.claudeModel ?? "sonnet"];
   return env;
 }
@@ -10108,7 +10672,7 @@ ${stderr}`);
             const reviewEvent = legacyNoChangesNeeded ? "review_ready_for_human" : "review_completed";
             await sendNotifications(config, {
               event: reviewEvent,
-              projectName: path23.basename(projectDir),
+              projectName: path24.basename(projectDir),
               exitCode,
               provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
               prUrl: fallbackPrDetails?.url,
@@ -10124,13 +10688,10 @@ ${stderr}`);
           } else {
             for (const target of notificationTargets) {
               const prDetails = fallbackPrDetails?.number === target.prNumber ? fallbackPrDetails : fetchPrDetailsByNumber(target.prNumber, projectDir);
-              if (target.noChangesNeeded && prDetails?.number) {
-                postReadyForHumanReviewComment(prDetails.number, finalScore, projectDir);
-              }
               const reviewEvent = target.noChangesNeeded ? "review_ready_for_human" : "review_completed";
               await sendNotifications(config, {
                 event: reviewEvent,
-                projectName: path23.basename(projectDir),
+                projectName: path24.basename(projectDir),
                 exitCode,
                 provider: formatProviderDisplay(
                   envVars.NW_PROVIDER_CMD,
@@ -10155,7 +10716,7 @@ ${stderr}`);
           const autoMergedPrDetails = fetchPrDetailsByNumber(autoMergedPrNumber, projectDir);
           const _mergeCtx = {
             event: "pr_auto_merged",
-            projectName: path23.basename(projectDir),
+            projectName: path24.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: autoMergedPrDetails?.number ?? autoMergedPrNumber,
@@ -10180,7 +10741,7 @@ ${stderr}`);
 
 // src/commands/qa.ts
 init_dist();
-import * as path24 from "path";
+import * as path25 from "path";
 function shouldSendQaNotification(scriptStatus) {
   if (!scriptStatus) {
     return true;
@@ -10321,7 +10882,7 @@ ${stderr}`);
           const qaScreenshotUrls = primaryQaPr !== void 0 ? fetchQaScreenshotUrlsForPr(primaryQaPr, projectDir, repo) : [];
           const _qaCtx = {
             event: "qa_completed",
-            projectName: path24.basename(projectDir),
+            projectName: path25.basename(projectDir),
             exitCode,
             provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL),
             prNumber: prDetails?.number ?? primaryQaPr,
@@ -10347,8 +10908,8 @@ ${stderr}`);
 
 // src/commands/audit.ts
 init_dist();
-import * as fs24 from "fs";
-import * as path25 from "path";
+import * as fs25 from "fs";
+import * as path26 from "path";
 function buildEnvVars4(config, options) {
   const env = buildBaseEnvVars(config, "audit", options.dryRun);
   env.NW_AUDIT_MAX_RUNTIME = String(config.audit.maxRuntime);
@@ -10392,7 +10953,7 @@ function auditCommand(program2) {
       configTable.push(["Provider CLI", PROVIDER_COMMANDS[auditProvider]]);
       configTable.push(["Max Runtime", `${config.audit.maxRuntime}s`]);
       configTable.push(["Target Column", config.audit.targetColumn]);
-      configTable.push(["Report File", path25.join(projectDir, "logs", "audit-report.md")]);
+      configTable.push(["Report File", path26.join(projectDir, "logs", "audit-report.md")]);
       console.log(configTable.toString());
       header("Provider Invocation");
       const providerCmd = PROVIDER_COMMANDS[auditProvider];
@@ -10427,8 +10988,8 @@ ${stderr}`);
         } else if (scriptResult?.status?.startsWith("skip_")) {
           spinner.succeed("Code audit skipped");
         } else {
-          const reportPath = path25.join(projectDir, "logs", "audit-report.md");
-          if (!fs24.existsSync(reportPath)) {
+          const reportPath = path26.join(projectDir, "logs", "audit-report.md");
+          if (!fs25.existsSync(reportPath)) {
             spinner.fail("Code audit finished without a report file");
             process.exit(1);
           }
@@ -10445,9 +11006,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 = path25.join(projectDir, "logs", "audit.log");
-        if (fs24.existsSync(logPath)) {
-          const logLines = fs24.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
+        const logPath = path26.join(projectDir, "logs", "audit.log");
+        if (fs25.existsSync(logPath)) {
+          const logLines = fs25.readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim()).slice(-8);
           if (logLines.length > 0) {
             process.stderr.write(logLines.join("\n") + "\n");
           }
@@ -10521,16 +11082,16 @@ function analyticsCommand(program2) {
 // src/commands/install.ts
 init_dist();
 import { execSync as execSync4 } from "child_process";
-import * as path26 from "path";
-import * as fs25 from "fs";
+import * as path27 from "path";
+import * as fs26 from "fs";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function getNightWatchBinPath() {
   try {
     const npmBin = execSync4("npm bin -g", { encoding: "utf-8" }).trim();
-    const binPath = path26.join(npmBin, "night-watch");
-    if (fs25.existsSync(binPath)) {
+    const binPath = path27.join(npmBin, "night-watch");
+    if (fs26.existsSync(binPath)) {
       return binPath;
     }
   } catch {
@@ -10543,17 +11104,17 @@ function getNightWatchBinPath() {
 }
 function getNodeBinDir() {
   if (process.execPath && process.execPath !== "node") {
-    return path26.dirname(process.execPath);
+    return path27.dirname(process.execPath);
   }
   try {
     const nodePath = execSync4("which node", { encoding: "utf-8" }).trim();
-    return path26.dirname(nodePath);
+    return path27.dirname(nodePath);
   } catch {
     return "";
   }
 }
 function buildCronPathPrefix(nodeBinDir, nightWatchBin) {
-  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path26.dirname(nightWatchBin) : "";
+  const nightWatchBinDir = nightWatchBin.includes("/") || nightWatchBin.includes("\\") ? path27.dirname(nightWatchBin) : "";
   const pathParts = Array.from(
     new Set([nodeBinDir, nightWatchBinDir].filter((part) => part.length > 0))
   );
@@ -10569,12 +11130,12 @@ function performInstall(projectDir, config, options) {
     const nightWatchBin = getNightWatchBinPath();
     const projectName = getProjectName(projectDir);
     const marker = generateMarker(projectName);
-    const logDir = path26.join(projectDir, LOG_DIR);
-    if (!fs25.existsSync(logDir)) {
-      fs25.mkdirSync(logDir, { recursive: true });
+    const logDir = path27.join(projectDir, LOG_DIR);
+    if (!fs26.existsSync(logDir)) {
+      fs26.mkdirSync(logDir, { recursive: true });
     }
-    const executorLog = path26.join(logDir, "executor.log");
-    const reviewerLog = path26.join(logDir, "reviewer.log");
+    const executorLog = path27.join(logDir, "executor.log");
+    const reviewerLog = path27.join(logDir, "reviewer.log");
     if (!options?.force) {
       const existingEntries2 = Array.from(
         /* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)])
@@ -10611,7 +11172,7 @@ function performInstall(projectDir, config, options) {
     const installSlicer = options?.noSlicer === true ? false : config.roadmapScanner.enabled;
     if (installSlicer) {
       const slicerSchedule = config.roadmapScanner.slicerSchedule;
-      const slicerLog = path26.join(logDir, "slicer.log");
+      const slicerLog = path27.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);
     }
@@ -10619,7 +11180,7 @@ function performInstall(projectDir, config, options) {
     const installQa = disableQa ? false : config.qa.enabled;
     if (installQa) {
       const qaSchedule = config.qa.schedule;
-      const qaLog = path26.join(logDir, "qa.log");
+      const qaLog = path27.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);
     }
@@ -10627,7 +11188,7 @@ function performInstall(projectDir, config, options) {
     const installAudit = disableAudit ? false : config.audit.enabled;
     if (installAudit) {
       const auditSchedule = config.audit.schedule;
-      const auditLog = path26.join(logDir, "audit.log");
+      const auditLog = path27.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);
     }
@@ -10635,7 +11196,7 @@ function performInstall(projectDir, config, options) {
     const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
     if (installAnalytics) {
       const analyticsSchedule = config.analytics.schedule;
-      const analyticsLog = path26.join(logDir, "analytics.log");
+      const analyticsLog = path27.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);
     }
@@ -10643,7 +11204,7 @@ function performInstall(projectDir, config, options) {
     const installPrResolver = disablePrResolver ? false : config.prResolver.enabled;
     if (installPrResolver) {
       const prResolverSchedule = config.prResolver.schedule;
-      const prResolverLog = path26.join(logDir, "pr-resolver.log");
+      const prResolverLog = path27.join(logDir, "pr-resolver.log");
       const prResolverEntry = `${prResolverSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} resolve >> ${shellQuote(prResolverLog)} 2>&1  ${marker}`;
       entries.push(prResolverEntry);
     }
@@ -10651,7 +11212,7 @@ function performInstall(projectDir, config, options) {
     const installMerger = disableMerger ? false : config.merger?.enabled ?? false;
     if (installMerger) {
       const mergerSchedule = config.merger.schedule;
-      const mergerLog = path26.join(logDir, "merger.log");
+      const mergerLog = path27.join(logDir, "merger.log");
       const mergerEntry = `${mergerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} merge >> ${shellQuote(mergerLog)} 2>&1  ${marker}`;
       entries.push(mergerEntry);
     }
@@ -10682,12 +11243,12 @@ function installCommand(program2) {
       const nightWatchBin = getNightWatchBinPath();
       const projectName = getProjectName(projectDir);
       const marker = generateMarker(projectName);
-      const logDir = path26.join(projectDir, LOG_DIR);
-      if (!fs25.existsSync(logDir)) {
-        fs25.mkdirSync(logDir, { recursive: true });
+      const logDir = path27.join(projectDir, LOG_DIR);
+      if (!fs26.existsSync(logDir)) {
+        fs26.mkdirSync(logDir, { recursive: true });
       }
-      const executorLog = path26.join(logDir, "executor.log");
-      const reviewerLog = path26.join(logDir, "reviewer.log");
+      const executorLog = path27.join(logDir, "executor.log");
+      const reviewerLog = path27.join(logDir, "reviewer.log");
       const existingEntries = Array.from(
         /* @__PURE__ */ new Set([...getEntries(marker), ...getProjectEntries(projectDir)])
       );
@@ -10723,7 +11284,7 @@ function installCommand(program2) {
       const installSlicer = options.noSlicer === true ? false : config.roadmapScanner.enabled;
       let slicerLog;
       if (installSlicer) {
-        slicerLog = path26.join(logDir, "slicer.log");
+        slicerLog = path27.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);
@@ -10732,7 +11293,7 @@ function installCommand(program2) {
       const installQa = disableQa ? false : config.qa.enabled;
       let qaLog;
       if (installQa) {
-        qaLog = path26.join(logDir, "qa.log");
+        qaLog = path27.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);
@@ -10741,7 +11302,7 @@ function installCommand(program2) {
       const installAudit = disableAudit ? false : config.audit.enabled;
       let auditLog;
       if (installAudit) {
-        auditLog = path26.join(logDir, "audit.log");
+        auditLog = path27.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);
@@ -10750,7 +11311,7 @@ function installCommand(program2) {
       const installAnalytics = disableAnalytics ? false : config.analytics.enabled;
       let analyticsLog;
       if (installAnalytics) {
-        analyticsLog = path26.join(logDir, "analytics.log");
+        analyticsLog = path27.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);
@@ -10759,7 +11320,7 @@ function installCommand(program2) {
       const installPrResolver = disablePrResolver ? false : config.prResolver.enabled;
       let prResolverLog;
       if (installPrResolver) {
-        prResolverLog = path26.join(logDir, "pr-resolver.log");
+        prResolverLog = path27.join(logDir, "pr-resolver.log");
         const prResolverSchedule = config.prResolver.schedule;
         const prResolverEntry = `${prResolverSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} resolve >> ${shellQuote(prResolverLog)} 2>&1  ${marker}`;
         entries.push(prResolverEntry);
@@ -10768,7 +11329,7 @@ function installCommand(program2) {
       const installMerger = disableMerger ? false : config.merger?.enabled ?? false;
       let mergerLog;
       if (installMerger) {
-        mergerLog = path26.join(logDir, "merger.log");
+        mergerLog = path27.join(logDir, "merger.log");
         const mergerSchedule = config.merger.schedule;
         const mergerEntry = `${mergerSchedule} ${pathPrefix}${providerEnvPrefix}${cliBinPrefix}${cronTriggerPrefix}cd ${shellQuote(projectDir)} && ${shellQuote(nightWatchBin)} merge >> ${shellQuote(mergerLog)} 2>&1  ${marker}`;
         entries.push(mergerEntry);
@@ -10822,8 +11383,8 @@ function installCommand(program2) {
 
 // src/commands/uninstall.ts
 init_dist();
-import * as path27 from "path";
-import * as fs26 from "fs";
+import * as path28 from "path";
+import * as fs27 from "fs";
 function performUninstall(projectDir, options) {
   try {
     const projectName = getProjectName(projectDir);
@@ -10838,8 +11399,8 @@ function performUninstall(projectDir, options) {
     const removedCount = removeEntriesForProject(projectDir, marker);
     unregisterProject(projectDir);
     if (!options?.keepLogs) {
-      const logDir = path27.join(projectDir, "logs");
-      if (fs26.existsSync(logDir)) {
+      const logDir = path28.join(projectDir, "logs");
+      if (fs27.existsSync(logDir)) {
         const logFiles = [
           "executor.log",
           "reviewer.log",
@@ -10848,15 +11409,15 @@ function performUninstall(projectDir, options) {
           "pr-resolver.log"
         ];
         logFiles.forEach((logFile) => {
-          const logPath = path27.join(logDir, logFile);
-          if (fs26.existsSync(logPath)) {
-            fs26.unlinkSync(logPath);
+          const logPath = path28.join(logDir, logFile);
+          if (fs27.existsSync(logPath)) {
+            fs27.unlinkSync(logPath);
           }
         });
         try {
-          const remainingFiles = fs26.readdirSync(logDir);
+          const remainingFiles = fs27.readdirSync(logDir);
           if (remainingFiles.length === 0) {
-            fs26.rmdirSync(logDir);
+            fs27.rmdirSync(logDir);
           }
         } catch {
         }
@@ -10889,8 +11450,8 @@ function uninstallCommand(program2) {
       existingEntries.forEach((entry) => dim(`  ${entry}`));
       const removedCount = removeEntriesForProject(projectDir, marker);
       if (!options.keepLogs) {
-        const logDir = path27.join(projectDir, "logs");
-        if (fs26.existsSync(logDir)) {
+        const logDir = path28.join(projectDir, "logs");
+        if (fs27.existsSync(logDir)) {
           const logFiles = [
             "executor.log",
             "reviewer.log",
@@ -10900,16 +11461,16 @@ function uninstallCommand(program2) {
           ];
           let logsRemoved = 0;
           logFiles.forEach((logFile) => {
-            const logPath = path27.join(logDir, logFile);
-            if (fs26.existsSync(logPath)) {
-              fs26.unlinkSync(logPath);
+            const logPath = path28.join(logDir, logFile);
+            if (fs27.existsSync(logPath)) {
+              fs27.unlinkSync(logPath);
               logsRemoved++;
             }
           });
           try {
-            const remainingFiles = fs26.readdirSync(logDir);
+            const remainingFiles = fs27.readdirSync(logDir);
             if (remainingFiles.length === 0) {
-              fs26.rmdirSync(logDir);
+              fs27.rmdirSync(logDir);
             }
           } catch {
           }
@@ -11195,14 +11756,14 @@ function statusCommand(program2) {
 // src/commands/logs.ts
 init_dist();
 import { spawn as spawn3 } from "child_process";
-import * as path28 from "path";
-import * as fs27 from "fs";
+import * as path29 from "path";
+import * as fs28 from "fs";
 function getLastLines(filePath, lineCount) {
-  if (!fs27.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     return `Log file not found: ${filePath}`;
   }
   try {
-    const content = fs27.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     const lines = content.trim().split("\n");
     return lines.slice(-lineCount).join("\n");
   } catch (error2) {
@@ -11210,7 +11771,7 @@ function getLastLines(filePath, lineCount) {
   }
 }
 function followLog(filePath) {
-  if (!fs27.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     console.log(`Log file not found: ${filePath}`);
     console.log("The log file will be created when the first execution runs.");
     return;
@@ -11234,15 +11795,15 @@ function logsCommand(program2) {
   ).action(async (options) => {
     try {
       const projectDir = process.cwd();
-      const logDir = path28.join(projectDir, LOG_DIR);
+      const logDir = path29.join(projectDir, LOG_DIR);
       const lineCount = parseInt(options.lines || "50", 10);
-      const executorLog = path28.join(logDir, EXECUTOR_LOG_FILE);
-      const reviewerLog = path28.join(logDir, REVIEWER_LOG_FILE);
-      const qaLog = path28.join(logDir, `${QA_LOG_NAME}.log`);
-      const auditLog = path28.join(logDir, `${AUDIT_LOG_NAME}.log`);
-      const plannerLog = path28.join(logDir, `${PLANNER_LOG_NAME}.log`);
-      const analyticsLog = path28.join(logDir, `${ANALYTICS_LOG_NAME}.log`);
-      const mergerLog = path28.join(logDir, `${MERGER_LOG_NAME}.log`);
+      const executorLog = path29.join(logDir, EXECUTOR_LOG_FILE);
+      const reviewerLog = path29.join(logDir, REVIEWER_LOG_FILE);
+      const qaLog = path29.join(logDir, `${QA_LOG_NAME}.log`);
+      const auditLog = path29.join(logDir, `${AUDIT_LOG_NAME}.log`);
+      const plannerLog = path29.join(logDir, `${PLANNER_LOG_NAME}.log`);
+      const analyticsLog = path29.join(logDir, `${ANALYTICS_LOG_NAME}.log`);
+      const mergerLog = path29.join(logDir, `${MERGER_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";
@@ -11325,8 +11886,8 @@ function logsCommand(program2) {
 // src/commands/prd.ts
 init_dist();
 import { execSync as execSync5, spawn as spawn4, spawnSync } from "child_process";
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { dirname as dirname9 } from "path";
 var __filename3 = fileURLToPath4(import.meta.url);
@@ -11334,21 +11895,21 @@ var __dirname3 = dirname9(__filename3);
 function findTemplatesDir2(startDir) {
   let current = startDir;
   for (let i = 0; i < 8; i++) {
-    const candidate = path29.join(current, "templates");
-    if (fs28.existsSync(candidate) && fs28.statSync(candidate).isDirectory()) {
+    const candidate = path30.join(current, "templates");
+    if (fs29.existsSync(candidate) && fs29.statSync(candidate).isDirectory()) {
       return candidate;
     }
-    current = path29.dirname(current);
+    current = path30.dirname(current);
   }
-  return path29.join(startDir, "templates");
+  return path30.join(startDir, "templates");
 }
 var TEMPLATES_DIR2 = findTemplatesDir2(__dirname3);
 function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function getNextPrdNumber2(prdDir) {
-  if (!fs28.existsSync(prdDir)) return 1;
-  const files = fs28.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+  if (!fs29.existsSync(prdDir)) return 1;
+  const files = fs29.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
   const numbers = files.map((f) => {
     const match = f.match(/^(\d+)-/);
     return match ? parseInt(match[1], 10) : 0;
@@ -11429,13 +11990,13 @@ function resolveGitHubBlobUrl(projectDir, relPath) {
       return null;
     }
     const ref = branch && branch !== "HEAD" ? branch : "main";
-    return `${httpsBase}/blob/${encodeURIComponent(ref).replace(/%2F/g, "/")}/${relPath.split(path29.sep).map((segment) => encodeURIComponent(segment)).join("/")}`;
+    return `${httpsBase}/blob/${encodeURIComponent(ref).replace(/%2F/g, "/")}/${relPath.split(path30.sep).map((segment) => encodeURIComponent(segment)).join("/")}`;
   } catch {
     return null;
   }
 }
 function buildGithubIssueBody(prdPath, projectDir, prdContent) {
-  const relPath = path29.relative(projectDir, prdPath);
+  const relPath = path30.relative(projectDir, prdPath);
   const blobUrl = resolveGitHubBlobUrl(projectDir, relPath);
   const fileLine = blobUrl ? `PRD file: [\`${relPath}\`](${blobUrl})` : `PRD file: \`${relPath}\``;
   return `${fileLine}
@@ -11446,13 +12007,13 @@ ${prdContent}
 Created via \`night-watch prd create\`.`;
 }
 async function generatePrdWithClaude(description, projectDir, model) {
-  const bundledTemplatePath = path29.join(TEMPLATES_DIR2, "prd-creator.md");
-  const installedTemplatePath = path29.join(projectDir, "instructions", "prd-creator.md");
-  const templatePath = fs28.existsSync(installedTemplatePath) ? installedTemplatePath : bundledTemplatePath;
-  if (!fs28.existsSync(templatePath)) {
+  const bundledTemplatePath = path30.join(TEMPLATES_DIR2, "prd-creator.md");
+  const installedTemplatePath = path30.join(projectDir, "instructions", "prd-creator.md");
+  const templatePath = fs29.existsSync(installedTemplatePath) ? installedTemplatePath : bundledTemplatePath;
+  if (!fs29.existsSync(templatePath)) {
     return null;
   }
-  const planningPrinciples = fs28.readFileSync(templatePath, "utf-8");
+  const planningPrinciples = fs29.readFileSync(templatePath, "utf-8");
   const prompt = buildPrdPrompt(description, projectDir, planningPrinciples);
   const modelId = model ?? CLAUDE_MODEL_IDS.opus;
   const env = buildNativeClaudeEnv(process.env);
@@ -11520,17 +12081,17 @@ function runGh(args, cwd) {
   return null;
 }
 function createGithubIssue(title, prdPath, projectDir, prdContent) {
-  const tmpFile = path29.join(projectDir, `.prd-issue-body-${Date.now()}.tmp`);
+  const tmpFile = path30.join(projectDir, `.prd-issue-body-${Date.now()}.tmp`);
   try {
     const body = buildGithubIssueBody(prdPath, projectDir, prdContent);
-    fs28.writeFileSync(tmpFile, body, "utf-8");
+    fs29.writeFileSync(tmpFile, body, "utf-8");
     const baseArgs = ["issue", "create", "--title", `PRD: ${title}`, "--body-file", tmpFile];
     return runGh([...baseArgs, "--label", "prd"], projectDir) ?? runGh(baseArgs, projectDir);
   } catch {
     return null;
   } finally {
     try {
-      fs28.unlinkSync(tmpFile);
+      fs29.unlinkSync(tmpFile);
     } catch {
     }
   }
@@ -11542,10 +12103,10 @@ function parseDependencies(content) {
 }
 function isClaimActive(claimPath, maxRuntime) {
   try {
-    if (!fs28.existsSync(claimPath)) {
+    if (!fs29.existsSync(claimPath)) {
       return { active: false };
     }
-    const content = fs28.readFileSync(claimPath, "utf-8");
+    const content = fs29.readFileSync(claimPath, "utf-8");
     const claim = JSON.parse(content);
     const age = Math.floor(Date.now() / 1e3) - claim.timestamp;
     if (age < maxRuntime) {
@@ -11560,9 +12121,9 @@ function prdCommand(program2) {
   const prd = program2.command("prd").description("Manage PRD files");
   prd.command("create").description("Generate a new PRD markdown file using Claude").argument("<name>", "PRD description").option("--number", "Add auto-numbering prefix to the filename", false).option("--model <model>", "Claude model to use (e.g. sonnet, opus, or a full model ID)").action(async (name, options) => {
     const projectDir = process.cwd();
-    const prdDir = path29.join(projectDir, resolvePrdCreateDir());
-    if (!fs28.existsSync(prdDir)) {
-      fs28.mkdirSync(prdDir, { recursive: true });
+    const prdDir = path30.join(projectDir, resolvePrdCreateDir());
+    if (!fs29.existsSync(prdDir)) {
+      fs29.mkdirSync(prdDir, { recursive: true });
     }
     const resolvedModel = options.model ? CLAUDE_MODEL_IDS[options.model] ?? options.model : void 0;
     const modelLabel = resolvedModel ?? CLAUDE_MODEL_IDS.opus;
@@ -11576,13 +12137,13 @@ function prdCommand(program2) {
     const prdTitle = extractPrdTitle(generated) ?? name;
     const slug = slugify2(prdTitle);
     const filename = options.number ? `${String(getNextPrdNumber2(prdDir)).padStart(2, "0")}-${slug}.md` : `${slug}.md`;
-    const filePath = path29.join(prdDir, filename);
-    if (fs28.existsSync(filePath)) {
+    const filePath = path30.join(prdDir, filename);
+    if (fs29.existsSync(filePath)) {
       error(`File already exists: ${filePath}`);
       dim("Use a different name or remove the existing file.");
       process.exit(1);
     }
-    fs28.writeFileSync(filePath, generated, "utf-8");
+    fs29.writeFileSync(filePath, generated, "utf-8");
     header("PRD Created");
     success(`Created: ${filePath}`);
     const issueUrl = createGithubIssue(prdTitle, filePath, projectDir, generated);
@@ -11595,15 +12156,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 = path29.join(projectDir, config.prdDir);
-    const doneDir = path29.join(absolutePrdDir, "done");
+    const absolutePrdDir = path30.join(projectDir, config.prdDir);
+    const doneDir = path30.join(absolutePrdDir, "done");
     const pending = [];
-    if (fs28.existsSync(absolutePrdDir)) {
-      const files = fs28.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md"));
+    if (fs29.existsSync(absolutePrdDir)) {
+      const files = fs29.readdirSync(absolutePrdDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs28.readFileSync(path29.join(absolutePrdDir, file), "utf-8");
+        const content = fs29.readFileSync(path30.join(absolutePrdDir, file), "utf-8");
         const deps = parseDependencies(content);
-        const claimPath = path29.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
+        const claimPath = path30.join(absolutePrdDir, file + CLAIM_FILE_EXTENSION);
         const claimStatus = isClaimActive(claimPath, config.maxRuntime);
         pending.push({
           name: file,
@@ -11614,10 +12175,10 @@ function prdCommand(program2) {
       }
     }
     const done = [];
-    if (fs28.existsSync(doneDir)) {
-      const files = fs28.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+    if (fs29.existsSync(doneDir)) {
+      const files = fs29.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const content = fs28.readFileSync(path29.join(doneDir, file), "utf-8");
+        const content = fs29.readFileSync(path30.join(doneDir, file), "utf-8");
         const deps = parseDependencies(content);
         done.push({ name: file, dependencies: deps });
       }
@@ -11654,7 +12215,7 @@ import blessed6 from "blessed";
 // src/commands/dashboard/tab-status.ts
 init_dist();
 import blessed from "blessed";
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 function sortPrdsByPriority(prds, priority) {
   if (priority.length === 0) return prds;
   const priorityMap = /* @__PURE__ */ new Map();
@@ -11750,7 +12311,7 @@ function renderLogPane(projectDir, logs) {
   let newestMtime = 0;
   for (const log of existingLogs) {
     try {
-      const stat = fs29.statSync(log.path);
+      const stat = fs30.statSync(log.path);
       if (stat.mtimeMs > newestMtime) {
         newestMtime = stat.mtimeMs;
         newestLog = log;
@@ -13406,8 +13967,8 @@ function createActionsTab() {
 // src/commands/dashboard/tab-logs.ts
 init_dist();
 import blessed5 from "blessed";
-import * as fs30 from "fs";
-import * as path30 from "path";
+import * as fs31 from "fs";
+import * as path31 from "path";
 var LOG_NAMES = ["executor", "reviewer"];
 var LOG_LINES = 200;
 function createLogsTab() {
@@ -13448,7 +14009,7 @@ function createLogsTab() {
   let activeKeyHandlers = [];
   let activeCtx = null;
   function getLogPath(projectDir, logName) {
-    return path30.join(projectDir, "logs", `${logName}.log`);
+    return path31.join(projectDir, "logs", `${logName}.log`);
   }
   function updateSelector() {
     const tabs = LOG_NAMES.map((name, idx) => {
@@ -13462,7 +14023,7 @@ function createLogsTab() {
   function loadLog(ctx) {
     const logName = LOG_NAMES[selectedLogIndex];
     const logPath = getLogPath(ctx.projectDir, logName);
-    if (!fs30.existsSync(logPath)) {
+    if (!fs31.existsSync(logPath)) {
       logContent.setContent(
         `{yellow-fg}No ${logName}.log file found{/yellow-fg}
 
@@ -13472,7 +14033,7 @@ Log will appear here once the ${logName} runs.`
       return;
     }
     try {
-      const stat = fs30.statSync(logPath);
+      const stat = fs31.statSync(logPath);
       const sizeKB = (stat.size / 1024).toFixed(1);
       logContent.setLabel(`[ ${logName}.log - ${sizeKB} KB ]`);
     } catch {
@@ -13970,12 +14531,12 @@ function doctorCommand(program2) {
 
 // src/commands/serve.ts
 init_dist();
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 
 // ../server/dist/index.js
 init_dist();
-import * as fs34 from "fs";
-import * as path36 from "path";
+import * as fs35 from "fs";
+import * as path37 from "path";
 import { dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import cors from "cors";
@@ -14060,8 +14621,8 @@ function setupGracefulShutdown(server, beforeClose) {
 
 // ../server/dist/middleware/project-resolver.middleware.js
 init_dist();
-import * as fs31 from "fs";
-import * as path31 from "path";
+import * as fs32 from "fs";
+import * as path32 from "path";
 function resolveProject(req, res, next) {
   const projectId = req.params.projectId;
   const decodedId = decodeURIComponent(projectId).replace(/~/g, "/");
@@ -14071,7 +14632,7 @@ function resolveProject(req, res, next) {
     res.status(404).json({ error: `Project not found: ${decodedId}` });
     return;
   }
-  if (!fs31.existsSync(entry.path) || !fs31.existsSync(path31.join(entry.path, CONFIG_FILE_NAME))) {
+  if (!fs32.existsSync(entry.path) || !fs32.existsSync(path32.join(entry.path, CONFIG_FILE_NAME))) {
     res.status(404).json({ error: `Project path invalid or missing config: ${entry.path}` });
     return;
   }
@@ -14116,8 +14677,8 @@ function startSseStatusWatcher(clients, projectDir, getConfig) {
 
 // ../server/dist/routes/action.routes.js
 init_dist();
-import * as fs32 from "fs";
-import * as path32 from "path";
+import * as fs33 from "fs";
+import * as path33 from "path";
 import { execSync as execSync6, spawn as spawn6 } from "child_process";
 import { Router } from "express";
 
@@ -14155,17 +14716,17 @@ function getBoardProvider(config, projectDir) {
 function cleanOrphanedClaims(dir) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir, { withFileTypes: true });
+    entries = fs33.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path32.join(dir, entry.name);
+    const fullPath = path33.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "done") {
       cleanOrphanedClaims(fullPath);
     } else if (entry.name.endsWith(CLAIM_FILE_EXTENSION)) {
       try {
-        fs32.unlinkSync(fullPath);
+        fs33.unlinkSync(fullPath);
       } catch {
       }
     }
@@ -14320,19 +14881,19 @@ function createActionRouteHandlers(ctx) {
         res.status(400).json({ error: "Invalid PRD name" });
         return;
       }
-      const prdDir = path32.join(projectDir, config.prdDir);
+      const prdDir = path33.join(projectDir, config.prdDir);
       const normalized = prdName.endsWith(".md") ? prdName : `${prdName}.md`;
-      const pendingPath = path32.join(prdDir, normalized);
-      const donePath = path32.join(prdDir, "done", normalized);
-      if (fs32.existsSync(pendingPath)) {
+      const pendingPath = path33.join(prdDir, normalized);
+      const donePath = path33.join(prdDir, "done", normalized);
+      if (fs33.existsSync(pendingPath)) {
         res.json({ message: `"${normalized}" is already pending` });
         return;
       }
-      if (!fs32.existsSync(donePath)) {
+      if (!fs33.existsSync(donePath)) {
         res.status(404).json({ error: `PRD "${normalized}" not found in done/` });
         return;
       }
-      fs32.renameSync(donePath, pendingPath);
+      fs33.renameSync(donePath, pendingPath);
       res.json({ message: `Moved "${normalized}" back to pending` });
     } catch (error2) {
       res.status(500).json({
@@ -14350,11 +14911,11 @@ function createActionRouteHandlers(ctx) {
         res.status(409).json({ error: "Executor is actively running \u2014 use Stop instead" });
         return;
       }
-      if (fs32.existsSync(lockPath)) {
-        fs32.unlinkSync(lockPath);
+      if (fs33.existsSync(lockPath)) {
+        fs33.unlinkSync(lockPath);
       }
-      const prdDir = path32.join(projectDir, config.prdDir);
-      if (fs32.existsSync(prdDir)) {
+      const prdDir = path33.join(projectDir, config.prdDir);
+      if (fs33.existsSync(prdDir)) {
         cleanOrphanedClaims(prdDir);
       }
       broadcastSSE(ctx.getSseClients(req), "status_changed", await fetchStatusSnapshot(projectDir, config));
@@ -15116,8 +15677,8 @@ function createProjectConfigRoutes() {
 
 // ../server/dist/routes/doctor.routes.js
 init_dist();
-import * as fs33 from "fs";
-import * as path33 from "path";
+import * as fs34 from "fs";
+import * as path34 from "path";
 import { execSync as execSync7 } from "child_process";
 import { Router as Router4 } from "express";
 function runDoctorChecks(projectDir, config) {
@@ -15150,7 +15711,7 @@ function runDoctorChecks(projectDir, config) {
     });
   }
   try {
-    const projectName = path33.basename(projectDir);
+    const projectName = path34.basename(projectDir);
     const marker = generateMarker(projectName);
     const crontabEntries = [...getEntries(marker), ...getProjectEntries(projectDir)];
     if (crontabEntries.length > 0) {
@@ -15173,8 +15734,8 @@ function runDoctorChecks(projectDir, config) {
       detail: "Failed to check crontab"
     });
   }
-  const configPath = path33.join(projectDir, CONFIG_FILE_NAME);
-  if (fs33.existsSync(configPath)) {
+  const configPath = path34.join(projectDir, CONFIG_FILE_NAME);
+  if (fs34.existsSync(configPath)) {
     checks.push({ name: "config", status: "pass", detail: "Config file exists" });
   } else {
     checks.push({
@@ -15183,56 +15744,374 @@ function runDoctorChecks(projectDir, config) {
       detail: "Config file not found (using defaults)"
     });
   }
-  const prdDir = path33.join(projectDir, config.prdDir);
-  if (fs33.existsSync(prdDir)) {
-    const prds = fs33.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
-    checks.push({
-      name: "prdDir",
-      status: "pass",
-      detail: `PRD directory exists (${prds.length} PRDs)`
-    });
-  } else {
-    checks.push({
-      name: "prdDir",
-      status: "warn",
-      detail: `PRD directory not found: ${config.prdDir}`
-    });
+  const prdDir = path34.join(projectDir, config.prdDir);
+  if (fs34.existsSync(prdDir)) {
+    const prds = fs34.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+    checks.push({
+      name: "prdDir",
+      status: "pass",
+      detail: `PRD directory exists (${prds.length} PRDs)`
+    });
+  } else {
+    checks.push({
+      name: "prdDir",
+      status: "warn",
+      detail: `PRD directory not found: ${config.prdDir}`
+    });
+  }
+  return checks;
+}
+function createDoctorRoutes(deps) {
+  const { projectDir, getConfig } = deps;
+  const router = Router4();
+  router.get("/", (_req, res) => {
+    try {
+      const checks = runDoctorChecks(projectDir, getConfig());
+      res.json(checks);
+    } catch (error2) {
+      res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
+    }
+  });
+  return router;
+}
+function createProjectDoctorRoutes() {
+  const router = Router4({ mergeParams: true });
+  router.get("/doctor", (req, res) => {
+    try {
+      const checks = runDoctorChecks(req.projectDir, req.projectConfig);
+      res.json(checks);
+    } catch (error2) {
+      res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
+    }
+  });
+  return router;
+}
+
+// ../server/dist/routes/job.routes.js
+init_dist();
+import { spawn as spawn7 } from "child_process";
+import { createHmac, randomUUID, timingSafeEqual } from "crypto";
+import { Router as Router5 } from "express";
+var SUPPORTED_GITHUB_EVENTS = [
+  "workflow_run",
+  "check_suite",
+  "pull_request",
+  "repository_dispatch"
+];
+function isSupportedGithubEvent(value) {
+  return SUPPORTED_GITHUB_EVENTS.some((event) => event === value);
+}
+function getRawBody(req) {
+  if (Buffer.isBuffer(req.body)) {
+    return req.body;
+  }
+  if (typeof req.body === "string") {
+    return Buffer.from(req.body, "utf-8");
+  }
+  return Buffer.alloc(0);
+}
+function verifyHmacSignature(rawBody, header2, secret) {
+  const match = header2?.match(/^sha256=([a-f0-9]{64})$/i);
+  if (!match) {
+    return false;
+  }
+  const expected = createHmac("sha256", secret).update(rawBody).digest();
+  const actual = Buffer.from(match[1], "hex");
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function getSignatureHeaders(req) {
+  return [req.get("X-Night-Watch-Signature"), req.get("X-Hub-Signature-256")];
+}
+function getGithubWebhookHeaders(req) {
+  return {
+    event: req.get("X-GitHub-Event"),
+    delivery: req.get("X-GitHub-Delivery"),
+    signature: req.get("X-Hub-Signature-256")
+  };
+}
+function hasGithubHeaders(headers) {
+  return Boolean(headers.event && headers.signature);
+}
+function isObjectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readObject(value) {
+  return isObjectRecord(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumberString(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return readString(value);
+}
+function readFirstPullRequestNumber(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  for (const item of value) {
+    const pr = readObject(item);
+    const number = readNumberString(pr?.number);
+    if (number)
+      return number;
+  }
+  return void 0;
+}
+function isFailureConclusion(value) {
+  const conclusion = readString(value)?.toLowerCase();
+  if (!conclusion)
+    return false;
+  return !["success", "neutral", "skipped"].includes(conclusion);
+}
+function parseJsonBody(rawBody) {
+  if (rawBody.length === 0) {
+    return {};
+  }
+  return JSON.parse(rawBody.toString("utf-8"));
+}
+function buildGithubContext(headers, payload) {
+  if (!headers.event || !isSupportedGithubEvent(headers.event)) {
+    return void 0;
+  }
+  const context = {
+    event: headers.event,
+    delivery: headers.delivery,
+    action: readString(payload.action),
+    failed: false
+  };
+  switch (headers.event) {
+    case "workflow_run": {
+      const workflowRun = readObject(payload.workflow_run);
+      context.branch = readString(workflowRun?.head_branch);
+      context.prNumber = readFirstPullRequestNumber(workflowRun?.pull_requests);
+      context.failed = isFailureConclusion(workflowRun?.conclusion);
+      break;
+    }
+    case "check_suite": {
+      const checkSuite = readObject(payload.check_suite);
+      context.branch = readString(checkSuite?.head_branch);
+      context.prNumber = readFirstPullRequestNumber(checkSuite?.pull_requests);
+      context.failed = isFailureConclusion(checkSuite?.conclusion);
+      break;
+    }
+    case "pull_request": {
+      const pullRequest = readObject(payload.pull_request);
+      const head = readObject(pullRequest?.head);
+      context.branch = readString(head?.ref);
+      context.prNumber = readNumberString(payload.number) ?? readNumberString(pullRequest?.number);
+      break;
+    }
+    case "repository_dispatch": {
+      const clientPayload = readObject(payload.client_payload);
+      context.action = readString(payload.action) ?? readString(payload.event_type);
+      context.branch = readString(clientPayload?.branch) ?? readString(clientPayload?.ref) ?? readString(payload.ref) ?? readString(payload.branch);
+      context.prNumber = readNumberString(clientPayload?.pr_number) ?? readNumberString(clientPayload?.pull_request_number) ?? readNumberString(payload.pr_number);
+      context.failed = readString(clientPayload?.status)?.toLowerCase() === "failure" || readString(clientPayload?.conclusion)?.toLowerCase() === "failure";
+      break;
+    }
+  }
+  return context;
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const wildcarded = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${wildcarded}$`);
+}
+function matchesBranchPattern(branch, branchPatterns) {
+  if (!branchPatterns || branchPatterns.length === 0)
+    return true;
+  if (!branch)
+    return false;
+  return branchPatterns.some((pattern) => globToRegExp(pattern).test(branch));
+}
+function findGithubWebhookMatch(config, headers, payload) {
+  const context = buildGithubContext(headers, payload);
+  if (!context)
+    return void 0;
+  if (config.webhookTriggers.github.events.length > 0) {
+    const eventAllowed = config.webhookTriggers.github.events.includes(context.event);
+    if (!eventAllowed)
+      return void 0;
+  }
+  const rule = config.webhookTriggers.github.rules.find((candidate) => {
+    if (candidate.event !== context.event)
+      return false;
+    if (candidate.action && candidate.action !== context.action)
+      return false;
+    if (candidate.onlyOnFailure && !context.failed)
+      return false;
+    return matchesBranchPattern(context.branch, candidate.branchPatterns);
+  });
+  if (!rule)
+    return void 0;
+  return { rule, context };
+}
+function buildGithubWebhookEnv(context) {
+  const env = {
+    NW_WEBHOOK_SOURCE: "github",
+    NW_WEBHOOK_EVENT: context.event
+  };
+  if (context.delivery) {
+    env.NW_WEBHOOK_DELIVERY = context.delivery;
+  }
+  if (context.prNumber) {
+    env.NW_WEBHOOK_PR_NUMBER = context.prNumber;
   }
-  return checks;
+  if (context.branch) {
+    env.NW_WEBHOOK_BRANCH = context.branch;
+  }
+  return env;
 }
-function createDoctorRoutes(deps) {
-  const { projectDir, getConfig } = deps;
-  const router = Router4();
-  router.get("/", (_req, res) => {
+function getLockPathForJob2(projectDir, jobId) {
+  switch (jobId) {
+    case "executor":
+      return executorLockPath(projectDir);
+    case "reviewer":
+      return reviewerLockPath(projectDir);
+    case "qa":
+      return qaLockPath(projectDir);
+    case "audit":
+      return auditLockPath(projectDir);
+    case "slicer":
+    case "planner":
+      return plannerLockPath(projectDir);
+    case "analytics":
+      return analyticsLockPath(projectDir);
+    case "pr-resolver":
+      return prResolverLockPath(projectDir);
+    case "merger":
+      return mergerLockPath(projectDir);
+  }
+}
+function createJobRouteHandlers(ctx) {
+  const router = Router5({ mergeParams: true });
+  const p = ctx.pathPrefix;
+  router.post(`/${p}:id/run`, (req, res) => {
     try {
-      const checks = runDoctorChecks(projectDir, getConfig());
-      res.json(checks);
+      const config = ctx.getConfig(req);
+      const webhookConfig = config.webhookTriggers;
+      if (!webhookConfig.enabled) {
+        res.status(403).json({ error: "Webhook triggers are disabled" });
+        return;
+      }
+      const secret = process.env[webhookConfig.secretEnv];
+      if (!secret) {
+        res.status(403).json({ error: "Webhook signing secret is not configured" });
+        return;
+      }
+      const rawBody = getRawBody(req);
+      const hasValidSignature = getSignatureHeaders(req).some((header2) => verifyHmacSignature(rawBody, header2, secret));
+      if (!hasValidSignature) {
+        res.status(401).json({ error: "Invalid signature" });
+        return;
+      }
+      const requestedJobId = req.params.id;
+      const requestedJobDef = JOB_REGISTRY.find((job) => job.id === requestedJobId);
+      if (!requestedJobDef) {
+        res.status(404).json({ error: "Unknown job id" });
+        return;
+      }
+      if (!webhookConfig.allowedJobIds.includes(requestedJobDef.id)) {
+        res.status(403).json({ error: "Job is not allowed for webhook dispatch" });
+        return;
+      }
+      const githubHeaders = getGithubWebhookHeaders(req);
+      let githubEnv = {};
+      let matchedGithubJobId;
+      if (hasGithubHeaders(githubHeaders) && webhookConfig.github.enabled) {
+        let payload;
+        try {
+          payload = parseJsonBody(rawBody);
+        } catch {
+          res.status(400).json({ error: "Malformed JSON payload" });
+          return;
+        }
+        const match = findGithubWebhookMatch(config, githubHeaders, readObject(payload) ?? {});
+        if (!match) {
+          const response2 = {
+            accepted: false,
+            ignored: true,
+            reason: "No matching GitHub webhook rule"
+          };
+          res.status(202).json(response2);
+          return;
+        }
+        matchedGithubJobId = match.rule.jobId;
+        githubEnv = buildGithubWebhookEnv(match.context);
+      }
+      const dispatchJobId = matchedGithubJobId ?? requestedJobDef.id;
+      const jobDef = JOB_REGISTRY.find((job) => job.id === dispatchJobId);
+      if (!jobDef) {
+        res.status(404).json({ error: "Unknown job id" });
+        return;
+      }
+      if (!webhookConfig.allowedJobIds.includes(jobDef.id)) {
+        res.status(403).json({ error: "Job is not allowed for webhook dispatch" });
+        return;
+      }
+      const projectDir = ctx.getProjectDir(req);
+      const lock = checkLockFile(getLockPathForJob2(projectDir, jobDef.id));
+      if (lock.running) {
+        res.status(409).json({
+          error: `${jobDef.name} is already running (PID ${lock.pid})`,
+          pid: lock.pid
+        });
+        return;
+      }
+      const dispatchId = randomUUID();
+      const child = spawn7("night-watch", [jobDef.cliCommand], {
+        detached: true,
+        stdio: "ignore",
+        cwd: projectDir,
+        env: {
+          ...process.env,
+          NW_WEBHOOK_DISPATCH_ID: dispatchId,
+          NW_WEBHOOK_JOB_ID: jobDef.id,
+          ...githubEnv
+        }
+      });
+      child.unref();
+      if (child.pid === void 0) {
+        res.status(500).json({ error: "Failed to spawn process: no PID assigned" });
+        return;
+      }
+      const response = {
+        accepted: true,
+        jobId: jobDef.id,
+        pid: child.pid,
+        dispatchId
+      };
+      res.status(202).json(response);
     } catch (error2) {
-      res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
+      res.status(500).json({
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
     }
   });
   return router;
 }
-function createProjectDoctorRoutes() {
-  const router = Router4({ mergeParams: true });
-  router.get("/doctor", (req, res) => {
-    try {
-      const checks = runDoctorChecks(req.projectDir, req.projectConfig);
-      res.json(checks);
-    } catch (error2) {
-      res.status(500).json({ error: error2 instanceof Error ? error2.message : String(error2) });
-    }
+function createJobRoutes(deps) {
+  return createJobRouteHandlers({
+    getConfig: () => deps.getConfig(),
+    getProjectDir: () => deps.projectDir,
+    pathPrefix: ""
+  });
+}
+function createProjectJobRoutes() {
+  return createJobRouteHandlers({
+    getConfig: (req) => req.projectConfig,
+    getProjectDir: (req) => req.projectDir,
+    pathPrefix: "jobs/"
   });
-  return router;
 }
 
 // ../server/dist/routes/log.routes.js
 init_dist();
-import * as path34 from "path";
-import { Router as Router5 } from "express";
+import * as path35 from "path";
+import { Router as Router6 } from "express";
 function createLogRoutes(deps) {
   const { projectDir } = deps;
-  const router = Router5();
+  const router = Router6();
   router.get("/:name", (req, res) => {
     try {
       const { name } = req.params;
@@ -15247,7 +16126,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 = path34.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path35.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -15257,7 +16136,7 @@ function createLogRoutes(deps) {
   return router;
 }
 function createProjectLogRoutes() {
-  const router = Router5({ mergeParams: true });
+  const router = Router6({ mergeParams: true });
   router.get("/logs/:name", (req, res) => {
     try {
       const projectDir = req.projectDir;
@@ -15273,7 +16152,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 = path34.join(projectDir, LOG_DIR, `${fileName}.log`);
+      const logPath = path35.join(projectDir, LOG_DIR, `${fileName}.log`);
       const logLines = getLastLogLines(logPath, linesToRead);
       res.json({ name, lines: logLines });
     } catch (error2) {
@@ -15284,9 +16163,9 @@ function createProjectLogRoutes() {
 }
 
 // ../server/dist/routes/prd.routes.js
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 function createPrdRoutes(_deps) {
-  const router = Router6();
+  const router = Router7();
   router.get("/", (_req, res) => {
     res.status(410).json({ error: "PRDs endpoint deprecated - use GitHub Board instead" });
   });
@@ -15296,7 +16175,7 @@ function createPrdRoutes(_deps) {
   return router;
 }
 function createProjectPrdRoutes() {
-  const router = Router6({ mergeParams: true });
+  const router = Router7({ mergeParams: true });
   router.get("/prds", (_req, res) => {
     res.status(410).json({ error: "PRDs endpoint deprecated - use GitHub Board instead" });
   });
@@ -15308,17 +16187,17 @@ function createProjectPrdRoutes() {
 
 // ../server/dist/routes/roadmap.routes.js
 init_dist();
-import * as path35 from "path";
-import { Router as Router7 } from "express";
+import * as path36 from "path";
+import { Router as Router8 } from "express";
 function createRoadmapRouteHandlers(ctx) {
-  const router = Router7({ mergeParams: true });
+  const router = Router8({ mergeParams: true });
   const p = ctx.pathPrefix;
   router.get(`/${p}`, (req, res) => {
     try {
       const config = ctx.getConfig(req);
       const projectDir = ctx.getProjectDir(req);
       const status = getRoadmapStatus(projectDir, config);
-      const prdDir = path35.join(projectDir, config.prdDir);
+      const prdDir = path36.join(projectDir, config.prdDir);
       const state = loadRoadmapState(prdDir);
       res.json({
         ...status,
@@ -15392,11 +16271,11 @@ function createProjectRoadmapRoutes() {
 
 // ../server/dist/routes/status.routes.js
 init_dist();
-import { Router as Router8 } from "express";
+import { Router as Router9 } from "express";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
 function createStatusRoutes(deps) {
   const { projectDir, getConfig, sseClients } = deps;
-  const router = Router8();
+  const router = Router9();
   router.get("/events", (req, res) => {
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
@@ -15525,7 +16404,7 @@ function buildScheduleInfoResponse(projectDir, config, entries, installed) {
 }
 function createScheduleInfoRoutes(deps) {
   const { projectDir, getConfig } = deps;
-  const router = Router8();
+  const router = Router9();
   router.get("/", async (_req, res) => {
     try {
       const config = getConfig();
@@ -15539,7 +16418,7 @@ function createScheduleInfoRoutes(deps) {
 }
 function createProjectSseRoutes(deps) {
   const { projectSseClients, projectSseWatchers } = deps;
-  const router = Router8({ mergeParams: true });
+  const router = Router9({ mergeParams: true });
   router.get("/status/events", (req, res) => {
     const projectDir = req.projectDir;
     if (!projectSseClients.has(projectDir)) {
@@ -15596,9 +16475,9 @@ data: ${JSON.stringify(snapshot)}
 
 // ../server/dist/routes/queue.routes.js
 init_dist();
-import { Router as Router9 } from "express";
+import { Router as Router10 } from "express";
 function createGlobalQueueRoutes() {
-  const router = Router9();
+  const router = Router10();
   router.get("/status", async (_req, res) => {
     try {
       const status = getQueueStatus();
@@ -15633,7 +16512,7 @@ function createGlobalQueueRoutes() {
 }
 function createQueueRoutes(deps) {
   const { getConfig } = deps;
-  const router = Router9();
+  const router = Router10();
   router.get("/status", async (_req, res) => {
     try {
       const config = getConfig();
@@ -15671,15 +16550,20 @@ function createQueueRoutes(deps) {
 // ../server/dist/index.js
 var __filename4 = fileURLToPath5(import.meta.url);
 var __dirname4 = dirname11(__filename4);
+var JOB_RAW_BODY_LIMIT = "1mb";
+function setupJobRawBodyParsing(app) {
+  app.use("/api/jobs", express.raw({ type: "*/*", limit: JOB_RAW_BODY_LIMIT }));
+  app.use("/api/projects/:projectId/jobs", express.raw({ type: "*/*", limit: JOB_RAW_BODY_LIMIT }));
+}
 function resolveWebDistPath() {
-  const bundled = path36.join(__dirname4, "web");
-  if (fs34.existsSync(path36.join(bundled, "index.html")))
+  const bundled = path37.join(__dirname4, "web");
+  if (fs35.existsSync(path37.join(bundled, "index.html")))
     return bundled;
   let d = __dirname4;
   for (let i = 0; i < 8; i++) {
-    if (fs34.existsSync(path36.join(d, "turbo.json"))) {
-      const dev = path36.join(d, "web/dist");
-      if (fs34.existsSync(path36.join(dev, "index.html")))
+    if (fs35.existsSync(path37.join(d, "turbo.json"))) {
+      const dev = path37.join(d, "web/dist");
+      if (fs35.existsSync(path37.join(dev, "index.html")))
         return dev;
       break;
     }
@@ -15689,7 +16573,7 @@ function resolveWebDistPath() {
 }
 function setupStaticFiles(app) {
   const webDistPath = resolveWebDistPath();
-  if (fs34.existsSync(webDistPath)) {
+  if (fs35.existsSync(webDistPath)) {
     app.use(express.static(webDistPath));
   }
   app.use((req, res, next) => {
@@ -15697,8 +16581,8 @@ function setupStaticFiles(app) {
       next();
       return;
     }
-    const indexPath = path36.resolve(webDistPath, "index.html");
-    if (fs34.existsSync(indexPath)) {
+    const indexPath = path37.resolve(webDistPath, "index.html");
+    if (fs35.existsSync(indexPath)) {
       res.sendFile(indexPath, (err) => {
         if (err)
           next();
@@ -15716,6 +16600,7 @@ function setupStaticFiles(app) {
 function createApp(projectDir) {
   const app = express();
   app.use(cors());
+  setupJobRawBodyParsing(app);
   app.use(express.json());
   let config = loadConfig(projectDir);
   const reloadConfig = () => {
@@ -15732,6 +16617,7 @@ function createApp(projectDir) {
   app.use("/api/config", createConfigRoutes({ projectDir, getConfig: () => config, reloadConfig }));
   app.use("/api/board", createBoardRoutes({ projectDir, getConfig: () => config }));
   app.use("/api/actions", createActionRoutes({ projectDir, getConfig: () => config, sseClients }));
+  app.use("/api/jobs", createJobRoutes({ projectDir, getConfig: () => config }));
   app.use("/api/roadmap", createRoadmapRoutes({ projectDir, getConfig: () => config, reloadConfig }));
   app.use("/api/logs", createLogRoutes({ projectDir }));
   app.use("/api/doctor", createDoctorRoutes({ projectDir, getConfig: () => config }));
@@ -15781,6 +16667,7 @@ function createProjectRouter() {
   router.use(createProjectLogRoutes());
   router.use(createProjectBoardRoutes());
   router.use(createProjectActionRoutes({ projectSseClients }));
+  router.use(createProjectJobRoutes());
   router.use(createProjectRoadmapRoutes());
   router.get("/prs", async (req, res) => {
     try {
@@ -15794,6 +16681,7 @@ function createProjectRouter() {
 function createGlobalApp() {
   const app = express();
   app.use(cors());
+  setupJobRawBodyParsing(app);
   app.use(express.json());
   app.get("/api/mode", (_req, res) => {
     res.json({ globalMode: true });
@@ -15831,7 +16719,7 @@ function createGlobalApp() {
   return app;
 }
 function bootContainer() {
-  initContainer(path36.dirname(getDbPath()));
+  initContainer(path37.dirname(getDbPath()));
 }
 function startServer(projectDir, port) {
   bootContainer();
@@ -15884,8 +16772,8 @@ function isProcessRunning2(pid) {
 }
 function readPid(lockPath) {
   try {
-    if (!fs35.existsSync(lockPath)) return null;
-    const raw = fs35.readFileSync(lockPath, "utf-8").trim();
+    if (!fs36.existsSync(lockPath)) return null;
+    const raw = fs36.readFileSync(lockPath, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -15897,10 +16785,10 @@ function acquireServeLock(mode, port) {
   let stalePidCleaned;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs35.openSync(lockPath, "wx");
-      fs35.writeFileSync(fd, `${process.pid}
+      const fd = fs36.openSync(lockPath, "wx");
+      fs36.writeFileSync(fd, `${process.pid}
 `);
-      fs35.closeSync(fd);
+      fs36.closeSync(fd);
       return { acquired: true, lockPath, stalePidCleaned };
     } catch (error2) {
       const err = error2;
@@ -15921,7 +16809,7 @@ function acquireServeLock(mode, port) {
         };
       }
       try {
-        fs35.unlinkSync(lockPath);
+        fs36.unlinkSync(lockPath);
         if (existingPid) {
           stalePidCleaned = existingPid;
         }
@@ -15944,10 +16832,10 @@ function acquireServeLock(mode, port) {
 }
 function releaseServeLock(lockPath) {
   try {
-    if (!fs35.existsSync(lockPath)) return;
+    if (!fs36.existsSync(lockPath)) return;
     const lockPid = readPid(lockPath);
     if (lockPid !== null && lockPid !== process.pid) return;
-    fs35.unlinkSync(lockPath);
+    fs36.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -16043,14 +16931,14 @@ function historyCommand(program2) {
 // src/commands/update.ts
 init_dist();
 import { spawnSync as spawnSync2 } from "child_process";
-import * as fs36 from "fs";
-import * as path37 from "path";
+import * as fs37 from "fs";
+import * as path38 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) => path37.resolve(cwd, entry));
+  const dirs = projects.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => path38.resolve(cwd, entry));
   return Array.from(new Set(dirs));
 }
 function shouldInstallGlobal(options) {
@@ -16092,7 +16980,7 @@ function updateCommand(program2) {
       }
       const nightWatchBin = resolveNightWatchBin();
       for (const projectDir of projectDirs) {
-        if (!fs36.existsSync(projectDir) || !fs36.statSync(projectDir).isDirectory()) {
+        if (!fs37.existsSync(projectDir) || !fs37.statSync(projectDir).isDirectory()) {
           warn(`Skipping invalid project directory: ${projectDir}`);
           continue;
         }
@@ -16136,8 +17024,8 @@ function prdStateCommand(program2) {
 
 // src/commands/retry.ts
 init_dist();
-import * as fs37 from "fs";
-import * as path38 from "path";
+import * as fs38 from "fs";
+import * as path39 from "path";
 function normalizePrdName(name) {
   if (!name.endsWith(".md")) {
     return `${name}.md`;
@@ -16145,26 +17033,26 @@ function normalizePrdName(name) {
   return name;
 }
 function getDonePrds(doneDir) {
-  if (!fs37.existsSync(doneDir)) {
+  if (!fs38.existsSync(doneDir)) {
     return [];
   }
-  return fs37.readdirSync(doneDir).filter((f) => f.endsWith(".md"));
+  return fs38.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 = path38.join(projectDir, config.prdDir);
-    const doneDir = path38.join(prdDir, "done");
+    const prdDir = path39.join(projectDir, config.prdDir);
+    const doneDir = path39.join(prdDir, "done");
     const normalizedPrdName = normalizePrdName(prdName);
-    const pendingPath = path38.join(prdDir, normalizedPrdName);
-    if (fs37.existsSync(pendingPath)) {
+    const pendingPath = path39.join(prdDir, normalizedPrdName);
+    if (fs38.existsSync(pendingPath)) {
       info(`"${normalizedPrdName}" is already pending, nothing to retry.`);
       return;
     }
-    const donePath = path38.join(doneDir, normalizedPrdName);
-    if (fs37.existsSync(donePath)) {
-      fs37.renameSync(donePath, pendingPath);
+    const donePath = path39.join(doneDir, normalizedPrdName);
+    if (fs38.existsSync(donePath)) {
+      fs38.renameSync(donePath, pendingPath);
       success(`Moved "${normalizedPrdName}" back to pending.`);
       dim(`From: ${donePath}`);
       dim(`To:   ${pendingPath}`);
@@ -16416,7 +17304,7 @@ function prdsCommand(program2) {
 
 // src/commands/cancel.ts
 init_dist();
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as readline2 from "readline";
 function getLockFilePaths2(projectDir) {
   const runtimeKey = projectRuntimeKey(projectDir);
@@ -16463,7 +17351,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   const pid = lockStatus.pid;
   if (!lockStatus.running) {
     try {
-      fs38.unlinkSync(lockPath);
+      fs39.unlinkSync(lockPath);
       return {
         success: true,
         message: `${processType} is not running (cleaned up stale lock file for PID ${pid})`,
@@ -16501,7 +17389,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(3e3);
   if (!isProcessRunning3(pid)) {
     try {
-      fs38.unlinkSync(lockPath);
+      fs39.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -16536,7 +17424,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
   await sleep2(500);
   if (!isProcessRunning3(pid)) {
     try {
-      fs38.unlinkSync(lockPath);
+      fs39.unlinkSync(lockPath);
     } catch {
     }
     return {
@@ -16597,31 +17485,31 @@ function cancelCommand(program2) {
 
 // src/commands/slice.ts
 init_dist();
-import * as fs39 from "fs";
-import * as path39 from "path";
+import * as fs40 from "fs";
+import * as path40 from "path";
 function plannerLockPath2(projectDir) {
   return `${LOCK_FILE_PREFIX}slicer-${projectRuntimeKey(projectDir)}.lock`;
 }
 function acquirePlannerLock(projectDir) {
   const lockFile = plannerLockPath2(projectDir);
-  if (fs39.existsSync(lockFile)) {
-    const pidRaw = fs39.readFileSync(lockFile, "utf-8").trim();
+  if (fs40.existsSync(lockFile)) {
+    const pidRaw = fs40.readFileSync(lockFile, "utf-8").trim();
     const pid = parseInt(pidRaw, 10);
     if (!Number.isNaN(pid) && isProcessRunning(pid)) {
       return { acquired: false, lockFile, pid };
     }
     try {
-      fs39.unlinkSync(lockFile);
+      fs40.unlinkSync(lockFile);
     } catch {
     }
   }
-  fs39.writeFileSync(lockFile, String(process.pid));
+  fs40.writeFileSync(lockFile, String(process.pid));
   return { acquired: true, lockFile };
 }
 function releasePlannerLock(lockFile) {
   try {
-    if (fs39.existsSync(lockFile)) {
-      fs39.unlinkSync(lockFile);
+    if (fs40.existsSync(lockFile)) {
+      fs40.unlinkSync(lockFile);
     }
   } catch {
   }
@@ -16630,12 +17518,12 @@ function resolvePlannerIssueColumn(config) {
   return config.roadmapScanner.issueColumn === "Draft" ? "Draft" : "Ready";
 }
 function buildPlannerIssueBody(projectDir, config, result) {
-  const relativePrdPath = path39.join(config.prdDir, result.file ?? "").replace(/\\/g, "/");
-  const absolutePrdPath = path39.join(projectDir, config.prdDir, result.file ?? "");
+  const relativePrdPath = path40.join(config.prdDir, result.file ?? "").replace(/\\/g, "/");
+  const absolutePrdPath = path40.join(projectDir, config.prdDir, result.file ?? "");
   const sourceItem = result.item;
   let prdContent;
   try {
-    prdContent = fs39.readFileSync(absolutePrdPath, "utf-8");
+    prdContent = fs40.readFileSync(absolutePrdPath, "utf-8");
   } catch {
     prdContent = `Unable to read generated PRD file at \`${relativePrdPath}\`.`;
   }
@@ -16842,7 +17730,7 @@ function sliceCommand(program2) {
       if (!options.dryRun && result.sliced) {
         await sendNotifications(config, {
           event: "run_succeeded",
-          projectName: path39.basename(projectDir),
+          projectName: path40.basename(projectDir),
           exitCode,
           provider: config.provider,
           prTitle: result.item?.title
@@ -16850,7 +17738,7 @@ function sliceCommand(program2) {
       } else if (!options.dryRun && !nothingPending) {
         await sendNotifications(config, {
           event: "run_failed",
-          projectName: path39.basename(projectDir),
+          projectName: path40.basename(projectDir),
           exitCode,
           provider: config.provider
         });
@@ -16867,20 +17755,20 @@ function sliceCommand(program2) {
 // src/commands/state.ts
 init_dist();
 import * as os9 from "os";
-import * as path40 from "path";
+import * as path41 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 || path40.join(os9.homedir(), GLOBAL_CONFIG_DIR);
+    const nightWatchHome = process.env.NIGHT_WATCH_HOME || path41.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(`  ${path40.join(nightWatchHome, "projects.json")}`);
-      console.log(`  ${path40.join(nightWatchHome, "history.json")}`);
-      console.log(`  ${path40.join(nightWatchHome, "prd-states.json")}`);
+      console.log(`  ${path41.join(nightWatchHome, "projects.json")}`);
+      console.log(`  ${path41.join(nightWatchHome, "history.json")}`);
+      console.log(`  ${path41.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;
@@ -16918,8 +17806,8 @@ function createStateCommand() {
 init_dist();
 init_dist();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs40 from "fs";
-import * as path41 from "path";
+import * as fs41 from "fs";
+import * as path42 from "path";
 import * as readline3 from "readline";
 import chalk6 from "chalk";
 async function run(fn) {
@@ -16941,7 +17829,7 @@ function getProvider(config, cwd) {
   return createBoardProvider(bp, cwd);
 }
 function defaultBoardTitle(cwd) {
-  return `${path41.basename(cwd)} Night Watch`;
+  return `${path42.basename(cwd)} Night Watch`;
 }
 async function ensureBoardConfigured(config, cwd, provider, options) {
   if (config.boardProvider?.projectNumber) {
@@ -17140,11 +18028,11 @@ function boardCommand(program2) {
       let body = options.body ?? "";
       if (options.bodyFile) {
         const filePath = options.bodyFile;
-        if (!fs40.existsSync(filePath)) {
+        if (!fs41.existsSync(filePath)) {
           console.error(`File not found: ${filePath}`);
           process.exit(1);
         }
-        body = fs40.readFileSync(filePath, "utf-8");
+        body = fs41.readFileSync(filePath, "utf-8");
       }
       const labels = [];
       if (options.label) {
@@ -17385,12 +18273,12 @@ function boardCommand(program2) {
       const config = loadConfig(cwd);
       const provider = getProvider(config, cwd);
       await ensureBoardConfigured(config, cwd, provider);
-      const roadmapPath = options.roadmap ?? path41.join(cwd, "ROADMAP.md");
-      if (!fs40.existsSync(roadmapPath)) {
+      const roadmapPath = options.roadmap ?? path42.join(cwd, "ROADMAP.md");
+      if (!fs41.existsSync(roadmapPath)) {
         console.error(`Roadmap file not found: ${roadmapPath}`);
         process.exit(1);
       }
-      const roadmapContent = fs40.readFileSync(roadmapPath, "utf-8");
+      const roadmapContent = fs41.readFileSync(roadmapPath, "utf-8");
       const items = parseRoadmap(roadmapContent);
       const uncheckedItems = getUncheckedItems(items);
       if (uncheckedItems.length === 0) {
@@ -17514,12 +18402,12 @@ function boardCommand(program2) {
 // src/commands/queue.ts
 init_dist();
 init_dist();
-import * as path42 from "path";
-import { spawn as spawn7 } from "child_process";
+import * as path43 from "path";
+import { spawn as spawn8 } from "child_process";
 import chalk7 from "chalk";
 import { Command as Command2 } from "commander";
 var logger6 = createLogger("queue");
-var VALID_JOB_TYPES2 = [
+var VALID_JOB_TYPES3 = [
   "executor",
   "reviewer",
   "qa",
@@ -17552,6 +18440,13 @@ function printQueueEntry(entry, indent = "") {
     console.log(`${indent}  Dispatched: ${formatTimestamp(entry.dispatchedAt)}`);
   }
 }
+function isJobPaused(projectDir, jobType) {
+  try {
+    return loadConfig(projectDir).pausedJobs?.[jobType] === true;
+  } catch {
+    return false;
+  }
+}
 function createQueueCommand() {
   const queue = new Command2("queue");
   queue.description("Manage the global job queue");
@@ -17620,18 +18515,18 @@ function createQueueCommand() {
     }
   });
   queue.command("clear").description("Clear pending jobs from the queue").option("--type <type>", "Only clear jobs of this type").option("--all", "Clear all entries including running (dangerous)").action((opts) => {
-    if (opts.type && !VALID_JOB_TYPES2.includes(opts.type)) {
+    if (opts.type && !VALID_JOB_TYPES3.includes(opts.type)) {
       console.error(chalk7.red(`Invalid job type: ${opts.type}`));
-      console.error(chalk7.dim(`Valid types: ${VALID_JOB_TYPES2.join(", ")}`));
+      console.error(chalk7.dim(`Valid types: ${VALID_JOB_TYPES3.join(", ")}`));
       process.exit(1);
     }
     const count = clearQueue(opts.type);
     console.log(chalk7.green(`Cleared ${count} pending job(s) from the queue.`));
   });
   queue.command("enqueue <job-type> <project-dir>").description("Manually enqueue a job").option("--env <json>", "JSON object of environment variables to store", "{}").option("--provider-key <key>", "Provider bucket key (e.g. claude-native, codex)").action((jobType, projectDir, opts) => {
-    if (!VALID_JOB_TYPES2.includes(jobType)) {
+    if (!VALID_JOB_TYPES3.includes(jobType)) {
       console.error(chalk7.red(`Invalid job type: ${jobType}`));
-      console.error(chalk7.dim(`Valid types: ${VALID_JOB_TYPES2.join(", ")}`));
+      console.error(chalk7.dim(`Valid types: ${VALID_JOB_TYPES3.join(", ")}`));
       process.exit(1);
     }
     let envVars = {};
@@ -17643,8 +18538,12 @@ function createQueueCommand() {
         process.exit(1);
       }
     }
-    const projectName = path42.basename(projectDir);
+    const projectName = path43.basename(projectDir);
     const queueConfig = loadConfig(projectDir).queue;
+    if (isJobPaused(projectDir, jobType)) {
+      logger6.info(`Skipping enqueue for paused job: ${jobType}`);
+      return;
+    }
     const id = enqueueJob(
       projectDir,
       projectName,
@@ -17682,6 +18581,11 @@ function createQueueCommand() {
       logger6.info("No pending jobs to dispatch");
       return;
     }
+    if (isJobPaused(entry.projectPath, entry.jobType)) {
+      logger6.info(`Skipping paused queued job: ${entry.jobType} for ${entry.projectName}`);
+      removeJob(entry.id);
+      return;
+    }
     logger6.info(`Dispatching ${entry.jobType} for ${entry.projectName} (ID: ${entry.id})`);
     const scriptName = getScriptNameForJobType(entry.jobType);
     if (!scriptName) {
@@ -17706,7 +18610,7 @@ function createQueueCommand() {
     const scriptPath = getScriptPath(scriptName);
     logger6.info(`Spawning: ${scriptPath} ${entry.projectPath}`);
     try {
-      const child = spawn7("bash", [scriptPath, entry.projectPath], {
+      const child = spawn8("bash", [scriptPath, entry.projectPath], {
         detached: true,
         stdio: "ignore",
         env,
@@ -17726,13 +18630,16 @@ function createQueueCommand() {
   queue.command("claim <job-type> <project-dir>").description(
     "Atomically claim a concurrency slot and insert a running entry (used by cron scripts)"
   ).option("--provider-key <key>", "Provider bucket key (e.g. claude-native, codex)").option("--pid <pid>", "PID of the calling process (stored for stale-job detection)").action((jobType, projectDir, opts) => {
-    if (!VALID_JOB_TYPES2.includes(jobType)) {
+    if (!VALID_JOB_TYPES3.includes(jobType)) {
       console.error(`Invalid job type: ${jobType}`);
-      console.error(`Valid types: ${VALID_JOB_TYPES2.join(", ")}`);
+      console.error(`Valid types: ${VALID_JOB_TYPES3.join(", ")}`);
       process.exit(1);
     }
     const queueConfig = loadConfig(projectDir).queue;
-    const projectName = path42.basename(projectDir);
+    if (isJobPaused(projectDir, jobType)) {
+      process.exit(2);
+    }
+    const projectName = path43.basename(projectDir);
     const callerPid = opts.pid ? parseInt(opts.pid, 10) : void 0;
     const result = claimJobSlot(
       projectDir,
@@ -17875,7 +18782,7 @@ function notifyCommand(program2) {
 
 // src/commands/summary.ts
 init_dist();
-import path43 from "path";
+import path44 from "path";
 import chalk8 from "chalk";
 function formatDuration2(seconds) {
   if (seconds === null) return "-";
@@ -17905,7 +18812,7 @@ function formatJobStatus(status) {
   return chalk8.dim(status);
 }
 function getProjectName2(projectPath) {
-  return path43.basename(projectPath) || projectPath;
+  return path44.basename(projectPath) || projectPath;
 }
 function formatProvider(providerKey) {
   return providerKey.split(":")[0] || providerKey;
@@ -18024,7 +18931,7 @@ function summaryCommand(program2) {
 // src/commands/resolve.ts
 init_dist();
 import { execFileSync as execFileSync7 } from "child_process";
-import * as path44 from "path";
+import * as path45 from "path";
 function buildEnvVars6(config, options) {
   const env = buildBaseEnvVars(config, "pr-resolver", options.dryRun);
   env.NW_PR_RESOLVER_MAX_RUNTIME = String(config.prResolver.maxRuntime);
@@ -18154,7 +19061,7 @@ ${stderr}`);
       const notificationEvent = exitCode === 0 ? "pr_resolver_completed" : "pr_resolver_failed";
       await sendNotifications(config, {
         event: notificationEvent,
-        projectName: path44.basename(projectDir),
+        projectName: path45.basename(projectDir),
         exitCode,
         provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL)
       });
@@ -18169,7 +19076,7 @@ ${stderr}`);
 
 // src/commands/merge.ts
 init_dist();
-import * as path45 from "path";
+import * as path46 from "path";
 function buildEnvVars7(config, options) {
   const env = buildBaseEnvVars(config, "merger", options.dryRun);
   env.NW_MERGER_MAX_RUNTIME = String(config.merger.maxRuntime);
@@ -18275,7 +19182,7 @@ ${stderr}`);
       if (notificationEvent) {
         await sendNotifications(config, {
           event: notificationEvent,
-          projectName: path45.basename(projectDir),
+          projectName: path46.basename(projectDir),
           exitCode,
           provider: formatProviderDisplay(envVars.NW_PROVIDER_CMD, envVars.NW_PROVIDER_LABEL)
         });
@@ -18289,19 +19196,289 @@ ${stderr}`);
   });
 }
 
+// src/commands/agent.ts
+init_dist();
+var SCHEMA_VERSION2 = 1;
+var JSON_OPTION = "--json";
+var JSON_OPTION_DESCRIPTION = "Output as JSON";
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function fail(message, options) {
+  if (options?.json) {
+    const payload = {
+      schemaVersion: SCHEMA_VERSION2,
+      ok: false,
+      error: message
+    };
+    process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  } else {
+    process.stderr.write(`${message}
+`);
+  }
+  process.exit(1);
+}
+function getProcess(snapshot, name) {
+  const processInfo = snapshot.processes.find((processEntry) => processEntry.name === name);
+  return { running: processInfo?.running ?? false, pid: processInfo?.pid ?? null };
+}
+function buildLegacyStatus(snapshot, config) {
+  const pendingPrds = snapshot.prds.filter(
+    (prd) => prd.status === "ready" || prd.status === "blocked"
+  ).length;
+  const claimedPrds = snapshot.prds.filter((prd) => prd.status === "in-progress").length;
+  const donePrds = snapshot.prds.filter((prd) => prd.status === "done").length;
+  const logs = Object.fromEntries(
+    snapshot.logs.map((log) => [
+      log.name,
+      { path: log.path, lastLines: log.lastLines, exists: log.exists, size: log.size }
+    ])
+  );
+  return {
+    projectName: snapshot.projectName,
+    projectDir: snapshot.projectDir,
+    provider: config.provider,
+    reviewerEnabled: config.reviewerEnabled,
+    autoMerge: config.autoMerge,
+    autoMergeMethod: config.autoMergeMethod,
+    executor: getProcess(snapshot, "executor"),
+    reviewer: getProcess(snapshot, "reviewer"),
+    qa: getProcess(snapshot, "qa"),
+    audit: getProcess(snapshot, "audit"),
+    planner: getProcess(snapshot, "planner"),
+    analytics: getProcess(snapshot, "analytics"),
+    merger: getProcess(snapshot, "merger"),
+    prds: { pending: pendingPrds, claimed: claimedPrds, done: donePrds },
+    prs: { open: snapshot.prs.length },
+    crontab: snapshot.crontab,
+    logs
+  };
+}
+function buildPausedState(config) {
+  return Object.fromEntries(
+    getValidJobTypes().map((jobType) => [jobType, config.pausedJobs?.[jobType] === true])
+  );
+}
+function buildLastRuns(analytics) {
+  const lastRuns = Object.fromEntries(
+    getValidJobTypes().map((jobType) => [
+      jobType,
+      { lastSuccessAt: null, lastFailureAt: null, lastExitCode: null }
+    ])
+  );
+  for (const run2 of analytics.recentRuns) {
+    const item = lastRuns[run2.jobType];
+    if (!item) continue;
+    const finishedAt = run2.finishedAt ? new Date(run2.finishedAt * 1e3).toISOString() : null;
+    if (run2.status === "success" && item.lastSuccessAt === null) {
+      item.lastSuccessAt = finishedAt;
+      item.lastExitCode = 0;
+    } else if (run2.status !== "success" && item.lastFailureAt === null) {
+      item.lastFailureAt = finishedAt;
+      item.lastExitCode = 1;
+    }
+  }
+  return lastRuns;
+}
+async function getBoardSnapshot(projectDir, config) {
+  if (config.boardProvider?.enabled === false || !config.boardProvider?.projectNumber) {
+    return { configured: false, columns: [], items: [], error: null };
+  }
+  try {
+    const provider = createBoardProvider(config.boardProvider, projectDir);
+    const [columns, items] = await Promise.all([provider.getColumns(), provider.getAllIssues()]);
+    return { configured: true, columns, items, error: null };
+  } catch (error2) {
+    return {
+      configured: true,
+      columns: [],
+      items: [],
+      error: error2 instanceof Error ? error2.message : String(error2)
+    };
+  }
+}
+function buildHealth(snapshot, config) {
+  const checks = [
+    {
+      name: "config",
+      ok: true,
+      message: "Configuration loaded"
+    },
+    {
+      name: "cron",
+      ok: snapshot.crontab.installed,
+      message: snapshot.crontab.installed ? "Cron entries installed" : "No Night Watch cron entries found"
+    },
+    {
+      name: "queue",
+      ok: true,
+      message: config.queue.enabled ? "Global queue enabled" : "Global queue disabled"
+    },
+    {
+      name: "provider",
+      ok: Boolean(config.provider),
+      message: config.provider ? `Provider configured: ${config.provider}` : "No provider configured"
+    }
+  ];
+  const staleLocks = snapshot.processes.filter(
+    (processInfo) => !processInfo.running && processInfo.pid !== null
+  );
+  checks.push({
+    name: "locks",
+    ok: staleLocks.length === 0,
+    message: staleLocks.length === 0 ? "No stale lock files detected" : `Stale lock files detected for ${staleLocks.map((lock) => lock.name).join(", ")}`
+  });
+  return { schemaVersion: SCHEMA_VERSION2, ok: checks.every((check) => check.ok), checks };
+}
+async function buildAgentStatus(projectDir) {
+  const config = loadConfig(projectDir);
+  const snapshot = await fetchStatusSnapshot(projectDir, config);
+  const analytics = getJobRunsAnalytics(24 * 30);
+  const health = buildHealth(snapshot, config);
+  return {
+    schemaVersion: SCHEMA_VERSION2,
+    generatedAt: snapshot.timestamp.toISOString(),
+    project: { name: snapshot.projectName, dir: snapshot.projectDir, provider: config.provider },
+    status: buildLegacyStatus(snapshot, config),
+    paused: buildPausedState(config),
+    queue: getQueueStatus(),
+    board: await getBoardSnapshot(projectDir, config),
+    health,
+    lastRuns: buildLastRuns(analytics)
+  };
+}
+function normalizeJobType(job) {
+  if (getValidJobTypes().includes(job)) {
+    return job;
+  }
+  throw new Error(`Invalid job: ${job}. Valid jobs: ${getValidJobTypes().join(", ")}`);
+}
+function agentCommand(program2) {
+  const agent = program2.command("agent").description("Machine-readable agent operations");
+  agent.command("status").description("Print a stable machine-readable project snapshot").requiredOption(JSON_OPTION, "Output status as JSON").action(async () => {
+    writeJson(await buildAgentStatus(process.cwd()));
+  });
+}
+function configCommand(program2) {
+  const config = program2.command("config").description("Inspect and edit Night Watch config");
+  config.command("list").description("Print resolved config").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action((options) => {
+    const value = loadConfig(process.cwd());
+    if (options.json) {
+      writeJson({ schemaVersion: SCHEMA_VERSION2, config: value });
+    } else {
+      writeJson(value);
+    }
+  });
+  config.command("get <path>").description("Read a resolved config value by dot path").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action((dotPath, options) => {
+    try {
+      const result = getConfigValue(process.cwd(), dotPath);
+      if (options.json) {
+        writeJson({ schemaVersion: SCHEMA_VERSION2, ...result });
+      } else {
+        writeJson(result.value);
+      }
+    } catch (error2) {
+      fail(error2 instanceof Error ? error2.message : String(error2), options);
+    }
+  });
+  config.command("set <path> <value>").description("Write a config value by dot path").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action((dotPath, rawValue, options) => {
+    try {
+      const result = setConfigValue(process.cwd(), dotPath, parseConfigValue(rawValue));
+      if (options.json) {
+        writeJson({ schemaVersion: SCHEMA_VERSION2, ok: true, ...result });
+      } else {
+        process.stdout.write(`Updated ${result.path}
+`);
+      }
+    } catch (error2) {
+      fail(error2 instanceof Error ? error2.message : String(error2), options);
+    }
+  });
+}
+function healthCommand(program2) {
+  program2.command("health").description("Check automation readiness").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action(async (options) => {
+    const config = loadConfig(process.cwd());
+    const snapshot = await fetchStatusSnapshot(process.cwd(), config);
+    const health = buildHealth(snapshot, config);
+    if (options.json) {
+      writeJson(health);
+    } else {
+      for (const check of health.checks) {
+        process.stdout.write(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}
+`);
+      }
+    }
+    if (!health.ok) {
+      process.exitCode = 1;
+    }
+  });
+}
+function jobCommand(program2) {
+  const job = program2.command("job").description("Manage Night Watch jobs");
+  job.command("pause <job>").description("Pause a cron/queue-dispatched job").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action((jobName, options) => {
+    try {
+      const jobType = normalizeJobType(jobName);
+      const result = setConfigValue(process.cwd(), `pausedJobs.${jobType}`, true);
+      if (options.json) {
+        writeJson({
+          schemaVersion: SCHEMA_VERSION2,
+          ok: true,
+          job: jobType,
+          paused: result.value
+        });
+      } else {
+        process.stdout.write(`Paused ${jobType}
+`);
+      }
+    } catch (error2) {
+      fail(error2 instanceof Error ? error2.message : String(error2), options);
+    }
+  });
+  job.command("resume <job>").description("Resume a cron/queue-dispatched job").option(JSON_OPTION, JSON_OPTION_DESCRIPTION).action((jobName, options) => {
+    try {
+      const jobType = normalizeJobType(jobName);
+      const result = setConfigValue(process.cwd(), `pausedJobs.${jobType}`, false);
+      if (options.json) {
+        writeJson({
+          schemaVersion: SCHEMA_VERSION2,
+          ok: true,
+          job: jobType,
+          paused: result.value
+        });
+      } else {
+        process.stdout.write(`Resumed ${jobType}
+`);
+      }
+    } catch (error2) {
+      fail(error2 instanceof Error ? error2.message : String(error2), options);
+    }
+  });
+  job.command("is-paused <job>").description("Return zero when a job is paused").action((jobName) => {
+    try {
+      const jobType = normalizeJobType(jobName);
+      const paused = loadConfig(process.cwd()).pausedJobs?.[jobType] === true;
+      process.exit(paused ? 0 : 1);
+    } catch {
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var __filename5 = fileURLToPath6(import.meta.url);
 var __dirname5 = dirname12(__filename5);
 function findPackageRoot(dir) {
   let d = dir;
   for (let i = 0; i < 5; i++) {
-    if (existsSync33(join37(d, "package.json"))) return d;
+    if (existsSync34(join38(d, "package.json"))) return d;
     d = dirname12(d);
   }
   return dir;
 }
 var packageRoot = findPackageRoot(__dirname5);
-var packageJson = JSON.parse(readFileSync20(join37(packageRoot, "package.json"), "utf-8"));
+var packageJson = JSON.parse(readFileSync21(join38(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);
@@ -18333,4 +19510,8 @@ notifyCommand(program);
 summaryCommand(program);
 resolveCommand(program);
 mergeCommand(program);
+agentCommand(program);
+configCommand(program);
+healthCommand(program);
+jobCommand(program);
 program.parse();