thuban 0.3.1 → 0.3.3

package/cli.js

@@ -14,12 +14,16 @@
  *   npx thuban report [path]        Full scan + deps + drift combined report
  *   npx thuban hallucinate [path]   Detect AI hallucinations and phantom imports
  *   npx thuban watch [path]         Live sentinel — continuous file monitoring
+ *   npx thuban monitor [path]       Recurring scans with saved history and alerts
+ *   npx thuban history [path]       View recurring scan history for a repo
+ *   npx thuban trend [path]         Show issue trends across recurring scans
  *   npx thuban dashboard [path]     Generate visual HTML dashboard report
  *   npx thuban diff [path]          Scan only git-changed files
  */
 
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 
 // Import engine components
 const CodeScanner = require('./packages/scanner/code-scanner.js');
@@ -40,6 +44,9 @@ const CopyPasteDriftDetector = require('./packages/scanner/copy-paste-detector.j
 const CodebasePassport = require('./packages/scanner/codebase-passport.js');
 const ExecutiveReport = require('./packages/scanner/executive-report.js');
 const BaselineManager = require('./packages/scanner/baseline-manager.js');
+const MonitorStore = require('./packages/scanner/monitor-store.js');
+const { MonitorService, resolveIntervalMs } = require('./packages/scanner/monitor-service.js');
+const { collectFiles } = require('./packages/scanner/file-collector.js');
 
 // ─── Helpers ───────────────────────────────────────────────
 
@@ -66,7 +73,7 @@ function banner() {
   console.log('');
   console.log(c('cyan', '  ╔══════════════════════════════════════╗'));
   console.log(c('cyan', '  ║') + c('bold', '        THUBAN Code Health Engine     ') + c('cyan', '║'));
-  console.log(c('cyan', '  ║') + c('gray', '     Scan · Map · Detect · Fix        ') + c('cyan', '║'));
+  console.log(c('cyan', '  ║') + c('gray', '   v0.3.3 · Public Beta · thuban.dev  ') + c('cyan', '║'));
   console.log(c('cyan', '  ╚══════════════════════════════════════╝'));
   console.log('');
 }
@@ -93,7 +100,8 @@ function printHelp() {
   // ─── SCAN & DETECT ───────────────────────────────────────
   console.log(c('bold', '  SCAN & DETECT'));
   console.log('');
-  console.log(`    ${c('cyan', 'scan')} [path]              Full health scan — score, grade, all issues`);
+  console.log(`    ${c('cyan', 'scan')} [path|url]           Full health scan — score, grade, all issues`);
+  console.log(`    ${c('cyan', 'compare')} [a] [b]          Compare two codebases side by side`);
   console.log(`    ${c('cyan', 'hallucinate')} [path]       Find phantom APIs and invented imports`);
   console.log(`    ${c('cyan', 'ghosts')} [path]            Dead functions nobody calls`);
   console.log(`    ${c('cyan', 'ai-score')} [path]          Probability each function is AI-generated`);
@@ -114,6 +122,9 @@ function printHelp() {
   console.log(`    ${c('cyan', 'inject')} [path]            Add Mother Code DNA to every file`);
   console.log(`    ${c('cyan', 'gate')}                     Install pre-commit hook ${c('gray', '(blocks hallucinations)')}`);
   console.log(`    ${c('cyan', 'watch')} [path]             Live sentinel — scans files as you save`);
+  console.log(`    ${c('cyan', 'monitor')} [path]           Recurring scans with saved history and alerts ${c('gray', '(Pro)')}`);
+  console.log(`    ${c('cyan', 'history')} [path]           View recurring scan history for a repo ${c('gray', '(Pro)')}`);
+  console.log(`    ${c('cyan', 'trend')} [path]             Show issue trends across recurring scans ${c('gray', '(Pro)')}`);
   console.log(`    ${c('cyan', 'baseline')} [path]          Snapshot issues so future scans show only NEW ones`);
   console.log('');
 
@@ -166,6 +177,9 @@ function printHelp() {
   console.log(c('gray', '  # Scan a specific folder, ignore tests'));
   console.log(`    ${c('white', 'npx thuban scan ./src --ignore "**/*.test.js"')}`);
   console.log('');
+  console.log(c('gray', '  Report a bug or request a feature:'));
+  console.log(`    ${c('cyan', 'https://github.com/SilverwingsBenefitsGit/thuban/issues')}`);
+  console.log('');
 }
 
 function parseArgs(args) {
@@ -183,6 +197,10 @@ function parseArgs(args) {
     licenseKey: null,
     baseline: false,
     baselineCreate: false,
+    frequency: 'daily',
+    intervalMs: null,
+    notify: 'inbox',
+    once: false,
   };
 
   const noPathCommands = ['activate', 'status', 'upgrade', 'help', 'version'];
@@ -197,6 +215,10 @@ function parseArgs(args) {
     else if (arg === '--git-commit' || arg === '--commit') { opts.gitCommit = true; }
     else if (arg === '--baseline') { opts.baseline = true; }
     else if (arg === '--baseline-create') { opts.baselineCreate = true; }
+    else if (arg === '--frequency' && args[i + 1]) { opts.frequency = args[++i]; }
+    else if (arg === '--interval-ms' && args[i + 1]) { opts.intervalMs = parseInt(args[++i], 10); }
+    else if (arg === '--notify' && args[i + 1]) { opts.notify = args[++i]; }
+    else if (arg === '--once') { opts.once = true; }
     else if (arg === '--verbose') { opts.verbose = true; }
     else if (arg === '--ignore' && args[i + 1]) { opts.ignore.push(args[++i]); }
     else if (arg === '--max-issues' && args[i + 1]) { opts.maxIssues = parseInt(args[++i], 10); }
@@ -204,7 +226,14 @@ function parseArgs(args) {
     else if (arg === '--version' || arg === '-v') { opts.command = 'version'; }
     else if (!opts.command) { opts.command = arg; }
     else if (opts.command === 'activate' && !opts.licenseKey) { opts.licenseKey = arg; }
-    else if (!noPathCommands.includes(opts.command)) { opts.targetPath = path.resolve(arg); }
+    else if (!noPathCommands.includes(opts.command)) {
+      // Don't resolve git URLs as local paths
+      if (arg.match(/^(https?:\/\/|git@)/)) {
+        opts.targetPath = arg;
+      } else {
+        opts.targetPath = path.resolve(arg);
+      }
+    }
     i++;
   }
 
@@ -213,55 +242,138 @@ function parseArgs(args) {
 
 // ─── Collect files recursively ───────────────────────────────
 
-function collectFiles(dir, ignorePatterns = []) {
-  const defaultIgnore = ['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.venv', 'venv', 'coverage', '.cache', '.turbo'];
-  const allIgnore = [...defaultIgnore, ...ignorePatterns];
-  const extensions = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py', '.pyw', '.go', '.rs', '.java', '.kt', '.cs', '.json'];
-  const MAX_FILE_SIZE = 1024 * 1024; // 1MB per file — skip anything larger
-  const MAX_FILES = 50000;           // Hard cap to prevent memory issues
-  const files = [];
-
-  function walk(currentDir) {
-    if (files.length >= MAX_FILES) return;
-    let entries;
-    try {
-      entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    } catch (e) {
-      return;
+function summarizeRemainingFiles(scannedFiles, allFiles, rootPath) {
+  const scannedSet = new Set(scannedFiles);
+  const remainingFiles = allFiles.filter(file => !scannedSet.has(file));
+  const directoryCounts = new Map();
+
+  for (const file of remainingFiles) {
+    const relativePath = path.relative(rootPath, file);
+    const segments = relativePath.split(path.sep).filter(Boolean);
+    const directory = segments.length > 1 ? segments[0] : '(root)';
+    directoryCounts.set(directory, (directoryCounts.get(directory) || 0) + 1);
+  }
+
+  const topDirectories = Array.from(directoryCounts.entries())
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .slice(0, 3)
+    .map(([directory, count]) => ({ directory, count }));
+
+  return {
+    remainingFiles,
+    remainingCount: remainingFiles.length,
+    topDirectories,
+    previewFiles: remainingFiles.slice(0, 5).map(file => path.relative(rootPath, file)),
+  };
+}
+
+function requireProFeature(featureName) {
+  const lm = new LicenseManager();
+  const access = lm.canUseProFeature(featureName);
+  if (!access.allowed) {
+    const upgradeUrl = 'https://thuban.dev/pricing';
+    console.log('');
+    console.log(c('yellow', '  ╔══════════════════════════════════════════════════════════════╗'));
+    console.log(c('yellow', '  ║') + c('bold', '  PRO FEATURE REQUIRED                                         ') + c('yellow', '║'));
+    console.log(c('yellow', '  ╠══════════════════════════════════════════════════════════════╣'));
+    console.log(c('yellow', '  ║') + `  ${featureName} is available on Thuban Pro.`.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + '  Free Thuban gives you a one-off checkup. Pro gives you'.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + '  a pair of eyes on your codebase all day every day with'.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + '  recurring scans, saved history, trends, and alerts.'.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + '                                                              ' + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + `  Upgrade now: ${upgradeUrl}`.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ║') + '  CLI shortcut: thuban upgrade'.padEnd(62) + c('yellow', '║'));
+    console.log(c('yellow', '  ╚══════════════════════════════════════════════════════════════╝'));
+    console.log('');
+    process.exit(0);
+  }
+  return lm;
+}
+
+function resolveRepoConfigOrExit(store, targetPath) {
+  const repo = store.getRepo(targetPath);
+  if (!repo) {
+    console.log('');
+    console.log(c('yellow', '  No monitor configuration found for this repo.'));
+    console.log(c('gray', '  Run `thuban monitor <path> --once` or `thuban monitor <path>` first.'));
+    console.log('');
+    process.exit(0);
+  }
+  return repo;
+}
+
+function printFileCapUpgradePrompt({ scannedCount, totalCount, remainingSummary, upgradeUrl }) {
+  const criticalDirectoryCount = remainingSummary.topDirectories.length;
+
+  console.log(c('yellow', '  ╔══════════════════════════════════════════════════════════════╗'));
+  console.log(c('yellow', '  ║') + c('bold', '  FREE TIER LIMIT REACHED                                     ') + c('yellow', '║'));
+  console.log(c('yellow', '  ╠══════════════════════════════════════════════════════════════╣'));
+  console.log(c('yellow', '  ║') + `  You have scanned ${scannedCount} of ${totalCount} files.`.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + '  Upgrade to Thuban Pro for continuous monitoring —'.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + '  a pair of eyes on your codebase, all day, every day.'.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + '  Your always-on guardian with unlimited scans.'.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + `  ${remainingSummary.remainingCount} more files remaining including ${criticalDirectoryCount}`.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + `  critical director${criticalDirectoryCount === 1 ? 'y' : 'ies'}.`.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + '                                                              ' + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + `  Upgrade now: ${upgradeUrl}`.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ║') + `  CLI shortcut: thuban upgrade`.padEnd(62) + c('yellow', '║'));
+  console.log(c('yellow', '  ╚══════════════════════════════════════════════════════════════╝'));
+  console.log('');
+
+  if (remainingSummary.topDirectories.length > 0) {
+    console.log(c('bold', '  Remaining scan preview'));
+    for (const item of remainingSummary.topDirectories) {
+      console.log(`    ${c('yellow', '•')} ${c('cyan', item.directory)} ${c('gray', `(${item.count} files)`)}`);
     }
-    for (const entry of entries) {
-      if (files.length >= MAX_FILES) return;
-      if (allIgnore.some(p => entry.name === p || entry.name.match(p))) continue;
-      const fullPath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-      } else if (extensions.some(ext => entry.name.endsWith(ext))) {
-        try {
-          const stat = fs.statSync(fullPath);
-          if (stat.size <= MAX_FILE_SIZE) {
-            files.push(fullPath);
-          }
-        } catch (e) {
-          // Skip files we can't stat
-        }
+    if (remainingSummary.previewFiles.length > 0) {
+      console.log('');
+      console.log(c('gray', '  Next files that would be scanned:'));
+      for (const file of remainingSummary.previewFiles) {
+        console.log(`    ${c('gray', '·')} ${file}`);
       }
     }
+    console.log('');
   }
-
-  walk(dir);
-  return files;
 }
 
 // ─── Commands ───────────────────────────────────────────────
 
 async function cmdScan(opts) {
   const startTime = Date.now();
-  const targetPath = path.resolve(opts.targetPath);
+  const gitUrlPattern = /^(https?:\/\/|git@)/;
+  const isGitUrl = gitUrlPattern.test(opts.targetPath);
+  let targetPath = isGitUrl ? opts.targetPath : path.resolve(opts.targetPath);
+  let clonedRepo = null;
+
+  // ─── Git URL detection — clone and scan ─────────────────
+  if (isGitUrl) {
+    if (!opts.json) {
+      console.log('');
+      console.log(c('cyan', '  Cloning repository...'));
+      console.log(c('gray', `  ${opts.targetPath}`));
+    }
+    const tmpDir = path.join(os.tmpdir(), 'thuban-scan-' + Date.now());
+    const { execFileSync } = require('child_process');
+    try {
+      execFileSync('git', ['clone', '--depth', '1', opts.targetPath, tmpDir], { stdio: 'pipe', timeout: 60000 });
+      targetPath = tmpDir;
+      clonedRepo = tmpDir;
+      if (!opts.json) {
+        console.log(c('cyan', '  Cloned successfully'));
+        console.log('');
+      }
+    } catch (e) {
+      console.error(c('red', `  Failed to clone repository: ${e.message}`));
+      console.error(c('gray', '  Check the URL is correct and the repo is accessible'));
+      process.exit(1);
+    }
+  }
 
   // ─── License check ───────────────────────────────────────
   const lm = new LicenseManager();
   const tier = lm.getTierConfig();
   const scanCheck = lm.canScan();
+  const upgradeUrl = 'https://thuban.dev/pricing';
 
   if (!scanCheck.allowed && !opts.json) {
     console.log('');
@@ -272,8 +384,8 @@ async function cmdScan(opts) {
     console.log(`  You've used ${c('bold', scanCheck.used + '/' + scanCheck.limit)} free scans this month.`);
     console.log(`  Resets on ${c('cyan', scanCheck.resetsOn)}.`);
     console.log('');
-    console.log(`  ${c('cyan', 'Upgrade to Pro')} for unlimited scans, full reports, and auto-fix:`);
-    console.log(`  ${c('bold', 'https://thuban.dev/pricing')}`);
+    console.log(`  ${c('cyan', 'Upgrade to Pro')} for unlimited scans, full reports, auto-fix, and an always-on pair of eyes via thuban monitor:`);
+    console.log(`  ${c('bold', upgradeUrl)}`);
     console.log('');
     console.log(`  Or activate a key: ${c('cyan', 'thuban activate <your-key>')}`);
     console.log('');
@@ -309,10 +421,11 @@ async function cmdScan(opts) {
   // File limit gating
   const files = tier.maxFiles < Infinity ? allFiles.slice(0, tier.maxFiles) : allFiles;
   const isFileCapped = totalFileCount > tier.maxFiles;
+  const remainingSummary = isFileCapped ? summarizeRemainingFiles(files, allFiles, targetPath) : null;
 
   if (!opts.json && isFileCapped) {
     console.log(c('yellow', `  Free tier: scanning ${tier.maxFiles} of ${totalFileCount} files`));
-    console.log(c('gray', `  Upgrade to Pro to scan your entire codebase`));
+    console.log(c('gray', `  Partial results below. Upgrade to scan your entire codebase.`));
     console.log('');
   } else if (!opts.json) {
     console.log(c('gray', `  Found ${files.length} files to scan...`));
@@ -338,12 +451,8 @@ async function cmdScan(opts) {
 
   // ─── Collect all issues ──────────────────────────────────
   const allIssues = [];
-  for (const [file, fileResults] of Object.entries(scanResults)) {
-    if (fileResults.issues) {
-      for (const issue of fileResults.issues) {
-        allIssues.push({ file: path.relative(targetPath, file), ...issue });
-      }
-    }
+  for (const issue of (scanResults.issues || [])) {
+    allIssues.push({ file: path.relative(targetPath, issue.file), ...issue });
   }
 
   // Add hallucination results as issues
@@ -389,6 +498,11 @@ async function cmdScan(opts) {
       issues: tier.showFullDetails ? allIssues : allIssues.slice(0, tier.teaserIssues),
       totalIssues: allIssues.length,
       gated: !tier.showFullDetails,
+      fileLimitReached: isFileCapped,
+      upgradeUrl: isFileCapped ? upgradeUrl : null,
+      remainingFiles: remainingSummary ? remainingSummary.remainingCount : 0,
+      remainingDirectories: remainingSummary ? remainingSummary.topDirectories : [],
+      remainingPreview: remainingSummary ? remainingSummary.previewFiles : [],
     }, null, 2));
     return;
   }
@@ -427,6 +541,7 @@ async function cmdScan(opts) {
 
   console.log(c('cyan', '  ╔══════════════════════════════════════════════════════╗'));
   console.log(c('cyan', '  ║') + c('bold', '  THUBAN SCAN RESULTS                                ') + c('cyan', '║'));
+  console.log(c('cyan', '  ║') + c('gray', '  v0.3.3 · Public Beta                               ') + c('cyan', '║'));
   console.log(c('cyan', '  ╠══════════════════════════════════════════════════════╣'));
   console.log(c('cyan', '  ║') + `  Files scanned:     ${c('bold', String(files.length).padEnd(6))}` + (isFileCapped ? c('yellow', ` of ${totalFileCount}`) : '              ') + c('cyan', '       ║'));
   console.log(c('cyan', '  ║') + `  Health score:      ${c(scoreColor, (grade + ' (' + Math.round(score) + '/100)').padEnd(20))}` + c('cyan', '           ║'));
@@ -436,6 +551,15 @@ async function cmdScan(opts) {
   console.log(c('cyan', '  ╚══════════════════════════════════════════════════════╝'));
   console.log('');
 
+  // ─── Python/non-JS scoring disclosure ───────────────────
+  const hasNonJsFiles = files.some(f => !f.endsWith('.js') && !f.endsWith('.ts') && !f.endsWith('.jsx') && !f.endsWith('.tsx') && !f.endsWith('.mjs'));
+  if (hasNonJsFiles) {
+    const nonJsExts = [...new Set(files.filter(f => !/\.(js|ts|jsx|tsx|mjs)$/.test(f)).map(f => path.extname(f)).filter(Boolean))];
+    console.log(c('gray', `  Note: Score includes Security + Hallucination + Code Quality categories.`));
+    console.log(c('gray', `  Architecture + Dependency analysis evaluated for JS/TS only. Detected non-JS: ${nonJsExts.join(', ')}`));
+    console.log('');
+  }
+
   // ─── CRITICAL: Hallucinated APIs (will crash) ────────────
   if (hallucinations.length > 0) {
     console.log(c('bgRed', ' CRITICAL ') + c('red', c('bold', ` ${hallucinations.length} Hallucinated API${hallucinations.length > 1 ? 's' : ''}`)));
@@ -633,9 +757,12 @@ async function cmdScan(opts) {
   }
 
   if (isFileCapped) {
-    console.log(c('yellow', `  ⚠ ${totalFileCount - tier.maxFiles} files were not scanned (free tier limit: ${tier.maxFiles} files)`));
-    console.log(c('gray', `  Your actual score may be worse. Upgrade to scan everything.`));
-    console.log('');
+    printFileCapUpgradePrompt({
+      scannedCount: files.length,
+      totalCount: totalFileCount,
+      remainingSummary,
+      upgradeUrl,
+    });
   }
 
   // ─── Continuous monitoring pitch ────────────────────────
@@ -720,6 +847,109 @@ async function cmdDeps(opts) {
   }
 }
 
+async function cmdMonitor(opts) {
+  requireProFeature('Scheduled monitoring');
+  const targetPath = path.resolve(opts.targetPath);
+  const service = new MonitorService();
+  const repoConfig = service.configureRepo({
+    repoPath: targetPath,
+    frequency: opts.frequency,
+    intervalMs: resolveIntervalMs(opts.frequency, opts.intervalMs),
+    notification: { channels: String(opts.notify || 'inbox').split(',').map(item => item.trim()).filter(Boolean) },
+  });
+
+  if (opts.once) {
+    const result = await service.runRepoScan(repoConfig);
+    if (opts.json) {
+      console.log(JSON.stringify(result.run, null, 2));
+      return;
+    }
+    console.log('');
+    console.log(c('bold', '  THUBAN MONITOR RUN'));
+    console.log(`  Repo: ${repoConfig.repoPath}`);
+    console.log(`  New issues: ${result.diff.added.length}`);
+    console.log(`  Resolved issues: ${result.diff.resolved.length}`);
+    console.log(`  History saved: ${result.runPath}`);
+    console.log('');
+    return;
+  }
+
+  console.log('');
+  console.log(c('bold', '  THUBAN MONITOR ACTIVE'));
+  console.log(`  Repo: ${repoConfig.repoPath}`);
+  console.log(`  Frequency: ${repoConfig.frequency} (${repoConfig.intervalMs}ms)`);
+  console.log(`  Notifications: ${(repoConfig.notification.channels || []).join(', ')}`);
+  console.log(c('gray', '  Press Ctrl+C to stop.'));
+  console.log('');
+
+  service.start(repoConfig);
+  process.on('SIGINT', () => {
+    service.stopAll();
+    process.exit(0);
+  });
+}
+
+async function cmdHistory(opts) {
+  requireProFeature('Scan history');
+  const store = new MonitorStore();
+  const repo = resolveRepoConfigOrExit(store, opts.targetPath);
+  const runs = store.listRuns(repo.repoId);
+
+  if (opts.json) {
+    console.log(JSON.stringify({ repo, runs }, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(c('bold', '  THUBAN HISTORY'));
+  console.log(`  Repo: ${repo.repoPath}`);
+  console.log(`  Runs: ${runs.length}`);
+  console.log('');
+
+  for (const run of runs.slice(-10).reverse()) {
+    console.log(`  ${c('cyan', run.timestamp)}  issues=${run.metrics.issueCount}  new=${run.diff?.added?.length || 0}  resolved=${run.diff?.resolved?.length || 0}`);
+  }
+
+  const notifications = store.getNotifications(10).filter(item => item.repoId === repo.repoId);
+  if (notifications.length) {
+    console.log('');
+    console.log(c('bold', '  RECENT ALERTS'));
+    for (const notification of notifications) {
+      console.log(`  ${c('yellow', notification.timestamp)}  ${notification.summary}`);
+    }
+  }
+  console.log('');
+}
+
+async function cmdTrend(opts) {
+  requireProFeature('Trend reporting');
+  const store = new MonitorStore();
+  const repo = resolveRepoConfigOrExit(store, opts.targetPath);
+  const runs = store.listRuns(repo.repoId);
+  const trend = runs.map(run => ({
+    timestamp: run.timestamp,
+    issueCount: run.metrics.issueCount,
+    hallucinations: run.metrics.hallucinations,
+    secrets: run.metrics.secrets,
+    techDebtScore: run.metrics.techDebtScore,
+    techDebtHours: run.metrics.techDebtHours,
+  }));
+
+  if (opts.json) {
+    console.log(JSON.stringify({ repo, trend }, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(c('bold', '  THUBAN TREND'));
+  console.log(`  Repo: ${repo.repoPath}`);
+  console.log('');
+  for (const point of trend.slice(-12)) {
+    console.log(`  ${c('cyan', point.timestamp)}  issues=${point.issueCount}  hallucinations=${point.hallucinations}  secrets=${point.secrets}  debtScore=${point.techDebtScore ?? 'n/a'}  debtHours=${point.techDebtHours ?? 'n/a'}`);
+  }
+  console.log('');
+}
+
 async function cmdDrift(opts) {
   const startTime = Date.now();
   const targetPath = path.resolve(opts.targetPath);
@@ -790,7 +1020,11 @@ async function cmdInject(opts) {
     console.log('');
   }
 
-  const files = collectFiles(targetPath, opts.ignore).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+  const files = collectFiles(targetPath, opts.ignore).filter(f =>
+    f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.jsx') || f.endsWith('.tsx') ||
+    f.endsWith('.py') || f.endsWith('.java') || f.endsWith('.cs') || f.endsWith('.go') ||
+    f.endsWith('.kt') || f.endsWith('.rs') || f.endsWith('.php') || f.endsWith('.rb')
+  );
   const graph = new DependencyGraph({ rootPath: targetPath });
   await graph.build(files);
 
@@ -809,8 +1043,26 @@ async function cmdInject(opts) {
         continue;
       }
 
-      const widget = generator.generateWidget(file, content);
-      if (!widget) { skipped++; continue; }
+      const rawWidget = await generator.generateWidget(file, content);
+      if (!rawWidget) { skipped++; continue; }
+      // generateWidget returns an object with { widgetString, ... }
+      const rawWidgetStr = (rawWidget && rawWidget.widgetString) ? rawWidget.widgetString : String(rawWidget);
+
+      // Select correct comment style by file extension
+      const ext = path.extname(file).toLowerCase();
+      let widget;
+      if (ext === '.py' || ext === '.rb') {
+        // Python and Ruby use # line comments
+        widget = rawWidgetStr.replace(/^\/\*\*\n/, '').replace(/\s*\*\/\s*$/, '')
+          .split('\n').map(l => l.replace(/^\s*\*\s?/, '# ')).join('\n');
+      } else if (ext === '.go' || ext === '.rs') {
+        // Go and Rust use // line comments
+        widget = rawWidgetStr.replace(/^\/\*\*\n/, '').replace(/\s*\*\/\s*$/, '')
+          .split('\n').map(l => l.replace(/^\s*\*\s?/, '// ')).join('\n');
+      } else {
+        // Java, Kotlin, C#, PHP all support /** */ block comments natively
+        widget = rawWidgetStr;
+      }
 
       if (opts.fix) {
         // Actually inject
@@ -846,7 +1098,7 @@ async function cmdInject(opts) {
   } else {
     console.log(c('green', `  ✓ Injected Mother Code into ${injected} files`));
   }
-  console.log(`  ${c('gray', `Skipped: ${skipped} (already annotated or non-JS/TS)`)}`);
+  console.log(`  ${c('gray', `Skipped: ${skipped} (already annotated or unsupported)`)}`);
   console.log('');
 }
 
@@ -891,12 +1143,10 @@ async function cmdReport(opts) {
   let totalIssues = 0;
   let criticalCount = 0;
   let highCount = 0;
-  for (const [, r] of Object.entries(scanResults)) {
-    if (r.issues) {
-      totalIssues += r.issues.length;
-      criticalCount += r.issues.filter(i => i.severity === 'critical').length;
-      highCount += r.issues.filter(i => i.severity === 'high').length;
-    }
+  for (const i of (scanResults.issues || [])) {
+    totalIssues++;
+    if (i.severity === 'critical') criticalCount++;
+    if (i.severity === 'high') highCount++;
   }
 
   const orphans = graph.getOrphanFiles();
@@ -966,6 +1216,8 @@ async function cmdReport(opts) {
     if (orphans.length > 5) console.log(`  ${c('gray', '→')} Consider removing ${orphans.length} orphan files`);
     console.log('');
   }
+
+  // Clean up cloned repo (clonedRepo only exists in cmdScan scope)
 }
 
 // ─── Tech Debt & Fix Commands ────────────────────────────
@@ -1113,13 +1365,24 @@ async function cmdFix(opts) {
     console.log(c('cyan', '  ╔══════════════════════════════════════════════════════╗'));
     console.log(c('cyan', '  ║') + c('bold', '  FIX RESULTS                                        ') + c('cyan', '║'));
     console.log(c('cyan', '  ╠══════════════════════════════════════════════════════╣'));
-    console.log(c('cyan', '  ║') + `  Fixed:             ${c('green', String(result.fixed).padEnd(20))}` + c('cyan', '           ║'));
+    // Split annotations (inject_widget/regenerate_widget) from real code fixes
+    const annotationsAdded = (result.fixes || []).filter(f => f.status === 'fixed' && (f.fixAction === 'inject_widget' || f.fixAction === 'regenerate_widget')).length;
+    const issuesFixed = result.fixed - annotationsAdded;
+    if (annotationsAdded > 0) {
+      console.log(c('cyan', '  ║') + `  Annotations added:  ${c('green', String(annotationsAdded).padEnd(19))}` + c('cyan', '           ║'));
+    }
+    if (issuesFixed > 0) {
+      console.log(c('cyan', '  ║') + `  Issues fixed:      ${c('green', String(issuesFixed).padEnd(20))}` + c('cyan', '           ║'));
+    }
+    if (annotationsAdded === 0 && issuesFixed === 0) {
+      console.log(c('cyan', '  ║') + `  Fixed:             ${c('green', String(result.fixed).padEnd(20))}` + c('cyan', '           ║'));
+    }
     console.log(c('cyan', '  ║') + `  Flagged for review: ${c('yellow', String(result.flagged).padEnd(19))}` + c('cyan', '           ║'));
     if (result.failed > 0) {
       console.log(c('cyan', '  ║') + `  Failed:            ${c('red', String(result.failed).padEnd(20))}` + c('cyan', '           ║'));
     }
-    if (result.skippedUnsafe > 0) {
-      console.log(c('cyan', '  ║') + `  Skipped (unsafe):  ${c('gray', String(result.skippedUnsafe).padEnd(20))}` + c('cyan', '           ║'));
+    if (result.skipped > 0) {
+      console.log(c('cyan', '  ║') + `  Skipped:           ${c('gray', String(result.skipped).padEnd(20))}` + c('cyan', '           ║'));
     }
     console.log(c('cyan', '  ╚══════════════════════════════════════════════════════╝'));
     console.log('');
@@ -1136,9 +1399,9 @@ async function cmdFix(opts) {
       console.log('');
     }
 
-    if (result.skippedUnsafe > 0) {
-      console.log(c('gray', `  ${result.skippedUnsafe} unsafe fixes were skipped. These change runtime behaviour.`));
-      console.log(c('gray', '  Review them with: ') + c('cyan', 'npx thuban fix . --fix --unsafe'));
+    if (result.skipped > 0) {
+      console.log(c('gray', `  ${result.skipped} items were skipped (no auto-fix available or pattern not matched).`));
+      console.log(c('gray', '  Review them manually or run: ') + c('cyan', 'npx thuban dashboard .'));
       console.log('');
     }
 
@@ -1363,12 +1626,11 @@ async function cmdDiff(opts) {
   let totalIssues = 0;
   const fileIssues = {};
 
-  for (const [file, result] of Object.entries(scanResults)) {
-    if (result.issues && result.issues.length > 0) {
-      const relFile = path.relative(targetPath, file);
-      fileIssues[relFile] = result.issues;
-      totalIssues += result.issues.length;
-    }
+  for (const issue of (scanResults.issues || [])) {
+    const relFile = path.relative(targetPath, issue.file);
+    if (!fileIssues[relFile]) fileIssues[relFile] = [];
+    fileIssues[relFile].push(issue);
+    totalIssues++;
   }
 
   totalIssues += hallResults.stats.totalIssues;
@@ -1471,7 +1733,7 @@ function cmdUpgrade() {
   console.log(c('bold', '  THUBAN PRICING'));
   console.log('');
   console.log(`  ${c('gray', 'FREE')}          ${c('bold', '£0/mo')}`);
-  console.log(`    3 scans/month, 100 files, summary only`);
+  console.log(`    5 scans/month, 100 files, summary only`);
   console.log('');
   console.log(`  ${c('cyan', 'PRO')}           ${c('bold', '£19/mo')}  ${c('gray', '(or £149/year — save 35%)')}`);
   console.log(`    Unlimited scans, full details, auto-fix, HTML dashboard`);
@@ -1585,12 +1847,8 @@ async function cmdCost(opts) {
 
   // Collect all issues
   const allIssues = [];
-  for (const [file, fileResults] of Object.entries(scanResults)) {
-    if (fileResults.issues) {
-      for (const issue of fileResults.issues) {
-        allIssues.push({ file: path.relative(targetPath, file), ...issue });
-      }
-    }
+  for (const issue of (scanResults.issues || [])) {
+    allIssues.push({ file: path.relative(targetPath, issue.file), ...issue });
   }
   for (const item of hallResults.phantomAPIs) {
     allIssues.push({ category: 'hallucination', severity: 'critical', message: item.name });
@@ -1831,12 +2089,8 @@ async function cmdExecutive(opts) {
 
   // Collect all issues for cost calculator
   const allIssues = [];
-  for (const [file, fileResults] of Object.entries(scanResults)) {
-    if (fileResults.issues) {
-      for (const issue of fileResults.issues) {
-        allIssues.push({ file: path.relative(targetPath, file), ...issue });
-      }
-    }
+  for (const issue of (scanResults.issues || [])) {
+    allIssues.push({ file: path.relative(targetPath, issue.file), ...issue });
   }
   for (const item of hallResults.phantomAPIs) {
     allIssues.push({ category: 'hallucination', severity: 'critical', message: item.name });
@@ -1910,12 +2164,8 @@ async function cmdBaseline(opts) {
     ]);
 
     const allIssues = [];
-    for (const [file, fileResults] of Object.entries(scanResults)) {
-      if (fileResults.issues) {
-        for (const issue of fileResults.issues) {
-          allIssues.push({ file: path.relative(targetPath, file), ...issue });
-        }
-      }
+    for (const issue of (scanResults.issues || [])) {
+      allIssues.push({ file: path.relative(targetPath, issue.file), ...issue });
     }
     for (const item of hallResults.phantomAPIs) {
       allIssues.push({ file: item.file, category: 'hallucination', severity: 'critical', id: item.id, message: item.name });
@@ -1948,6 +2198,292 @@ async function cmdBaseline(opts) {
   }
 }
 
+// ─── Telemetry (opt-in anonymous usage stats) ───────────────
+
+function getTelemetryConfigPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, '.thuban-telemetry.json');
+}
+
+function isTelemetryEnabled() {
+  try {
+    const config = JSON.parse(fs.readFileSync(getTelemetryConfigPath(), 'utf-8'));
+    return config.enabled === true;
+  } catch { return false; }
+}
+
+function sendAnonymousTelemetry(data) {
+  if (!isTelemetryEnabled()) return;
+  try {
+    const payload = JSON.stringify({
+      v: data.version || '0.3.1',
+      cmd: data.command,
+      files: data.fileCount,
+      score: data.score,
+      grade: data.grade,
+      langs: data.languages,
+      issues: data.issueCount,
+      duration: data.duration,
+      os: process.platform,
+      node: process.version,
+      ts: new Date().toISOString()
+    });
+    // Fire and forget — never blocks the CLI
+    const https = require('https');
+    const req = https.request({
+      hostname: 'thuban-telemetry.silverwingsbenefits.workers.dev',
+      path: '/report',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+      timeout: 3000
+    });
+    req.on('error', () => {}); // silently ignore
+    req.write(payload);
+    req.end();
+  } catch { /* never fail the CLI for telemetry */ }
+}
+
+async function cmdTelemetry(opts) {
+  const configPath = getTelemetryConfigPath();
+  const args = process.argv.slice(2);
+
+  if (args.includes('--on')) {
+    fs.writeFileSync(configPath, JSON.stringify({ enabled: true, updated: new Date().toISOString() }));
+    console.log('');
+    console.log(c('cyan', '  Telemetry enabled'));
+    console.log(c('gray', '  Anonymous usage stats will be sent (no code, no paths, no PII)'));
+    console.log(c('gray', '  Turn off anytime: npx thuban telemetry --off'));
+    console.log('');
+  } else if (args.includes('--off')) {
+    fs.writeFileSync(configPath, JSON.stringify({ enabled: false, updated: new Date().toISOString() }));
+    console.log('');
+    console.log(c('cyan', '  Telemetry disabled'));
+    console.log(c('gray', '  No data will be collected'));
+    console.log('');
+  } else {
+    const enabled = isTelemetryEnabled();
+    console.log('');
+    console.log(c('bold', '  TELEMETRY STATUS'));
+    console.log('');
+    console.log(`  Status:   ${enabled ? c('cyan', 'Enabled') : c('gray', 'Disabled (default)')}`);
+    console.log('');
+    console.log(c('gray', '  Thuban telemetry is 100% opt-in and anonymous.'));
+    console.log(c('gray', '  We collect: file count, score, grade, languages, OS, scan duration.'));
+    console.log(c('gray', '  We never collect: code, file names, paths, project names, or PII.'));
+    console.log('');
+    console.log(`  Enable:   ${c('cyan', 'npx thuban telemetry --on')}`);
+    console.log(`  Disable:  ${c('cyan', 'npx thuban telemetry --off')}`);
+    console.log('');
+  }
+}
+
+// ─── Internal scan (returns data without printing) ──────────
+
+async function runScanSilent(targetInput) {
+  const gitUrlPattern = /^(https?:\/\/|git@)/;
+  const isGitUrl = gitUrlPattern.test(targetInput);
+  let targetPath = isGitUrl ? targetInput : path.resolve(targetInput);
+  let clonedRepo = null;
+  let label = targetInput;
+
+  if (isGitUrl) {
+    const tmpDir = path.join(os.tmpdir(), 'thuban-compare-' + Date.now() + '-' + Math.random().toString(36).slice(2,6));
+    const { execFileSync } = require('child_process');
+    execFileSync('git', ['clone', '--depth', '1', targetInput, tmpDir], { stdio: 'pipe', timeout: 60000 });
+    targetPath = tmpDir;
+    clonedRepo = tmpDir;
+    // Extract repo name for label
+    const parts = targetInput.replace(/\.git$/, '').split('/');
+    label = parts[parts.length - 1] || targetInput;
+  } else {
+    label = path.basename(path.resolve(targetInput)) || targetInput;
+  }
+
+  const startTime = Date.now();
+  const scanner = new CodeScanner();
+  const graph = new DependencyGraph();
+  const hallDetector = new HallucinationDetector({ rootPath: targetPath });
+
+  const files = collectFiles(targetPath, []);
+  const scanResults = {};
+  let annotated = 0;
+  let driftCount = 0;
+
+  for (const file of files) {
+    try {
+      const result = scanner.scanFile(file);
+      const relPath = path.relative(targetPath, file);
+      scanResults[file] = result;
+      graph.addFile(file, targetPath);
+      if (result.motherCode && result.motherCode.hasDNA) annotated++;
+      if (result.drifts && result.drifts.length > 0) driftCount++;
+    } catch (e) { /* skip */ }
+  }
+
+  // Run hallucination detection (same as main scan)
+  const hallResults = hallDetector.scan(files, targetPath);
+
+  const elapsed = Date.now() - startTime;
+  let totalIssues = 0, criticalCount = 0, highCount = 0;
+  const issueByCat = {};
+
+  // Count code scanner issues
+  for (const [, r] of Object.entries(scanResults)) {
+    if (r.issues) {
+      totalIssues += r.issues.length;
+      for (const iss of r.issues) {
+        if (iss.severity === 'critical') criticalCount++;
+        if (iss.severity === 'high') highCount++;
+        const cat = iss.category || iss.type || 'other';
+        issueByCat[cat] = (issueByCat[cat] || 0) + 1;
+      }
+    }
+  }
+
+  // Count hallucination issues
+  const hallIssueCount = (hallResults.phantomAPIs || []).length
+    + (hallResults.phantomImports || []).length
+    + (hallResults.deprecatedAPIs || []).length;
+  totalIssues += hallIssueCount;
+  criticalCount += (hallResults.phantomAPIs || []).length + (hallResults.phantomImports || []).length;
+  highCount += (hallResults.deprecatedAPIs || []).length;
+  if (hallIssueCount > 0) issueByCat['hallucination'] = hallIssueCount;
+
+  const orphans = graph.getOrphanFiles();
+  const circular = graph.circularDeps || [];
+  const coverage = files.length > 0 ? Math.round((annotated / files.length) * 100) : 0;
+
+  const score = Math.max(0, Math.round(
+    100 - (criticalCount * 15) - (highCount * 5) - (circular.length * 10)
+    - (orphans.length * 1) - ((100 - coverage) * 0.1) - (driftCount * 3)
+  ));
+
+  const grade = score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : score >= 60 ? 'D' : 'F';
+
+  if (clonedRepo) {
+    try { fs.rmSync(clonedRepo, { recursive: true, force: true }); } catch {}
+  }
+
+  return {
+    label,
+    files: files.length,
+    score,
+    grade,
+    elapsed,
+    issues: { total: totalIssues, critical: criticalCount, high: highCount },
+    categories: issueByCat,
+    dependencies: { circular: circular.length, orphans: orphans.length },
+    motherCode: { annotated, coverage, drifted: driftCount }
+  };
+}
+
+// ─── Compare Command ────────────────────────────────────────
+
+async function cmdCompare(opts) {
+  const args = process.argv.slice(2);
+  // Find the two paths after 'compare'
+  const paths = args.filter(a => a !== 'compare' && !a.startsWith('--'));
+
+  if (paths.length < 2) {
+    console.log('');
+    console.log(c('red', '  Compare requires two paths or URLs'));
+    console.log('');
+    console.log(c('gray', '  Usage:'));
+    console.log(`    ${c('cyan', 'npx thuban compare ./project-a ./project-b')}`);
+    console.log(`    ${c('cyan', 'npx thuban compare . https://github.com/user/repo')}`);
+    console.log(`    ${c('cyan', 'npx thuban compare https://github.com/a/repo https://github.com/b/repo')}`);
+    console.log('');
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(c('bold', '  ╔══════════════════════════════════════╗'));
+  console.log(c('bold', '  ║     THUBAN — Codebase Comparison     ║'));
+  console.log(c('bold', '  ╚══════════════════════════════════════╝'));
+  console.log('');
+
+  console.log(c('cyan', `  Scanning: ${paths[0]}`));
+  const resultA = await runScanSilent(paths[0]);
+  console.log(c('cyan', `  Scanning: ${paths[1]}`));
+  const resultB = await runScanSilent(paths[1]);
+
+  console.log('');
+
+  // ─── Side by side comparison ────────────────────────────
+  const pad = (str, len) => String(str).padEnd(len);
+  const padL = (str, len) => String(str).padStart(len);
+  const colW = 20;
+  const labelA = resultA.label.length > colW ? resultA.label.slice(0, colW - 2) + '..' : resultA.label;
+  const labelB = resultB.label.length > colW ? resultB.label.slice(0, colW - 2) + '..' : resultB.label;
+
+  const scoreColorA = resultA.score >= 80 ? 'green' : resultA.score >= 60 ? 'yellow' : 'red';
+  const scoreColorB = resultB.score >= 80 ? 'green' : resultB.score >= 60 ? 'yellow' : 'red';
+
+  const arrow = (a, b) => {
+    if (a === b) return c('gray', '  =');
+    return a > b ? c('green', '  ↑') : c('red', '  ↓');
+  };
+
+  const better = (a, b, lowerIsBetter) => {
+    if (a === b) return c('gray', ' draw');
+    if (lowerIsBetter) return a < b ? c('green', ' ← winner') : c('red', '');
+    return a > b ? c('green', ' ← winner') : c('red', '');
+  };
+
+  console.log(c('bold', '  ┌──────────────────────┬──────────────────────┬──────────────────────┐'));
+  console.log(c('bold', `  │ ${pad('METRIC', colW)} │ ${pad(labelA, colW)} │ ${pad(labelB, colW)} │`));
+  console.log(c('bold', '  ├──────────────────────┼──────────────────────┼──────────────────────┤'));
+
+  const row = (label, valA, valB) => {
+    console.log(`  │ ${c('gray', pad(label, colW))} │ ${pad(valA, colW)} │ ${pad(valB, colW)} │`);
+  };
+
+  row('Health Score', `${c(scoreColorA, resultA.score + '/100')}`, `${c(scoreColorB, resultB.score + '/100')}`);
+  row('Grade', `${c(scoreColorA, resultA.grade)}`, `${c(scoreColorB, resultB.grade)}`);
+  row('Files Scanned', String(resultA.files), String(resultB.files));
+  row('Total Issues', String(resultA.issues.total), String(resultB.issues.total));
+  row('Critical Issues', String(resultA.issues.critical), String(resultB.issues.critical));
+  row('High Issues', String(resultA.issues.high), String(resultB.issues.high));
+  row('Circular Deps', String(resultA.dependencies.circular), String(resultB.dependencies.circular));
+  row('Orphan Files', String(resultA.dependencies.orphans), String(resultB.dependencies.orphans));
+  row('Mother Code DNA', `${resultA.motherCode.coverage}%`, `${resultB.motherCode.coverage}%`);
+  row('Drift Issues', String(resultA.motherCode.drifted), String(resultB.motherCode.drifted));
+  row('Scan Time', `${resultA.elapsed}ms`, `${resultB.elapsed}ms`);
+
+  console.log(c('bold', '  └──────────────────────┴──────────────────────┴──────────────────────┘'));
+  console.log('');
+
+  // ─── Verdict ────────────────────────────────────────────
+  const diff = resultA.score - resultB.score;
+  if (diff === 0) {
+    console.log(c('cyan', `  VERDICT: Both codebases score identically (${resultA.score}/100)`));
+  } else {
+    const winner = diff > 0 ? resultA : resultB;
+    const loser = diff > 0 ? resultB : resultA;
+    console.log(c('cyan', `  VERDICT: ${winner.label} is healthier`));
+    console.log(c('gray', `  ${winner.label} scores ${winner.score}/100 (${winner.grade}) vs ${loser.label} at ${loser.score}/100 (${loser.grade})`));
+    console.log(c('gray', `  ${Math.abs(diff)} point difference — ${Math.abs(diff) > 20 ? 'significant gap' : Math.abs(diff) > 10 ? 'moderate gap' : 'close race'}`));
+  }
+
+  // ─── Issue breakdown comparison ─────────────────────────
+  const allCats = new Set([...Object.keys(resultA.categories), ...Object.keys(resultB.categories)]);
+  if (allCats.size > 0) {
+    console.log('');
+    console.log(c('bold', '  ISSUE BREAKDOWN'));
+    for (const cat of allCats) {
+      const countA = resultA.categories[cat] || 0;
+      const countB = resultB.categories[cat] || 0;
+      const catLabel = cat.charAt(0).toUpperCase() + cat.slice(1);
+      console.log(c('gray', `    ${pad(catLabel, 22)} ${padL(countA, 5)} vs ${padL(countB, 5)}  ${countA < countB ? c('green', `← ${labelA}`) : countA > countB ? c('green', `→ ${labelB}`) : c('gray', 'tied')}`));
+    }
+  }
+
+  console.log('');
+  console.log(c('gray', `  Full scan: npx thuban scan ${paths[0]}`));
+  console.log(c('gray', `  Full scan: npx thuban scan ${paths[1]}`));
+  console.log('');
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const opts = parseArgs(args);
@@ -1964,9 +2500,9 @@ async function main() {
   }
 
   // Verify target path exists
-  const noPathCommands2 = ['activate', 'status', 'upgrade'];
+  const noPathCommands2 = ['activate', 'status', 'upgrade', 'telemetry', 'compare'];
 
-  if (!noPathCommands2.includes(opts.command) && !fs.existsSync(opts.targetPath)) {
+  if (!noPathCommands2.includes(opts.command) && !opts.targetPath.match(/^(https?:\/\/|git@)/) && !fs.existsSync(opts.targetPath)) {
     console.error(c('red', `  Error: Path not found: ${opts.targetPath}`));
     process.exit(1);
   }
@@ -2005,6 +2541,15 @@ async function main() {
       case 'watch':
         await cmdWatch(opts);
         break;
+      case 'monitor':
+        await cmdMonitor(opts);
+        break;
+      case 'history':
+        await cmdHistory(opts);
+        break;
+      case 'trend':
+        await cmdTrend(opts);
+        break;
       case 'dashboard':
       case 'dash':
         await cmdDashboard(opts);
@@ -2049,12 +2594,18 @@ async function main() {
       case 'baseline':
         await cmdBaseline(opts);
         break;
+      case 'telemetry':
+        await cmdTelemetry(opts);
+        break;
+      case 'compare':
+        await cmdCompare(opts);
+        break;
       default:
         console.error('');
         console.error(c('red', `  Unknown command: ${opts.command}`));
         console.error('');
         // Suggest closest match
-        const allCmds = ['scan','deps','drift','inject','health','report','debt','fix','hallucinate','watch','dashboard','diff','gate','cost','ghosts','ai-score','clones','passport','executive','baseline','activate','status','upgrade'];
+        const allCmds = ['scan','compare','deps','drift','inject','health','report','debt','fix','hallucinate','watch','dashboard','diff','gate','cost','ghosts','ai-score','clones','passport','executive','baseline','activate','status','upgrade','telemetry'];
         const suggestions = allCmds.filter(cmd => cmd.startsWith(opts.command.slice(0,2)) || cmd.includes(opts.command));
         if (suggestions.length > 0) {
           console.error(c('gray', `  Did you mean: `) + c('cyan', suggestions.join(', ')) + c('gray', '?'));