@triedotdev/mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,3882 @@
+#!/usr/bin/env node
+import {
+  listCustomAgents,
+  loadAgentConfig,
+  parseDocument
+} from "./chunk-EYNAGEQK.js";
+import {
+  AgentRegistry,
+  TrieFixTool,
+  TrieScanTool,
+  getPrompt,
+  getSystemPrompt
+} from "./chunk-E7CKHS3R.js";
+import "./chunk-3CS6Z2SL.js";
+import "./chunk-MR755QGT.js";
+import "./chunk-6NLHFIYA.js";
+import "./chunk-DGUM43GV.js";
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/tools/explain.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { extname, relative, resolve, isAbsolute } from "path";
+var TrieExplainTool = class {
+  async execute(args) {
+    const { type, target, context, depth = "standard" } = args || {};
+    if (!type || !target) {
+      return {
+        content: [{
+          type: "text",
+          text: this.getHelpText()
+        }]
+      };
+    }
+    switch (type) {
+      case "code":
+        return this.explainCode(target, context, depth);
+      case "issue":
+        return this.explainIssue(target, context);
+      case "change":
+        return this.explainChange(target, context);
+      case "risk":
+        return this.explainRisk(target, context);
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown explanation type: ${type}`
+          }]
+        };
+    }
+  }
+  async explainCode(target, context, _depth) {
+    let code;
+    let filePath;
+    let language;
+    const resolvedPath = isAbsolute(target) ? target : resolve(process.cwd(), target);
+    if (existsSync(resolvedPath)) {
+      code = await readFile(resolvedPath, "utf-8");
+      filePath = relative(process.cwd(), resolvedPath);
+      language = this.detectLanguage(resolvedPath);
+    } else {
+      code = target;
+      filePath = "inline";
+      language = this.guessLanguage(code);
+    }
+    const imports = this.extractImports(code, language);
+    const exports = this.extractExports(code);
+    const functions = this.extractFunctions(code, language);
+    const prompt = getPrompt("explain", "code", {
+      code,
+      language,
+      filePath
+    });
+    const systemPrompt = getSystemPrompt("explain");
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F4D6} CODE EXPLANATION
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4C2} Source
+
+`;
+    output += `- **File:** \`${filePath}\`
+`;
+    output += `- **Language:** ${language}
+`;
+    output += `- **Lines:** ${code.split("\n").length}
+
+`;
+    output += `## \u{1F50D} Structure Analysis
+
+`;
+    if (imports.length > 0) {
+      output += `**Imports (${imports.length}):**
+`;
+      for (const imp of imports.slice(0, 10)) {
+        output += `- ${imp}
+`;
+      }
+      if (imports.length > 10) {
+        output += `- *...and ${imports.length - 10} more*
+`;
+      }
+      output += "\n";
+    }
+    if (exports.length > 0) {
+      output += `**Exports (${exports.length}):**
+`;
+      for (const exp of exports) {
+        output += `- ${exp}
+`;
+      }
+      output += "\n";
+    }
+    if (functions.length > 0) {
+      output += `**Functions/Methods (${functions.length}):**
+`;
+      for (const fn of functions.slice(0, 15)) {
+        output += `- \`${fn}\`
+`;
+      }
+      if (functions.length > 15) {
+        output += `- *...and ${functions.length - 15} more*
+`;
+      }
+      output += "\n";
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F9E0} Deep Explanation Request
+
+`;
+    output += `**Role:** ${systemPrompt.split("\n")[0]}
+
+`;
+    output += prompt;
+    output += `
+${"\u2500".repeat(60)}
+`;
+    if (context) {
+      output += `
+**Additional Context:** ${context}
+`;
+    }
+    return { content: [{ type: "text", text: output }] };
+  }
+  async explainIssue(target, _context) {
+    let file = "";
+    let line = 0;
+    let issue = target;
+    let severity = "unknown";
+    const match = target.match(/^(.+?):(\d+):(.+)$/);
+    if (match) {
+      file = match[1];
+      line = parseInt(match[2], 10);
+      issue = match[3].trim();
+    }
+    if (/critical|injection|rce|xss/i.test(issue)) severity = "critical";
+    else if (/serious|auth|password|secret/i.test(issue)) severity = "serious";
+    else if (/moderate|warning/i.test(issue)) severity = "moderate";
+    else severity = "low";
+    let codeContext = "";
+    if (file && existsSync(file)) {
+      const content = await readFile(file, "utf-8");
+      const lines = content.split("\n");
+      const start = Math.max(0, line - 5);
+      const end = Math.min(lines.length, line + 5);
+      codeContext = lines.slice(start, end).map((l, i) => {
+        const lineNum = start + i + 1;
+        const marker = lineNum === line ? "\u2192 " : "  ";
+        return `${marker}${lineNum.toString().padStart(4)} | ${l}`;
+      }).join("\n");
+    }
+    const prompt = getPrompt("explain", "issue", {
+      issue,
+      severity,
+      filePath: file || "unknown",
+      line: String(line || "?")
+    });
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F50D} ISSUE EXPLANATION
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4CD} Issue Details
+
+`;
+    output += `- **Issue:** ${issue}
+`;
+    output += `- **Severity:** ${this.getSeverityIcon(severity)} ${severity}
+`;
+    if (file) output += `- **File:** \`${file}\`
+`;
+    if (line) output += `- **Line:** ${line}
+`;
+    output += "\n";
+    if (codeContext) {
+      output += `## \u{1F4C4} Code Context
+
+`;
+      output += `\`\`\`
+${codeContext}
+\`\`\`
+
+`;
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F9E0} Explanation Request
+
+`;
+    output += prompt;
+    output += `
+${"\u2500".repeat(60)}
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async explainChange(target, context) {
+    const files = target.split(",").map((f) => f.trim());
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F4DD} CHANGE ANALYSIS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4C2} Changed Files
+
+`;
+    for (const file of files) {
+      output += `- \`${file}\`
+`;
+    }
+    output += "\n";
+    output += `## \u{1F9E0} Analysis Request
+
+`;
+    output += `Analyze these changes and explain:
+
+`;
+    output += `1. **What changed** - Summary of modifications
+`;
+    output += `2. **Why it matters** - Impact on the system
+`;
+    output += `3. **Dependencies** - What else might be affected
+`;
+    output += `4. **Testing needed** - What to test after this change
+`;
+    output += `5. **Rollback plan** - How to undo if needed
+
+`;
+    if (context) {
+      output += `**Context:** ${context}
+
+`;
+    }
+    output += `Please review the changed files and provide this analysis.
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async explainRisk(target, context) {
+    const resolvedPath = isAbsolute(target) ? target : resolve(process.cwd(), target);
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u26A0\uFE0F RISK ASSESSMENT
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    if (existsSync(resolvedPath)) {
+      const code = await readFile(resolvedPath, "utf-8");
+      const filePath = relative(process.cwd(), resolvedPath);
+      const riskIndicators = this.detectRiskIndicators(code);
+      output += `## \u{1F4C2} Target
+
+`;
+      output += `- **File:** \`${filePath}\`
+`;
+      output += `- **Lines:** ${code.split("\n").length}
+
+`;
+      if (riskIndicators.length > 0) {
+        output += `## \u{1F6A8} Risk Indicators Found
+
+`;
+        for (const indicator of riskIndicators) {
+          output += `- ${indicator}
+`;
+        }
+        output += "\n";
+      }
+      const prompt = getPrompt("explain", "risk", {
+        files: filePath,
+        summary: context || "Code change"
+      });
+      output += `${"\u2500".repeat(60)}
+`;
+      output += `## \u{1F9E0} Risk Analysis Request
+
+`;
+      output += prompt;
+      output += `
+${"\u2500".repeat(60)}
+`;
+    } else {
+      output += `## \u{1F4CB} Feature/Change
+
+`;
+      output += `${target}
+
+`;
+      output += `## \u{1F9E0} Risk Analysis Request
+
+`;
+      output += `Analyze the risks of this change:
+
+`;
+      output += `1. **Technical risks** - What could break?
+`;
+      output += `2. **Security risks** - Any vulnerabilities introduced?
+`;
+      output += `3. **Performance risks** - Any slowdowns?
+`;
+      output += `4. **Data risks** - Any data integrity concerns?
+`;
+      output += `5. **User impact** - How might users be affected?
+`;
+      output += `6. **Mitigation** - How to reduce these risks?
+`;
+    }
+    return { content: [{ type: "text", text: output }] };
+  }
+  detectRiskIndicators(code) {
+    const indicators = [];
+    const checks = [
+      { pattern: /delete|drop|truncate/i, message: "\u26A0\uFE0F Destructive operations detected" },
+      { pattern: /password|secret|key|token/i, message: "\u{1F510} Credential handling detected" },
+      { pattern: /exec|eval|spawn/i, message: "\u{1F489} Code execution patterns detected" },
+      { pattern: /SELECT.*FROM|INSERT|UPDATE|DELETE/i, message: "\u{1F5C4}\uFE0F Direct database operations" },
+      { pattern: /fetch|axios|request|http/i, message: "\u{1F310} External API calls detected" },
+      { pattern: /process\.env/i, message: "\u2699\uFE0F Environment variable usage" },
+      { pattern: /fs\.|writeFile|readFile/i, message: "\u{1F4C1} File system operations" },
+      { pattern: /setTimeout|setInterval/i, message: "\u23F0 Async timing operations" },
+      { pattern: /try\s*{/i, message: "\u{1F6E1}\uFE0F Error handling present" },
+      { pattern: /catch\s*\(/i, message: "\u{1F6E1}\uFE0F Exception handling present" }
+    ];
+    for (const { pattern, message } of checks) {
+      if (pattern.test(code)) {
+        indicators.push(message);
+      }
+    }
+    return indicators;
+  }
+  extractImports(code, _language) {
+    const imports = [];
+    const lines = code.split("\n");
+    for (const line of lines) {
+      const es6Match = line.match(/import\s+(?:{[^}]+}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/);
+      if (es6Match) {
+        imports.push(es6Match[1]);
+        continue;
+      }
+      const cjsMatch = line.match(/require\s*\(['"]([^'"]+)['"]\)/);
+      if (cjsMatch) {
+        imports.push(cjsMatch[1]);
+        continue;
+      }
+      const pyMatch = line.match(/^(?:from\s+(\S+)\s+)?import\s+(\S+)/);
+      if (pyMatch && _language === "python") {
+        imports.push(pyMatch[1] || pyMatch[2]);
+      }
+    }
+    return [...new Set(imports)];
+  }
+  extractExports(code) {
+    const exports = [];
+    const lines = code.split("\n");
+    for (const line of lines) {
+      const es6Match = line.match(/export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type)\s+(\w+)/);
+      if (es6Match) {
+        exports.push(es6Match[1]);
+      }
+      const namedMatch = line.match(/export\s*\{([^}]+)\}/);
+      if (namedMatch) {
+        const names = namedMatch[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+        exports.push(...names);
+      }
+    }
+    return [...new Set(exports)];
+  }
+  extractFunctions(code, _language) {
+    const functions = [];
+    const lines = code.split("\n");
+    for (const line of lines) {
+      const funcMatch = line.match(/(?:async\s+)?function\s+(\w+)/);
+      if (funcMatch) {
+        functions.push(funcMatch[1]);
+        continue;
+      }
+      const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/);
+      if (arrowMatch) {
+        functions.push(arrowMatch[1]);
+        continue;
+      }
+      const methodMatch = line.match(/^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/);
+      if (methodMatch && !["if", "for", "while", "switch", "catch"].includes(methodMatch[1])) {
+        functions.push(methodMatch[1]);
+      }
+    }
+    return [...new Set(functions)];
+  }
+  detectLanguage(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const langMap = {
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".js": "javascript",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".rb": "ruby",
+      ".php": "php",
+      ".vue": "vue",
+      ".svelte": "svelte"
+    };
+    return langMap[ext] || "plaintext";
+  }
+  guessLanguage(code) {
+    if (/import.*from|export\s+(default|const|function|class)/.test(code)) return "typescript";
+    if (/def\s+\w+.*:/.test(code)) return "python";
+    if (/func\s+\w+.*\{/.test(code)) return "go";
+    if (/fn\s+\w+.*->/.test(code)) return "rust";
+    return "javascript";
+  }
+  getSeverityIcon(severity) {
+    const icons = {
+      critical: "\u{1F534}",
+      serious: "\u{1F7E0}",
+      moderate: "\u{1F7E1}",
+      low: "\u{1F535}",
+      unknown: "\u26AA"
+    };
+    return icons[severity] || "\u26AA";
+  }
+  getHelpText() {
+    return `
+${"\u2501".repeat(60)}
+\u{1F4D6} TRIE EXPLAIN - AI-POWERED CODE EXPLANATION
+${"\u2501".repeat(60)}
+
+## Usage
+
+### Explain code:
+\`\`\`
+trie_explain type:"code" target:"src/app.ts"
+\`\`\`
+
+### Explain an issue:
+\`\`\`
+trie_explain type:"issue" target:"SQL injection vulnerability"
+\`\`\`
+or with file context:
+\`\`\`
+trie_explain type:"issue" target:"src/db.ts:42:Unvalidated input"
+\`\`\`
+
+### Explain changes:
+\`\`\`
+trie_explain type:"change" target:"src/auth.ts, src/user.ts"
+\`\`\`
+
+### Assess risk:
+\`\`\`
+trie_explain type:"risk" target:"src/payment.ts"
+\`\`\`
+or for a feature:
+\`\`\`
+trie_explain type:"risk" target:"Adding Stripe integration for payments"
+\`\`\`
+
+## Explanation Types
+
+| Type | Description |
+|------|-------------|
+| code | What does this code do? |
+| issue | Why is this a problem? |
+| change | What's the impact? |
+| risk | What could go wrong? |
+`;
+  }
+};
+
+// src/tools/test.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2, dirname, basename, join } from "path";
+var TrieTestTool = class {
+  async execute(args) {
+    const { action, files, framework, style = "unit" } = args || {};
+    if (!action || !files || files.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: this.getHelpText()
+        }]
+      };
+    }
+    switch (action) {
+      case "generate":
+        return this.generateTests(files, framework, style);
+      case "coverage":
+        return this.analyzeCoverage(files);
+      case "suggest":
+        return this.suggestTests(files);
+      case "run":
+        return this.runTestsInfo(files);
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown action: ${action}`
+          }]
+        };
+    }
+  }
+  async generateTests(files, framework, style) {
+    const detectedFramework = framework || await this.detectTestFramework();
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F9EA} TEST GENERATION
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u2699\uFE0F Configuration
+
+`;
+    output += `- **Framework:** ${detectedFramework}
+`;
+    output += `- **Style:** ${style}
+`;
+    output += `- **Files:** ${files.length}
+
+`;
+    const allUnits = [];
+    for (const file of files) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(process.cwd(), file);
+      if (!existsSync2(resolvedPath)) {
+        output += `\u26A0\uFE0F File not found: ${file}
+`;
+        continue;
+      }
+      const code = await readFile2(resolvedPath, "utf-8");
+      const language = this.detectLanguage(resolvedPath);
+      const relativePath = relative2(process.cwd(), resolvedPath);
+      const units = this.extractTestableUnits(code, language);
+      allUnits.push({ file: relativePath, units });
+      output += `### \u{1F4C4} ${relativePath}
+
+`;
+      output += `Found **${units.length}** testable units:
+
+`;
+      for (const unit of units) {
+        const complexityIcon = unit.complexity > 10 ? "\u{1F534}" : unit.complexity > 5 ? "\u{1F7E1}" : "\u{1F7E2}";
+        output += `- ${complexityIcon} \`${unit.name}\` (${unit.type}, complexity: ${unit.complexity})
+`;
+        if (unit.dependencies.length > 0) {
+          output += `  - Dependencies: ${unit.dependencies.join(", ")}
+`;
+        }
+      }
+      output += "\n";
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F9E0} Test Generation Request
+
+`;
+    const systemPrompt = getSystemPrompt("test");
+    output += `**Role:** ${systemPrompt.split("\n")[0]}
+
+`;
+    for (const { file, units } of allUnits) {
+      if (units.length === 0) continue;
+      const code = await readFile2(resolve2(process.cwd(), file), "utf-8");
+      const language = this.detectLanguage(file);
+      const prompt = getPrompt("test", "generate", {
+        code,
+        language,
+        filePath: file,
+        framework: detectedFramework
+      });
+      output += `### Tests for ${file}
+
+`;
+      output += prompt;
+      output += "\n\n";
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `
+## \u{1F4DD} Expected Test Output
+
+`;
+    output += `Generate complete test files with:
+`;
+    output += `- All imports and setup
+`;
+    output += `- Tests for each function/method
+`;
+    output += `- Edge cases and error scenarios
+`;
+    output += `- Mock requirements clearly stated
+`;
+    output += `- Ready to copy and run
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async analyzeCoverage(files) {
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F4CA} COVERAGE ANALYSIS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    for (const file of files) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(process.cwd(), file);
+      if (!existsSync2(resolvedPath)) {
+        output += `\u26A0\uFE0F File not found: ${file}
+`;
+        continue;
+      }
+      const code = await readFile2(resolvedPath, "utf-8");
+      const language = this.detectLanguage(resolvedPath);
+      const relativePath = relative2(process.cwd(), resolvedPath);
+      const units = this.extractTestableUnits(code, language);
+      const testFile = await this.findTestFile(resolvedPath);
+      let testCode = "";
+      let testedUnits = [];
+      if (testFile) {
+        testCode = await readFile2(testFile, "utf-8");
+        testedUnits = this.findTestedUnits(testCode, units.map((u) => u.name));
+      }
+      const coverage = units.length > 0 ? Math.round(testedUnits.length / units.length * 100) : 0;
+      const coverageIcon = coverage >= 80 ? "\u{1F7E2}" : coverage >= 50 ? "\u{1F7E1}" : "\u{1F534}";
+      output += `### \u{1F4C4} ${relativePath}
+
+`;
+      output += `**Coverage:** ${coverageIcon} ${coverage}% (${testedUnits.length}/${units.length} units)
+`;
+      if (testFile) {
+        output += `**Test file:** \`${relative2(process.cwd(), testFile)}\`
+`;
+      } else {
+        output += `**Test file:** \u274C Not found
+`;
+      }
+      output += "\n";
+      const untested = units.filter((u) => !testedUnits.includes(u.name));
+      if (untested.length > 0) {
+        output += `**Missing Tests:**
+`;
+        for (const unit of untested) {
+          const priority = unit.complexity > 5 ? "\u{1F534} HIGH" : "\u{1F7E1} MEDIUM";
+          output += `- ${priority}: \`${unit.name}\` (${unit.type})
+`;
+        }
+        output += "\n";
+      }
+      if (testedUnits.length > 0) {
+        output += `**Tested:**
+`;
+        for (const name of testedUnits) {
+          output += `- \u2705 \`${name}\`
+`;
+        }
+        output += "\n";
+      }
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F4CB} Recommendations
+
+`;
+    output += `To improve coverage:
+`;
+    output += `1. Focus on high-complexity untested functions first
+`;
+    output += `2. Add edge case tests for existing coverage
+`;
+    output += `3. Consider integration tests for complex interactions
+`;
+    output += `
+Run \`trie_test action:generate files:["file.ts"]\` to generate missing tests.
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async suggestTests(files) {
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F4A1} TEST SUGGESTIONS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    for (const file of files) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(process.cwd(), file);
+      if (!existsSync2(resolvedPath)) {
+        output += `\u26A0\uFE0F File not found: ${file}
+`;
+        continue;
+      }
+      const code = await readFile2(resolvedPath, "utf-8");
+      const relativePath = relative2(process.cwd(), resolvedPath);
+      const patterns = this.detectTestablePatterns(code);
+      output += `### \u{1F4C4} ${relativePath}
+
+`;
+      if (patterns.length === 0) {
+        output += `No specific test suggestions for this file.
+
+`;
+        continue;
+      }
+      output += `| Priority | Pattern | Suggested Test |
+`;
+      output += `|----------|---------|----------------|
+`;
+      for (const pattern of patterns) {
+        output += `| ${pattern.priority} | ${pattern.name} | ${pattern.suggestion} |
+`;
+      }
+      output += "\n";
+    }
+    return { content: [{ type: "text", text: output }] };
+  }
+  async runTestsInfo(files) {
+    const framework = await this.detectTestFramework();
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F3C3} RUN TESTS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## Detected Configuration
+
+`;
+    output += `- **Framework:** ${framework}
+`;
+    output += `- **Files:** ${files.join(", ")}
+
+`;
+    output += `## Commands
+
+`;
+    switch (framework) {
+      case "jest":
+        output += `\`\`\`bash
+`;
+        output += `# Run all tests
+`;
+        output += `npx jest
+
+`;
+        output += `# Run specific files
+`;
+        output += `npx jest ${files.join(" ")}
+
+`;
+        output += `# Run with coverage
+`;
+        output += `npx jest --coverage
+`;
+        output += `\`\`\`
+`;
+        break;
+      case "vitest":
+        output += `\`\`\`bash
+`;
+        output += `# Run all tests
+`;
+        output += `npx vitest run
+
+`;
+        output += `# Run specific files
+`;
+        output += `npx vitest run ${files.join(" ")}
+
+`;
+        output += `# Run with coverage
+`;
+        output += `npx vitest run --coverage
+`;
+        output += `\`\`\`
+`;
+        break;
+      case "pytest":
+        output += `\`\`\`bash
+`;
+        output += `# Run all tests
+`;
+        output += `pytest
+
+`;
+        output += `# Run specific files
+`;
+        output += `pytest ${files.join(" ")}
+
+`;
+        output += `# Run with coverage
+`;
+        output += `pytest --cov
+`;
+        output += `\`\`\`
+`;
+        break;
+      default:
+        output += `Run your test framework with the specified files.
+`;
+    }
+    output += `
+*Note: This tool provides test commands but doesn't execute them directly.*
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  extractTestableUnits(code, language) {
+    const units = [];
+    const lines = code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || "";
+      const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+      if (funcMatch) {
+        const endLine = this.findBlockEnd(lines, i);
+        const body = lines.slice(i, endLine + 1).join("\n");
+        units.push({
+          name: funcMatch[1],
+          type: "function",
+          startLine: i + 1,
+          endLine: endLine + 1,
+          signature: `${funcMatch[1]}(${funcMatch[2]})`,
+          complexity: this.calculateComplexity(body),
+          dependencies: this.extractDependencies(body)
+        });
+      }
+      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?:=>|:)/);
+      if (arrowMatch) {
+        const endLine = this.findBlockEnd(lines, i);
+        const body = lines.slice(i, endLine + 1).join("\n");
+        units.push({
+          name: arrowMatch[1],
+          type: "function",
+          startLine: i + 1,
+          endLine: endLine + 1,
+          signature: arrowMatch[1],
+          complexity: this.calculateComplexity(body),
+          dependencies: this.extractDependencies(body)
+        });
+      }
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) {
+        const endLine = this.findBlockEnd(lines, i);
+        units.push({
+          name: classMatch[1],
+          type: "class",
+          startLine: i + 1,
+          endLine: endLine + 1,
+          signature: `class ${classMatch[1]}`,
+          complexity: this.calculateComplexity(lines.slice(i, endLine + 1).join("\n")),
+          dependencies: []
+        });
+      }
+      const componentMatch = line.match(/(?:export\s+)?(?:const|function)\s+([A-Z]\w+)\s*[=:]/);
+      if (componentMatch && /jsx|tsx/.test(language)) {
+        const endLine = this.findBlockEnd(lines, i);
+        units.push({
+          name: componentMatch[1],
+          type: "component",
+          startLine: i + 1,
+          endLine: endLine + 1,
+          signature: componentMatch[1],
+          complexity: this.calculateComplexity(lines.slice(i, endLine + 1).join("\n")),
+          dependencies: this.extractDependencies(lines.slice(i, endLine + 1).join("\n"))
+        });
+      }
+    }
+    return units;
+  }
+  findBlockEnd(lines, startLine) {
+    let braceCount = 0;
+    let started = false;
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i] || "";
+      for (const char of line) {
+        if (char === "{") {
+          braceCount++;
+          started = true;
+        } else if (char === "}") {
+          braceCount--;
+        }
+      }
+      if (started && braceCount === 0) {
+        return i;
+      }
+    }
+    return lines.length - 1;
+  }
+  calculateComplexity(code) {
+    let complexity = 1;
+    const patterns = [
+      /if\s*\(/g,
+      /else\s+if/g,
+      /\?\s*[^:]/g,
+      // Conditionals
+      /for\s*\(/g,
+      /while\s*\(/g,
+      /do\s*\{/g,
+      // Loops
+      /catch\s*\(/g,
+      // Error handling
+      /&&/g,
+      /\|\|/g,
+      // Logical operators
+      /case\s+/g
+      // Switch cases
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) {
+        complexity += matches.length;
+      }
+    }
+    return complexity;
+  }
+  extractDependencies(code) {
+    const deps = [];
+    const calls = code.match(/\b([a-z]\w+)\s*\(/gi) || [];
+    const builtins = ["if", "for", "while", "switch", "catch", "function", "return", "throw", "new", "await", "async"];
+    for (const call of calls) {
+      const name = call.replace(/\s*\($/, "");
+      if (!builtins.includes(name.toLowerCase()) && !deps.includes(name)) {
+        deps.push(name);
+      }
+    }
+    return deps.slice(0, 10);
+  }
+  async findTestFile(sourcePath) {
+    const dir = dirname(sourcePath);
+    const base = basename(sourcePath, extname2(sourcePath));
+    const ext = extname2(sourcePath);
+    const patterns = [
+      `${base}.test${ext}`,
+      `${base}.spec${ext}`,
+      `${base}_test${ext}`,
+      `test_${base}${ext}`
+    ];
+    for (const pattern of patterns) {
+      const testPath = join(dir, pattern);
+      if (existsSync2(testPath)) {
+        return testPath;
+      }
+    }
+    const testsDir = join(dir, "__tests__");
+    if (existsSync2(testsDir)) {
+      for (const pattern of patterns) {
+        const testPath = join(testsDir, pattern);
+        if (existsSync2(testPath)) {
+          return testPath;
+        }
+      }
+    }
+    return null;
+  }
+  findTestedUnits(testCode, unitNames) {
+    const tested = [];
+    for (const name of unitNames) {
+      const patterns = [
+        new RegExp(`describe\\s*\\([^)]*${name}`, "i"),
+        new RegExp(`it\\s*\\([^)]*${name}`, "i"),
+        new RegExp(`test\\s*\\([^)]*${name}`, "i"),
+        new RegExp(`expect\\s*\\([^)]*${name}`, "i")
+      ];
+      for (const pattern of patterns) {
+        if (pattern.test(testCode)) {
+          tested.push(name);
+          break;
+        }
+      }
+    }
+    return tested;
+  }
+  detectTestablePatterns(code) {
+    const patterns = [];
+    const checks = [
+      { pattern: /async\s+function|await\s+/i, priority: "\u{1F534} HIGH", name: "Async code", suggestion: "Test async flows and error handling" },
+      { pattern: /try\s*{[^}]*catch/i, priority: "\u{1F534} HIGH", name: "Error handling", suggestion: "Test both success and error paths" },
+      { pattern: /if\s*\([^)]*&&[^)]*\)/i, priority: "\u{1F7E1} MED", name: "Complex conditionals", suggestion: "Test all condition branches" },
+      { pattern: /\.map\(|\.filter\(|\.reduce\(/i, priority: "\u{1F7E1} MED", name: "Array operations", suggestion: "Test with empty, single, multiple items" },
+      { pattern: /fetch\(|axios\.|request\(/i, priority: "\u{1F534} HIGH", name: "HTTP requests", suggestion: "Mock API calls, test error responses" },
+      { pattern: /localStorage|sessionStorage/i, priority: "\u{1F7E1} MED", name: "Storage usage", suggestion: "Mock storage, test read/write" },
+      { pattern: /setTimeout|setInterval/i, priority: "\u{1F7E1} MED", name: "Timers", suggestion: "Use fake timers in tests" },
+      { pattern: /useState|useEffect|useCallback/i, priority: "\u{1F534} HIGH", name: "React hooks", suggestion: "Test hook behavior and updates" },
+      { pattern: /form|input|submit/i, priority: "\u{1F7E1} MED", name: "Form handling", suggestion: "Test validation and submission" }
+    ];
+    for (const { pattern, priority, name, suggestion } of checks) {
+      if (pattern.test(code)) {
+        patterns.push({ priority, name, suggestion });
+      }
+    }
+    return patterns;
+  }
+  async detectTestFramework() {
+    const packagePath = resolve2(process.cwd(), "package.json");
+    if (existsSync2(packagePath)) {
+      try {
+        const pkg = JSON.parse(await readFile2(packagePath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.vitest) return "vitest";
+        if (deps.jest) return "jest";
+        if (deps.mocha) return "mocha";
+      } catch {
+      }
+    }
+    if (existsSync2(resolve2(process.cwd(), "pytest.ini")) || existsSync2(resolve2(process.cwd(), "pyproject.toml"))) {
+      return "pytest";
+    }
+    return "jest";
+  }
+  detectLanguage(filePath) {
+    const ext = extname2(filePath).toLowerCase();
+    const langMap = {
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".js": "javascript",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust"
+    };
+    return langMap[ext] || "javascript";
+  }
+  getHelpText() {
+    return `
+${"\u2501".repeat(60)}
+\u{1F9EA} TRIE TEST - AI-POWERED TEST GENERATION
+${"\u2501".repeat(60)}
+
+## Usage
+
+### Generate tests:
+\`\`\`
+trie_test action:"generate" files:["src/utils.ts"]
+\`\`\`
+
+### Analyze coverage:
+\`\`\`
+trie_test action:"coverage" files:["src/utils.ts"]
+\`\`\`
+
+### Get test suggestions:
+\`\`\`
+trie_test action:"suggest" files:["src/app.ts"]
+\`\`\`
+
+### Get run commands:
+\`\`\`
+trie_test action:"run" files:["src/utils.test.ts"]
+\`\`\`
+
+## Options
+
+| Option | Values | Description |
+|--------|--------|-------------|
+| action | generate, coverage, suggest, run | What to do |
+| files | Array of paths | Files to analyze |
+| framework | jest, vitest, mocha, pytest | Test framework |
+| style | unit, integration, e2e, all | Test style |
+`;
+  }
+};
+
+// src/tools/register-agent.ts
+var TrieRegisterAgentTool = class {
+  async execute(args) {
+    const { name, path } = args;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u{1F916} Register agent tool called with name: ${name}, path: ${path}
+
+TODO: Implement register agent functionality`
+        }
+      ]
+    };
+  }
+};
+
+// src/tools/watch.ts
+import { watch } from "fs";
+import { stat } from "fs/promises";
+import { join as join2, extname as extname3, basename as basename2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".py",
+  ".go",
+  ".rs"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".turbo",
+  ".cache"
+]);
+var TrieWatchTool = class {
+  scanTool = new TrieScanTool();
+  fixTool = new TrieFixTool();
+  state = {
+    isRunning: false,
+    yoloMode: false,
+    lastScan: /* @__PURE__ */ new Map(),
+    pendingFiles: /* @__PURE__ */ new Set(),
+    scanDebounceTimer: null,
+    issueCache: /* @__PURE__ */ new Map(),
+    totalIssuesFound: 0,
+    totalIssuesFixed: 0,
+    filesScanned: 0
+  };
+  watchers = /* @__PURE__ */ new Map();
+  async execute(args) {
+    const { action, directory, debounceMs = 1e3, yolo = false } = args;
+    switch (action) {
+      case "start":
+        return this.startWatching(directory || process.cwd(), debounceMs, yolo);
+      case "stop":
+        return this.stopWatching();
+      case "status":
+        return this.getStatus();
+      case "issues":
+        return this.getCurrentIssues();
+      case "yolo":
+        return this.toggleYoloMode();
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown action: ${action}. Use 'start', 'stop', 'status', 'issues', or 'yolo'.`
+          }]
+        };
+    }
+  }
+  async startWatching(directory, debounceMs, yoloMode) {
+    if (this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: "\u26A0\uFE0F Watch mode is already running. Use `trie_watch stop` to stop it first."
+        }]
+      };
+    }
+    this.state.isRunning = true;
+    this.state.yoloMode = yoloMode;
+    this.state.issueCache.clear();
+    this.state.totalIssuesFound = 0;
+    this.state.totalIssuesFixed = 0;
+    this.state.filesScanned = 0;
+    const modeEmoji = yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
+    const modeName = yoloMode ? "YOLO MODE" : "WATCH MODE";
+    console.error("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.error(`${modeEmoji}  TRIE AGENT - AUTONOMOUS ${modeName}`);
+    console.error("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+    console.error(`\u{1F4C2} Watching: ${directory}`);
+    console.error(`\u23F1\uFE0F  Debounce: ${debounceMs}ms`);
+    if (yoloMode) {
+      console.error("\u{1F525} YOLO MODE: Auto-fixing issues as they occur!");
+    }
+    console.error("");
+    await this.watchDirectory(directory, debounceMs);
+    console.error("\u{1F50D} Running initial scan...\n");
+    const initialResult = await this.scanTool.execute({ directory });
+    const yoloMessage = yoloMode ? `
+### \u{1F525} YOLO MODE ENABLED
+Issues will be **automatically fixed** as they're detected!
+- High-confidence fixes applied immediately
+- No confirmation needed
+- Living on the edge \u{1F680}
+
+` : `
+### \u{1F4A1} Want auto-fixes?
+Run \`trie_watch yolo\` to enable YOLO mode and auto-fix issues as they occur!
+
+`;
+    return {
+      content: [{
+        type: "text",
+        text: `${modeEmoji} **AUTONOMOUS ${modeName} ACTIVATED**
+
+Trie Agent is now watching for file changes and will automatically scan them.
+
+**Watching:** \`${directory}\`
+**Debounce:** ${debounceMs}ms (waits for you to stop typing)
+**YOLO Mode:** ${yoloMode ? "\u{1F525} ON - Auto-fixing!" : "\u274C OFF"}
+
+### How it works:
+1. \u{1F4DD} You write/edit code
+2. \u{1F441}\uFE0F Trie detects the change
+3. \u{1F50D} Automatically scans the modified file
+4. ${yoloMode ? "\u{1F527} Auto-fixes issues immediately!" : "\u{1F6A8} Reports issues immediately"}
+${yoloMessage}
+### Commands:
+- \`trie_watch status\` - See current watch status
+- \`trie_watch yolo\` - Toggle YOLO mode (auto-fix)
+- \`trie_watch issues\` - Get all issues found so far  
+- \`trie_watch stop\` - Stop autonomous mode
+
+---
+
+${initialResult.content?.[0]?.text || "Initial scan complete."}`
+      }]
+    };
+  }
+  toggleYoloMode() {
+    if (!this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u26A0\uFE0F Watch mode is not running. Start it first with:
+          
+\`trie_watch start\` - Normal mode
+\`trie_watch start yolo:true\` - YOLO mode from the start`
+        }]
+      };
+    }
+    this.state.yoloMode = !this.state.yoloMode;
+    if (this.state.yoloMode) {
+      console.error("\n\u{1F525} YOLO MODE ACTIVATED! Auto-fixing issues as they occur...\n");
+      return {
+        content: [{
+          type: "text",
+          text: `\u{1F525} **YOLO MODE ACTIVATED**
+
+Issues will now be **automatically fixed** as they're detected!
+
+\u26A0\uFE0F **Warning:** This will modify your files without confirmation.
+- High-confidence fixes only
+- Backs up original code in memory
+- You can always undo with git
+
+Run \`trie_watch yolo\` again to disable.`
+        }]
+      };
+    } else {
+      console.error("\n\u{1F441}\uFE0F YOLO mode disabled. Back to watch-only mode.\n");
+      return {
+        content: [{
+          type: "text",
+          text: `\u{1F441}\uFE0F **YOLO MODE DISABLED**
+
+Back to normal watch mode. Issues will be reported but not auto-fixed.
+
+Run \`trie_watch yolo\` to re-enable.`
+        }]
+      };
+    }
+  }
+  async watchDirectory(dir, debounceMs) {
+    if (!existsSync3(dir)) return;
+    try {
+      const dirStat = await stat(dir);
+      if (!dirStat.isDirectory()) return;
+      const dirName = basename2(dir);
+      if (SKIP_DIRS.has(dirName) || dirName.startsWith(".")) return;
+      const watcher = watch(dir, { persistent: true }, async (_eventType, filename) => {
+        if (!filename) return;
+        const fullPath = join2(dir, filename);
+        const ext = extname3(filename).toLowerCase();
+        if (!WATCH_EXTENSIONS.has(ext)) return;
+        if (!existsSync3(fullPath)) return;
+        this.state.pendingFiles.add(fullPath);
+        if (this.state.scanDebounceTimer) {
+          clearTimeout(this.state.scanDebounceTimer);
+        }
+        this.state.scanDebounceTimer = setTimeout(() => {
+          this.processPendingFiles();
+        }, debounceMs);
+      });
+      this.watchers.set(dir, watcher);
+      const { readdir: readdir3 } = await import("fs/promises");
+      const entries = await readdir3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await this.watchDirectory(join2(dir, entry.name), debounceMs);
+        }
+      }
+    } catch (error) {
+    }
+  }
+  async processPendingFiles() {
+    if (this.state.pendingFiles.size === 0) return;
+    const files = Array.from(this.state.pendingFiles);
+    this.state.pendingFiles.clear();
+    const modeEmoji = this.state.yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
+    console.error(`
+${modeEmoji} Detected changes in ${files.length} file(s):`);
+    for (const file of files) {
+      console.error(`   \u2022 ${basename2(file)}`);
+    }
+    console.error("");
+    try {
+      const result = await this.scanTool.execute({ files });
+      const resultText = result.content?.[0]?.text || "";
+      this.state.filesScanned += files.length;
+      const issueMatch = resultText.match(/(\d+) total/);
+      if (issueMatch?.[1] !== void 0) {
+        const newIssues = parseInt(issueMatch[1], 10);
+        this.state.totalIssuesFound += newIssues;
+        if (newIssues > 0) {
+          console.error(`
+\u{1F6A8} Found ${newIssues} issues in changed files!`);
+          const criticalMatch = resultText.match(/(\d+) CRITICAL/);
+          const seriousMatch = resultText.match(/(\d+) SERIOUS/);
+          const moderateMatch = resultText.match(/(\d+) MODERATE/);
+          if (criticalMatch) {
+            console.error(`   \u{1F534} ${criticalMatch[1]} critical issues`);
+          }
+          if (seriousMatch) {
+            console.error(`   \u{1F7E0} ${seriousMatch[1]} serious issues`);
+          }
+          if (moderateMatch) {
+            console.error(`   \u{1F7E1} ${moderateMatch[1]} moderate issues`);
+          }
+          if (this.state.yoloMode) {
+            console.error("\n\u{1F525} YOLO MODE: Attempting auto-fix...");
+            await this.autoFixIssues(files);
+          } else {
+            console.error("\n\u{1F4A1} Run `trie_watch yolo` to auto-fix issues");
+          }
+        } else {
+          console.error("   \u2705 No issues found - code looks good!");
+        }
+      }
+      for (const file of files) {
+        this.state.lastScan.set(file, Date.now());
+      }
+    } catch (error) {
+      console.error(`\u274C Scan error: ${error}`);
+    }
+  }
+  async autoFixIssues(files) {
+    try {
+      const fixResult = await this.fixTool.execute({
+        files,
+        autoApprove: true,
+        minConfidence: 0.8
+        // Only fix high-confidence issues
+      });
+      const fixText = fixResult.content?.[0]?.text || "";
+      const fixedMatch = fixText.match(/(\d+) issues? fixed/i);
+      if (fixedMatch?.[1] !== void 0) {
+        const fixed = parseInt(fixedMatch[1], 10);
+        this.state.totalIssuesFixed += fixed;
+        console.error(`   \u2705 Auto-fixed ${fixed} issues!`);
+      } else if (fixText.includes("No issues")) {
+        console.error("   \u2139\uFE0F  No auto-fixable issues found");
+      } else {
+        const firstLine = fixText.split("\n")[0];
+        console.error(`   \u{1F527} ${firstLine}`);
+      }
+    } catch (error) {
+      console.error(`   \u26A0\uFE0F Auto-fix error: ${error}`);
+    }
+  }
+  stopWatching() {
+    if (!this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: "\u26A0\uFE0F Watch mode is not running."
+        }]
+      };
+    }
+    for (const [_dir, watcher] of this.watchers) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    if (this.state.scanDebounceTimer) {
+      clearTimeout(this.state.scanDebounceTimer);
+    }
+    const wasYolo = this.state.yoloMode;
+    this.state.isRunning = false;
+    this.state.yoloMode = false;
+    const modeEmoji = wasYolo ? "\u{1F525}" : "\u{1F441}\uFE0F";
+    console.error(`
+${modeEmoji} Watch mode stopped.
+`);
+    const yoloStats = wasYolo ? `
+- \u{1F525} **Issues auto-fixed: ${this.state.totalIssuesFixed}**` : "";
+    return {
+      content: [{
+        type: "text",
+        text: `${modeEmoji} **AUTONOMOUS MODE STOPPED**
+
+### Session Summary:
+- Files scanned: ${this.state.filesScanned}
+- Total issues found: ${this.state.totalIssuesFound}${yoloStats}
+- Directories watched: ${this.watchers.size}
+${wasYolo ? `
+\u{1F525} YOLO mode was ON - issues were auto-fixed as they occurred!` : ""}
+
+Use \`trie_watch start\` to start watching again.
+Use \`trie_watch start yolo:true\` for YOLO mode.`
+      }]
+    };
+  }
+  getStatus() {
+    if (!this.state.isRunning) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u{1F441}\uFE0F **Watch Mode Status: STOPPED**
+
+Use \`trie_watch start\` to begin autonomous scanning.
+Use \`trie_watch start yolo:true\` for YOLO mode (auto-fix).`
+        }]
+      };
+    }
+    const modeEmoji = this.state.yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
+    const modeName = this.state.yoloMode ? "YOLO MODE" : "WATCH MODE";
+    const recentScans = Array.from(this.state.lastScan.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([file, time]) => {
+      const ago = Math.round((Date.now() - time) / 1e3);
+      return `- \`${basename2(file)}\` (${ago}s ago)`;
+    }).join("\n");
+    const yoloStats = this.state.yoloMode ? `
+- \u{1F525} Issues auto-fixed: ${this.state.totalIssuesFixed}` : "";
+    return {
+      content: [{
+        type: "text",
+        text: `${modeEmoji} **${modeName} Status: RUNNING**
+
+### Stats:
+- Directories watched: ${this.watchers.size}
+- Files scanned this session: ${this.state.filesScanned}
+- Total issues found: ${this.state.totalIssuesFound}${yoloStats}
+- Pending files: ${this.state.pendingFiles.size}
+- YOLO Mode: ${this.state.yoloMode ? "\u{1F525} ON" : "\u274C OFF"}
+
+### Recently Scanned:
+${recentScans || "(none yet)"}
+
+### Commands:
+- \`trie_watch yolo\` - ${this.state.yoloMode ? "Disable" : "Enable"} YOLO mode
+- \`trie_watch issues\` - Get all issues found
+- \`trie_watch stop\` - Stop watching`
+      }]
+    };
+  }
+  getCurrentIssues() {
+    return {
+      content: [{
+        type: "text",
+        text: `\u{1F4CB} **Issues Found This Session**
+
+Total issues: ${this.state.totalIssuesFound}
+Files scanned: ${this.state.filesScanned}
+
+To get a full report, run \`trie_scan\` on your codebase.`
+      }]
+    };
+  }
+};
+
+// src/tools/agent.ts
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, extname as extname5, isAbsolute as isAbsolute3, resolve as resolve3, basename as basename4 } from "path";
+
+// src/ai/engine.ts
+import { readFile as readFile3 } from "fs/promises";
+import { extname as extname4, relative as relative3, basename as basename3 } from "path";
+function detectLanguage(filePath) {
+  const ext = extname4(filePath).toLowerCase();
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".rb": "ruby",
+    ".php": "php",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".sql": "sql",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".md": "markdown",
+    ".html": "html",
+    ".css": "css",
+    ".scss": "scss"
+  };
+  return langMap[ext] || "plaintext";
+}
+function analyzeFileContext(content, _filePath) {
+  const summary = {
+    hasAuth: false,
+    hasDatabase: false,
+    hasUserInput: false,
+    hasFileOps: false,
+    hasCrypto: false,
+    hasExternalAPIs: false,
+    exports: [],
+    imports: []
+  };
+  if (/auth|login|session|jwt|token|password|credential|oauth/i.test(content)) {
+    summary.hasAuth = true;
+  }
+  if (/prisma|sequelize|knex|mongodb|sql|query|database|postgres|mysql|sqlite/i.test(content)) {
+    summary.hasDatabase = true;
+  }
+  if (/req\.body|req\.params|req\.query|formData|input|textarea|userinput/i.test(content)) {
+    summary.hasUserInput = true;
+  }
+  if (/readFile|writeFile|createReadStream|createWriteStream|fs\.|multer|upload/i.test(content)) {
+    summary.hasFileOps = true;
+  }
+  if (/crypto|bcrypt|argon|scrypt|encrypt|decrypt|hash|sign|verify/i.test(content)) {
+    summary.hasCrypto = true;
+  }
+  if (/fetch\(|axios|http\.|https\.|request\(|got\(|api\//i.test(content)) {
+    summary.hasExternalAPIs = true;
+  }
+  if (/from\s+['"]react['"]|import\s+React/i.test(content)) {
+    summary.framework = "React";
+  } else if (/from\s+['"]next|NextRequest|getServerSideProps/i.test(content)) {
+    summary.framework = "Next.js";
+  } else if (/from\s+['"]express['"]|express\(\)/i.test(content)) {
+    summary.framework = "Express";
+  } else if (/from\s+['"]fastify['"]|fastify\(\)/i.test(content)) {
+    summary.framework = "Fastify";
+  } else if (/from\s+['"]vue['"]|defineComponent/i.test(content)) {
+    summary.framework = "Vue";
+  }
+  const exportMatches = content.match(/export\s+(const|function|class|interface|type)\s+(\w+)/g) || [];
+  summary.exports = exportMatches.map((m) => m.split(/\s+/).pop() || "").filter(Boolean).slice(0, 10);
+  const importMatches = content.match(/import\s+.*from\s+['"]([^'"]+)['"]/g) || [];
+  summary.imports = importMatches.map((m) => {
+    const match = m.match(/from\s+['"]([^'"]+)['"]/);
+    return match ? match[1] : "";
+  }).filter((s) => Boolean(s)).slice(0, 10);
+  return summary;
+}
+function buildPromptContext(contexts, agent) {
+  let contextSummary = "";
+  const hasAuth = contexts.some((c) => c.summary?.hasAuth);
+  const hasDatabase = contexts.some((c) => c.summary?.hasDatabase);
+  const hasUserInput = contexts.some((c) => c.summary?.hasUserInput);
+  const hasFileOps = contexts.some((c) => c.summary?.hasFileOps);
+  const hasCrypto = contexts.some((c) => c.summary?.hasCrypto);
+  const hasExternalAPIs = contexts.some((c) => c.summary?.hasExternalAPIs);
+  const frameworks = [...new Set(contexts.map((c) => c.summary?.framework).filter(Boolean))];
+  contextSummary += "## Code Context Summary\n\n";
+  contextSummary += `**Files analyzed:** ${contexts.length}
+`;
+  contextSummary += `**Total lines:** ${contexts.reduce((sum, c) => sum + c.lineCount, 0)}
+`;
+  if (frameworks.length > 0) {
+    contextSummary += `**Frameworks detected:** ${frameworks.join(", ")}
+`;
+  }
+  const features = [];
+  if (hasAuth) features.push("Authentication/Authorization");
+  if (hasDatabase) features.push("Database operations");
+  if (hasUserInput) features.push("User input handling");
+  if (hasFileOps) features.push("File operations");
+  if (hasCrypto) features.push("Cryptography");
+  if (hasExternalAPIs) features.push("External API calls");
+  if (features.length > 0) {
+    contextSummary += `**Key features:** ${features.join(", ")}
+`;
+  }
+  contextSummary += "\n";
+  if (agent === "security") {
+    if (hasAuth) contextSummary += "\u26A0\uFE0F **Auth code detected** - Review authentication flows carefully\n";
+    if (hasDatabase) contextSummary += "\u26A0\uFE0F **Database ops detected** - Check for injection vulnerabilities\n";
+    if (hasUserInput) contextSummary += "\u26A0\uFE0F **User input detected** - Verify input validation\n";
+  } else if (agent === "privacy") {
+    if (hasAuth) contextSummary += "\u26A0\uFE0F **Auth code detected** - Review credential handling\n";
+    if (hasDatabase) contextSummary += "\u26A0\uFE0F **Database ops detected** - Check PII storage\n";
+  } else if (agent === "bugs") {
+    if (hasExternalAPIs) contextSummary += "\u26A0\uFE0F **External APIs detected** - Check error handling\n";
+    if (hasFileOps) contextSummary += "\u26A0\uFE0F **File ops detected** - Verify error handling and cleanup\n";
+  }
+  return contextSummary;
+}
+async function buildAnalysis(request) {
+  const { agent, files, context = {}, depth = "standard" } = request;
+  const codeContexts = [];
+  console.error(`\u{1F52C} AI Engine: Preparing ${agent} analysis for ${files.length} files...`);
+  for (const filePath of files) {
+    try {
+      const content = await readFile3(filePath, "utf-8");
+      const language = detectLanguage(filePath);
+      const summary = analyzeFileContext(content, filePath);
+      console.error(`   \u{1F4C4} ${basename3(filePath)} - ${content.split("\n").length} lines`);
+      codeContexts.push({
+        filePath,
+        relativePath: relative3(process.cwd(), filePath),
+        language,
+        content: depth === "quick" && content.length > 5e3 ? content.substring(0, 5e3) + "\n\n... (truncated for quick analysis)" : content,
+        lineCount: content.split("\n").length,
+        summary
+      });
+    } catch (error) {
+      console.error(`   \u26A0\uFE0F Error reading ${filePath}:`, error);
+    }
+  }
+  const codeBlocks = codeContexts.map(
+    (ctx) => `### File: ${ctx.relativePath}
+\`\`\`${ctx.language}
+${ctx.content}
+\`\`\``
+  ).join("\n\n");
+  const promptContext = buildPromptContext(codeContexts, agent);
+  const variables = {
+    ...context,
+    code: codeBlocks,
+    language: codeContexts[0]?.language || "unknown",
+    filePath: codeContexts.map((c) => c.relativePath).join(", ")
+  };
+  const analysisPrompt = getPrompt(agent, "analysis", variables);
+  const systemPrompt = getSystemPrompt(agent);
+  const suggestedFollowUps = [];
+  if (codeContexts.some((c) => c.summary?.hasAuth)) {
+    suggestedFollowUps.push("\u{1F510} Review authentication implementation");
+  }
+  if (codeContexts.some((c) => c.summary?.hasDatabase)) {
+    suggestedFollowUps.push("\u{1F5C4}\uFE0F Check database query security");
+  }
+  if (codeContexts.some((c) => c.summary?.hasUserInput)) {
+    suggestedFollowUps.push("\u{1F4DD} Verify input validation");
+  }
+  const filesSummary = codeContexts.map((c) => {
+    const features = [];
+    if (c.summary?.hasAuth) features.push("auth");
+    if (c.summary?.hasDatabase) features.push("db");
+    if (c.summary?.hasUserInput) features.push("input");
+    if (c.summary?.framework) features.push(c.summary.framework);
+    const featureStr = features.length > 0 ? ` [${features.join(", ")}]` : "";
+    return `\`${c.relativePath}\` (${c.lineCount} lines)${featureStr}`;
+  }).join("\n");
+  console.error(`\u{1F9E0} AI Engine: Analysis prepared - ready for Claude`);
+  return {
+    agent,
+    systemPrompt,
+    prompt: promptContext + "\n" + analysisPrompt,
+    codeContext: codeContexts,
+    suggestedFollowUps,
+    filesSummary
+  };
+}
+function formatAnalysisResponse(result, options = {}) {
+  const { agent, systemPrompt, prompt, codeContext, suggestedFollowUps, filesSummary } = result;
+  const includePrompt = options.includePrompt ?? true;
+  let output = "";
+  output += `
+${"\u2501".repeat(60)}
+`;
+  output += `\u{1F9E0} ${agent.toUpperCase()} AGENT - AI ANALYSIS
+`;
+  output += `${"\u2501".repeat(60)}
+
+`;
+  output += `## \u{1F4C2} Files for Analysis
+
+`;
+  output += filesSummary + "\n\n";
+  if (suggestedFollowUps.length > 0) {
+    output += `## \u{1F3AF} Focus Areas
+
+`;
+    for (const followUp of suggestedFollowUps) {
+      output += `- ${followUp}
+`;
+    }
+    output += "\n";
+  }
+  output += `${"\u2500".repeat(60)}
+`;
+  output += `## \u{1F9E0} Analysis Request for Claude
+
+`;
+  if (includePrompt) {
+    output += `**Role:** ${systemPrompt.split("\n")[0]}
+
+`;
+    output += `---
+
+`;
+    output += prompt;
+    output += `
+
+${"\u2500".repeat(60)}
+`;
+  } else {
+    output += `*Run with \`output: "full"\` to see the complete analysis prompt.*
+
+`;
+    output += `**Summary:** ${codeContext.length} files ready for ${agent} analysis
+`;
+  }
+  output += `
+**Claude:** Please analyze the code above according to the ${agent} analysis instructions and provide your findings.
+`;
+  return output;
+}
+
+// src/knowledge/index.ts
+var SECURITY_SOURCES = [
+  {
+    name: "OWASP Top 10",
+    url: "https://owasp.org/Top10/",
+    description: "Most critical web application security risks"
+  },
+  {
+    name: "NIST NVD",
+    url: "https://nvd.nist.gov/",
+    description: "National Vulnerability Database"
+  },
+  {
+    name: "CVE Database",
+    url: "https://cve.mitre.org/",
+    description: "Common Vulnerabilities and Exposures"
+  },
+  {
+    name: "Snyk Vulnerability DB",
+    url: "https://security.snyk.io/",
+    description: "Open source vulnerability database"
+  },
+  {
+    name: "GitHub Advisory Database",
+    url: "https://github.com/advisories",
+    description: "Security advisories from GitHub"
+  }
+];
+var DOCS_SOURCES = {
+  react: [
+    { name: "React Docs", url: "https://react.dev/", description: "Official React documentation" },
+    { name: "React Security", url: "https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html", description: "React security guidance" }
+  ],
+  nextjs: [
+    { name: "Next.js Docs", url: "https://nextjs.org/docs", description: "Official Next.js documentation" },
+    { name: "Next.js Security", url: "https://nextjs.org/docs/advanced-features/security-headers", description: "Next.js security headers" }
+  ],
+  express: [
+    { name: "Express Docs", url: "https://expressjs.com/", description: "Official Express.js documentation" },
+    { name: "Express Security", url: "https://expressjs.com/en/advanced/best-practice-security.html", description: "Express security best practices" }
+  ],
+  node: [
+    { name: "Node.js Docs", url: "https://nodejs.org/docs/", description: "Official Node.js documentation" },
+    { name: "Node.js Security", url: "https://nodejs.org/en/docs/guides/security/", description: "Node.js security guidance" }
+  ],
+  typescript: [
+    { name: "TypeScript Docs", url: "https://www.typescriptlang.org/docs/", description: "Official TypeScript documentation" }
+  ]
+};
+var COMPLIANCE_SOURCES = {
+  gdpr: [
+    { name: "GDPR Official Text", url: "https://gdpr.eu/", description: "Complete GDPR regulation text" },
+    { name: "GDPR Checklist", url: "https://gdpr.eu/checklist/", description: "GDPR compliance checklist" }
+  ],
+  hipaa: [
+    { name: "HIPAA Guidelines", url: "https://www.hhs.gov/hipaa/", description: "Official HIPAA guidance" }
+  ],
+  wcag: [
+    { name: "WCAG 2.1", url: "https://www.w3.org/WAI/WCAG21/quickref/", description: "WCAG 2.1 quick reference" }
+  ],
+  pci: [
+    { name: "PCI DSS", url: "https://www.pcisecuritystandards.org/", description: "Payment Card Industry standards" }
+  ]
+};
+function generateCVELookup(library, version) {
+  let prompt = `## \u{1F512} Security Vulnerability Lookup
+
+`;
+  prompt += `**Library:** ${library}
+`;
+  if (version) prompt += `**Version:** ${version}
+`;
+  prompt += `
+`;
+  prompt += `### Action Required
+
+`;
+  prompt += `Please check for known vulnerabilities:
+
+`;
+  prompt += `1. Search the **NIST NVD** (https://nvd.nist.gov/) for CVEs affecting \`${library}\`
+`;
+  prompt += `2. Check **Snyk** (https://security.snyk.io/) for vulnerability reports
+`;
+  prompt += `3. Review **GitHub Advisory Database** for any security advisories
+`;
+  prompt += `4. Check npm audit / yarn audit if it's an npm package
+
+`;
+  prompt += `### Report Format
+
+`;
+  prompt += `For each vulnerability found, provide:
+`;
+  prompt += `- CVE ID (if applicable)
+`;
+  prompt += `- Severity (Critical/High/Medium/Low)
+`;
+  prompt += `- Affected versions
+`;
+  prompt += `- Description of the vulnerability
+`;
+  prompt += `- Remediation (upgrade version, patches, mitigations)
+`;
+  return prompt;
+}
+function generateDocsLookup(topic, framework) {
+  let prompt = `## \u{1F4DA} Documentation Lookup
+
+`;
+  prompt += `**Topic:** ${topic}
+`;
+  if (framework) prompt += `**Framework:** ${framework}
+`;
+  prompt += `
+`;
+  const sources = framework ? DOCS_SOURCES[framework.toLowerCase()] : [];
+  if (sources && sources.length > 0) {
+    prompt += `### Recommended Sources
+
+`;
+    for (const source of sources) {
+      prompt += `- [${source.name}](${source.url}) - ${source.description}
+`;
+    }
+    prompt += `
+`;
+  }
+  prompt += `### Information Needed
+
+`;
+  prompt += `Please look up the latest documentation and provide:
+
+`;
+  prompt += `1. Current best practices for "${topic}"
+`;
+  prompt += `2. Common pitfalls to avoid
+`;
+  prompt += `3. Code examples demonstrating correct usage
+`;
+  prompt += `4. Any recent changes or deprecations
+`;
+  return prompt;
+}
+function generateSecurityLookup(pattern, context) {
+  let prompt = `## \u{1F6E1}\uFE0F Security Best Practices Lookup
+
+`;
+  prompt += `**Pattern:** ${pattern}
+`;
+  if (context) prompt += `**Context:** ${context}
+`;
+  prompt += `
+`;
+  prompt += `### Reference Sources
+
+`;
+  for (const source of SECURITY_SOURCES.slice(0, 3)) {
+    prompt += `- [${source.name}](${source.url})
+`;
+  }
+  prompt += `
+`;
+  prompt += `### Analysis Requested
+
+`;
+  prompt += `Please research and provide:
+
+`;
+  prompt += `1. **OWASP guidance** for this security pattern
+`;
+  prompt += `2. **Attack vectors** - how this could be exploited
+`;
+  prompt += `3. **Defense strategies** - recommended mitigations
+`;
+  prompt += `4. **Code examples** - secure implementation patterns
+`;
+  prompt += `5. **Testing approaches** - how to verify security
+`;
+  return prompt;
+}
+function generateComplianceLookup(regulation, requirement) {
+  let prompt = `## \u2696\uFE0F Compliance Requirement Lookup
+
+`;
+  prompt += `**Regulation:** ${regulation}
+`;
+  if (requirement) prompt += `**Specific Requirement:** ${requirement}
+`;
+  prompt += `
+`;
+  const sources = COMPLIANCE_SOURCES[regulation.toLowerCase()];
+  if (sources && sources.length > 0) {
+    prompt += `### Official Sources
+
+`;
+    for (const source of sources) {
+      prompt += `- [${source.name}](${source.url})
+`;
+    }
+    prompt += `
+`;
+  }
+  prompt += `### Compliance Information Needed
+
+`;
+  prompt += `Please research and provide:
+
+`;
+  prompt += `1. **Specific requirement text** from the regulation
+`;
+  prompt += `2. **Technical requirements** for compliance
+`;
+  prompt += `3. **Implementation guidance** with code examples
+`;
+  prompt += `4. **Documentation requirements** - what records to keep
+`;
+  prompt += `5. **Penalties** for non-compliance
+`;
+  return prompt;
+}
+function generateChangelogLookup(library, fromVersion, toVersion) {
+  let prompt = `## \u{1F4CB} Changelog Lookup
+
+`;
+  prompt += `**Library:** ${library}
+`;
+  prompt += `**Current Version:** ${fromVersion}
+`;
+  if (toVersion) prompt += `**Target Version:** ${toVersion}
+`;
+  prompt += `
+`;
+  prompt += `### Information Needed
+
+`;
+  prompt += `Please find the changelog/release notes and provide:
+
+`;
+  prompt += `1. **Breaking changes** between versions
+`;
+  prompt += `2. **New features** added
+`;
+  prompt += `3. **Deprecations** to be aware of
+`;
+  prompt += `4. **Security fixes** included
+`;
+  prompt += `5. **Migration guide** if available
+`;
+  prompt += `6. **Known issues** with the upgrade
+`;
+  return prompt;
+}
+function lookupKnowledge(request) {
+  const { type, query, context = {} } = request;
+  switch (type) {
+    case "cve":
+      return generateCVELookup(query, context.version);
+    case "docs":
+      return generateDocsLookup(query, context.framework);
+    case "security":
+      return generateSecurityLookup(query, context.context);
+    case "best-practices":
+      return generateComplianceLookup(query, context.requirement);
+    case "changelog":
+      return generateChangelogLookup(query, context.fromVersion || "current", context.toVersion);
+    default:
+      return `Unknown knowledge request type: ${type}`;
+  }
+}
+
+// src/tools/agent.ts
+var SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".py",
+  ".go",
+  ".rs"
+]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  ".pytest_cache",
+  "vendor",
+  ".venv",
+  "venv",
+  "target",
+  ".turbo",
+  ".cache"
+]);
+var AGENT_TO_AI_TYPE = {
+  "security": "security",
+  "privacy": "privacy",
+  "legal": "legal",
+  "design-engineer": "accessibility",
+  "software-architect": "architecture",
+  "bug-finding": "bugs",
+  "user-testing": "ux",
+  "typecheck": "types",
+  "devops": "devops",
+  "comprehension": "explain",
+  "test": "test",
+  "trie_clean": "vibe"
+};
+var TrieAgentTool = class {
+  agentRegistry = new AgentRegistry();
+  async execute(args) {
+    const { agent, files, directory, depth = "standard", lookup, output = "full" } = args;
+    if (lookup) {
+      return this.handleKnowledgeLookup(lookup);
+    }
+    if (!agent) {
+      return this.listAgents();
+    }
+    const agentInstance = this.agentRegistry.getAgent(agent);
+    if (!agentInstance) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C Agent not found: ${agent}
+
+Available agents:
+${this.agentRegistry.getAgentNames().map((n) => `- ${n}`).join("\n")}`
+        }]
+      };
+    }
+    let filesToScan = files || [];
+    if (!filesToScan.length) {
+      const scanDir = directory || process.cwd();
+      console.error(`
+\u{1F50D} Discovering files in: ${scanDir}`);
+      filesToScan = await this.discoverFiles(scanDir);
+      console.error(`   Found ${filesToScan.length} files
+`);
+    } else {
+      filesToScan = filesToScan.map(
+        (f) => isAbsolute3(f) ? f : resolve3(process.cwd(), f)
+      );
+    }
+    const validFiles = filesToScan.filter((f) => existsSync4(f));
+    if (validFiles.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C No valid files found to scan.`
+        }]
+      };
+    }
+    const startTime = Date.now();
+    const aiAgentType = AGENT_TO_AI_TYPE[agent];
+    if (aiAgentType) {
+      return this.runAIAnalysis(
+        aiAgentType,
+        validFiles,
+        agentInstance.name,
+        agentInstance.description,
+        depth,
+        output
+      );
+    } else {
+      return this.runStaticAnalysis(agentInstance, validFiles, startTime);
+    }
+  }
+  async runAIAnalysis(agentType, files, agentName, agentDescription, depth, outputMode) {
+    const startTime = Date.now();
+    console.error(`
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.error(`\u{1F9E0} Running AI-POWERED ${agentName.toUpperCase()} analysis`);
+    console.error(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+`);
+    console.error(`\u{1F4C4} ${agentDescription}`);
+    console.error(`\u{1F4C2} Analyzing ${files.length} files (${depth} depth)...
+`);
+    try {
+      const analysis = await buildAnalysis({
+        agent: agentType,
+        files,
+        depth
+      });
+      const executionTime = Date.now() - startTime;
+      const includePrompt = outputMode === "full";
+      let output = formatAnalysisResponse(analysis, { includePrompt });
+      if (analysis.suggestedFollowUps.length > 0) {
+        output += this.generateKnowledgeSuggestions(analysis.suggestedFollowUps, agentType);
+      }
+      output += `
+*Analysis completed in ${(executionTime / 1e3).toFixed(2)}s*
+`;
+      return {
+        content: [{
+          type: "text",
+          text: output
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C Analysis error: ${error instanceof Error ? error.message : String(error)}`
+        }]
+      };
+    }
+  }
+  async runStaticAnalysis(agentInstance, files, startTime) {
+    console.error(`
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.error(`\u{1F50D} Running ${agentInstance.name.toUpperCase()} static analysis`);
+    console.error(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+`);
+    console.error(`\u{1F4C4} ${agentInstance.description}`);
+    console.error(`\u{1F4C2} Scanning ${files.length} files...
+`);
+    try {
+      const result = await agentInstance.scan(files, { workingDir: process.cwd() });
+      const executionTime = Date.now() - startTime;
+      return {
+        content: [{
+          type: "text",
+          text: await this.formatStaticResult(agentInstance.name, result.issues, files, executionTime)
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C Agent error: ${error instanceof Error ? error.message : String(error)}`
+        }]
+      };
+    }
+  }
+  generateKnowledgeSuggestions(followUps, agentType) {
+    if (followUps.length === 0) {
+      return "";
+    }
+    let output = `
+## \u{1F517} Suggested Follow-ups
+
+`;
+    for (const followUp of followUps) {
+      output += `- ${followUp}
+`;
+    }
+    if (agentType === "security") {
+      output += `- **CVE Check**: Run \`trie_security lookup:"cve" query:"[library-name]"\` to check for vulnerabilities
+`;
+    }
+    return output;
+  }
+  handleKnowledgeLookup(lookup) {
+    const result = lookupKnowledge({
+      type: lookup.type,
+      query: lookup.query,
+      context: lookup.context ?? {}
+    });
+    return {
+      content: [{
+        type: "text",
+        text: result
+      }]
+    };
+  }
+  listAgents() {
+    const agents = this.agentRegistry.getAgentDescriptions();
+    const agentList = agents.map((a) => {
+      const command = this.getAgentCommand(a.name);
+      const aiPowered = AGENT_TO_AI_TYPE[a.name] ? "\u{1F9E0}" : "\u{1F50D}";
+      return `| \`${command}\` | ${aiPowered} ${a.name} | ${a.description} |`;
+    }).join("\n");
+    return {
+      content: [{
+        type: "text",
+        text: `# \u{1F916} Available Agents
+
+| Command | Agent | Description |
+|---------|-------|-------------|
+${agentList}
+
+**Legend:** \u{1F9E0} = AI-powered deep analysis, \u{1F50D} = Static pattern matching
+
+## Usage
+
+### Run a specific agent:
+\`\`\`
+trie_security                    # Security vulnerabilities
+trie_privacy                     # Privacy/GDPR compliance  
+trie_accessibility               # WCAG accessibility audit
+trie_bugs                        # Bug detection
+trie_ux                          # User experience testing
+trie_types                       # Type safety analysis
+trie_architecture                # Architecture review
+trie_devops                      # DevOps readiness
+trie_legal                       # Legal compliance
+\`\`\`
+
+### With options:
+\`\`\`
+trie_security files:["src/auth.ts"] depth:"deep"
+\`\`\`
+
+### Knowledge lookup:
+\`\`\`
+trie_security lookup:{type:"cve", query:"lodash"}
+trie_security lookup:{type:"docs", query:"XSS prevention", context:{framework:"react"}}
+\`\`\`
+
+### Run all agents:
+\`\`\`
+trie_scan                        # Full scan with smart triaging
+\`\`\``
+      }]
+    };
+  }
+  getAgentCommand(agentName) {
+    const commandMap = {
+      "security": "trie_security",
+      "privacy": "trie_privacy",
+      "legal": "trie_legal",
+      "design-engineer": "trie_accessibility",
+      "software-architect": "trie_architecture",
+      "bug-finding": "trie_bugs",
+      "user-testing": "trie_ux",
+      "typecheck": "trie_types",
+      "devops": "trie_devops",
+      "comprehension": "trie_explain",
+      "test": "trie_test"
+    };
+    return commandMap[agentName] || `trie_scan --agent ${agentName}`;
+  }
+  async formatStaticResult(agentName, issues, files, executionTime) {
+    const critical = issues.filter((i) => i.severity === "critical").length;
+    const serious = issues.filter((i) => i.severity === "serious").length;
+    const moderate = issues.filter((i) => i.severity === "moderate").length;
+    const low = issues.filter((i) => i.severity === "low").length;
+    const agentEmoji = this.getAgentEmoji(agentName);
+    let output = `
+`;
+    output += `# ${agentEmoji} ${agentName.toUpperCase()} SCAN
+
+`;
+    output += `**Files:** ${files.length} | **Time:** ${(executionTime / 1e3).toFixed(2)}s
+
+`;
+    if (issues.length === 0) {
+      output += `## \u2705 No Issues Found
+
+`;
+      output += `Your code passed all ${agentName} checks.
+
+`;
+      return output;
+    }
+    output += `## \u{1F3AF} ${issues.length} Issues Found
+
+`;
+    if (critical > 0) output += `\u{1F534} ${critical} Critical `;
+    if (serious > 0) output += `\u{1F7E0} ${serious} Serious `;
+    if (moderate > 0) output += `\u{1F7E1} ${moderate} Moderate `;
+    if (low > 0) output += `\u{1F535} ${low} Low`;
+    output += `
+
+`;
+    const sorted = [...issues].sort((a, b) => {
+      const severityOrder = { critical: 0, serious: 1, moderate: 2, low: 3 };
+      if (severityOrder[a.severity] !== severityOrder[b.severity]) {
+        return severityOrder[a.severity] - severityOrder[b.severity];
+      }
+      return (a.line || 0) - (b.line || 0);
+    });
+    for (const issue of sorted) {
+      const icon = { critical: "\u{1F534}", serious: "\u{1F7E0}", moderate: "\u{1F7E1}", low: "\u{1F535}" }[issue.severity];
+      output += `---
+
+`;
+      output += `${icon} **${issue.issue}**
+
+`;
+      output += `\u{1F4CD} \`${issue.file}:${issue.line || "?"}\`
+
+`;
+      const snippet = await this.getCodeSnippet(issue.file, issue.line);
+      if (snippet) {
+        output += `\`\`\`
+${snippet}
+\`\`\`
+
+`;
+      }
+      output += `**Fix:** ${issue.fix}
+
+`;
+      if (issue.cwe) output += `CWE: ${issue.cwe}
+`;
+      if (issue.regulation) output += `Regulation: ${issue.regulation}
+`;
+      output += `<details>
+<summary>\u{1F4AC} Prompt to fix this</summary>
+
+`;
+      output += `\`\`\`
+Fix the ${issue.issue.toLowerCase()} in ${basename4(issue.file)}${issue.line ? ` at line ${issue.line}` : ""}.
+
+${issue.fix}
+\`\`\`
+
+`;
+      output += `</details>
+
+`;
+    }
+    output += `---
+`;
+    output += `*${agentName} scan completed in ${(executionTime / 1e3).toFixed(2)}s*
+`;
+    return output;
+  }
+  /**
+   * Get a code snippet around a specific line
+   */
+  async getCodeSnippet(filePath, line) {
+    if (!line || !existsSync4(filePath)) return null;
+    try {
+      const content = await readFile4(filePath, "utf-8");
+      const lines = content.split("\n");
+      const start = Math.max(0, line - 3);
+      const end = Math.min(lines.length, line + 2);
+      return lines.slice(start, end).map((l, idx) => {
+        const lineNum = start + idx + 1;
+        const marker = lineNum === line ? "\u2192" : " ";
+        return `${marker} ${lineNum.toString().padStart(4)} | ${l}`;
+      }).join("\n");
+    } catch {
+      return null;
+    }
+  }
+  getAgentEmoji(agentName) {
+    const emojis = {
+      "security": "\u{1F512}",
+      "privacy": "\u{1F464}",
+      "legal": "\u2696\uFE0F",
+      "design-engineer": "\u267F",
+      "software-architect": "\u{1F3D7}\uFE0F",
+      "bug-finding": "\u{1F41B}",
+      "user-testing": "\u{1F3AF}",
+      "typecheck": "\u{1F4DD}",
+      "devops": "\u2699\uFE0F",
+      "comprehension": "\u{1F4D6}",
+      "test": "\u{1F9EA}"
+    };
+    return emojis[agentName] || "\u{1F916}";
+  }
+  async discoverFiles(dir, maxFiles = 200) {
+    const files = [];
+    async function walk(currentDir) {
+      if (files.length >= maxFiles) return;
+      try {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (files.length >= maxFiles) break;
+          const fullPath = join3(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            if (!SKIP_DIRS2.has(entry.name) && !entry.name.startsWith(".")) {
+              await walk(fullPath);
+            }
+          } else if (entry.isFile()) {
+            const ext = extname5(entry.name).toLowerCase();
+            if (SCANNABLE_EXTENSIONS.has(ext)) {
+              files.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+      }
+    }
+    await walk(dir);
+    return files;
+  }
+};
+
+// src/tools/create-agent.ts
+import { existsSync as existsSync5 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join as join4, basename as basename5, extname as extname6 } from "path";
+var TrieCreateAgentTool = class {
+  async execute(args) {
+    const { filePath, documentContent, agentName, displayName, description, category } = args;
+    if (!agentName) {
+      return this.errorResponse("Missing required parameter: agentName");
+    }
+    if (!filePath && !documentContent) {
+      return this.errorResponse(
+        "Provide either filePath (path to PDF/TXT/MD file) or documentContent (raw text from drag-and-drop)"
+      );
+    }
+    try {
+      let rawText;
+      let title = agentName;
+      let wordCount = 0;
+      if (filePath) {
+        if (!existsSync5(filePath)) {
+          return this.errorResponse(`File not found: ${filePath}`);
+        }
+        const ext = filePath.toLowerCase().split(".").pop();
+        if (!["pdf", "txt", "md", "markdown", "rtf"].includes(ext || "")) {
+          return this.errorResponse(
+            `Unsupported file type: .${ext}
+Supported types: .pdf, .txt, .md, .rtf`
+          );
+        }
+        const document = await parseDocument(filePath);
+        rawText = document.rawText;
+        title = document.metadata.title || basename5(filePath, extname6(filePath));
+        wordCount = document.metadata.wordCount;
+      } else {
+        rawText = documentContent;
+        wordCount = rawText.split(/\s+/).filter((w) => w.length > 0).length;
+        const firstLine = rawText.split("\n")[0]?.trim();
+        if (firstLine && firstLine.length < 100) {
+          title = firstLine;
+        }
+      }
+      const chunks = this.chunkText(rawText, 6e3);
+      const extractionPrompt = this.buildExtractionPrompt(
+        chunks,
+        title,
+        agentName,
+        category,
+        displayName,
+        description
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: this.formatExtractionRequest(
+              agentName,
+              title,
+              wordCount,
+              chunks.length,
+              extractionPrompt
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return this.errorResponse(`Failed to parse document: ${errorMessage}`);
+    }
+  }
+  /**
+   * Chunk text into manageable pieces
+   */
+  chunkText(text, maxChunkSize) {
+    if (text.length <= maxChunkSize) {
+      return [text];
+    }
+    const chunks = [];
+    const paragraphs = text.split(/\n\s*\n/);
+    let currentChunk = "";
+    for (const para of paragraphs) {
+      if (currentChunk.length + para.length + 2 > maxChunkSize) {
+        if (currentChunk) chunks.push(currentChunk.trim());
+        currentChunk = para;
+      } else {
+        currentChunk += (currentChunk ? "\n\n" : "") + para;
+      }
+    }
+    if (currentChunk) chunks.push(currentChunk.trim());
+    return chunks;
+  }
+  /**
+   * Build the extraction prompt for Claude
+   */
+  buildExtractionPrompt(chunks, title, agentName, category, displayName, description) {
+    const prefix = agentName.toUpperCase().replace(/[^A-Z]/g, "").slice(0, 4) || "CUST";
+    const documentContent = chunks.length === 1 ? chunks[0] : chunks.map((c, i) => `--- SECTION ${i + 1}/${chunks.length} ---
+${c}`).join("\n\n");
+    return `# Create Code Review Agent: "${displayName || this.formatDisplayName(agentName)}"
+
+## Your Task
+Analyze the following document and extract structured knowledge to create a code review agent.
+
+## Document Information
+- **Title**: ${title}
+- **Agent Name**: ${agentName}
+- **Category**: ${category || "auto-detect"}
+${description ? `- **Description**: ${description}` : ""}
+
+## Document Content
+${documentContent}
+
+---
+
+## Instructions
+
+Please analyze this document and produce a **single JSON object** with the following structure. This will be used to create a custom code review agent.
+
+**IMPORTANT**: Your response should be ONLY the JSON object, no other text.
+
+\`\`\`json
+{
+  "agentConfig": {
+    "name": "${this.sanitizeAgentName(agentName)}",
+    "displayName": "${displayName || this.formatDisplayName(agentName)}",
+    "description": "${description || `Code review agent based on ${title}`}",
+    "version": "1.0.0",
+    "category": "string (technical | legal | policy | security | architecture | general)"
+  },
+  "knowledge": {
+    "domain": "string (technical | legal | policy | security | architecture | general)",
+    "summary": "2-3 paragraph summary of the document's key insights for code review",
+    "coreConcepts": [
+      {
+        "name": "string",
+        "description": "string",
+        "importance": "critical | important | supplementary",
+        "keywords": ["string"]
+      }
+    ],
+    "bestPractices": [
+      {
+        "name": "string",
+        "description": "string",
+        "rationale": "why this is important",
+        "codeExample": "optional code example or null"
+      }
+    ],
+    "antiPatterns": [
+      {
+        "name": "string",
+        "description": "string",
+        "whyBad": "why to avoid",
+        "betterAlternative": "what to do instead"
+      }
+    ],
+    "glossary": {
+      "term": "definition"
+    }
+  },
+  "detectionRules": [
+    {
+      "id": "${prefix}-001",
+      "name": "Rule Name",
+      "description": "What this rule detects",
+      "severity": "critical | serious | moderate | low | info",
+      "patterns": {
+        "regex": ["JavaScript regex patterns"],
+        "keywords": ["words that indicate this issue"],
+        "semantic": "Natural language description for AI detection"
+      },
+      "fix": {
+        "description": "How to fix this issue",
+        "example": "Code example or null",
+        "autoFixable": false
+      },
+      "category": "string"
+    }
+  ],
+  "prompts": {
+    "systemPrompt": "You are an expert code reviewer specializing in [topic]. Your role is to...",
+    "analysisPrompt": "Review this code for issues related to [topic]. Look for: ...\\n\\nCode:\\n\\\`\\\`\\\`{{language}}\\n{{code}}\\n\\\`\\\`\\\`\\n\\nFile: {{filePath}}",
+    "fixPrompt": "Fix this issue: {{issue}}\\n\\nCode:\\n\\\`\\\`\\\`{{language}}\\n{{code}}\\n\\\`\\\`\\\`"
+  }
+}
+\`\`\`
+
+## Guidelines
+
+1. **Core Concepts**: Extract 10-20 key concepts that are fundamental to the material
+2. **Best Practices**: Extract 10-15 recommended approaches with rationale
+3. **Anti-Patterns**: Extract 10-15 things to avoid with explanations
+4. **Detection Rules**: Generate 15-30 rules with regex patterns that could detect issues in code
+5. **Prompts**: Create prompts that embody the expertise from this document
+
+Focus on extracting actionable, code-reviewable knowledge. The agent should be able to find violations of the principles in this document.
+
+**Output ONLY the JSON object, starting with \`{\` and ending with \`}\`.**`;
+  }
+  /**
+   * Format the extraction request output
+   */
+  formatExtractionRequest(agentName, title, wordCount, chunkCount, prompt) {
+    return `
+\u{1F4DA} **Document Parsed Successfully!**
+
+${"\u2501".repeat(50)}
+
+**Creating Agent:** \`${agentName}\`
+**Source Document:** ${title}
+**Word Count:** ${wordCount.toLocaleString()}
+**Processing Chunks:** ${chunkCount}
+
+${"\u2501".repeat(50)}
+
+## Next Step
+
+I've prepared the document for analysis. Please process the following prompt to extract the knowledge, then pass the result to \`trie_save_agent\` to save the agent.
+
+${"\u2500".repeat(50)}
+
+${prompt}
+`;
+  }
+  sanitizeAgentName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  formatDisplayName(name) {
+    return name.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  errorResponse(message) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C **Error:** ${message}`
+        }
+      ],
+      isError: true
+    };
+  }
+};
+var TrieSaveAgentTool = class {
+  async execute(args) {
+    const { agentConfig, knowledge, detectionRules, prompts, sourceFile } = args;
+    if (!agentConfig?.name) {
+      return this.errorResponse("Missing agentConfig.name");
+    }
+    if (!knowledge?.summary) {
+      return this.errorResponse("Missing knowledge.summary");
+    }
+    if (!prompts?.systemPrompt) {
+      return this.errorResponse("Missing prompts.systemPrompt");
+    }
+    try {
+      const fullConfig = {
+        name: this.sanitizeAgentName(agentConfig.name),
+        displayName: agentConfig.displayName || this.formatDisplayName(agentConfig.name),
+        description: agentConfig.description,
+        version: agentConfig.version || "1.0.0",
+        category: agentConfig.category || knowledge.domain || "general",
+        source: {
+          type: "document",
+          originalFile: sourceFile || "user-provided",
+          fileType: "txt",
+          compressedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        systemPrompt: prompts.systemPrompt,
+        analysisPrompt: prompts.analysisPrompt,
+        fixPrompt: prompts.fixPrompt,
+        activationRules: this.buildActivationRules(knowledge, detectionRules),
+        patterns: detectionRules.map((rule, i) => {
+          const fixObj = {
+            description: rule.fix?.description || "Review and fix manually",
+            autoFixable: rule.fix?.autoFixable || false
+          };
+          if (rule.fix?.example) {
+            fixObj.example = rule.fix.example;
+          }
+          return {
+            id: rule.id || `CUST-${String(i + 1).padStart(3, "0")}`,
+            name: rule.name,
+            description: rule.description,
+            severity: rule.severity || "moderate",
+            patterns: {
+              regex: rule.patterns?.regex || [],
+              keywords: rule.patterns?.keywords || [],
+              semantic: rule.patterns?.semantic || ""
+            },
+            fix: fixObj,
+            category: rule.category || agentConfig.category
+          };
+        }),
+        knowledge: {
+          domain: knowledge.domain || "general",
+          summary: knowledge.summary,
+          coreConcepts: knowledge.coreConcepts.map((c) => ({
+            name: c.name,
+            description: c.description,
+            importance: c.importance || "important",
+            relatedPatterns: c.relatedPatterns || [],
+            keywords: c.keywords || []
+          })),
+          bestPractices: knowledge.bestPractices.map((bp) => {
+            const practice = {
+              name: bp.name,
+              description: bp.description,
+              rationale: bp.rationale,
+              category: bp.category || agentConfig.category
+            };
+            if (bp.codeExample) {
+              practice.codeExample = bp.codeExample;
+            }
+            return practice;
+          }),
+          antiPatterns: knowledge.antiPatterns.map((ap) => ({
+            name: ap.name,
+            description: ap.description,
+            whyBad: ap.whyBad,
+            betterAlternative: ap.betterAlternative
+          })),
+          detectionRules: [],
+          glossary: knowledge.glossary || {},
+          sourceDocument: {
+            title: agentConfig.displayName || agentConfig.name,
+            wordCount: 0,
+            compressionRatio: 0
+          }
+        }
+      };
+      const configPath = await this.saveAgentConfig(fullConfig);
+      return {
+        content: [
+          {
+            type: "text",
+            text: this.formatSuccessResponse(fullConfig, configPath)
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return this.errorResponse(`Failed to save agent: ${errorMessage}`);
+    }
+  }
+  buildActivationRules(knowledge, detectionRules) {
+    const domainRules = {
+      technical: {
+        filePatterns: ["*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.go", "*.rs"],
+        contextSignals: ["touchesUI", "touchesAPI"],
+        priority: 2
+      },
+      legal: {
+        filePatterns: ["*"],
+        contextSignals: ["touchesUserData", "touchesAuth", "touchesPayments"],
+        priority: 2
+      },
+      policy: {
+        filePatterns: ["*"],
+        contextSignals: ["touchesAuth", "touchesAPI", "touchesDatabase"],
+        priority: 3
+      },
+      security: {
+        filePatterns: ["*"],
+        contextSignals: ["touchesAuth", "touchesCrypto", "touchesAPI", "touchesDatabase"],
+        priority: 1
+      },
+      architecture: {
+        filePatterns: ["*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.go"],
+        contextSignals: ["touchesAPI", "touchesDatabase"],
+        priority: 2
+      },
+      general: {
+        filePatterns: ["*"],
+        contextSignals: [],
+        priority: 3
+      }
+    };
+    const defaults = domainRules[knowledge.domain] || domainRules.general;
+    const contentPatterns = [];
+    for (const rule of detectionRules) {
+      if (rule.patterns?.keywords) {
+        contentPatterns.push(...rule.patterns.keywords.slice(0, 3));
+      }
+    }
+    for (const concept of knowledge.coreConcepts.slice(0, 5)) {
+      if (concept.keywords) {
+        contentPatterns.push(...concept.keywords.slice(0, 2));
+      }
+    }
+    return {
+      filePatterns: defaults.filePatterns || ["*"],
+      contentPatterns: [...new Set(contentPatterns)].slice(0, 20),
+      contextSignals: defaults.contextSignals || [],
+      minConfidence: 0.3,
+      priority: defaults.priority || 2
+    };
+  }
+  async saveAgentConfig(config) {
+    const trieDir = join4(process.cwd(), ".trie", "agents");
+    await mkdir(trieDir, { recursive: true });
+    const configPath = join4(trieDir, `${config.name}.json`);
+    await writeFile(configPath, JSON.stringify(config, null, 2));
+    return configPath;
+  }
+  formatSuccessResponse(config, configPath) {
+    return `
+\u2705 **Agent Created Successfully!**
+
+${"\u2501".repeat(50)}
+
+**Agent Name:** \`${config.name}\`
+**Display Name:** ${config.displayName}
+**Category:** ${config.category}
+**Config Saved To:** \`${configPath}\`
+
+\u{1F4CA} **Statistics:**
+   \u2022 Core concepts: ${config.knowledge.coreConcepts.length}
+   \u2022 Best practices: ${config.knowledge.bestPractices.length}
+   \u2022 Anti-patterns: ${config.knowledge.antiPatterns.length}
+   \u2022 Detection rules: ${config.patterns.length}
+
+\u{1F680} **Next Steps:**
+   1. The agent is now registered and will activate during scans
+   2. Run \`trie_scan\` to test the new agent
+   3. Edit \`${configPath}\` to customize detection rules
+
+\u{1F4A1} **Usage:**
+   The agent will automatically activate when scanning code that matches its patterns.
+   Use \`trie_list_agents\` to see all registered agents.
+`.trim();
+  }
+  sanitizeAgentName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  formatDisplayName(name) {
+    return name.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  errorResponse(message) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C **Error:** ${message}`
+        }
+      ],
+      isError: true
+    };
+  }
+};
+var TrieListAgentsTool = class {
+  async execute(args) {
+    const { includeBuiltin = true } = args;
+    try {
+      const customAgentNames = await listCustomAgents();
+      const customAgents = await Promise.all(
+        customAgentNames.map(async (name) => {
+          const config = await loadAgentConfig(name);
+          return config ? {
+            name: config.name,
+            displayName: config.displayName,
+            category: config.category,
+            source: config.source.originalFile,
+            patterns: config.patterns.length,
+            isCustom: true
+          } : null;
+        })
+      );
+      const validCustomAgents = customAgents.filter(Boolean);
+      const builtinAgents = includeBuiltin ? [
+        { name: "security", displayName: "Security Agent", category: "security", isCustom: false },
+        { name: "privacy", displayName: "Privacy Agent", category: "privacy", isCustom: false },
+        { name: "legal", displayName: "Legal Agent", category: "compliance", isCustom: false },
+        { name: "typecheck", displayName: "TypeCheck Agent", category: "quality", isCustom: false },
+        { name: "comprehension", displayName: "Comprehension Agent", category: "communication", isCustom: false },
+        { name: "design-engineer", displayName: "Design Engineer Agent", category: "accessibility", isCustom: false },
+        { name: "test", displayName: "Test Agent", category: "testing", isCustom: false },
+        { name: "software-architect", displayName: "Software Architect Agent", category: "architecture", isCustom: false },
+        { name: "devops", displayName: "DevOps Agent", category: "devops", isCustom: false },
+        { name: "bug-finding", displayName: "Bug Finding Agent", category: "quality", isCustom: false },
+        { name: "user-testing", displayName: "User Testing Agent", category: "ux", isCustom: false },
+        { name: "trie_clean", displayName: "Trie Clean Agent", category: "ai-code", isCustom: false }
+      ] : [];
+      let response = `# \u{1F916} Registered Agents
+
+`;
+      if (builtinAgents.length > 0) {
+        response += `## Built-in Agents (${builtinAgents.length})
+
+`;
+        for (const agent of builtinAgents) {
+          response += `- **${agent.displayName}** (\`${agent.name}\`) - ${agent.category}
+`;
+        }
+        response += "\n";
+      }
+      response += `## Custom Agents (${validCustomAgents.length})
+
+`;
+      if (validCustomAgents.length === 0) {
+        response += `_No custom agents created yet._
+
+`;
+        response += `\u{1F4A1} Create one with: \`trie_create_agent\`
+`;
+        response += `   - Provide a PDF, TXT, or MD file path
+`;
+        response += `   - Or paste/drag document content directly
+`;
+      } else {
+        for (const agent of validCustomAgents) {
+          if (agent) {
+            response += `- **${agent.displayName}** (\`${agent.name}\`)
+`;
+            response += `  - Category: ${agent.category}
+`;
+            response += `  - Patterns: ${agent.patterns}
+`;
+            response += `  - Source: ${agent.source}
+
+`;
+          }
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: response
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u274C Error listing agents: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+};
+
+// src/utils/ai-tool-detector.ts
+function detectAITool() {
+  if (process.env.CLAUDE_CODE_VERSION) {
+    return {
+      name: "claude-code",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: true
+    };
+  }
+  if (process.env.CURSOR_IDE) {
+    return {
+      name: "cursor",
+      preferredOutputFormat: "rich-text",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  if (process.env.OPENCODE_INSTANCE) {
+    return {
+      name: "opencode",
+      preferredOutputFormat: "plain-text",
+      supportsDiffs: false,
+      supportsInlineActions: false
+    };
+  }
+  const parentProcess = process.env.PARENT_PROCESS_NAME;
+  if (parentProcess?.toLowerCase().includes("claude")) {
+    return {
+      name: "claude-code",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: true
+    };
+  }
+  if (parentProcess?.toLowerCase().includes("cursor")) {
+    return {
+      name: "cursor",
+      preferredOutputFormat: "rich-text",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  if (parentProcess?.toLowerCase().includes("opencode")) {
+    return {
+      name: "opencode",
+      preferredOutputFormat: "plain-text",
+      supportsDiffs: false,
+      supportsInlineActions: false
+    };
+  }
+  return {
+    name: "unknown",
+    preferredOutputFormat: "markdown",
+    supportsDiffs: true,
+    supportsInlineActions: false
+  };
+}
+
+// src/config/loader.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  version: "1.0",
+  triaging: {
+    enabled: true,
+    riskThresholds: {
+      critical: 70,
+      high: 40,
+      medium: 20
+    },
+    autoFixConfidence: 0.95
+  },
+  agents: {
+    builtin: {
+      security: { enabled: true },
+      privacy: { enabled: true },
+      legal: { enabled: true },
+      "design-engineer": { enabled: true },
+      "software-architect": { enabled: true },
+      comprehension: { enabled: true },
+      devops: { enabled: true },
+      git: { enabled: true },
+      typecheck: { enabled: true },
+      test: { enabled: true },
+      "user-testing": { enabled: true },
+      "bug-finding": { enabled: true }
+    },
+    custom: []
+  },
+  ai: {
+    provider: "hybrid",
+    cloudModel: "claude-sonnet-4-20250514",
+    localModel: "codellama:13b",
+    useLocalFor: ["privacy-sensitive", "quick-checks"]
+  },
+  output: {
+    format: "markdown",
+    verbosity: "detailed",
+    showConfidenceScores: true,
+    includeAgentReasonings: false
+  },
+  compliance: {
+    standards: ["GDPR", "HIPAA", "SOC2"],
+    generateDocumentation: true,
+    auditTrail: true
+  }
+};
+
+// src/config/loader.ts
+async function loadConfig() {
+  try {
+    const configPath = join5(process.cwd(), ".trie", "config.json");
+    const configFile = await readFile5(configPath, "utf-8");
+    const userConfig = JSON.parse(configFile);
+    return mergeConfig(DEFAULT_CONFIG, userConfig);
+  } catch (error) {
+    console.error("No config found, using defaults");
+    return DEFAULT_CONFIG;
+  }
+}
+function mergeConfig(defaults, user) {
+  if (typeof user !== "object" || user === null) {
+    return defaults;
+  }
+  const result = { ...defaults };
+  for (const [key, value] of Object.entries(user)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = mergeConfig(defaults[key] || {}, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "trie",
+    version: "1.0.0",
+    description: "Intelligent Agent Orchestration for AI Coding Tools"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+var scanTool = new TrieScanTool();
+var fixTool = new TrieFixTool();
+var explainTool = new TrieExplainTool();
+var testTool = new TrieTestTool();
+var registerAgentTool = new TrieRegisterAgentTool();
+var watchTool = new TrieWatchTool();
+var agentTool = new TrieAgentTool();
+var createAgentTool = new TrieCreateAgentTool();
+var saveAgentTool = new TrieSaveAgentTool();
+var listAgentsTool = new TrieListAgentsTool();
+var tools = [
+  {
+    name: "scan",
+    description: "Scan code with intelligent agent selection. Scans entire codebase if no files specified.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files to scan (absolute paths). If empty, scans entire codebase."
+        },
+        directory: {
+          type: "string",
+          description: "Directory to scan (if files not specified). Defaults to current working directory."
+        },
+        context: {
+          type: "object",
+          properties: {
+            changeType: {
+              type: "string",
+              enum: ["ui", "api", "database", "auth", "payment", "general"]
+            },
+            isNewFeature: { type: "boolean" },
+            touchesUserData: { type: "boolean" }
+          }
+        },
+        forceAgents: {
+          type: "array",
+          items: { type: "string" },
+          description: "Manually specify agents to run (overrides triaging)"
+        }
+      }
+    }
+  },
+  {
+    name: "trie",
+    description: "Quick menu of available Trie commands and aliases.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // Alias so users can call `trie_scan` directly (no server prefix needed)
+  {
+    name: "trie_scan",
+    description: "Alias for scan (same behavior as scan).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files to scan (absolute paths). If empty, scans entire codebase."
+        },
+        directory: {
+          type: "string",
+          description: "Directory to scan (if files not specified). Defaults to current working directory."
+        },
+        context: {
+          type: "object",
+          properties: {
+            changeType: {
+              type: "string",
+              enum: ["ui", "api", "database", "auth", "payment", "general"]
+            },
+            isNewFeature: { type: "boolean" },
+            touchesUserData: { type: "boolean" }
+          }
+        },
+        forceAgents: {
+          type: "array",
+          items: { type: "string" },
+          description: "Manually specify agents to run (overrides triaging)"
+        }
+      }
+    }
+  },
+  {
+    name: "fix",
+    description: "Apply high-confidence fixes to code",
+    inputSchema: {
+      type: "object",
+      properties: {
+        issueIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Specific issues to fix (empty = all high-confidence)"
+        },
+        autoApprove: {
+          type: "boolean",
+          description: "Skip human review for high-confidence fixes"
+        }
+      }
+    }
+  },
+  {
+    name: "explain",
+    description: "Explain code, issues, or changes in plain language",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["code", "issue", "change", "risk"]
+        },
+        target: {
+          type: "string",
+          description: "What to explain (file path, issue ID, etc.)"
+        }
+      },
+      required: ["type", "target"]
+    }
+  },
+  {
+    name: "test",
+    description: "Generate tests or check test coverage",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["generate", "coverage", "run"]
+        },
+        files: {
+          type: "array",
+          items: { type: "string" }
+        }
+      },
+      required: ["action", "files"]
+    }
+  },
+  {
+    name: "register_agent",
+    description: "Register a custom agent for your project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        path: {
+          type: "string",
+          description: "Path to agent implementation"
+        },
+        activationRules: {
+          type: "object",
+          description: "When to activate this agent"
+        }
+      },
+      required: ["name", "path"]
+    }
+  },
+  {
+    name: "watch",
+    description: "Autonomous mode: watch for file changes and scan/fix automatically. Use yolo:true for auto-fix!",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["start", "stop", "status", "issues", "yolo"],
+          description: "start = begin watching, stop = end, status = check, issues = list, yolo = toggle auto-fix"
+        },
+        directory: {
+          type: "string",
+          description: "Directory to watch (defaults to current working directory)"
+        },
+        yolo: {
+          type: "boolean",
+          description: "\u{1F525} YOLO MODE: Auto-fix issues as they occur! (default: false)"
+        },
+        debounceMs: {
+          type: "number",
+          description: "Milliseconds to wait after file change before scanning (default: 1000)"
+        }
+      },
+      required: ["action"]
+    }
+  },
+  // Individual agent commands
+  {
+    name: "security",
+    description: "Run security agent: detect vulnerabilities, injection risks, auth issues, hardcoded secrets",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan (or scans codebase)" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "privacy",
+    description: "Run privacy agent: PII handling, GDPR/HIPAA compliance, data encryption",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "legal",
+    description: "Run legal agent: GDPR, CCPA, consent patterns, data retention compliance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "accessibility",
+    description: "Run accessibility agent: WCAG 2.1 compliance, keyboard nav, screen readers, color contrast",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "architecture",
+    description: "Run architecture agent: code organization, SOLID principles, N+1 queries, scalability",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "bugs",
+    description: "Run bug-finding agent: null safety, edge cases, common bugs, async issues",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "ux",
+    description: "Run UX testing agent: simulate happy path, security tester, confused user, impatient user",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "types",
+    description: "Run type safety agent: type errors, missing annotations, null checks",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "devops",
+    description: "Run devops agent: config issues, logging, environment variables, deployment patterns",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  {
+    name: "clean",
+    description: "\u{1F9F9} Clean up AI-generated code: find common mistakes, bad patterns, and quick fixes",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: { type: "array", items: { type: "string" }, description: "Files to scan" },
+        directory: { type: "string", description: "Directory to scan" },
+        output: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "summary = concise (default), full = includes AI prompt/code (large output)"
+        }
+      }
+    }
+  },
+  // Custom agent creation tools (two-step process - no API key needed!)
+  {
+    name: "create_agent",
+    description: "\u{1F4DA} Step 1: Parse a document to create a custom agent. Supports file path OR drag-and-drop content. Returns extraction prompt for Claude to process.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "Path to the document file (PDF, TXT, MD, or RTF)"
+        },
+        documentContent: {
+          type: "string",
+          description: "Raw document text (for drag-and-drop or pasted content). Use this OR filePath."
+        },
+        agentName: {
+          type: "string",
+          description: 'Name for the new agent (e.g., "react-fundamentals", "gdpr-compliance")'
+        },
+        displayName: {
+          type: "string",
+          description: 'Optional display name (e.g., "React Fundamentals Expert")'
+        },
+        description: {
+          type: "string",
+          description: "Optional description of what the agent does"
+        },
+        category: {
+          type: "string",
+          description: 'Optional category (e.g., "react", "security", "compliance", "architecture")'
+        }
+      },
+      required: ["agentName"]
+    }
+  },
+  {
+    name: "save_agent",
+    description: "\u{1F4E6} Step 2: Save the agent config after Claude extracts knowledge from the document. Pass the JSON output from trie_create_agent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentConfig: {
+          type: "object",
+          description: "Agent configuration (name, displayName, description, category)",
+          properties: {
+            name: { type: "string" },
+            displayName: { type: "string" },
+            description: { type: "string" },
+            version: { type: "string" },
+            category: { type: "string" }
+          },
+          required: ["name", "category"]
+        },
+        knowledge: {
+          type: "object",
+          description: "Extracted knowledge (domain, summary, coreConcepts, bestPractices, antiPatterns, glossary)"
+        },
+        detectionRules: {
+          type: "array",
+          description: "Array of detection rules with patterns and fixes"
+        },
+        prompts: {
+          type: "object",
+          description: "Agent prompts (systemPrompt, analysisPrompt, fixPrompt)",
+          properties: {
+            systemPrompt: { type: "string" },
+            analysisPrompt: { type: "string" },
+            fixPrompt: { type: "string" }
+          },
+          required: ["systemPrompt", "analysisPrompt", "fixPrompt"]
+        },
+        sourceFile: {
+          type: "string",
+          description: "Original source file path (optional)"
+        }
+      },
+      required: ["agentConfig", "knowledge", "detectionRules", "prompts"]
+    }
+  },
+  {
+    name: "list_agents",
+    description: "\u{1F4CB} List all registered agents including custom agents created from documents",
+    inputSchema: {
+      type: "object",
+      properties: {
+        includeBuiltin: {
+          type: "boolean",
+          description: "Include built-in agents in the list (default: true)"
+        }
+      }
+    }
+  }
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const stripNamespace = (n) => {
+    const parts = n.split(":");
+    const base = parts[0] || n;
+    const slashParts = base.split("/");
+    return slashParts[slashParts.length - 1] || base;
+  };
+  const rawName = stripNamespace(name);
+  const normalizedName = rawName.startsWith("trie_") ? rawName.slice("trie_".length) : rawName;
+  try {
+    switch (normalizedName) {
+      case "trie":
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                "## Trie Menu",
+                "",
+                "- `trie_scan` or `scan`: Full intelligent scan (auto triage agents)",
+                "- `fix`: Apply high-confidence fixes",
+                "- `explain`: Explain code/issues/risks",
+                "- `watch`: Watch mode (scan on change)",
+                "- `security`, `privacy`, `legal`, `bugs`, `types`, `devops`, `architecture`, `ux`, `clean`: Run a specific agent",
+                "- `test`: Generate/check tests",
+                "- `register_agent`, `create_agent`, `save_agent`, `list_agents`: Custom agent lifecycle",
+                "",
+                "You can call these without any namespace; `trie_` aliases also work."
+              ].join("\n")
+            }
+          ]
+        };
+      case "scan":
+        return await scanTool.execute(args);
+      case "fix":
+        return await fixTool.execute(args);
+      case "explain":
+        return await explainTool.execute(args);
+      case "test":
+        return await testTool.execute(args);
+      case "register_agent":
+        return await registerAgentTool.execute(args);
+      case "watch":
+        return await watchTool.execute(args);
+      // Individual agent commands
+      case "security":
+        return await agentTool.execute({ ...args, agent: "security" });
+      case "privacy":
+        return await agentTool.execute({ ...args, agent: "privacy" });
+      case "legal":
+        return await agentTool.execute({ ...args, agent: "legal" });
+      case "accessibility":
+        return await agentTool.execute({ ...args, agent: "design-engineer" });
+      case "architecture":
+        return await agentTool.execute({ ...args, agent: "software-architect" });
+      case "bugs":
+        return await agentTool.execute({ ...args, agent: "bug-finding" });
+      case "ux":
+        return await agentTool.execute({ ...args, agent: "user-testing" });
+      case "types":
+        return await agentTool.execute({ ...args, agent: "typecheck" });
+      case "devops":
+        return await agentTool.execute({ ...args, agent: "devops" });
+      case "clean":
+        return await agentTool.execute({ ...args, agent: "trie_clean" });
+      // Custom agent creation tools (two-step process)
+      case "create_agent":
+        return await createAgentTool.execute(args);
+      case "save_agent":
+        return await saveAgentTool.execute(args);
+      case "list_agents":
+        return await listAgentsTool.execute(args);
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+});
+var agentRegistry = new AgentRegistry();
+async function getAvailableResources() {
+  const resources = [];
+  resources.push({
+    uri: "trie://agents",
+    name: "Available Agents",
+    description: "List of all available Trie agents (built-in and custom)",
+    mimeType: "application/json"
+  });
+  resources.push({
+    uri: "trie://config",
+    name: "Trie Configuration",
+    description: "Current Trie configuration settings",
+    mimeType: "application/json"
+  });
+  resources.push({
+    uri: "trie://cache/stats",
+    name: "Cache Statistics",
+    description: "Trie scan cache statistics and performance metrics",
+    mimeType: "application/json"
+  });
+  resources.push({
+    uri: "trie://signatures",
+    name: "Vulnerability Signatures",
+    description: "Summary of loaded vulnerability detection signatures",
+    mimeType: "application/json"
+  });
+  try {
+    const reportsDir = join6(process.cwd(), "trie-reports");
+    const files = await readdir2(reportsDir);
+    const reportFiles = files.filter((f) => f.endsWith(".txt") || f.endsWith(".json"));
+    for (const file of reportFiles.slice(0, 10)) {
+      resources.push({
+        uri: `trie://reports/${file}`,
+        name: `Scan Report: ${file}`,
+        description: `Trie scan report from ${file}`,
+        mimeType: file.endsWith(".json") ? "application/json" : "text/plain"
+      });
+    }
+  } catch {
+  }
+  try {
+    await agentRegistry.loadCustomAgents();
+    const customAgents = agentRegistry.getCustomAgents();
+    for (const agent of customAgents) {
+      resources.push({
+        uri: `trie://agents/custom/${agent.name}`,
+        name: `Custom Agent: ${agent.name}`,
+        description: agent.description,
+        mimeType: "application/json"
+      });
+    }
+  } catch {
+  }
+  return resources;
+}
+async function readResourceContent(uri) {
+  const parsedUri = uri.replace("trie://", "");
+  if (parsedUri === "agents") {
+    await agentRegistry.loadCustomAgents();
+    const agents = agentRegistry.getAgentDescriptions();
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify({
+          totalAgents: agents.length,
+          builtinCount: agents.filter((a) => !a.isCustom).length,
+          customCount: agents.filter((a) => a.isCustom).length,
+          agents: agents.map((a) => ({
+            name: a.name,
+            description: a.description,
+            type: a.isCustom ? "custom" : "builtin"
+          }))
+        }, null, 2)
+      }]
+    };
+  }
+  if (parsedUri.startsWith("agents/custom/")) {
+    const agentName = parsedUri.replace("agents/custom/", "");
+    await agentRegistry.loadCustomAgents();
+    const metadata = agentRegistry.getCustomAgentMetadata(agentName);
+    if (!metadata) {
+      throw new Error(`Custom agent not found: ${agentName}`);
+    }
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(metadata, null, 2)
+      }]
+    };
+  }
+  if (parsedUri === "config") {
+    const config = await loadConfig();
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(config, null, 2)
+      }]
+    };
+  }
+  if (parsedUri === "cache/stats") {
+    try {
+      const cachePath = join6(process.cwd(), ".trie", ".trie-cache.json");
+      const cacheContent = await readFile6(cachePath, "utf-8");
+      const cache = JSON.parse(cacheContent);
+      const fileCount = Object.keys(cache.files || {}).length;
+      const totalVulns = Object.values(cache.files || {}).reduce((acc, file) => {
+        return acc + (file.vulnerabilities?.length || 0);
+      }, 0);
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({
+            version: cache.version,
+            created: new Date(cache.created).toISOString(),
+            lastUpdated: new Date(cache.lastUpdated).toISOString(),
+            cachedFiles: fileCount,
+            totalVulnerabilitiesFound: totalVulns,
+            cacheAgeMinutes: Math.round((Date.now() - cache.lastUpdated) / 6e4)
+          }, null, 2)
+        }]
+      };
+    } catch {
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({
+            error: "No cache found. Run a scan first to build the cache.",
+            hint: "Use trie_scan to scan your codebase"
+          }, null, 2)
+        }]
+      };
+    }
+  }
+  if (parsedUri === "signatures") {
+    const { getVulnerabilityStats } = await import("./vulnerability-signatures-J3CUQ7VR.js");
+    const { getVibeCodeStats } = await import("./vibe-code-signatures-4CBHUSI7.js");
+    const vulnStats = getVulnerabilityStats();
+    const vibeStats = getVibeCodeStats();
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify({
+          vulnerabilitySignatures: vulnStats,
+          vibeCodeSignatures: vibeStats,
+          totalSignatures: vulnStats.total + vibeStats.total
+        }, null, 2)
+      }]
+    };
+  }
+  if (parsedUri.startsWith("reports/")) {
+    const fileName = parsedUri.replace("reports/", "");
+    const reportPath = join6(process.cwd(), "trie-reports", fileName);
+    try {
+      const content = await readFile6(reportPath, "utf-8");
+      return {
+        contents: [{
+          uri,
+          mimeType: fileName.endsWith(".json") ? "application/json" : "text/plain",
+          text: content
+        }]
+      };
+    } catch {
+      throw new Error(`Report not found: ${fileName}`);
+    }
+  }
+  throw new Error(`Unknown resource: ${uri}`);
+}
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const resources = await getAvailableResources();
+  return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  return await readResourceContent(uri);
+});
+async function main() {
+  const aiTool = detectAITool();
+  console.error(`Detected AI Tool: ${aiTool.name}`);
+  const config = await loadConfig();
+  console.error(`Loaded config for ${config.agents.builtin ? Object.keys(config.agents.builtin).length : 0} built-in agents`);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Trie Agent MCP Server running...");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=index.js.map