@triedotdev/mcp 1.0.37 → 1.0.39

package/dist/{chunk-VSCPOIWS.js → chunk-HG5AWUH7.js}

@@ -1,7 +1,7 @@
 import {
   CustomAgent,
   getAgentRegistry
-} from "./chunk-QFTSX2BX.js";
+} from "./chunk-B3MBKB2U.js";
 import {
   ProgressReporter
 } from "./chunk-OB45V2QC.js";
@@ -21,9 +21,9 @@ import {
 } from "./chunk-DGUM43GV.js";
 
 // src/tools/scan.ts
-import { readFile as readFile8, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { basename as basename6, isAbsolute, resolve as resolve2, join as join6, extname as extname3 } from "path";
+import { readFile as readFile9, readdir as readdir2, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { basename as basename6, isAbsolute, resolve as resolve2, join as join7, extname as extname3 } from "path";
 
 // src/orchestrator/context-analyzer.ts
 import { readFile } from "fs/promises";
@@ -650,11 +650,366 @@ var RiskAssessor = class {
   }
 };
 
+// src/utils/context-state.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join } from "path";
+var AGENTS_MD_PATH = ".trie/AGENTS.md";
+var STATE_JSON_PATH = ".trie/state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join(workDir, STATE_JSON_PATH);
+  try {
+    if (existsSync2(statePath)) {
+      const content = await readFile2(statePath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return getDefaultState();
+}
+async function saveContextState(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const trieDir = join(workDir, ".trie");
+  const statePath = join(workDir, STATE_JSON_PATH);
+  await mkdir(trieDir, { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2));
+}
+async function updateContextAfterScan(results, filesScanned, contextSignals, duration) {
+  const state = await loadContextState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const allIssues = results.flatMap((r) => r.issues);
+  const issueCounts = {
+    critical: allIssues.filter((i) => i.severity === "critical").length,
+    serious: allIssues.filter((i) => i.severity === "serious").length,
+    moderate: allIssues.filter((i) => i.severity === "moderate").length,
+    low: allIssues.filter((i) => i.severity === "low").length,
+    total: allIssues.length
+  };
+  const fileIssueMap = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    const count = fileIssueMap.get(issue.file) || 0;
+    fileIssueMap.set(issue.file, count + 1);
+  }
+  const hotFiles = Array.from(fileIssueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, issueCount]) => ({ file, issueCount }));
+  const scanSummary = {
+    timestamp: now,
+    agents: results.map((r) => r.agent),
+    filesScanned,
+    issues: issueCounts,
+    duration,
+    hotFiles
+  };
+  for (const result of results) {
+    state.agentStatus[result.agent] = {
+      lastRun: now,
+      issuesFound: result.issues.length
+    };
+  }
+  const criticalPenalty = issueCounts.critical * 25;
+  const seriousPenalty = issueCounts.serious * 10;
+  const moderatePenalty = issueCounts.moderate * 3;
+  const lowPenalty = issueCounts.low * 1;
+  const totalPenalty = Math.min(100, criticalPenalty + seriousPenalty + moderatePenalty + lowPenalty);
+  state.healthScore = Math.max(0, 100 - totalPenalty);
+  state.activePriorities = generatePriorities(issueCounts, contextSignals);
+  state.contextSignals = { ...state.contextSignals, ...contextSignals };
+  state.scanHistory = [scanSummary, ...state.scanHistory.slice(0, 19)];
+  state.lastScan = scanSummary;
+  await saveContextState(state);
+  await updateAgentsMd(state);
+}
+async function updateAgentsMd(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const mdPath = join(workDir, AGENTS_MD_PATH);
+  let content;
+  try {
+    content = await readFile2(mdPath, "utf-8");
+  } catch {
+    content = getAgentsMdTemplate();
+  }
+  content = updateSection(content, "Project State", generateProjectStateTable(state));
+  content = updateSection(content, "Active Priorities", generatePrioritiesList(state));
+  content = updateSection(content, "Agent Status", generateAgentStatusTable(state));
+  content = updateSection(content, "Recent Scan History", generateScanHistoryTable(state));
+  content = updateSection(content, "Context Signals Detected", generateContextSignals(state));
+  content = updateSection(content, "Risk Assessment", generateRiskAssessment(state));
+  content = updateSection(content, "Hot Files", generateHotFilesSection(state));
+  content = content.replace(
+    /Last updated:.*$/m,
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  );
+  await writeFile(mdPath, content);
+}
+function updateSection(content, sectionName, newContent) {
+  const sectionRegex = new RegExp(
+    `(### ${sectionName}[\\s\\S]*?)(?=###|---|
+## |$)`,
+    "g"
+  );
+  const replacement = `### ${sectionName}
+${newContent}
+
+`;
+  if (content.match(sectionRegex)) {
+    return content.replace(sectionRegex, replacement);
+  }
+  return content;
+}
+function generateProjectStateTable(state) {
+  const lastScan = state.lastScan;
+  const lastScanDate = lastScan ? new Date(lastScan.timestamp).toLocaleString() : "Never";
+  const criticalCount = lastScan?.issues.critical ?? 0;
+  const totalTasks = lastScan?.issues.total ?? 0;
+  return `| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | ${lastScanDate} | ${lastScan ? "Auto" : "-"} |
+| Critical Issues | ${criticalCount} | ${lastScan ? "Auto" : "-"} |
+| Open Tasks | ${totalTasks} | ${lastScan ? "Auto" : "-"} |
+| Health Score | ${state.healthScore}% | ${lastScan ? "Auto" : "-"} |`;
+}
+function generatePrioritiesList(state) {
+  if (state.activePriorities.length === 0) {
+    return "_No active priorities. Run a scan to identify issues._";
+  }
+  return state.activePriorities.map((p, i) => `${i + 1}. ${p}`).join("\n");
+}
+function generatePriorities(issues, contextSignals) {
+  const priorities = [];
+  if (issues.critical > 0) {
+    priorities.push(`\u{1F6A8} Fix ${issues.critical} critical security issue${issues.critical > 1 ? "s" : ""} immediately`);
+  }
+  if (issues.serious > 0) {
+    priorities.push(`\u26A0\uFE0F Address ${issues.serious} serious issue${issues.serious > 1 ? "s" : ""} before deployment`);
+  }
+  if (contextSignals.touchesAuth && issues.critical === 0) {
+    priorities.push("\u2705 Auth code reviewed - continue monitoring");
+  }
+  if (contextSignals.touchesPayments) {
+    priorities.push("\u{1F4B3} Payment code detected - ensure PCI compliance");
+  }
+  if (contextSignals.touchesUserData) {
+    priorities.push("\u{1F510} User data handling detected - verify privacy compliance");
+  }
+  if (issues.moderate > 5) {
+    priorities.push(`\u{1F4CB} Schedule time to address ${issues.moderate} moderate issues`);
+  }
+  if (priorities.length === 0) {
+    priorities.push("\u2728 No critical issues - focus on feature development");
+  }
+  return priorities.slice(0, 5);
+}
+function generateAgentStatusTable(state) {
+  const builtInAgents = [
+    "security",
+    "privacy",
+    "legal",
+    "accessibility",
+    "bugs",
+    "design",
+    "architecture",
+    "performance",
+    "devops",
+    "soc2",
+    "e2e",
+    "typecheck",
+    "visual-qa",
+    "data-flow"
+  ];
+  let table = `| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|`;
+  for (const agent of builtInAgents) {
+    const status = state.agentStatus[agent];
+    const lastRun = status?.lastRun ? new Date(status.lastRun).toLocaleDateString() : "Never";
+    const issues = status?.issuesFound ?? "-";
+    const statusEmoji = status ? "\u2705" : "\u23F8\uFE0F";
+    table += `
+| ${agent} | ${statusEmoji} Ready | ${lastRun} | ${issues} |`;
+  }
+  return table;
+}
+function generateScanHistoryTable(state) {
+  if (state.scanHistory.length === 0) {
+    return `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |`;
+  }
+  let table = `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|`;
+  for (const scan of state.scanHistory.slice(0, 10)) {
+    const date = new Date(scan.timestamp).toLocaleDateString();
+    const agents = scan.agents.slice(0, 3).join(", ") + (scan.agents.length > 3 ? "..." : "");
+    const duration = `${(scan.duration / 1e3).toFixed(1)}s`;
+    table += `
+| ${date} | ${agents} | ${scan.filesScanned} | ${scan.issues.total} | ${duration} |`;
+  }
+  return table;
+}
+function generateContextSignals(state) {
+  const signals = [
+    "touchesAuth",
+    "touchesPayments",
+    "touchesUserData",
+    "touchesAPI",
+    "touchesDatabase",
+    "touchesCrypto"
+  ];
+  return signals.map((s) => {
+    const value = state.contextSignals[s];
+    const emoji = value === true ? "\u2705" : value === false ? "\u274C" : "\u2753";
+    return `- \`${s}\`: ${emoji} ${value === void 0 ? "Unknown" : value ? "Yes" : "No"}`;
+  }).join("\n");
+}
+function generateRiskAssessment(state) {
+  const score = state.healthScore;
+  let riskLevel;
+  let confidence;
+  if (state.lastScan === null) {
+    return `- Overall Risk: Unknown
+- Confidence: 0%`;
+  }
+  if (score >= 90) {
+    riskLevel = "\u{1F7E2} Low";
+    confidence = 95;
+  } else if (score >= 70) {
+    riskLevel = "\u{1F7E1} Medium";
+    confidence = 85;
+  } else if (score >= 50) {
+    riskLevel = "\u{1F7E0} High";
+    confidence = 80;
+  } else {
+    riskLevel = "\u{1F534} Critical";
+    confidence = 90;
+  }
+  return `- Overall Risk: ${riskLevel}
+- Health Score: ${score}%
+- Confidence: ${confidence}%`;
+}
+function generateHotFilesSection(state) {
+  if (!state.lastScan || state.lastScan.hotFiles.length === 0) {
+    return "_Run a scan to identify hot files._";
+  }
+  return state.lastScan.hotFiles.map((f) => `- \`${f.file}\` - ${f.issueCount} issue${f.issueCount > 1 ? "s" : ""}`).join("\n");
+}
+function getDefaultState() {
+  return {
+    lastScan: null,
+    healthScore: 0,
+    activePriorities: [
+      "Initial setup required - run first scan with `trie scan`",
+      "Configure agents in `.trie/config.json`",
+      "Set up CI/CD integration"
+    ],
+    contextSignals: {},
+    agentStatus: {},
+    scanHistory: [],
+    customAgents: []
+  };
+}
+function getAgentsMdTemplate() {
+  return `# Trie Agent Context
+
+> **Auto-generated file** - Updated automatically when agents run.
+> Last updated: Never (initial state)
+
+This file provides prioritized context for all AI coding assistants working with this codebase.
+Agents should read this file first and update it after completing scans.
+
+---
+
+## Quick Context (Read First)
+
+### Project State
+| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | Never | - |
+| Critical Issues | 0 | - |
+| Open Tasks | 0 | - |
+| Health Score | Unknown | - |
+
+### Active Priorities
+1. Initial setup required - run first scan with \`trie scan\`
+2. Configure agents in \`.trie/config.json\`
+3. Set up CI/CD integration
+
+### Hot Files
+_Run a scan to identify hot files._
+
+---
+
+## Agent Status
+
+### Agent Status
+| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|
+| security | Ready | Never | - |
+| privacy | Ready | Never | - |
+| bugs | Ready | Never | - |
+
+### Recent Scan History
+| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |
+
+---
+
+## Context Analysis
+
+### Context Signals Detected
+- \`touchesAuth\`: Unknown
+- \`touchesPayments\`: Unknown
+- \`touchesUserData\`: Unknown
+- \`touchesAPI\`: Unknown
+- \`touchesDatabase\`: Unknown
+- \`touchesCrypto\`: Unknown
+
+### Risk Assessment
+- Overall Risk: Unknown
+- Confidence: 0%
+
+---
+
+*This file is maintained by Trie agents. Manual edits will be preserved in non-auto sections.*
+`;
+}
+async function getContextForAI() {
+  const state = await loadContextState();
+  const lines = [
+    "## Trie Context Summary",
+    "",
+    `**Health Score:** ${state.healthScore}%`,
+    `**Last Scan:** ${state.lastScan ? new Date(state.lastScan.timestamp).toLocaleString() : "Never"}`,
+    "",
+    "**Active Priorities:**",
+    ...state.activePriorities.map((p) => `- ${p}`),
+    ""
+  ];
+  if (state.lastScan) {
+    lines.push(
+      "**Recent Issues:**",
+      `- Critical: ${state.lastScan.issues.critical}`,
+      `- Serious: ${state.lastScan.issues.serious}`,
+      `- Moderate: ${state.lastScan.issues.moderate}`,
+      `- Low: ${state.lastScan.issues.low}`,
+      ""
+    );
+    if (state.lastScan.hotFiles.length > 0) {
+      lines.push(
+        "**Hot Files (most issues):**",
+        ...state.lastScan.hotFiles.slice(0, 5).map((f) => `- ${f.file}: ${f.issueCount} issues`),
+        ""
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/orchestrator/triager.ts
 var Triager = class {
   agentRegistry = getAgentRegistry();
   config;
   customAgentsLoaded = false;
+  contextState = null;
   constructor(config) {
     this.config = {
       minConfidence: 0.15,
@@ -665,6 +1020,18 @@ var Triager = class {
       ...config
     };
   }
+  /**
+   * Load previous context state for smart triaging
+   */
+  async loadPreviousContext() {
+    if (this.contextState === null) {
+      try {
+        this.contextState = await loadContextState();
+      } catch {
+        this.contextState = null;
+      }
+    }
+  }
   /**
    * Ensure custom agents are loaded before triaging
    */
@@ -676,11 +1043,20 @@ var Triager = class {
   }
   async selectAgents(context, riskLevel) {
     await this.ensureCustomAgentsLoaded();
-    if (riskLevel === "critical" || riskLevel === "high") {
-      console.error(`   \u26A0\uFE0F  ${riskLevel.toUpperCase()} risk - activating all agents for comprehensive review`);
+    await this.loadPreviousContext();
+    let effectiveRiskLevel = riskLevel;
+    if (this.contextState?.healthScore !== void 0 && this.contextState.healthScore < 50) {
+      if (riskLevel === "low" || riskLevel === "medium") {
+        effectiveRiskLevel = "high";
+        console.error(`   \u{1F4CA} Health score ${this.contextState.healthScore}% - escalating to ${effectiveRiskLevel.toUpperCase()} risk`);
+      }
+    }
+    if (effectiveRiskLevel === "critical" || effectiveRiskLevel === "high") {
+      console.error(`   \u26A0\uFE0F  ${effectiveRiskLevel.toUpperCase()} risk - activating all agents for comprehensive review`);
       return this.getAllAgents();
     }
-    const scores = this.scoreAgents(context, riskLevel);
+    const scores = this.scoreAgents(context, effectiveRiskLevel);
+    this.boostAgentsWithHistory(scores);
     this.logAgentScoring(scores);
     const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
     qualified.sort((a, b) => {
@@ -692,6 +1068,20 @@ var Triager = class {
     }
     return qualified.map((s) => s.agent);
   }
+  /**
+   * Boost confidence for agents that found issues in previous scans
+   */
+  boostAgentsWithHistory(scores) {
+    if (!this.contextState?.agentStatus) return;
+    for (const score of scores) {
+      const previousRun = this.contextState.agentStatus[score.agent.name];
+      if (previousRun?.issuesFound && previousRun.issuesFound > 0) {
+        const boost = Math.min(0.3, previousRun.issuesFound * 0.05);
+        score.confidence = Math.min(1, score.confidence + boost);
+        score.reasons.push(`found ${previousRun.issuesFound} issues in last scan`);
+      }
+    }
+  }
   scoreAgents(context, riskLevel) {
     const allAgents = this.getAllAgents();
     const scores = [];
@@ -998,6 +1388,64 @@ var Triager = class {
         reasons.push("data access");
       }
     }
+    if (agent.name === "moneybags") {
+      tier = 3;
+      if (context.touchesPayments) {
+        confidence += 0.6;
+        reasons.push("payment code = high cost risk");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.4;
+        reasons.push("auth bugs are expensive");
+      }
+      if (context.touchesHealthData) {
+        confidence += 0.5;
+        reasons.push("HIPAA violations");
+      }
+      if (context.touchesUserData) {
+        confidence += 0.3;
+        reasons.push("PII exposure costs");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.25;
+        reasons.push("data loss risk");
+      }
+      if (context.isNewFeature) {
+        confidence += 0.2;
+        reasons.push("new code risk");
+      }
+      if (riskLevel === "high" || riskLevel === "critical") {
+        confidence *= 1.3;
+        reasons.push("high-stakes context");
+      }
+    }
+    if (agent.name === "production-ready") {
+      tier = 3;
+      if (context.touchesAPI) {
+        confidence += 0.4;
+        reasons.push("API deployment");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.35;
+        reasons.push("database operations");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.35;
+        reasons.push("auth system");
+      }
+      if (context.touchesPayments) {
+        confidence += 0.5;
+        reasons.push("payment processing");
+      }
+      if (context.linesChanged > 200) {
+        confidence += 0.3;
+        reasons.push("significant changes");
+      }
+      if (riskLevel === "high" || riskLevel === "critical") {
+        confidence += 0.4;
+        reasons.push("production gate check");
+      }
+    }
     confidence = Math.min(1, confidence);
     return { agent, confidence, reasons, tier, isCustom: false };
   }
@@ -1373,8 +1821,8 @@ function calculateOptimalConcurrency() {
 }
 
 // src/utils/cache-manager.ts
-import { readFile as readFile2, writeFile, mkdir, stat } from "fs/promises";
-import { join } from "path";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, stat } from "fs/promises";
+import { join as join2 } from "path";
 import { createHash } from "crypto";
 var CacheManager = class {
   cacheDir;
@@ -1384,8 +1832,8 @@ var CacheManager = class {
   // 24 hours
   MAX_ENTRIES = 1e3;
   constructor(baseDir) {
-    this.cacheDir = join(baseDir, ".trie", "cache");
-    this.indexPath = join(this.cacheDir, "index.json");
+    this.cacheDir = join2(baseDir, ".trie", "cache");
+    this.indexPath = join2(this.cacheDir, "index.json");
   }
   /**
    * Generate cache key for a file and agent combination
@@ -1399,7 +1847,7 @@ var CacheManager = class {
    */
   async getFileHash(filePath) {
     try {
-      const content = await readFile2(filePath, "utf-8");
+      const content = await readFile3(filePath, "utf-8");
       const stats = await stat(filePath);
       const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
       return {
@@ -1416,7 +1864,7 @@ var CacheManager = class {
    */
   async loadIndex() {
     try {
-      const content = await readFile2(this.indexPath, "utf-8");
+      const content = await readFile3(this.indexPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -1431,8 +1879,8 @@ var CacheManager = class {
    */
   async saveIndex(index) {
     try {
-      await mkdir(this.cacheDir, { recursive: true });
-      await writeFile(this.indexPath, JSON.stringify(index, null, 2));
+      await mkdir2(this.cacheDir, { recursive: true });
+      await writeFile2(this.indexPath, JSON.stringify(index, null, 2));
     } catch (error) {
       console.warn("Failed to save cache index:", error);
     }
@@ -1639,8 +2087,8 @@ var Executor = class {
 };
 
 // src/analysis/cross-file.ts
-import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join2, extname as extname2, relative, dirname, basename as basename2 } from "path";
+import { readFile as readFile4, readdir } from "fs/promises";
+import { join as join3, extname as extname2, relative, dirname, basename as basename2 } from "path";
 async function buildDependencyGraph(rootDir, maxFiles = 200) {
   const files = /* @__PURE__ */ new Map();
   const issues = [];
@@ -1670,7 +2118,7 @@ async function buildDependencyGraph(rootDir, maxFiles = 200) {
 }
 async function parseFile(filePath, rootDir) {
   try {
-    const content = await readFile3(filePath, "utf-8");
+    const content = await readFile4(filePath, "utf-8");
     const relativePath = relative(rootDir, filePath);
     const lines = content.split("\n");
     const imports = [];
@@ -1759,7 +2207,7 @@ function resolveImport(source, fromPath, files) {
     return null;
   }
   const fromDir = dirname(fromPath);
-  let resolvedPath = join2(fromDir, source);
+  let resolvedPath = join3(fromDir, source);
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
   for (const ext of extensions) {
     const tryPath = resolvedPath + ext;
@@ -1873,7 +2321,7 @@ async function discoverFiles(dir, maxFiles) {
       const entries = await readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= maxFiles) break;
-        const fullPath = join2(currentDir, entry.name);
+        const fullPath = join3(currentDir, entry.name);
         if (entry.isDirectory()) {
           if (!skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
             await walk(fullPath);
@@ -1980,7 +2428,7 @@ ${"\u2501".repeat(60)}
 }
 
 // src/analysis/semantic-analyzer.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import { basename as basename3, relative as relative2 } from "path";
 var SemanticAnalyzer = class {
   functions = [];
@@ -1993,7 +2441,7 @@ var SemanticAnalyzer = class {
   async analyze(files, rootDir) {
     for (const file of files) {
       try {
-        const content = await readFile4(file, "utf-8");
+        const content = await readFile5(file, "utf-8");
         const relPath = relative2(rootDir, file);
         this.detectFramework(content);
         this.parseFunctions(content, relPath);
@@ -2554,7 +3002,7 @@ function formatPrioritizedResults(result) {
 }
 
 // src/analysis/attack-surface.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { basename as basename5, relative as relative3 } from "path";
 var AttackSurfaceAnalyzer = class {
   endpoints = [];
@@ -2564,7 +3012,7 @@ var AttackSurfaceAnalyzer = class {
   async analyze(files, rootDir) {
     for (const file of files) {
       try {
-        const content = await readFile5(file, "utf-8");
+        const content = await readFile6(file, "utf-8");
         const relPath = relative3(rootDir, file);
         this.findEndpoints(content, relPath);
         this.findDataFlows(content, relPath);
@@ -3309,9 +3757,9 @@ function getSymbolIndex() {
 
 // src/trie/incremental-scanner.ts
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 var CACHE_VERSION = "1.0.0";
 var CACHE_FILE = ".trie-cache.json";
 var IncrementalScanner = class {
@@ -3320,7 +3768,7 @@ var IncrementalScanner = class {
   cacheDir;
   dirty = false;
   constructor(projectRoot) {
-    this.cacheDir = join3(projectRoot, ".trie");
+    this.cacheDir = join4(projectRoot, ".trie");
     this.symbolIndex = getSymbolIndex();
     this.cache = {
       version: CACHE_VERSION,
@@ -3333,12 +3781,12 @@ var IncrementalScanner = class {
    * Load cache from disk
    */
   async loadCache() {
-    const cachePath = join3(this.cacheDir, CACHE_FILE);
-    if (!existsSync2(cachePath)) {
+    const cachePath = join4(this.cacheDir, CACHE_FILE);
+    if (!existsSync3(cachePath)) {
       return false;
     }
     try {
-      const data = await readFile6(cachePath, "utf-8");
+      const data = await readFile7(cachePath, "utf-8");
       const parsed = JSON.parse(data);
       if (parsed.version !== CACHE_VERSION) {
         console.error("   \u26A0\uFE0F Cache version mismatch, rebuilding...");
@@ -3358,10 +3806,10 @@ var IncrementalScanner = class {
   async saveCache() {
     if (!this.dirty) return;
     try {
-      await mkdir2(this.cacheDir, { recursive: true });
-      const cachePath = join3(this.cacheDir, CACHE_FILE);
+      await mkdir3(this.cacheDir, { recursive: true });
+      const cachePath = join4(this.cacheDir, CACHE_FILE);
       this.cache.lastUpdated = Date.now();
-      await writeFile2(cachePath, JSON.stringify(this.cache, null, 2));
+      await writeFile3(cachePath, JSON.stringify(this.cache, null, 2));
       this.dirty = false;
     } catch (error) {
       console.error("   \u26A0\uFE0F Failed to save cache");
@@ -3383,7 +3831,7 @@ var IncrementalScanner = class {
     if (!cached) return true;
     if (!content) {
       try {
-        content = await readFile6(filePath, "utf-8");
+        content = await readFile7(filePath, "utf-8");
       } catch {
         return true;
       }
@@ -3398,7 +3846,7 @@ var IncrementalScanner = class {
   async scanFile(filePath, forceRescan = false) {
     let content;
     try {
-      content = await readFile6(filePath, "utf-8");
+      content = await readFile7(filePath, "utf-8");
     } catch {
       return { vulnerabilities: [], fromCache: false, symbolCount: 0 };
     }
@@ -4581,14 +5029,14 @@ var InteractiveDashboard = class {
 };
 
 // src/config/loader.ts
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 
 // src/config/validation.ts
 import { z } from "zod";
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { resolve, join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { resolve, join as join5 } from "path";
 var API_KEY_PATTERNS = {
   anthropic: /^sk-ant-api\d{2}-[\w-]{95}$/,
   openai: /^sk-[\w]{48}$/,
@@ -4701,8 +5149,8 @@ var ConfigValidator = class {
     let anthropicKey = process.env.ANTHROPIC_API_KEY;
     if (!anthropicKey) {
       try {
-        const configPath = join4(getWorkingDirectory(void 0, true), ".trie", "config.json");
-        if (existsSync3(configPath)) {
+        const configPath = join5(getWorkingDirectory(void 0, true), ".trie", "config.json");
+        if (existsSync4(configPath)) {
           const config = JSON.parse(readFileSync(configPath, "utf-8"));
           anthropicKey = config.apiKeys?.anthropic;
         }
@@ -4732,14 +5180,14 @@ var ConfigValidator = class {
     if (paths?.include) {
       for (const path of paths.include) {
         const resolvedPath = resolve(path);
-        if (!existsSync3(resolvedPath)) {
+        if (!existsSync4(resolvedPath)) {
           errors.push(`Include path does not exist: ${path}`);
         }
       }
     }
     if (paths?.configDir) {
       const configPath = resolve(paths.configDir);
-      if (!existsSync3(configPath)) {
+      if (!existsSync4(configPath)) {
         try {
           __require("fs").mkdirSync(configPath, { recursive: true });
         } catch {
@@ -4859,8 +5307,8 @@ var ConfigValidator = class {
         const workDir = getWorkingDirectory(void 0, true);
         const envFiles = [".env", ".env.local", ".env.production"];
         for (const envFile of envFiles) {
-          const envPath = join4(workDir, envFile);
-          if (existsSync3(envPath)) {
+          const envPath = join5(workDir, envFile);
+          if (existsSync4(envPath)) {
             const envContent = readFileSync(envPath, "utf-8");
             if (envContent.includes("ANTHROPIC_API_KEY=")) {
               hasApiKey = true;
@@ -4937,12 +5385,12 @@ var DEFAULT_CONFIG = {
 // src/config/loader.ts
 async function loadConfig() {
   const validator = new ConfigValidator();
-  const configPath = join5(getWorkingDirectory(void 0, true), ".trie", "config.json");
+  const configPath = join6(getWorkingDirectory(void 0, true), ".trie", "config.json");
   try {
-    if (!existsSync4(configPath)) {
+    if (!existsSync5(configPath)) {
       return DEFAULT_CONFIG;
     }
-    const configFile = await readFile7(configPath, "utf-8");
+    const configFile = await readFile8(configPath, "utf-8");
     const userConfig = JSON.parse(configFile);
     const merged = mergeConfig(DEFAULT_CONFIG, userConfig);
     const result = validator.validateConfig(merged);
@@ -5801,7 +6249,7 @@ var TrieScanTool = class {
         return resolve2(workDir, f);
       });
       const validFiles = resolvedFiles.filter((f) => {
-        if (!existsSync5(f)) {
+        if (!existsSync6(f)) {
           this.progress.warn("File not found", f);
           return false;
         }
@@ -5863,6 +6311,14 @@ var TrieScanTool = class {
       const allAgentNames = this.agentRegistry.getAgentNames();
       this.logTriaging(selectedAgents.map((a) => a.name), allAgentNames, context, riskLevel);
       this.progress.update(`${selectedAgents.length} agents selected for ${riskLevel} risk code`);
+      const userCount = args?.userCount;
+      if (userCount) {
+        const moneybags = selectedAgents.find((a) => a.name === "moneybags");
+        if (moneybags && "configure" in moneybags && typeof moneybags.configure === "function") {
+          moneybags.configure({ userCount });
+          console.error(`   \u{1F4B0} Cost estimates scaled for ${userCount.toLocaleString()} users`);
+        }
+      }
       this.progress.startPhase("ai-review", "Running AI analysis...");
       this.progress.ai("Starting agent analysis", `${selectedAgents.length} agents`);
       const agentResults = await this.executor.executeAgents(
@@ -6021,7 +6477,24 @@ var TrieScanTool = class {
           prioritization: prioritized,
           grouping: priorityReport
         };
-        await writeFile3(args.output, JSON.stringify(report, null, 2));
+        await writeFile4(args.output, JSON.stringify(report, null, 2));
+      }
+      try {
+        const contextSignals = {
+          touchesAuth: context.touchesAuth ?? false,
+          touchesPayments: context.touchesPayments ?? false,
+          touchesUserData: context.touchesUserData ?? false,
+          touchesAPI: context.touchesAPI ?? false,
+          touchesDatabase: context.touchesDatabase ?? false,
+          touchesCrypto: context.touchesCrypto ?? false
+        };
+        await updateContextAfterScan(
+          agentResults,
+          validFiles.length,
+          contextSignals,
+          Date.now() - startTime
+        );
+      } catch {
       }
       return {
         content: [
@@ -6120,8 +6593,8 @@ var TrieScanTool = class {
     const enriched = [];
     for (const issue of issues) {
       try {
-        if (issue.line && existsSync5(issue.file)) {
-          const content = await readFile8(issue.file, "utf-8");
+        if (issue.line && existsSync6(issue.file)) {
+          const content = await readFile9(issue.file, "utf-8");
           const lines = content.split("\n");
           const startLine = Math.max(0, issue.line - 3);
           const endLine = Math.min(lines.length, issue.line + 2);
@@ -6360,9 +6833,9 @@ ${issue.fix}
    * Get a code snippet around a specific line
    */
   async getCodeSnippet(filePath, line) {
-    if (!line || !existsSync5(filePath)) return null;
+    if (!line || !existsSync6(filePath)) return null;
     try {
-      const content = await readFile8(filePath, "utf-8");
+      const content = await readFile9(filePath, "utf-8");
       const lines = content.split("\n");
       const start = Math.max(0, line - 3);
       const end = Math.min(lines.length, line + 2);
@@ -6386,7 +6859,7 @@ ${issue.fix}
         const entries = await readdir2(currentDir, { withFileTypes: true });
         for (const entry of entries) {
           if (files.length >= maxFiles) break;
-          const fullPath = join6(currentDir, entry.name);
+          const fullPath = join7(currentDir, entry.name);
           if (entry.isDirectory()) {
             if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
               await walk(fullPath);
@@ -6411,12 +6884,12 @@ ${issue.fix}
     return files;
   }
   async loadTeamMembers(workDir) {
-    const teamConfigPath = join6(workDir, ".trie", "team.json");
-    if (!existsSync5(teamConfigPath)) {
+    const teamConfigPath = join7(workDir, ".trie", "team.json");
+    if (!existsSync6(teamConfigPath)) {
       return [];
     }
     try {
-      const content = await readFile8(teamConfigPath, "utf-8");
+      const content = await readFile9(teamConfigPath, "utf-8");
       const data = JSON.parse(content);
       return Array.isArray(data.members) ? data.members : [];
     } catch {
@@ -6435,6 +6908,8 @@ ${issue.fix}
 
 export {
   loadConfig,
+  loadContextState,
+  getContextForAI,
   TrieScanTool
 };
-//# sourceMappingURL=chunk-VSCPOIWS.js.map
+//# sourceMappingURL=chunk-HG5AWUH7.js.map