muaddib-scanner 2.11.52 → 2.11.57

package/src/monitor/queue.js

@@ -10,30 +10,24 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { Worker } = require('worker_threads');
-const { run } = require('../index.js');
-const { runSandbox, isDockerAvailable, tryAcquireSandboxSlot, SANDBOX_CONCURRENCY_MAX } = require('../sandbox/index.js');
+const { runSandbox, tryAcquireSandboxSlot } = require('../sandbox/index.js');
 const { sendWebhook } = require('../webhook.js');
-const { downloadToFile, extractTarGz, extractArchive, sanitizePackageName } = require('../shared/download.js');
+const { downloadToFile, extractArchive, sanitizePackageName } = require('../shared/download.js');
 const { MAX_TARBALL_SIZE } = require('../shared/constants.js');
 const { acquireRegistrySlot, releaseRegistrySlot } = require('../shared/http-limiter.js');
 const { loadCachedIOCs } = require('../ioc/updater.js');
 const { scanPackageJson } = require('../scanner/package.js');
 const { scanShellScripts } = require('../scanner/shell.js');
 const { buildTrainingRecord } = require('../ml/feature-extractor.js');
-const { appendRecord: appendTrainingRecord, relabelRecords, getStats: getTrainingStats } = require('../ml/jsonl-writer.js');
+const { appendRecord: appendTrainingRecord, relabelRecords } = require('../ml/jsonl-writer.js');
 
 // From ./state.js
 const {
   cacheTarball,
   updateScanStats,
   appendDetection,
-  saveScanMemory,
   maybePersistDailyStats,
-  loadNpmSeq,
-  saveNpmSeq,
-  getParisDateString,
   appendTemporalDetection,
-  atomicWriteFileSync,
   tarballCacheKey,
   tarballCachePath,
   appendAlert,
@@ -46,21 +40,11 @@ const {
 const {
   isSuspectClassification,
   hasHighConfidenceThreat,
-  hasIOCMatch,
-  hasTyposquat,
-  hasLifecycleWithIntent,
   isSandboxEnabled,
   isCanaryEnabled,
   recordError,
-  classifyError,
   formatFindings,
-  evaluateCacheTrigger,
-  isFirstPublishHighRisk,
-  DOWNLOADS_CACHE_TTL,
-  HIGH_CONFIDENCE_MALICE_TYPES,
-  IOC_MATCH_TYPES,
-  TIER1_TYPES,
-  hasHighOrCritical
+  isFirstPublishHighRisk
 } = require('./classify.js');
 
 // From ./webhook.js
@@ -74,7 +58,6 @@ const {
   getWebhookUrl,
   computeReputationFactor,
   triageRisk,
-  computeRiskLevel,
   sendDailyReport,
   alertedPackageRules,
   DAILY_REPORT_HOUR
@@ -82,16 +65,11 @@ const {
 
 // From ./temporal.js
 const {
-  isTemporalEnabled,
   runTemporalCheck,
-  isTemporalAstEnabled,
   runTemporalAstCheck,
-  isTemporalPublishEnabled,
   runTemporalPublishCheck,
-  isTemporalMaintainerEnabled,
   runTemporalMaintainerCheck,
   getTemporalMaxSeverity,
-  isPublishAnomalyOnly,
   tryTemporalAlert,
   tryTemporalAstAlert,
   isSafeLifecycleScript
@@ -115,13 +93,32 @@ let _targetConcurrency = BASE_CONCURRENCY;
 const SCAN_CONCURRENCY = BASE_CONCURRENCY; // legacy export — tests check this value
 let _activeWorkers = 0;
 const _workerPromises = new Set();
+// Live static-scan Worker threads — tracked so the daemon's EMERGENCY memory
+// handler can terminate orphaned workers (each retains its isolate heap + parsed
+// ASTs). Bounded by concurrency, so it stays tiny.
+const _liveWorkers = new Set();
 
 function getTargetConcurrency() { return _targetConcurrency; }
 function setTargetConcurrency(n) { _targetConcurrency = Math.max(MIN_CONCURRENCY, Math.min(MAX_CONCURRENCY, n)); }
 function getActiveWorkers() { return _activeWorkers; }
+
+/**
+ * Terminate every live static-scan Worker (best-effort). Returns the count.
+ * Called by daemon.js handleMemoryPressure() at EMERGENCY — a wedged/slow worker
+ * holds its isolate heap and parsed ASTs, part of the off-heap RSS leak.
+ */
+function terminateAllWorkers() {
+  let n = 0;
+  for (const w of Array.from(_liveWorkers)) {
+    try { w.terminate(); n++; } catch { /* already gone */ }
+    _liveWorkers.delete(w);
+  }
+  return n;
+}
 const SCAN_TIMEOUT_MS = 300_000; // 5 minutes per package (3 sandbox runs × 90s + static scan headroom)
 const STATIC_SCAN_TIMEOUT_MS = 45_000; // 45s for static analysis only
 const LARGE_PACKAGE_SIZE = 10 * 1024 * 1024; // 10MB
+const RECENTLY_SCANNED_MAX = 50_000; // FIFO cap for the dedup Set (P0c — bounded resource)
 
 // First-publish sandbox: max pending sandbox items before deferring first-publish clean scans
 // Prevents starving T1a sandbox capacity when many first-publish packages arrive at once
@@ -246,56 +243,58 @@ function countPackageFiles(dir) {
  *   and a monitorMode flag to perform registry queries.
  * @returns {Promise<object>} Scan result (same shape as run(_, {_capture:true}))
  */
-function runScanInWorker(extractedDir, timeoutMs, scanContext = null) {
+function runScanInWorker(extractedDir, timeoutMs, scanContext = null, signal = null) {
   return new Promise((resolve, reject) => {
     const worker = new Worker(SCAN_WORKER_PATH, {
       workerData: { extractedDir, scanContext: scanContext || {} }
     });
+    _liveWorkers.add(worker);
 
     let settled = false;
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        worker.terminate().then(() => {
-          reject(new Error(`Static scan timeout after ${timeoutMs / 1000}s (worker terminated)`));
-        }).catch(() => {
-          reject(new Error(`Static scan timeout after ${timeoutMs / 1000}s (worker terminate failed)`));
-        });
-      }
-    }, timeoutMs);
-
-    worker.on('message', (msg) => {
+    let timer = null;
+    const done = (fn) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      if (msg.type === 'result') {
-        resolve(msg.data);
-      } else if (msg.type === 'error') {
-        reject(new Error(msg.message));
-      }
+      if (signal) { try { signal.removeEventListener('abort', onAbort); } catch { /* not added */ } }
+      _liveWorkers.delete(worker);
+      fn();
+    };
+
+    // Outer-timeout abort (processQueueItem's SCAN_TIMEOUT_MS): terminate the worker
+    // so a static scan that outlives the whole-package budget cannot keep its isolate
+    // (heap + ASTs) alive in the background.
+    const onAbort = () => done(() => {
+      worker.terminate().finally(() => reject(new Error('Static scan aborted (outer timeout — worker terminated)')));
     });
 
-    worker.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      reject(err);
-    });
+    timer = setTimeout(() => done(() => {
+      worker.terminate()
+        .then(() => reject(new Error(`Static scan timeout after ${timeoutMs / 1000}s (worker terminated)`)))
+        .catch(() => reject(new Error(`Static scan timeout after ${timeoutMs / 1000}s (worker terminate failed)`)));
+    }), timeoutMs);
 
-    worker.on('exit', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (code !== 0) {
-        reject(new Error(`Worker exited with code ${code}`));
-      }
-    });
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    worker.on('message', (msg) => done(() => {
+      if (msg.type === 'result') resolve(msg.data);
+      else if (msg.type === 'error') reject(new Error(msg.message));
+    }));
+
+    worker.on('error', (err) => done(() => reject(err)));
+
+    worker.on('exit', (code) => done(() => {
+      if (code !== 0) reject(new Error(`Worker exited with code ${code}`));
+    }));
   });
 }
 
 // --- Package scanning ---
 
-async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, stats, dailyAlerts, recentlyScanned, downloadsCache, scanQueue, sandboxAvailable) {
+async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, stats, dailyAlerts, recentlyScanned, downloadsCache, scanQueue, sandboxAvailable, signal = null) {
   const startTime = Date.now();
   const tmpBase = path.join(os.tmpdir(), 'muaddib-monitor');
   if (!fs.existsSync(tmpBase)) fs.mkdirSync(tmpBase, { recursive: true });
@@ -375,7 +374,6 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
     // Malware payloads are tiny (<1MB); 10MB has 10x safety margin.
     // Quick scan: extract + check package.json + shell scripts for lifecycle threats.
     const unpackedSize = meta.unpackedSize || 0;
-    let alreadyExtracted = false;
     let extractedDir = null;
 
     if (unpackedSize > LARGE_PACKAGE_SIZE || meta.fastTrack) {
@@ -394,7 +392,6 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
         // Validates actual tarball contents (not just registry metadata).
         let bypassQuickScan = false;
         try {
-          alreadyExtracted = true;
           extractedDir = extractArchive(tgzPath, tmpDir);
 
           const [pkgThreats, shellThreats] = await Promise.all([
@@ -417,9 +414,8 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
             updateScanStats('clean');
             return;
           }
-        } catch (extractErr) {
+        } catch {
           // Extract/quick scan failed — fallback to registry metadata check
-          alreadyExtracted = false;
           extractedDir = null;
           const scripts = meta.registryScripts || {};
           const DANGEROUS_LIFECYCLE = ['preinstall', 'install', 'postinstall'];
@@ -467,19 +463,34 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
         // the full 20-scanner pipeline (unchanged behaviour).
         scanMode: (meta && meta.scanMode) || 'full'
       };
-      result = await runScanInWorker(extractedDir, STATIC_SCAN_TIMEOUT_MS, scanContext);
+      result = await runScanInWorker(extractedDir, STATIC_SCAN_TIMEOUT_MS, scanContext, signal);
     } catch (staticErr) {
       if (/static scan timeout/i.test(staticErr.message)) {
-        console.error(`[MONITOR] STATIC_TIMEOUT: ${name}@${version} — exceeded ${STATIC_SCAN_TIMEOUT_MS / 1000}s (worker terminated)`);
+        console.error(`[MONITOR] STATIC_TIMEOUT: ${name}@${version} — exceeded ${STATIC_SCAN_TIMEOUT_MS / 1000}s (worker terminated, kept INCONCLUSIVE not clean)`);
         recordError(staticErr, stats);
         stats.scanned++;
         stats.totalTimeMs += Date.now() - startTime;
-        updateScanStats('clean');
+        // Garde-fou: a static-scan timeout must NOT count as clean — a package that
+        // deliberately hangs the parser to evade analysis would otherwise be relabelled
+        // benign. Count as inconclusive (excluded from the FP/TP denominator).
+        updateScanStats('sandbox_inconclusive');
         return { sandboxResult: null, staticClean: false };
       }
       throw staticErr;
     }
 
+    // Phase 3 signal — agent-supply-chain lens. Pure observability, no scoring impact.
+    // Cisco AI Defense / SkillSieve / Snyk Agent Scan EVO scan skill marketplaces;
+    // they don't monitor the npm/PyPI firehose. Tracking which packages bundle a
+    // SKILL.md is our unique intersection (npm-package-bundling-malicious-skill).
+    try {
+      const det = detectSkillMdBundled(extractedDir, result && result.threats);
+      if (det.bundled) {
+        stats.skillMdBundled = (stats.skillMdBundled || 0) + 1;
+        console.log(`[MONITOR] SKILL_MD_BUNDLED: ${name}@${version} (${ecosystem}) — ${det.count} file(s)`);
+      }
+    } catch { /* observability signal — never let it break the scan */ }
+
     // First-publish detection: used for sandbox priority below
     const isFirstPublish = cacheTrigger && cacheTrigger.reason === 'first_publish';
 
@@ -518,7 +529,7 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
         try {
           const canary = isCanaryEnabled();
           console.log(`[MONITOR] SANDBOX (first-publish): launching for ${name}@${version}${canary ? ' (canary: on)' : ''}...`);
-          sandboxResult = await runSandbox(name, { canary });
+          sandboxResult = await runSandbox(name, { canary, signal });
           console.log(`[MONITOR] SANDBOX: ${name}@${version} → score: ${sandboxResult.score}, severity: ${sandboxResult.severity}`);
         } catch (err) {
           console.error(`[MONITOR] SANDBOX ERROR: ${name}@${version} — ${err.message}`);
@@ -678,7 +689,8 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
               // LOG-ONLY: record ML prediction for retraining data but do NOT filter.
               // When model is retrained and validated, remove the 'true ||' guard below.
               console.log(`[MONITOR] ML LOG-ONLY: ${name}@${version} (prediction=${mlResult.prediction}, p=${mlResult.probability}, score=${riskScore})`);
-              if (false && mlResult.prediction === 'clean') {
+              const ML_FILTER_ENABLED = false;
+              if (ML_FILTER_ENABLED && mlResult.prediction === 'clean') {
                 // DISABLED: model collapsed (p≈0.002 for all inputs). Re-enable after retrain.
                 console.log(`[MONITOR] ML CLEAN: ${name}@${version} (p=${mlResult.probability}, score=${riskScore})`);
                 stats.mlFiltered++;
@@ -774,12 +786,12 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
             if (tier === '1a') {
               // T1a: mandatory sandbox — block-wait (high-confidence threats MUST get sandbox)
               console.log(`[MONITOR] SANDBOX: launching for ${name}@${version}${canary ? ' (canary: on)' : ''}...`);
-              sandboxResult = await runSandbox(name, { canary, maxRuns });
+              sandboxResult = await runSandbox(name, { canary, maxRuns, signal });
             } else if (tryAcquireSandboxSlot()) {
               // T1b/T2: non-blocking — slot acquired atomically, run with skipSemaphore
               const reason = tier === 2 ? ' (T2, queue low)' : ' (T1b, conditional)';
               console.log(`[MONITOR] SANDBOX${reason}: launching for ${name}@${version}${canary ? ' (canary: on)' : ''}...`);
-              sandboxResult = await runSandbox(name, { canary, maxRuns, skipSemaphore: true });
+              sandboxResult = await runSandbox(name, { canary, maxRuns, skipSemaphore: true, signal });
             } else {
               // T1b/T2: all sandbox slots busy — defer instead of blocking worker
               console.log(`[MONITOR] SANDBOX DEFER (slots full): ${name}@${version} (tier=${tier}, score=${riskScore})`);
@@ -950,7 +962,7 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
         // LLM Detective: AI-powered analysis for T1a/T1b suspects
         // Skip for fast-track (large boring packages — LLM analysis adds 10-30s for no value)
         let llmResult = null;
-        if (!meta.fastTrack && (tier === '1a' || tier === '1b') && (adjustedResult.summary.riskScore || 0) >= 25) {
+        if (!meta.fastTrack && (tier === '1a' || tier === '1b') && (adjustedResult.summary.riskScore || 0) >= 25 && !(signal && signal.aborted)) {
           try {
             const { investigatePackage, isLlmEnabled, getLlmMode } = require('../ml/llm-detective.js');
             if (isLlmEnabled()) {
@@ -1004,6 +1016,34 @@ async function scanPackage(name, version, ecosystem, tarballUrl, registryMeta, s
   }
 }
 
+/**
+ * Detect whether a package bundles a SKILL.md (Anthropic Agent Skills spec).
+ * Pure observability — drives the `stats.skillMdBundled` counter, no scoring effect.
+ *
+ * Two-pass check: (1) inspect emitted threats for SKILL.md filenames so we catch
+ * cases the scanner already touched without re-walking the tree; (2) fall back to
+ * a bounded findFiles walk (maxDepth 4, maxFiles 5) for packages where no scanner
+ * has flagged anything.
+ *
+ * @param {string|null} extractedDir - Unpacked tarball root, or null if unknown.
+ * @param {Array<{file?:string}>|null} threats - Threats array from the scan result.
+ * @returns {{bundled: boolean, count: number}}
+ */
+function detectSkillMdBundled(extractedDir, threats) {
+  const fromThreats = Array.isArray(threats) && threats.some(
+    t => /(?:^|[\\/])SKILL\.md$/i.test((t && t.file) || '')
+  );
+  if (fromThreats) return { bundled: true, count: 1 };
+  if (!extractedDir) return { bundled: false, count: 0 };
+  try {
+    const { findFiles } = require('../utils.js');
+    const found = findFiles(extractedDir, { extensions: ['SKILL.md'], maxDepth: 4, maxFiles: 5 });
+    return { bundled: found.length > 0, count: found.length };
+  } catch {
+    return { bundled: false, count: 0 };
+  }
+}
+
 function timeoutPromise(ms) {
   return new Promise((_, reject) => {
     setTimeout(() => reject(new Error(`Scan timeout after ${ms / 1000}s`)), ms);
@@ -1102,6 +1142,16 @@ async function _spawnWorker(scanQueue, stats, dailyAlerts, recentlyScanned, down
   }
 }
 
+/**
+ * Pure spawn-count decision: how many workers to start given the target concurrency, the number
+ * already active, and the queue depth. Never negative (active can exceed target during scale-down)
+ * and never more than the backlog. Extracted so the adaptive worker-pool math is unit-testable
+ * without spawning real (network-bound) workers.
+ */
+function computeWorkersToSpawn(targetConcurrency, activeWorkers, queueLength) {
+  return Math.max(0, Math.min(targetConcurrency - activeWorkers, queueLength));
+}
+
 /**
  * Ensure the target number of workers are running. Non-blocking: spawns
  * missing workers as background promises. Called from the daemon main loop
@@ -1109,7 +1159,7 @@ async function _spawnWorker(scanQueue, stats, dailyAlerts, recentlyScanned, down
  */
 function ensureWorkers(scanQueue, stats, dailyAlerts, recentlyScanned, downloadsCache, sandboxAvailable) {
   if (scanQueue.length === 0) return;
-  const toSpawn = Math.min(_targetConcurrency - _activeWorkers, scanQueue.length);
+  const toSpawn = computeWorkersToSpawn(_targetConcurrency, _activeWorkers, scanQueue.length);
   if (toSpawn <= 0) return;
 
   console.log(`[MONITOR] Spawning ${toSpawn} worker(s) (active: ${_activeWorkers}, target: ${_targetConcurrency}, queue: ${scanQueue.length})`);
@@ -1274,6 +1324,13 @@ async function resolveTarballAndScan(item, stats, dailyAlerts, recentlyScanned,
     return;
   }
   recentlyScanned.add(dedupeKey);
+  // FIFO eviction (P0c — bounded resource): a Set preserves insertion order, so the
+  // first value is the oldest. Evicting at most one per insert pins the size at the
+  // cap and prevents unbounded heap growth within an uptime (the hourly clear in
+  // daemon.js pruneMemoryCaches remains a coarse backstop).
+  if (recentlyScanned.size > RECENTLY_SCANNED_MAX) {
+    recentlyScanned.delete(recentlyScanned.values().next().value);
+  }
   // Coverage numerator: one count per unique (ecosystem, name, version) that
   // reaches a scan attempt. Excludes ATO burst extras that lose the dedup
   // race, retries, size-cap rejections — those inflate stats.scanned but
@@ -1360,7 +1417,7 @@ async function resolveTarballAndScan(item, stats, dailyAlerts, recentlyScanned,
     _cacheTrigger: item._cacheTrigger || null,
     fastTrack: item.fastTrack || false,
     scanMode: effectiveScanMode
-  }, stats, dailyAlerts, recentlyScanned, downloadsCache, scanQueue, sandboxAvailable);
+  }, stats, dailyAlerts, recentlyScanned, downloadsCache, scanQueue, sandboxAvailable, signal);
   const sandboxResult = scanResult && scanResult.sandboxResult;
   const staticClean = scanResult && scanResult.staticClean;
 
@@ -1470,6 +1527,8 @@ module.exports = {
   getTargetConcurrency,
   setTargetConcurrency,
   getActiveWorkers,
+  terminateAllWorkers,
+  computeWorkersToSpawn,
   ensureWorkers,
   drainWorkers,
 
@@ -1480,6 +1539,7 @@ module.exports = {
   runScanInWorker,
   scanPackage,
   timeoutPromise,
+  detectSkillMdBundled,
   isDailyReportDue,
   processQueueItem,
   processQueue,

package/src/monitor/state.js

@@ -165,12 +165,12 @@ function atomicWriteFileSync(filePath, data) {
   } catch (err) {
     if (err.code === 'EROFS' || err.code === 'EACCES' || err.code === 'EPERM') {
       console.warn(`[MONITOR] Cannot write ${path.basename(filePath)} (${err.code}) — skipping`);
-      try { fs.unlinkSync(tmpFile); } catch (_) { /* ignore */ }
+      try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
       return;
     }
     if (err.code === 'ENOSPC') {
       console.warn(`[MONITOR] WARNING: disk full (ENOSPC) — cannot write ${path.basename(filePath)}. Free space in /tmp and data/ immediately.`);
-      try { fs.unlinkSync(tmpFile); } catch (_) { /* ignore */ }
+      try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
       return;
     }
     throw err;

package/src/monitor/webhook.js

@@ -18,28 +18,20 @@ const {
   getParisHour,
   loadScanStats,
   loadDetections,
-  loadLastDailyReportDate,
   saveLastDailyReportDate,
-  saveDailyStats,
   resetDailyStats,
   saveScanMemory,
   shouldSuppressByMemory,
   recordScanMemory,
-  loadState,
   saveState,
   loadStateRaw,
   getScansSinceLastMemoryPersist,
-  setScansSinceLastMemoryPersist,
-  STATE_FILE
+  setScansSinceLastMemoryPersist
 } = require('./state.js');
 const {
   HIGH_CONFIDENCE_MALICE_TYPES,
   hasIOCMatch,
   hasHighOrCritical,
-  hasHighConfidenceThreat,
-  hasTyposquat,
-  hasLifecycleWithIntent,
-  isSuspectClassification,
   formatErrorBreakdown
 } = require('./classify.js');
 
@@ -48,6 +40,7 @@ const {
 // Webhook dedup: track alerted packages by name -> Set<rule_ids> (cleared with daily report).
 // If a new version triggers the same rules, skip the webhook. If new rules appear, let it through.
 const alertedPackageRules = new Map();
+const ALERTED_PACKAGES_MAX = 5_000; // single source of truth for the alerted-packages cap (daemon.js imports this for pruneMemoryCaches)
 
 // Scope grouping: buffer scoped npm packages for grouped webhooks (monorepo noise reduction).
 // @scope -> { packages[], timer, maxScore, ecosystem }
@@ -358,7 +351,7 @@ function triageRisk(item, meta) {
     reasons.push('no_metadata');
   } else if (ecosystem === 'npm') {
     const factor = computeReputationFactor(meta);
-    if (factor >= 1.0) reasons.push(`reputation_factor=${factor.toFixed(2)}`);
+    if (factor >= 1.2) reasons.push(`reputation_factor=${factor.toFixed(2)}`);
   } else if (ecosystem === 'pypi') {
     // PyPI has no weekly_downloads source today, so we cannot reuse
     // computeReputationFactor as-is. Use direct signals instead.
@@ -559,6 +552,11 @@ async function trySendWebhook(name, version, ecosystem, result, sandboxResult, m
     for (const r of currentRules) previousRules.add(r);
   } else {
     alertedPackageRules.set(name, new Set(currentRules));
+    // FIFO size cap (bounded resource): evict the oldest tracked package when over
+    // the cap. A Map preserves insertion order, so the first key is the oldest.
+    if (alertedPackageRules.size > ALERTED_PACKAGES_MAX) {
+      alertedPackageRules.delete(alertedPackageRules.keys().next().value);
+    }
   }
 
   // Scope grouping: buffer scoped npm packages for grouped webhook
@@ -1291,6 +1289,7 @@ module.exports = {
   // Constants
   HIGH_INTENT_TYPES,
   DAILY_REPORT_HOUR,
+  ALERTED_PACKAGES_MAX,
 
   // Functions
   getWebhookUrl,

package/src/output/cyclonedx.js

@@ -189,7 +189,7 @@ function saveCycloneDX(results, outputPath) {
   try {
     fs.writeFileSync(outputPath, JSON.stringify(bom, null, 2));
   } catch (e) {
-    throw new Error('Failed to write CycloneDX report to ' + outputPath + ': ' + e.message);
+    throw new Error('Failed to write CycloneDX report to ' + outputPath + ': ' + e.message, { cause: e });
   }
   return outputPath;
 }

package/src/output/report.js

@@ -262,7 +262,7 @@ function saveReport(results, outputPath) {
   try {
     fs.writeFileSync(outputPath, html);
   } catch (e) {
-    throw new Error(`Failed to write HTML report to ${outputPath}: ${e.message}`);
+    throw new Error(`Failed to write HTML report to ${outputPath}: ${e.message}`, { cause: e });
   }
   return outputPath;
 }

package/src/output/sarif.js

@@ -99,7 +99,7 @@ function saveSARIF(results, outputPath) {
   try {
     fs.writeFileSync(outputPath, JSON.stringify(sarif, null, 2));
   } catch (e) {
-    throw new Error(`Failed to write SARIF report to ${outputPath}: ${e.message}`);
+    throw new Error(`Failed to write SARIF report to ${outputPath}: ${e.message}`, { cause: e });
   }
   return outputPath;
 }

package/src/pipeline/executor.js

@@ -18,8 +18,8 @@ const { scanEntropy } = require('../scanner/entropy.js');
 const { scanAIConfig } = require('../scanner/ai-config.js');
 const { deobfuscate } = require('../scanner/deobfuscate.js');
 const { buildModuleGraph, annotateTaintedExports, detectCrossFileFlows, annotateSinkExports, detectCallbackCrossFileFlows, detectEventEmitterFlows } = require('../scanner/module-graph');
-const { loadCachedIOCs, checkIOCStaleness } = require('../ioc/updater.js');
-const { detectPythonProject, normalizePythonName } = require('../scanner/python.js');
+const { loadCachedIOCs } = require('../ioc/updater.js');
+const { normalizePythonName } = require('../scanner/python.js');
 const { scanPythonSource } = require('../scanner/python-source.js');
 const { initPythonParser, scanPythonAST } = require('../scanner/python-ast.js');
 const { Spinner, listInstalledPackages, wasFilesCapped, getOverflowFiles, debugLog } = require('../utils.js');

package/src/pipeline/processor.js

@@ -5,7 +5,7 @@ const { getPlaybook } = require('../response/playbooks.js');
 const { computeReachableFiles, computeReachableFunctions } = require('../scanner/reachability.js');
 const { applyFPReductions, applyCompoundBoosts, calculateRiskScore, getSeverityWeights, applyContextualFPCaps, applySingleFireCriticalFloor, applyReputationFactor, applyMatureStableCap, applySandboxVerdict, applyDeltaMultiplier } = require('../scoring.js');
 const { loadPriorVersionSignatures, computeSignatures, saveCachedSignatures } = require('../scoring/delta-multiplier.js');
-const { annotateConfidenceTiers, tierAtLeast } = require('../rules/confidence-tiers.js');
+const { annotateConfidenceTiers } = require('../rules/confidence-tiers.js');
 const { buildIntentPairs } = require('../intent-graph.js');
 const { debugLog } = require('../utils.js');
 const { getPackageMetadata } = require('../scanner/npm-registry.js');
@@ -472,7 +472,7 @@ async function process(threats, targetPath, options, pythonDeps, warnings, scann
   // Per-file max scoring (v2.2.11) with intent graph bonus
   const {
     riskScore, riskLevel, globalRiskScore,
-    maxFileScore, packageScore, intentBonus, mostSuspiciousFile, fileScores,
+    maxFileScore, packageScore, mostSuspiciousFile, fileScores,
     criticalCount, highCount, mediumCount, lowCount
   } = calculateRiskScore(deduped, intentResult);
 

package/src/runtime/monitor-feed.js

@@ -13,12 +13,9 @@
  */
 
 const fs = require('fs');
-const path = require('path');
 
 const {
   DAILY_STATS_FILE,
-  SCAN_STATS_FILE,
-  STATE_FILE,
   LAST_DAILY_REPORT_FILE,
   loadScanStats,
   loadStateRaw,

package/src/sandbox/compound-triggers.js

@@ -206,10 +206,10 @@ function evaluateSandboxTrigger(threats, score, fileSizes) {
     return { shouldRun: false, compound: null, watchpoints: [], reason: 'score above window' };
   }
   for (const trigger of TRIGGERS) {
-    let matched = false;
+    let matched;
     try {
       matched = trigger.matches(threats, fileSizes || {});
-    } catch (e) {
+    } catch {
       matched = false;
     }
     if (matched) {