@triedotdev/mcp 1.0.59 → 1.0.60

package/dist/{chunk-3B2JBLSP.js → chunk-NM7ZVUHO.js}

@@ -1,16 +1,16 @@
 import {
   Executor,
-  Triager
-} from "./chunk-KLKY34RE.js";
+  Triager,
+  getChangedFilesSinceTimestamp,
+  isGitRepo
+} from "./chunk-4EHBRED6.js";
 import {
   getSkillRegistry,
   updateContextAfterScan
-} from "./chunk-HUQQSQOD.js";
+} from "./chunk-3XWSM2DU.js";
 import {
-  ProgressReporter,
-  isInteractiveMode,
-  setInteractiveMode
-} from "./chunk-6ODT4U4O.js";
+  getOutputManager
+} from "./chunk-C7LXN754.js";
 import {
   getWorkingDirectory
 } from "./chunk-ASGSTVVF.js";
@@ -18,10 +18,15 @@ import {
   getVulnerabilityStats,
   getVulnerabilityTrie,
   scanForVulnerabilities
-} from "./chunk-MR755QGT.js";
+} from "./chunk-ULOW5HSH.js";
 import {
   Trie
 } from "./chunk-6NLHFIYA.js";
+import {
+  ProgressReporter,
+  isInteractiveMode,
+  setInteractiveMode
+} from "./chunk-RAZUNSBI.js";
 import {
   __require
 } from "./chunk-DGUM43GV.js";
@@ -76,7 +81,9 @@ var ContextAnalyzer = class {
     for (const file of files) {
       try {
         if (!existsSync(file)) {
-          console.error(`File not found: ${file}`);
+          if (!isInteractiveMode()) {
+            console.error(`File not found: ${file}`);
+          }
           continue;
         }
         if (this.isSignatureFile(file)) {
@@ -119,7 +126,9 @@ var ContextAnalyzer = class {
         const fileComplexity = await this.analyzeCodeContent(content, file, context);
         totalComplexity += fileComplexity;
       } catch (error) {
-        console.error(`Error analyzing file ${file}:`, error);
+        if (!isInteractiveMode()) {
+          console.error(`Error analyzing file ${file}:`, error);
+        }
       }
     }
     context.linesChanged = totalLines;
@@ -2327,17 +2336,21 @@ function getSymbolIndex() {
 
 // src/trie/incremental-scanner.ts
 import { createHash } from "crypto";
-import { readFile as readFile5, writeFile, mkdir } from "fs/promises";
+import { readFile as readFile5, writeFile, mkdir, stat } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
-var CACHE_VERSION = "1.0.0";
+var SCAN_CONCURRENCY = 10;
+var CACHE_VERSION = "1.1.0";
 var CACHE_FILE = ".trie-cache.json";
 var IncrementalScanner = class {
   cache;
   symbolIndex;
   cacheDir;
+  projectRoot;
   dirty = false;
+  isGitRepoCache = null;
   constructor(projectRoot) {
+    this.projectRoot = projectRoot;
     this.cacheDir = join2(projectRoot, ".trie");
     this.symbolIndex = getSymbolIndex();
     this.cache = {
@@ -2359,14 +2372,20 @@ var IncrementalScanner = class {
       const data = await readFile5(cachePath, "utf-8");
       const parsed = JSON.parse(data);
       if (parsed.version !== CACHE_VERSION) {
-        console.error("   \u26A0\uFE0F Cache version mismatch, rebuilding...");
+        if (!isInteractiveMode()) {
+          console.error("   \u26A0\uFE0F Cache version mismatch, rebuilding...");
+        }
         return false;
       }
       this.cache = parsed;
-      console.error(`   \u2705 Loaded cache with ${Object.keys(this.cache.files).length} files`);
+      if (!isInteractiveMode()) {
+        console.error(`   \u2705 Loaded cache with ${Object.keys(this.cache.files).length} files`);
+      }
       return true;
     } catch (error) {
-      console.error("   \u26A0\uFE0F Failed to load cache, rebuilding...");
+      if (!isInteractiveMode()) {
+        console.error("   \u26A0\uFE0F Failed to load cache, rebuilding...");
+      }
       return false;
     }
   }
@@ -2382,7 +2401,9 @@ var IncrementalScanner = class {
       await writeFile(cachePath, JSON.stringify(this.cache, null, 2));
       this.dirty = false;
     } catch (error) {
-      console.error("   \u26A0\uFE0F Failed to save cache");
+      if (!isInteractiveMode()) {
+        console.error("   \u26A0\uFE0F Failed to save cache");
+      }
     }
   }
   /**
@@ -2392,6 +2413,57 @@ var IncrementalScanner = class {
   computeHash(content) {
     return createHash("sha256").update(content).digest("hex").slice(0, 16);
   }
+  /**
+   * Fast pre-check using file stats (mtime + size)
+   * Returns true if file might have changed (needs hash check)
+   * Returns false if file definitely hasn't changed (skip hash)
+   * O(1) - just a stat call, no file read
+   */
+  async fastPreCheck(filePath) {
+    const cached = this.cache.files[filePath];
+    if (!cached || cached.mtime === void 0 || cached.size === void 0) {
+      try {
+        const stats = await stat(filePath);
+        return { changed: true, stats: { mtime: stats.mtimeMs, size: stats.size } };
+      } catch {
+        return { changed: true };
+      }
+    }
+    try {
+      const stats = await stat(filePath);
+      const currentMtime = stats.mtimeMs;
+      const currentSize = stats.size;
+      if (currentMtime === cached.mtime && currentSize === cached.size) {
+        return { changed: false, stats: { mtime: currentMtime, size: currentSize } };
+      }
+      return { changed: true, stats: { mtime: currentMtime, size: currentSize } };
+    } catch {
+      return { changed: true };
+    }
+  }
+  /**
+   * Check if this project is a git repo (cached)
+   */
+  async checkIsGitRepo() {
+    if (this.isGitRepoCache !== null) return this.isGitRepoCache;
+    this.isGitRepoCache = await isGitRepo(this.projectRoot);
+    return this.isGitRepoCache;
+  }
+  /**
+   * Get files changed since last scan using git (fast path)
+   * Returns null if not a git repo or git detection fails
+   */
+  async getGitChangedFiles() {
+    if (!await this.checkIsGitRepo()) return null;
+    const lastScanTime = this.cache.lastFullScanTime;
+    if (!lastScanTime) return null;
+    try {
+      const changedFiles = await getChangedFilesSinceTimestamp(this.projectRoot, lastScanTime);
+      return changedFiles ? new Set(changedFiles) : null;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Check if a file has changed since last scan
    * O(1) for cache lookup + O(n) for hash if needed
@@ -2412,17 +2484,39 @@ var IncrementalScanner = class {
   /**
    * Scan a single file incrementally
    * Returns cached results if file unchanged
+   * 
+   * Optimization layers:
+   * 1. Fast pre-check (mtime + size) - O(1), avoids file read
+   * 2. Hash comparison - O(n), only if pre-check fails
    */
   async scanFile(filePath, forceRescan = false) {
+    const cached = this.cache.files[filePath];
+    if (!forceRescan && cached) {
+      const preCheck = await this.fastPreCheck(filePath);
+      if (!preCheck.changed) {
+        return {
+          vulnerabilities: cached.vulnerabilities,
+          fromCache: true,
+          symbolCount: cached.symbolCount
+        };
+      }
+    }
     let content;
+    let fileStats;
     try {
+      const stats = await stat(filePath);
+      fileStats = { mtime: stats.mtimeMs, size: stats.size };
       content = await readFile5(filePath, "utf-8");
     } catch {
       return { vulnerabilities: [], fromCache: false, symbolCount: 0 };
     }
     const hash = this.computeHash(content);
-    const cached = this.cache.files[filePath];
     if (!forceRescan && cached && cached.hash === hash) {
+      if (fileStats) {
+        cached.mtime = fileStats.mtime;
+        cached.size = fileStats.size;
+        this.dirty = true;
+      }
       return {
         vulnerabilities: cached.vulnerabilities,
         fromCache: true,
@@ -2438,7 +2532,9 @@ var IncrementalScanner = class {
       lastScanned: Date.now(),
       lineCount: content.split("\n").length,
       vulnerabilities,
-      symbolCount: symbols.length
+      symbolCount: symbols.length,
+      mtime: fileStats?.mtime,
+      size: fileStats?.size
     };
     this.dirty = true;
     return {
@@ -2449,6 +2545,11 @@ var IncrementalScanner = class {
   }
   /**
    * Scan multiple files with incremental caching
+   * 
+   * Optimizations:
+   * 1. Git-based change detection (when available) - only scan changed files
+   * 2. Parallel file scanning with concurrency limit
+   * 3. Fast pre-check (mtime + size) per file
    */
   async scanFiles(filePaths, forceRescan = false, onFileProgress) {
     const startTime = Date.now();
@@ -2462,9 +2563,20 @@ var IncrementalScanner = class {
     for (const [path, state] of Object.entries(this.cache.files)) {
       previousVulnerabilities.set(path, state.vulnerabilities);
     }
-    for (const filePath of filePaths) {
-      const result = await this.scanFile(filePath, forceRescan);
-      onFileProgress?.(filePath, result.fromCache);
+    let gitChangedFiles = null;
+    if (!forceRescan) {
+      gitChangedFiles = await this.getGitChangedFiles();
+      if (gitChangedFiles && !isInteractiveMode()) {
+        console.error(`   \u26A1 Git detected ${gitChangedFiles.size} changed files`);
+      }
+    }
+    const scanResults = await this.parallelScan(
+      filePaths,
+      forceRescan,
+      gitChangedFiles,
+      onFileProgress
+    );
+    for (const { filePath, result } of scanResults) {
       allVulnerabilities.push(...result.vulnerabilities);
       if (result.fromCache) {
         filesSkipped++;
@@ -2493,6 +2605,8 @@ var IncrementalScanner = class {
         }
       }
     }
+    this.cache.lastFullScanTime = Date.now();
+    this.dirty = true;
     const scanTimeMs = Date.now() - startTime;
     const totalFiles = filesScanned + filesSkipped;
     const cacheHitRate = totalFiles > 0 ? filesSkipped / totalFiles * 100 : 0;
@@ -2507,6 +2621,38 @@ var IncrementalScanner = class {
       cacheHitRate
     };
   }
+  /**
+   * Parallel file scanning with concurrency limit
+   * Processes SCAN_CONCURRENCY files at a time
+   */
+  async parallelScan(filePaths, forceRescan, gitChangedFiles, onFileProgress) {
+    const results = [];
+    for (let i = 0; i < filePaths.length; i += SCAN_CONCURRENCY) {
+      const batch = filePaths.slice(i, i + SCAN_CONCURRENCY);
+      const batchPromises = batch.map(async (filePath) => {
+        if (gitChangedFiles && !gitChangedFiles.has(filePath)) {
+          const cached = this.cache.files[filePath];
+          if (cached) {
+            onFileProgress?.(filePath, true);
+            return {
+              filePath,
+              result: {
+                vulnerabilities: cached.vulnerabilities,
+                fromCache: true,
+                symbolCount: cached.symbolCount
+              }
+            };
+          }
+        }
+        const result = await this.scanFile(filePath, forceRescan);
+        onFileProgress?.(filePath, result.fromCache);
+        return { filePath, result };
+      });
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+    }
+    return results;
+  }
   /**
    * Remove a file from the cache
    */
@@ -2645,6 +2791,7 @@ ${"\u2501".repeat(60)}
 }
 
 // src/utils/streaming.ts
+var shouldSuppressConsole = () => isInteractiveMode();
 var StreamingManager = class {
   listeners = /* @__PURE__ */ new Set();
   progress = {
@@ -2675,7 +2822,9 @@ var StreamingManager = class {
       try {
         listener(update);
       } catch (error) {
-        console.warn("Stream listener error:", error);
+        if (!shouldSuppressConsole()) {
+          console.warn("Stream listener error:", error);
+        }
       }
     });
   }
@@ -2806,6 +2955,51 @@ var StreamingManager = class {
   reportMemory(action, details) {
     this.emit("memory", { action, details });
   }
+  // ============================================
+  // Rich Content Events (for TUI panes)
+  // ============================================
+  /**
+   * Report a code snippet for display
+   */
+  reportSnippet(snippet) {
+    this.emit("snippet", snippet);
+  }
+  /**
+   * Report cost estimate from Moneybags
+   */
+  reportCost(cost) {
+    this.emit("cost_report", cost);
+  }
+  /**
+   * Report production readiness score
+   */
+  reportReadiness(readiness) {
+    this.emit("readiness_report", readiness);
+  }
+  /**
+   * Report semantic analysis results
+   */
+  reportSemantic(semantic) {
+    this.emit("semantic_report", semantic);
+  }
+  /**
+   * Report attack surface analysis
+   */
+  reportAttackSurface(attack) {
+    this.emit("attack_surface", attack);
+  }
+  /**
+   * Report skill banner (ASCII art + quote)
+   */
+  reportBanner(banner) {
+    this.emit("skill_banner", banner);
+  }
+  /**
+   * Report raw log entry
+   */
+  reportRawLog(level, message) {
+    this.emit("raw_log", { level, message, time: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }) });
+  }
 };
 function formatConsoleUpdate(update) {
   if (isInteractiveMode()) {
@@ -3185,7 +3379,9 @@ var colors = {
   alert: (s) => pc.bold(pc.red(s)),
   // Interactive
   selected: (s) => pc.bold(pc.magenta(s)),
-  highlight: (s) => pc.bold(pc.white(s))
+  highlight: (s) => pc.bold(pc.white(s)),
+  // Additional
+  yellow: (s) => pc.yellow(s)
 };
 var stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 var visibleLength = (s) => {
@@ -3271,7 +3467,27 @@ var InteractiveDashboard = class {
         directories: 0,
         recentChanges: []
       },
-      agents: {}
+      agents: {},
+      // Rich content state
+      codeSnippets: /* @__PURE__ */ new Map(),
+      costReport: null,
+      readiness: null,
+      semanticAnalysis: null,
+      attackSurface: null,
+      skillBanners: [],
+      rawLog: [],
+      rawLogPage: 0,
+      scrollPositions: {
+        overview: 0,
+        issues: 0,
+        agents: 0,
+        files: 0,
+        details: 0,
+        costs: 0,
+        readiness: 0,
+        analysis: 0,
+        rawlog: 0
+      }
     };
   }
   /**
@@ -3283,8 +3499,64 @@ var InteractiveDashboard = class {
     this.addActivity("Guardian started");
     this.setupKeyboardHandlers();
     this.startUpdateLoop();
+    this.registerOutputManagerCallbacks();
     this.render();
   }
+  /**
+   * Register callbacks with OutputManager for rich content
+   */
+  registerOutputManagerCallbacks() {
+    const outputManager = getOutputManager();
+    outputManager.setMode("tui");
+    outputManager.registerTUICallbacks({
+      onBanner: (banner) => {
+        this.state.skillBanners.unshift(banner);
+        if (this.state.skillBanners.length > 5) {
+          this.state.skillBanners.pop();
+        }
+        this.addActivity(`[BANNER] ${banner.skill}${banner.quote ? ": " + banner.quote.slice(0, 40) + "..." : ""}`);
+        this.render();
+      },
+      onSnippet: (snippet) => {
+        this.state.codeSnippets.set(this.state.selectedIssue, snippet);
+        this.render();
+      },
+      onCost: (cost) => {
+        this.state.costReport = cost;
+        this.addActivity(`[COST] Fix: $${cost.fixNowCost} | Prod: $${cost.productionCost}`);
+        this.render();
+      },
+      onReadiness: (readiness) => {
+        this.state.readiness = readiness;
+        this.addActivity(`[READY] Score: ${readiness.score}/100 - ${readiness.status.toUpperCase()}`);
+        this.render();
+      },
+      onSemantic: (semantic) => {
+        this.state.semanticAnalysis = semantic;
+        this.addActivity(`[SEMANTIC] DataFlow: ${semantic.dataFlowIssues} | Race: ${semantic.raceConditions} | Auth: ${semantic.authIssues}`);
+        this.render();
+      },
+      onAttack: (attack) => {
+        this.state.attackSurface = attack;
+        this.addActivity(`[ATTACK] ${attack.totalEndpoints} endpoints (${attack.unprotected} unprotected)`);
+        this.render();
+      },
+      onActivity: (message) => {
+        this.addActivity(message);
+        this.render();
+      },
+      onLog: (level, message) => {
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        this.state.rawLog.unshift({ time, level, message });
+        if (this.state.rawLog.length > 500) {
+          this.state.rawLog.pop();
+        }
+        if (this.state.view === "rawlog") {
+          this.render();
+        }
+      }
+    });
+  }
   /**
    * Stop the dashboard
    */
@@ -3294,6 +3566,9 @@ var InteractiveDashboard = class {
       clearInterval(this.updateInterval);
     }
     this.rl.close();
+    const outputManager = getOutputManager();
+    outputManager.clearTUICallbacks();
+    outputManager.setMode("console");
     process.stdout.write("\x1B[2J\x1B[H\x1B[?25h");
   }
   /**
@@ -3404,6 +3679,53 @@ var InteractiveDashboard = class {
           this.addActivity(`[~] Learning: ${update.data.details || "analyzing patterns"}`);
         }
         break;
+      // === Rich Content Events ===
+      case "snippet":
+        this.state.codeSnippets.set(this.state.selectedIssue, update.data);
+        break;
+      case "cost_report":
+        this.state.costReport = update.data;
+        this.addActivity(`[COST] Fix now: $${update.data.fixNowCost} | Production: $${update.data.productionCost}`);
+        break;
+      case "readiness_report":
+        this.state.readiness = update.data;
+        this.addActivity(`[READINESS] ${update.data.score}/100 - ${update.data.status}`);
+        break;
+      case "semantic_report":
+        this.state.semanticAnalysis = update.data;
+        {
+          const sem = update.data;
+          const total = sem.dataFlowIssues + sem.raceConditions + sem.authIssues;
+          if (total > 0) {
+            this.addActivity(`[SEMANTIC] ${total} issues (${sem.dataFlowIssues} dataflow, ${sem.raceConditions} race, ${sem.authIssues} auth)`);
+          }
+        }
+        break;
+      case "attack_surface":
+        this.state.attackSurface = update.data;
+        {
+          const atk = update.data;
+          this.addActivity(`[ATTACK] ${atk.totalEndpoints} endpoints, ${atk.unprotected} unprotected, risk ${atk.riskScore}/100`);
+        }
+        break;
+      case "skill_banner":
+        const banner = update.data;
+        this.state.skillBanners.unshift(banner);
+        if (this.state.skillBanners.length > 5) {
+          this.state.skillBanners.pop();
+        }
+        this.addActivity(`[SKILL] ${banner.skill}${banner.quote ? ': "' + banner.quote.slice(0, 30) + '..."' : ""}`);
+        break;
+      case "raw_log":
+        this.state.rawLog.unshift({
+          time: update.data.time || new Date(update.timestamp).toLocaleTimeString("en-US", { hour12: false }),
+          level: update.data.level,
+          message: update.data.message
+        });
+        if (this.state.rawLog.length > 500) {
+          this.state.rawLog.pop();
+        }
+        break;
     }
     if (this.isActive) {
       this.render();
@@ -3477,6 +3799,30 @@ var InteractiveDashboard = class {
         case "?":
           this.showHelp();
           break;
+        // === NEW VIEW SHORTCUTS ===
+        case "d":
+          if (this.state.scanComplete && this.state.issues.length > 0) {
+            this.goToView("details");
+          }
+          break;
+        case "m":
+          if (this.state.costReport) {
+            this.goToView("costs");
+          }
+          break;
+        case "r":
+          if (this.state.readiness) {
+            this.goToView("readiness");
+          }
+          break;
+        case "a":
+          if (this.state.semanticAnalysis || this.state.attackSurface) {
+            this.goToView("analysis");
+          }
+          break;
+        case "l":
+          this.goToView("rawlog");
+          break;
       }
       this.render();
     });
@@ -3629,6 +3975,22 @@ var InteractiveDashboard = class {
         case "files":
           this.renderFilesView(width);
           break;
+        // === NEW VIEWS ===
+        case "details":
+          this.renderDetailsView(width, height);
+          break;
+        case "costs":
+          this.renderCostsView(width, height);
+          break;
+        case "readiness":
+          this.renderReadinessView(width, height);
+          break;
+        case "analysis":
+          this.renderAnalysisView(width, height);
+          break;
+        case "rawlog":
+          this.renderRawLogView(width, height);
+          break;
       }
     }
     this.renderFooter(width);
@@ -3966,6 +4328,240 @@ var InteractiveDashboard = class {
       this.renderLine("", width);
     }
   }
+  // ============================================
+  // NEW VIEWS
+  // ============================================
+  /**
+   * Render details view - selected issue with code snippet
+   */
+  renderDetailsView(width, _height) {
+    const sectionBorder = colors.border(box.leftT + this.line(width - 2) + box.rightT);
+    const filteredIssues = this.getFilteredIssues();
+    const issue = filteredIssues[this.state.selectedIssue];
+    if (!issue) {
+      this.renderLine("  " + colors.dim("No issue selected. Press [b] to go back."), width);
+      return;
+    }
+    const severityColor = issue.severity === "critical" ? colors.critical : issue.severity === "serious" ? colors.serious : issue.severity === "moderate" ? colors.moderate : colors.low;
+    this.renderLine("  " + colors.header("ISSUE DETAILS") + "  " + severityColor(`[${issue.severity.toUpperCase()}]`), width);
+    this.bufferLine(sectionBorder);
+    this.renderLine("  " + colors.dim("File:") + " " + issue.file, width);
+    this.renderLine("  " + colors.dim("Line:") + " " + (issue.line || "?") + "  " + colors.dim("Scout:") + " " + (issue.agent || "unknown"), width);
+    this.renderLine("", width);
+    this.renderLine("  " + colors.header("Issue"), width);
+    const issueLines = this.wrapText(issue.issue, width - 8);
+    for (const line of issueLines.slice(0, 4)) {
+      this.renderLine("    " + severityColor(line), width);
+    }
+    this.renderLine("", width);
+    this.bufferLine(sectionBorder);
+    this.renderLine("  " + colors.header("CODE SNIPPET"), width);
+    const snippet = this.state.codeSnippets.get(this.state.selectedIssue);
+    if (snippet) {
+      this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+      const maxLines = Math.min(snippet.lines.length, 10);
+      for (let i = 0; i < maxLines; i++) {
+        const lineNum = snippet.startLine + i;
+        const isHighlight = lineNum === snippet.highlightLine;
+        const prefix = isHighlight ? colors.critical("\u2192") : " ";
+        const lineNumStr = colors.dim(lineNum.toString().padStart(4));
+        const lineContent = isHighlight ? colors.yellow(snippet.lines[i] || "") : snippet.lines[i] || "";
+        this.renderLine("  " + prefix + " " + lineNumStr + " " + colors.dim("\u2502") + " " + lineContent, width);
+      }
+      if (snippet.lines.length > 10) {
+        this.renderLine("  " + colors.dim(`    ... ${snippet.lines.length - 10} more lines`), width);
+      }
+    } else {
+      this.renderLine("  " + colors.dim("No code snippet available. Snippet is loaded when issue is selected."), width);
+    }
+    this.renderLine("", width);
+    this.bufferLine(sectionBorder);
+    this.renderLine("  " + colors.success("SUGGESTED FIX"), width);
+    const fixLines = this.wrapText(issue.fix, width - 8);
+    for (const line of fixLines.slice(0, 4)) {
+      this.renderLine("    " + colors.success(line), width);
+    }
+    if (issue.cwe || issue.owasp || issue.effort) {
+      this.renderLine("", width);
+      this.bufferLine(sectionBorder);
+      this.renderLine("  " + colors.header("METADATA"), width);
+      if (issue.cwe) this.renderLine("  " + colors.dim("CWE:") + " " + issue.cwe, width);
+      if (issue.owasp) this.renderLine("  " + colors.dim("OWASP:") + " " + issue.owasp, width);
+      if (issue.effort) this.renderLine("  " + colors.dim("Effort:") + " " + issue.effort, width);
+    }
+  }
+  /**
+   * Render costs view - Moneybags cost breakdown
+   */
+  renderCostsView(width, _height) {
+    const sectionBorder = colors.border(box.leftT + this.line(width - 2) + box.rightT);
+    this.renderLine("  " + colors.header("\u{1F4B0} COST ANALYSIS") + "  " + colors.dim("(Moneybags)"), width);
+    this.bufferLine(sectionBorder);
+    const cost = this.state.costReport;
+    if (!cost) {
+      this.renderLine("  " + colors.dim("No cost data available. Run a full scan to get cost estimates."), width);
+      this.renderLine("", width);
+      return;
+    }
+    const fmt = (n) => n >= 1e6 ? `$${(n / 1e6).toFixed(2)}M` : n >= 1e3 ? `$${(n / 1e3).toFixed(1)}k` : `$${n}`;
+    this.renderLine("", width);
+    this.renderLine("  " + colors.header("SUMMARY"), width);
+    this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+    const fixNowLabel = colors.success("Fix Now Cost:");
+    const prodLabel = colors.critical("Production Cost:");
+    const savingsLabel = colors.running("Potential Savings:");
+    this.renderLine("  " + fixNowLabel + "     " + colors.success(fmt(cost.fixNowCost)), width);
+    this.renderLine("  " + prodLabel + " " + colors.critical(fmt(cost.productionCost)), width);
+    this.renderLine("  " + savingsLabel + " " + colors.running(fmt(cost.savings)), width);
+    this.renderLine("", width);
+    const roi = cost.fixNowCost > 0 ? Math.round(cost.savings / cost.fixNowCost * 100) : 0;
+    this.renderLine("  " + colors.dim("ROI:") + " " + colors.highlight(`${roi}%`) + " " + colors.dim("return on fixing these issues now"), width);
+    this.renderLine("", width);
+    if (cost.perIssue && cost.perIssue.length > 0) {
+      this.bufferLine(sectionBorder);
+      this.renderLine("  " + colors.header("PER-ISSUE BREAKDOWN"), width);
+      this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+      const maxRows = Math.min(cost.perIssue.length, 8);
+      for (let i = 0; i < maxRows; i++) {
+        const item = cost.perIssue[i];
+        if (!item) continue;
+        const issueName = item.issue.slice(0, 40) + (item.issue.length > 40 ? "..." : "");
+        this.renderLine("  " + colors.dim("\u2022") + " " + issueName.padEnd(45) + " " + colors.serious(fmt(item.cost)), width);
+      }
+      if (cost.perIssue.length > 8) {
+        this.renderLine("  " + colors.dim(`... and ${cost.perIssue.length - 8} more`), width);
+      }
+    }
+    this.renderLine("", width);
+  }
+  /**
+   * Render readiness view - Production readiness checklist
+   */
+  renderReadinessView(width, _height) {
+    const sectionBorder = colors.border(box.leftT + this.line(width - 2) + box.rightT);
+    this.renderLine("  " + colors.header("\u{1F4CA} PRODUCTION READINESS"), width);
+    this.bufferLine(sectionBorder);
+    const readiness = this.state.readiness;
+    if (!readiness) {
+      this.renderLine("  " + colors.dim("No readiness data. Run production-ready agent for assessment."), width);
+      return;
+    }
+    const statusColor = readiness.status === "ready" ? colors.success : readiness.status === "caution" ? colors.running : colors.critical;
+    const statusIcon = readiness.status === "ready" ? "\u2713" : readiness.status === "caution" ? "~" : "\u2717";
+    this.renderLine("", width);
+    this.renderLine("  " + colors.header("STATUS"), width);
+    this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+    this.renderLine("  " + statusColor(`[${statusIcon}] ${readiness.status.toUpperCase()}`), width);
+    this.renderLine("", width);
+    const scoreWidth = 40;
+    const scoreFilled = Math.round(readiness.score / 100 * scoreWidth);
+    const scoreEmpty = scoreWidth - scoreFilled;
+    const scoreBar = statusColor("\u2588".repeat(scoreFilled)) + colors.dim("\u2591".repeat(scoreEmpty));
+    this.renderLine("  " + colors.dim("Score:") + " " + scoreBar + " " + statusColor(`${readiness.score}/100`), width);
+    this.renderLine("", width);
+    this.bufferLine(sectionBorder);
+    this.renderLine("  " + colors.header("REQUIREMENTS"), width);
+    this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+    this.renderLine("  " + colors.dim("Met:") + " " + colors.highlight(`${readiness.requirementsMet}/${readiness.total}`), width);
+    this.renderLine("", width);
+    if (readiness.requirements && readiness.requirements.length > 0) {
+      for (const req of readiness.requirements.slice(0, 10)) {
+        const icon = req.met ? colors.success("\u2713") : colors.critical("\u2717");
+        const text = req.met ? colors.dim(req.name) : req.name;
+        this.renderLine("  " + icon + " " + text, width);
+      }
+    }
+    this.renderLine("", width);
+  }
+  /**
+   * Render analysis view - Semantic + Attack Surface
+   */
+  renderAnalysisView(width, _height) {
+    const sectionBorder = colors.border(box.leftT + this.line(width - 2) + box.rightT);
+    this.renderLine("  " + colors.header("\u{1F50D} ANALYSIS REPORT"), width);
+    this.bufferLine(sectionBorder);
+    const semantic = this.state.semanticAnalysis;
+    if (semantic) {
+      this.renderLine("  " + colors.header("SEMANTIC ANALYSIS"), width);
+      this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+      if (semantic.dataFlowIssues > 0) {
+        this.renderLine("  " + colors.critical("[!]") + " " + colors.critical(`${semantic.dataFlowIssues} Data Flow Vulnerabilities`), width);
+        this.renderLine("      " + colors.dim("Untrusted input reaching dangerous sinks"), width);
+      }
+      if (semantic.raceConditions > 0) {
+        this.renderLine("  " + colors.running("[~]") + " " + colors.running(`${semantic.raceConditions} Race Conditions`), width);
+        this.renderLine("      " + colors.dim("TOCTOU, double-spend risks"), width);
+      }
+      if (semantic.authIssues > 0) {
+        this.renderLine("  " + colors.critical("[!]") + " " + colors.critical(`${semantic.authIssues} Authentication Issues`), width);
+        this.renderLine("      " + colors.dim("Missing or bypassable auth"), width);
+      }
+      const total = semantic.dataFlowIssues + semantic.raceConditions + semantic.authIssues;
+      if (total === 0) {
+        this.renderLine("  " + colors.success("\u2713 No semantic issues detected"), width);
+      }
+      this.renderLine("", width);
+    }
+    const attack = this.state.attackSurface;
+    if (attack) {
+      this.bufferLine(sectionBorder);
+      this.renderLine("  " + colors.header("ATTACK SURFACE"), width);
+      this.renderLine("  " + colors.dim(this.line(width - 6)), width);
+      this.renderLine("  " + colors.dim("Endpoints:") + "    " + colors.highlight(attack.totalEndpoints.toString()), width);
+      if (attack.unprotected > 0) {
+        this.renderLine("  " + colors.critical("Unprotected:") + "  " + colors.critical(attack.unprotected.toString()), width);
+      } else {
+        this.renderLine("  " + colors.success("Unprotected:") + "  " + colors.success("0"), width);
+      }
+      const riskWidth = 30;
+      const riskFilled = Math.round(attack.riskScore / 100 * riskWidth);
+      const riskEmpty = riskWidth - riskFilled;
+      const riskColor = attack.riskScore > 70 ? colors.critical : attack.riskScore > 40 ? colors.running : colors.success;
+      const riskBar = riskColor("\u2588".repeat(riskFilled)) + colors.dim("\u2591".repeat(riskEmpty));
+      this.renderLine("  " + colors.dim("Risk Score:") + "   " + riskBar + " " + riskColor(`${attack.riskScore}/100`), width);
+      this.renderLine("", width);
+      if (attack.endpoints && attack.endpoints.length > 0) {
+        this.renderLine("  " + colors.dim("Top Endpoints:"), width);
+        for (const ep of attack.endpoints.slice(0, 5)) {
+          const authIcon = ep.auth ? colors.success("\u{1F512}") : colors.critical("\u{1F513}");
+          const method = colors.dim(ep.method.padEnd(6));
+          const path = ep.sensitive ? colors.serious(ep.path) : ep.path;
+          this.renderLine("    " + authIcon + " " + method + " " + path, width);
+        }
+      }
+    }
+    if (!semantic && !attack) {
+      this.renderLine("  " + colors.dim("No analysis data available. Run a full scan for semantic analysis."), width);
+    }
+    this.renderLine("", width);
+  }
+  /**
+   * Render raw log view - All console output
+   */
+  renderRawLogView(width, height) {
+    const sectionBorder = colors.border(box.leftT + this.line(width - 2) + box.rightT);
+    const pageSize = Math.max(10, height - 15);
+    const totalPages = Math.max(1, Math.ceil(this.state.rawLog.length / pageSize));
+    this.renderLine("  " + colors.header("\u{1F4CB} RAW LOG") + "  " + colors.dim(`Page ${this.state.rawLogPage + 1}/${totalPages}`) + "  " + colors.highlight(`${this.state.rawLog.length}`) + colors.dim(" entries"), width);
+    this.bufferLine(sectionBorder);
+    if (this.state.rawLog.length === 0) {
+      this.renderLine("  " + colors.dim("No log entries yet."), width);
+      this.renderLine("", width);
+      return;
+    }
+    const startIdx = this.state.rawLogPage * pageSize;
+    const logs = this.state.rawLog.slice(startIdx, startIdx + pageSize);
+    for (const entry of logs) {
+      const levelColor = entry.level === "error" ? colors.critical : entry.level === "warn" ? colors.running : entry.level === "info" ? colors.success : colors.dim;
+      const levelStr = levelColor(`[${entry.level.toUpperCase().padEnd(5)}]`);
+      const timeStr = colors.dim(entry.time);
+      const message = entry.message.slice(0, width - 25);
+      this.renderLine("  " + timeStr + " " + levelStr + " " + message, width);
+    }
+    for (let i = logs.length; i < pageSize; i++) {
+      this.renderLine("", width);
+    }
+  }
   /**
    * Render footer with controls
    */
@@ -3974,25 +4570,44 @@ var InteractiveDashboard = class {
     this.bufferLine(bottomBorder);
     const key = (k) => colors.border("[") + colors.highlight(k) + colors.border("]");
     const hint = (k, desc) => key(k) + colors.dim(` ${desc}`);
+    const paneHints = [];
+    if (this.state.issues.length > 0) paneHints.push(hint("d", "Details"));
+    if (this.state.costReport) paneHints.push(hint("m", "Cost"));
+    if (this.state.readiness) paneHints.push(hint("r", "Ready"));
+    if (this.state.semanticAnalysis || this.state.attackSurface) paneHints.push(hint("a", "Analysis"));
+    paneHints.push(hint("l", "Log"));
+    const paneStr = paneHints.length > 0 ? "  " + paneHints.join(" ") : "";
     if (!this.state.scanComplete) {
-      this.bufferLine("   " + hint("q", "Quit") + "  " + hint("?", "Help"));
+      this.bufferLine("   " + hint("l", "Log") + "  " + hint("q", "Quit") + "  " + hint("?", "Help"));
+    } else if (this.state.view === "details" || this.state.view === "costs" || this.state.view === "readiness" || this.state.view === "analysis" || this.state.view === "rawlog") {
+      this.bufferLine("   " + hint("b", "Back") + "  " + hint("n/p", "Pages") + "  " + hint("Tab", "Main") + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
     } else if (this.state.view === "agents") {
-      this.bufferLine("   " + hint("j/k", "Select") + "  " + hint("Enter", "View issues") + "  " + hint("n/p", "Pages") + "  " + hint("Tab", "Views") + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
-    } else if (this.state.view === "issues" && this.state.previousView === "agents") {
-      this.bufferLine("   " + hint("b", "Back") + "  " + hint("j/k", "Nav") + "  " + hint("Enter", "Details") + "  " + hint("1-4", "Severity") + "  " + hint("f", "Search") + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
+      this.bufferLine("   " + hint("j/k", "Select") + "  " + hint("Enter", "View") + "  " + hint("n/p", "Pages") + "  " + hint("Tab", "Views") + paneStr + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
     } else if (this.state.view === "issues") {
-      this.bufferLine("   " + hint("j/k", "Nav") + "  " + hint("Enter", "Details") + "  " + hint("1-4", "Severity") + "  " + hint("f", "Search") + "  " + hint("s", "Scout") + "  " + hint("c", "Clear") + "  " + hint("Tab", "Views") + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
+      this.bufferLine("   " + hint("j/k", "Nav") + "  " + hint("Enter", "Details") + "  " + hint("1-4", "Sev") + "  " + hint("f", "Find") + "  " + hint("Tab", "Views") + paneStr + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
     } else {
-      this.bufferLine("   " + hint("Tab", "Views") + "  " + hint("n/p", "Pages") + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
+      this.bufferLine("   " + hint("Tab", "Views") + "  " + hint("n/p", "Pages") + paneStr + "  " + hint("?", "Help") + "  " + hint("q", "Quit"));
     }
   }
   // Helper methods
   switchView() {
     if (!this.state.scanComplete) return;
-    const views = ["overview", "issues", "agents", "files"];
-    const currentIndex = views.indexOf(this.state.view);
-    const nextIndex = (currentIndex + 1) % views.length;
-    this.state.view = views[nextIndex] ?? "overview";
+    const mainViews = ["overview", "issues", "agents", "files"];
+    const currentIndex = mainViews.indexOf(this.state.view);
+    if (currentIndex >= 0) {
+      const nextIndex = (currentIndex + 1) % mainViews.length;
+      this.state.view = mainViews[nextIndex] ?? "overview";
+    } else {
+      this.state.view = "overview";
+    }
+  }
+  /**
+   * Navigate to a specific view
+   */
+  goToView(view) {
+    if (!this.state.scanComplete && view !== "rawlog") return;
+    this.state.previousView = this.state.view;
+    this.state.view = view;
   }
   navigateUp() {
     if (this.state.view === "issues") {
@@ -4233,11 +4848,18 @@ var InteractiveDashboard = class {
     pLine("  " + colors.brand("TRIE GUARDIAN") + " " + colors.dim("-") + " " + colors.header("HELP"));
     console.log(colors.border(box.leftT + this.line(w - 2) + box.rightT));
     pLine("  " + colors.header("Navigation"));
-    keyLine("Tab", "Switch view (overview/issues/scouts/files)");
+    keyLine("Tab", "Cycle main views (overview/issues/scouts/files)");
     keyLine("j/k", "Navigate up/down in lists");
     keyLine("n/p", "Next/previous page");
     keyLine("Enter", "View details / drill into scout");
-    keyLine("b", "Go back (after drilling into scout)");
+    keyLine("b", "Go back to previous view");
+    pLine("");
+    pLine("  " + colors.header("Panes"));
+    keyLine("d", "Issue Details with code snippet");
+    keyLine("m", "Cost Analysis (Moneybags)");
+    keyLine("r", "Production Readiness score");
+    keyLine("a", "Analysis (Semantic + Attack Surface)");
+    keyLine("l", "Raw Log viewer");
     pLine("");
     pLine("  " + colors.header("Filters"));
     keyLine("1-4", "Filter by severity (1=critical, 4=low)");
@@ -5585,6 +6207,13 @@ var TrieScanTool = class {
       const dashboard = interactiveEnabled ? args?.dashboard instanceof InteractiveDashboard ? args.dashboard : new InteractiveDashboard() : void 0;
       if (interactiveEnabled) {
         setInteractiveMode(true);
+        getOutputManager().setMode("tui");
+      } else {
+        const isMCPContext = !process.stdout.isTTY;
+        getOutputManager().setMode(isMCPContext ? "mcp" : "console");
+      }
+      if (streamingManager) {
+        getOutputManager().setStreamingManager(streamingManager);
       }
       if (dashboard && streamingManager) {
         if (!(args?.dashboard instanceof InteractiveDashboard)) {
@@ -6243,6 +6872,22 @@ ${issue.fix}
 
 `;
     }
+    const outputManager = getOutputManager();
+    if (outputManager.getMode() === "mcp") {
+      const accumulatedMarkdown = outputManager.getMarkdown();
+      if (accumulatedMarkdown.trim()) {
+        output2 += `---
+
+`;
+        output2 += `## Additional Analysis
+
+`;
+        output2 += accumulatedMarkdown;
+        output2 += `
+`;
+      }
+      outputManager.clearBuffers();
+    }
     output2 += `---
 `;
     output2 += `*Powered by Trie Agent \u2014 showing you what matters.*
@@ -6332,4 +6977,4 @@ export {
   InteractiveDashboard,
   TrieScanTool
 };
-//# sourceMappingURL=chunk-3B2JBLSP.js.map
+//# sourceMappingURL=chunk-NM7ZVUHO.js.map