@triedotdev/mcp 1.0.93 → 1.0.97

package/dist/index.js

@@ -1,9 +1,4 @@
 #!/usr/bin/env node
-import {
-  listCustomAgents,
-  loadAgentConfig,
-  parseDocument
-} from "./chunk-SJFJ6GLR.js";
 import {
   IncidentIndex,
   LearningEngine,
@@ -17,6 +12,7 @@ import {
   initializeBootstrapFiles,
   listCheckpoints,
   loadBootstrapContext,
+  loadConfig,
   loadRules,
   loadTeamInfo,
   needsBootstrap,
@@ -24,50 +20,45 @@ import {
   reasonAboutChangesHumanReadable,
   saveCheckpoint,
   trackIssueOccurrence
-} from "./chunk-YTJXD664.js";
+} from "./chunk-FNCCZ3XB.js";
 import {
   InteractiveDashboard,
   StreamingManager,
-  TrieScanTool
-} from "./chunk-R6AUYN3R.js";
-import "./chunk-MZI46HQT.js";
-import "./chunk-NMGINYYX.js";
-import {
-  isTrieInitialized,
-  loadConfig
-} from "./chunk-CUXXRM3T.js";
-import "./chunk-HFQ5ORON.js";
-import "./chunk-IOUOVBJZ.js";
-import {
-  ContextGraph
-} from "./chunk-F55XBLIA.js";
-import "./chunk-5Z7O66DE.js";
-import "./chunk-T5UOH56R.js";
+  TrieScanTool,
+  getOutputManager,
+  listInstalledSkills
+} from "./chunk-SLL2MDJD.js";
+import "./chunk-B3MNN3XB.js";
 import {
-  CRITICAL_REVIEW_CHECKLIST,
-  SuperReviewerSkill,
   appendToSection,
   getContextForAI,
   getProjectInfoStructured,
   getProjectSection,
   getProjectSections,
-  getSkillRegistry,
   initProjectInfo,
-  listInstalledSkills,
+  isTrieInitialized,
   loadContextState,
   loadProjectInfo,
   projectInfoExists,
+  runShellCommandSync,
   updateProjectSection
-} from "./chunk-BG2BHWCC.js";
-import {
-  runShellCommandSync
-} from "./chunk-MURGTWG4.js";
+} from "./chunk-HSNE46VE.js";
 import {
+  ContextGraph,
   findCrossProjectPatterns,
   getGlobalMemoryStats,
+  getStorage,
   listTrackedProjects,
   searchGlobalPatterns
-} from "./chunk-LT7MKIXU.js";
+} from "./chunk-NIASHOAB.js";
+import "./chunk-F4NJ4CBP.js";
+import "./chunk-IXO4G4D3.js";
+import "./chunk-6NLHFIYA.js";
+import {
+  getSkillRegistry
+} from "./chunk-G76DYVGX.js";
+import "./chunk-OVRG5RP3.js";
+import "./chunk-R3I2GCZC.js";
 import {
   findSimilarIssues,
   getMemoryStats,
@@ -75,20 +66,14 @@ import {
   markIssueResolved,
   purgeIssues,
   searchIssues
-} from "./chunk-LP4MVJDW.js";
-import "./chunk-LVVG2DMW.js";
-import "./chunk-6NLHFIYA.js";
-import {
-  getOutputManager
-} from "./chunk-KWDNYWOR.js";
-import "./chunk-74NPKTZV.js";
+} from "./chunk-JDHR5BDR.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-RDOJCRKJ.js";
+} from "./chunk-R4AAPFXC.js";
 import {
   isInteractiveMode
-} from "./chunk-D25EIBPO.js";
+} from "./chunk-APMV77PU.js";
 import "./chunk-DGUM43GV.js";
 
 // src/server/mcp-server.ts
@@ -223,43 +208,6 @@ Provide:
 1. The exact code fix (ready to apply)
 2. Explanation of why this fix works
 3. Any additional hardening recommendations`
-  },
-  privacy: {
-    system: `You are a data privacy officer and GDPR/HIPAA compliance expert.
-Analyze code for privacy violations and data protection issues.
-
-Key regulations to enforce:
-- GDPR (EU data protection)
-- CCPA (California privacy)
-- HIPAA (health data)
-- COPPA (children's privacy)
-- PCI DSS (payment data)
-
-Look for:
-- PII without encryption
-- Missing consent mechanisms
-- Data retention violations
-- Cross-border data transfer issues
-- Third-party data sharing without disclosure`,
-    analysis: `## Privacy Compliance Audit
-
-Analyze this code for privacy/compliance issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Data Types Detected:** {{dataTypes}}
-
-For each issue:
-1. Regulation violated (e.g., GDPR Article 32)
-2. Specific requirement not met
-3. Risk level and potential fine exposure
-4. Remediation steps with code examples
-5. Documentation requirements
-
-Reference current regulatory guidance when applicable.`
   },
   legal: {
     system: `You are a tech-focused legal compliance analyst.
@@ -2518,27 +2466,585 @@ trie_test action:"run" files:["src/utils.test.ts"]
   }
 };
 
-// src/tools/register-agent.ts
-var TrieRegisterAgentTool = class {
-  async execute(args) {
-    const { name, path: path3 } = args;
+// src/tools/watch.ts
+import { watch, existsSync as existsSync4, readFileSync } from "fs";
+import { stat, readFile as readFile4 } from "fs/promises";
+import { join as join2, extname as extname4, basename as basename2 } from "path";
+
+// src/extraction/signal-extractor.ts
+import Anthropic from "@anthropic-ai/sdk";
+var EXTRACTION_PROMPT = `You are a signal extraction system. Your job is to extract structured information from raw content.
+
+Extract:
+1. DECISIONS - Clear choices made during development
+   - What was decided
+   - Why it was decided (reasoning/tradeoffs)
+   - What alternatives were considered but NOT chosen
+   - Which files are affected
+   
+2. FACTS - Concrete, verifiable information
+   - Technical constraints (e.g., "Stripe requires TLS 1.2+")
+   - API requirements
+   - Business rules
+   - Dependencies
+   
+3. BLOCKERS - Things preventing progress
+   - What's blocked
+   - Impact level (critical/high/medium/low)
+   - What areas are affected
+   
+4. QUESTIONS - Open items needing resolution
+   - What's unclear
+   - Context around the question
+
+CRITICAL: Extract rich metadata:
+- Tags: Use specific, searchable tags (e.g., "auth", "payments", "eu-compliance", "validation")
+- Files: Full paths when mentioned (e.g., "src/auth/validator.ts")
+- Tradeoffs: What was considered but rejected
+- Related terms: Alternative names/keywords (e.g., "password" + "credentials" + "auth")
+
+Format as JSON:
+{
+  "decisions": [{
+    "decision": "Use bcrypt for password hashing",
+    "context": "Security requirement for user authentication",
+    "reasoning": "Industry standard, resistant to GPU attacks",
+    "files": ["src/auth/hash.ts", "src/models/user.ts"],
+    "tags": ["security", "auth", "passwords", "encryption"],
+    "tradeoffs": ["Considered argon2 but bcrypt has better library support"]
+  }],
+  "facts": [{
+    "fact": "Stripe requires TLS 1.2+ for all API calls",
+    "source": "Stripe API docs",
+    "tags": ["payments", "stripe", "security", "api"],
+    "confidence": 0.95
+  }],
+  "blockers": [{
+    "blocker": "Missing VAT calculation endpoint",
+    "impact": "high",
+    "affectedAreas": ["checkout", "eu-payments"],
+    "tags": ["payments", "eu", "compliance", "vat"]
+  }],
+  "questions": [{
+    "question": "Should we cache user sessions in Redis or memory?",
+    "context": "Performance optimization for auth layer",
+    "tags": ["auth", "performance", "caching", "sessions"]
+  }]
+}
+
+Be specific with tags. Use concrete technical terms. Extract ALL file paths mentioned.
+Empty arrays are fine if nothing to extract.`;
+var SignalExtractor = class {
+  client = null;
+  model;
+  constructor(model = "claude-3-haiku-20240307") {
+    this.model = model;
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (apiKey) {
+      this.client = new Anthropic({ apiKey });
+    }
+  }
+  /**
+   * Extract structured signals from raw content
+   */
+  async extract(content, sourceType, sourceId) {
+    if (!this.client) {
+      return this.basicExtraction(content, sourceType, sourceId);
+    }
+    try {
+      const response = await this.client.messages.create({
+        model: this.model,
+        max_tokens: 2048,
+        temperature: 0.3,
+        messages: [{
+          role: "user",
+          content: `${EXTRACTION_PROMPT}
+
+Content to analyze:
+${content}`
+        }]
+      });
+      const firstBlock = response.content[0];
+      const text = firstBlock && firstBlock.type === "text" ? firstBlock.text : "";
+      const extracted = this.parseExtraction(text);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const metadata = {
+        extractedAt: now,
+        sourceType,
+        extractionModel: this.model
+      };
+      if (sourceId !== void 0) {
+        metadata.sourceId = sourceId;
+      }
+      const signal = {
+        decisions: extracted.decisions.map((d, i) => ({
+          id: `dec-${Date.now()}-${i}`,
+          decision: d.decision || "",
+          context: d.context || "",
+          files: d.files || [],
+          tags: d.tags || [],
+          ...d,
+          when: now,
+          status: "active"
+        })),
+        facts: extracted.facts.map((f, i) => ({
+          id: `fact-${Date.now()}-${i}`,
+          fact: f.fact || "",
+          source: f.source || sourceType,
+          tags: f.tags || [],
+          confidence: f.confidence ?? 0.8,
+          ...f,
+          when: now
+        })),
+        blockers: extracted.blockers.map((b, i) => ({
+          id: `block-${Date.now()}-${i}`,
+          blocker: b.blocker || "",
+          impact: b.impact || "medium",
+          affectedAreas: b.affectedAreas || [],
+          tags: b.tags || [],
+          ...b,
+          when: now
+        })),
+        questions: extracted.questions.map((q, i) => ({
+          id: `q-${Date.now()}-${i}`,
+          question: q.question || "",
+          context: q.context || "",
+          tags: q.tags || [],
+          ...q,
+          when: now
+        })),
+        metadata
+      };
+      return signal;
+    } catch (error) {
+      console.error("Extraction failed, using basic extraction:", error);
+      return this.basicExtraction(content, sourceType, sourceId);
+    }
+  }
+  /**
+   * Parse extraction from model response
+   */
+  parseExtraction(text) {
+    try {
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+    } catch (e) {
+    }
     return {
-      content: [
-        {
-          type: "text",
-          text: `\u{1F916} Register agent tool called with name: ${name}, path: ${path3}
+      decisions: [],
+      facts: [],
+      blockers: [],
+      questions: []
+    };
+  }
+  /**
+   * Basic extraction without AI (fallback)
+   */
+  basicExtraction(content, sourceType, sourceId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const hasDecision = /\b(decided|decision|chose|picked)\b/i.test(content);
+    const hasBlocker = /\b(blocked|blocker|blocked by|can't|cannot|unable)\b/i.test(content);
+    const hasQuestion = /\?|what|how|why|should we/i.test(content);
+    const decisions = [];
+    const facts = [];
+    const blockers = [];
+    const questions = [];
+    if (hasDecision) {
+      decisions.push({
+        id: `dec-${Date.now()}`,
+        decision: content.substring(0, 200),
+        context: sourceType,
+        when: now,
+        files: [],
+        tags: [sourceType],
+        status: "active"
+      });
+    }
+    if (hasBlocker) {
+      blockers.push({
+        id: `block-${Date.now()}`,
+        blocker: content.substring(0, 200),
+        impact: "medium",
+        affectedAreas: [],
+        when: now,
+        tags: [sourceType]
+      });
+    }
+    if (hasQuestion) {
+      questions.push({
+        id: `q-${Date.now()}`,
+        question: content.substring(0, 200),
+        context: sourceType,
+        when: now,
+        tags: [sourceType]
+      });
+    }
+    const metadata = {
+      extractedAt: now,
+      sourceType,
+      extractionModel: "basic"
+    };
+    if (sourceId !== void 0) {
+      metadata.sourceId = sourceId;
+    }
+    return {
+      decisions,
+      facts,
+      blockers,
+      questions,
+      metadata
+    };
+  }
+  /**
+   * Extract from incident report (trie tell)
+   */
+  async extractFromIncident(incidentText) {
+    return this.extract(incidentText, "incident");
+  }
+  /**
+   * Extract from commit message and diff
+   */
+  async extractFromCommit(message, diff, commitId) {
+    const content = diff ? `${message}
+
+Changes:
+${diff}` : message;
+    return this.extract(content, "commit", commitId);
+  }
+  /**
+   * Extract from PR description and comments
+   */
+  async extractFromPR(title, description, comments, prNumber) {
+    const content = `
+Title: ${title}
+
+Description:
+${description}
+
+Comments:
+${comments.join("\n\n")}
+    `.trim();
+    return this.extract(content, "pr", prNumber);
+  }
+};
+
+// src/extraction/metadata-enricher.ts
+var MetadataEnricher = class {
+  tagSynonyms;
+  constructor() {
+    this.tagSynonyms = this.initializeTagSynonyms();
+  }
+  /**
+   * Enrich an extracted signal with additional metadata
+   */
+  async enrichSignal(signal, context) {
+    const gitContext = {};
+    if (context?.gitBranch) gitContext.branch = context.gitBranch;
+    if (context?.gitCommit) gitContext.commit = context.gitCommit;
+    const metadata = {
+      relatedFiles: await this.findRelatedFiles(signal),
+      dependencies: await this.extractDependencies(signal),
+      expandedTags: this.expandTags(signal),
+      codebaseArea: this.inferCodebaseArea(signal),
+      domain: this.inferDomain(signal),
+      relatedDecisions: [],
+      // Will be populated by storage layer
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (Object.keys(gitContext).length > 0) {
+      metadata.gitContext = gitContext;
+    }
+    return {
+      signal,
+      metadata
+    };
+  }
+  /**
+   * Expand tags with synonyms and related terms
+   * This is our "semantic" layer without embeddings
+   */
+  expandTags(signal) {
+    const allTags = /* @__PURE__ */ new Set();
+    for (const decision of signal.decisions) {
+      decision.tags.forEach((tag) => allTags.add(tag.toLowerCase()));
+    }
+    for (const fact of signal.facts) {
+      fact.tags.forEach((tag) => allTags.add(tag.toLowerCase()));
+    }
+    for (const blocker of signal.blockers) {
+      blocker.tags.forEach((tag) => allTags.add(tag.toLowerCase()));
+    }
+    for (const question of signal.questions) {
+      question.tags.forEach((tag) => allTags.add(tag.toLowerCase()));
+    }
+    const expandedTags = new Set(allTags);
+    for (const tag of allTags) {
+      const synonyms = this.tagSynonyms.get(tag) || [];
+      synonyms.forEach((syn) => expandedTags.add(syn));
+    }
+    return Array.from(expandedTags);
+  }
+  /**
+   * Find related files based on signal content
+   */
+  async findRelatedFiles(signal) {
+    const relatedFiles = /* @__PURE__ */ new Set();
+    for (const decision of signal.decisions) {
+      decision.files.forEach((file) => relatedFiles.add(file));
+    }
+    const inferredFiles = await this.inferFilesFromTags(signal);
+    inferredFiles.forEach((file) => relatedFiles.add(file));
+    return Array.from(relatedFiles);
+  }
+  /**
+   * Extract dependencies from signal
+   */
+  async extractDependencies(signal) {
+    const dependencies = /* @__PURE__ */ new Set();
+    const allText = [
+      ...signal.decisions.map((d) => `${d.decision} ${d.context} ${d.reasoning}`),
+      ...signal.facts.map((f) => `${f.fact} ${f.source}`)
+    ].join(" ");
+    const packagePatterns = [
+      /\b(react|vue|angular|next|express|fastify|stripe|bcrypt|jwt|redis|prisma)\b/gi
+    ];
+    for (const pattern of packagePatterns) {
+      const matches = allText.match(pattern) || [];
+      matches.forEach((dep) => dependencies.add(dep.toLowerCase()));
+    }
+    return Array.from(dependencies);
+  }
+  /**
+   * Infer codebase area from file paths and tags
+   */
+  inferCodebaseArea(signal) {
+    const areas = /* @__PURE__ */ new Set();
+    for (const decision of signal.decisions) {
+      for (const file of decision.files) {
+        const area = this.filePathToArea(file);
+        if (area) areas.add(area);
+      }
+    }
+    const areaKeywords = ["frontend", "backend", "api", "ui", "database", "auth", "payments"];
+    const allTags = this.expandTags(signal);
+    for (const tag of allTags) {
+      if (areaKeywords.includes(tag)) {
+        areas.add(tag);
+      }
+    }
+    return Array.from(areas);
+  }
+  /**
+   * Infer domain from tags and content
+   */
+  inferDomain(signal) {
+    const domains = /* @__PURE__ */ new Set();
+    const domainKeywords = [
+      "payments",
+      "billing",
+      "compliance",
+      "security",
+      "auth",
+      "analytics",
+      "notifications",
+      "messaging",
+      "search"
+    ];
+    const allTags = this.expandTags(signal);
+    for (const tag of allTags) {
+      if (domainKeywords.includes(tag)) {
+        domains.add(tag);
+      }
+    }
+    return Array.from(domains);
+  }
+  /**
+   * Convert file path to codebase area
+   */
+  filePathToArea(filePath) {
+    const normalized = filePath.toLowerCase();
+    if (normalized.includes("/frontend/") || normalized.includes("/client/") || normalized.includes("/ui/")) {
+      return "frontend";
+    }
+    if (normalized.includes("/backend/") || normalized.includes("/server/") || normalized.includes("/api/")) {
+      return "backend";
+    }
+    if (normalized.includes("/database/") || normalized.includes("/models/") || normalized.includes("/schema/")) {
+      return "database";
+    }
+    if (normalized.includes("/auth/")) {
+      return "auth";
+    }
+    return null;
+  }
+  /**
+   * Infer related files from tags
+   */
+  async inferFilesFromTags(_signal) {
+    return [];
+  }
+  /**
+   * Initialize tag synonyms and related terms
+   * This is our "semantic" understanding without embeddings
+   */
+  initializeTagSynonyms() {
+    return /* @__PURE__ */ new Map([
+      // Auth & Security
+      ["auth", ["authentication", "login", "signin", "credentials", "password"]],
+      ["password", ["credentials", "auth", "hashing", "bcrypt"]],
+      ["security", ["vulnerability", "exploit", "attack", "protection"]],
+      ["encryption", ["crypto", "hashing", "encoding", "security"]],
+      // Payments
+      ["payments", ["billing", "checkout", "stripe", "pricing"]],
+      ["stripe", ["payments", "billing", "api", "checkout"]],
+      ["vat", ["tax", "eu", "compliance", "billing"]],
+      // Database & Performance
+      ["database", ["db", "sql", "query", "storage", "persistence"]],
+      ["cache", ["caching", "redis", "memory", "performance"]],
+      ["performance", ["optimization", "speed", "latency", "cache"]],
+      // Frontend
+      ["ui", ["frontend", "interface", "component", "view"]],
+      ["component", ["ui", "react", "vue", "frontend"]],
+      ["validation", ["form", "input", "error", "ui"]],
+      // Backend & API
+      ["api", ["endpoint", "route", "backend", "server"]],
+      ["endpoint", ["api", "route", "url", "backend"]],
+      ["backend", ["server", "api", "service"]],
+      // Compliance & Legal
+      ["compliance", ["gdpr", "hipaa", "legal", "regulation"]],
+      ["gdpr", ["compliance", "privacy", "eu", "data-protection"]],
+      ["privacy", ["gdpr", "compliance", "data-protection", "security"]]
+    ]);
+  }
+};
 
-TODO: Implement register agent functionality`
+// src/extraction/pipeline.ts
+import { randomBytes } from "crypto";
+var ExtractionPipeline = class {
+  extractor;
+  enricher;
+  storage;
+  workDir;
+  constructor(options) {
+    this.extractor = new SignalExtractor(options.anthropicApiKey);
+    this.enricher = new MetadataEnricher();
+    this.storage = getStorage(options.workingDirectory);
+    this.workDir = options.workingDirectory;
+  }
+  /**
+   * Process raw content through the entire pipeline
+   */
+  async process(content, context) {
+    console.log("\u{1F50D} Extracting signals from content...");
+    let extractedSignal = await this.extractor.extract(content, context.sourceType, context.sourceId);
+    extractedSignal = this.addIds(extractedSignal, context);
+    console.log(`   \u2713 Extracted ${extractedSignal.decisions.length} decisions, ${extractedSignal.facts.length} facts, ${extractedSignal.blockers.length} blockers, ${extractedSignal.questions.length} questions`);
+    console.log("\u{1F3F7}\uFE0F  Enriching with metadata...");
+    const { metadata: enrichedMeta } = await this.enricher.enrichSignal(extractedSignal, {
+      workingDirectory: this.workDir
+    });
+    if (enrichedMeta.expandedTags.length > 0) {
+      console.log(`   \u2713 Expanded tags: ${enrichedMeta.expandedTags.slice(0, 5).join(", ")}${enrichedMeta.expandedTags.length > 5 ? "..." : ""}`);
+    }
+    if (enrichedMeta.dependencies.length > 0) {
+      console.log(`   \u2713 Dependencies: ${enrichedMeta.dependencies.join(", ")}`);
+    }
+    if (enrichedMeta.codebaseArea.length > 0) {
+      console.log(`   \u2713 Codebase areas: ${enrichedMeta.codebaseArea.join(", ")}`);
+    }
+    if (enrichedMeta.domain.length > 0) {
+      console.log(`   \u2713 Domains: ${enrichedMeta.domain.join(", ")}`);
+    }
+    console.log("\u{1F4BE} Storing in decision ledger...");
+    await this.storage.storeSignal(extractedSignal, {
+      expandedTags: enrichedMeta.expandedTags,
+      dependencies: enrichedMeta.dependencies,
+      codebaseArea: enrichedMeta.codebaseArea,
+      domain: enrichedMeta.domain
+    });
+    console.log("\u2705 Successfully stored in decision ledger");
+    return extractedSignal;
+  }
+  /**
+   * Add IDs and metadata to extracted signal
+   */
+  addIds(signal, context) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = {
+      extractedAt: now,
+      sourceType: context.sourceType,
+      extractionModel: "claude-haiku"
+    };
+    if (context.sourceId !== void 0) {
+      metadata.sourceId = context.sourceId;
+    }
+    return {
+      decisions: signal.decisions.map((d) => {
+        const decision = {
+          ...d,
+          id: d.id || this.generateId(),
+          when: d.when || now,
+          status: d.status || "active"
+        };
+        if (context.who !== void 0) {
+          decision.who = d.who || context.who;
         }
-      ]
+        return decision;
+      }),
+      facts: signal.facts.map((f) => ({
+        ...f,
+        id: f.id || this.generateId(),
+        when: f.when || now,
+        confidence: f.confidence ?? 0.8
+      })),
+      blockers: signal.blockers.map((b) => ({
+        ...b,
+        id: b.id || this.generateId(),
+        when: b.when || now
+      })),
+      questions: signal.questions.map((q) => ({
+        ...q,
+        id: q.id || this.generateId(),
+        when: q.when || now
+      })),
+      metadata
     };
   }
+  /**
+   * Generate a unique ID
+   */
+  generateId() {
+    return randomBytes(8).toString("hex");
+  }
+  /**
+   * Initialize storage
+   */
+  async initialize() {
+    await this.storage.initialize();
+  }
+  /**
+   * Close storage connections
+   */
+  close() {
+    this.storage.close();
+  }
 };
+async function processIncident(incidentDescription, options) {
+  const pipeline = new ExtractionPipeline(options);
+  await pipeline.initialize();
+  try {
+    return await pipeline.process(incidentDescription, {
+      sourceType: "incident",
+      sourceId: `incident-${Date.now()}`
+    });
+  } finally {
+    pipeline.close();
+  }
+}
 
 // src/tools/watch.ts
-import { watch, existsSync as existsSync4, readFileSync } from "fs";
-import { stat } from "fs/promises";
-import { join as join2, extname as extname4, basename as basename2 } from "path";
 var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -2565,6 +3071,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 var TrieWatchTool = class {
   scanTool = new TrieScanTool();
+  extractionPipeline = null;
   state = {
     isRunning: false,
     lastScan: /* @__PURE__ */ new Map(),
@@ -2622,6 +3129,14 @@ var TrieWatchTool = class {
         }]
       };
     }
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (anthropicApiKey) {
+      this.extractionPipeline = new ExtractionPipeline({
+        workingDirectory: directory,
+        anthropicApiKey
+      });
+      await this.extractionPipeline.initialize();
+    }
     this.state.isRunning = true;
     this.state.issueCache.clear();
     this.state.totalIssuesFound = 0;
@@ -2633,6 +3148,7 @@ var TrieWatchTool = class {
       console.error("TRIE AGENT - NOW WATCHING");
       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("Your Trie agent is now watching over your codebase.");
+      console.error("Signal extraction: ENABLED (building decision ledger)");
       console.error(`Watching: ${directory}`);
       console.error(`Debounce: ${debounceMs}ms`);
       console.error("");
@@ -2671,23 +3187,30 @@ var TrieWatchTool = class {
     return {
       content: [{
         type: "text",
-        text: `**TRIE AGENT ACTIVATED**
+        text: `**TRIE AGENT ACTIVATED** 
 
-Your Trie agent is now watching over your codebase. It will warn you about risky changes, remember what broke before, and nudge you when something looks dangerous.
+Your Trie agent is now autonomously watching and learning from your codebase.
 
 **Watching:** \`${directory}\`
 **Debounce:** ${debounceMs}ms (waits for you to stop typing)
+**Signal Extraction:** ${process.env.ANTHROPIC_API_KEY ? "\u2713 ENABLED" : "\u26A0\uFE0F LIMITED (set ANTHROPIC_API_KEY for full extraction)"}
 
-### How it works:
+### How the agent works:
 1. [*] You write/edit code
-2. [#] Guardian detects the change
-3. [?] Scans for risks based on your project's history
-4. [>] Nudges you in plain English if something looks risky
+2. [#] Agent detects the change
+3. [\u{1F9E0}] Extracts decisions, facts, blockers \u2192 stores in ledger
+4. [?] Predicts risks based on historical patterns
+5. [>] Nudges you in plain English if something looks risky
+
+### The agent learns:
+- Every commit builds the decision ledger
+- \`trie gotcha\` queries the ledger for predictions
+- \`trie ok\` / \`trie bad\` teach the agent what matters (coming soon)
 
 ### Commands:
-- \`trie_watch status\` - See guardian status
+- \`trie_watch status\` - See agent status
 - \`trie_watch issues\` - Get all issues found so far  
-- \`trie_watch stop\` - Stop the guardian
+- \`trie_watch stop\` - Stop the agent
 
 ---
 
@@ -2717,8 +3240,8 @@ ${initialResult.content?.[0]?.text || "Initial scan complete."}`
         }, debounceMs);
       });
       this.watchers.set(dir, watcher);
-      const { readdir: readdir3 } = await import("fs/promises");
-      const entries = await readdir3(dir, { withFileTypes: true });
+      const { readdir: readdir2 } = await import("fs/promises");
+      const entries = await readdir2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           await this.watchDirectory(join2(dir, entry.name), debounceMs);
@@ -2747,6 +3270,52 @@ Detected changes in ${files.length} file(s):`);
       console.error("");
     }
     try {
+      if (this.extractionPipeline) {
+        try {
+          const fileContents = await Promise.all(
+            files.map(async (file) => {
+              try {
+                const content = await readFile4(file, "utf-8");
+                return { file, content };
+              } catch {
+                return null;
+              }
+            })
+          );
+          const validFiles = fileContents.filter((f) => f !== null);
+          if (validFiles.length > 0) {
+            const combinedContent = validFiles.map(
+              (f) => `File: ${basename2(f.file)}
+${f.content.slice(0, 1e3)}`
+              // First 1KB of each file
+            ).join("\n\n---\n\n");
+            if (!isInteractiveMode()) {
+              console.error("\u{1F9E0} Extracting signals from changes...");
+            }
+            const signal = await this.extractionPipeline.process(combinedContent, {
+              sourceType: "file",
+              sourceId: `watch-${Date.now()}`
+            });
+            if (signal.decisions.length > 0 || signal.facts.length > 0 || signal.blockers.length > 0) {
+              if (!isInteractiveMode()) {
+                console.error(`   \u2713 Extracted: ${signal.decisions.length} decisions, ${signal.facts.length} facts, ${signal.blockers.length} blockers`);
+              }
+              if (this.streamingManager) {
+                this.streamingManager.reportSignalExtraction({
+                  decisions: signal.decisions.length,
+                  facts: signal.facts.length,
+                  blockers: signal.blockers.length,
+                  questions: signal.questions.length
+                });
+              }
+            }
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`   \u26A0\uFE0F Signal extraction failed: ${error}`);
+          }
+        }
+      }
       if (this.streamingManager) {
         for (const file of files) {
           this.streamingManager.reportWatchChange(file);
@@ -2921,6 +3490,10 @@ Found ${newIssues} issues in changed files!`);
       watcher.close();
     }
     this.watchers.clear();
+    if (this.extractionPipeline) {
+      this.extractionPipeline.close();
+      this.extractionPipeline = null;
+    }
     if (this.state.scanDebounceTimer) {
       clearTimeout(this.state.scanDebounceTimer);
     }
@@ -2941,14 +3514,16 @@ Found ${newIssues} issues in changed files!`);
     return {
       content: [{
         type: "text",
-        text: `[*] **AUTONOMOUS WATCH MODE STOPPED**
+        text: `[*] **TRIE AGENT STOPPED** \u{1F916}
 
 ### Session Summary:
 - Files scanned: ${this.state.filesScanned}
 - Total issues found: ${this.state.totalIssuesFound}
 - Directories watched: ${this.watchers.size}
+- Decision ledger: Updated continuously
 
-Use \`trie_watch start\` to start watching again.`
+The agent's learning has been stored in the decision ledger.
+Use \`trie_watch start\` to resume autonomous operation.`
       }]
     };
   }
@@ -2972,7 +3547,7 @@ Use \`trie_watch start\` to begin autonomous scanning.`
     ).join("\n");
     let agencyStatus = "";
     try {
-      const { getGuardian } = await import("./guardian-agent-ZHJXLBOU.js");
+      const { getGuardian } = await import("./guardian-agent-M352CBE5.js");
       const guardian = getGuardian(getWorkingDirectory(void 0, true));
       await guardian.initialize();
       const status = await guardian.getAgencyStatus();
@@ -3018,1226 +3593,66 @@ ${recentNudges || "(none)"}
           text: `[#] Recent nudges (${this.state.nudges.length} this session)
 ` + (this.state.nudges.length ? this.state.nudges.map(
             (n) => `- ${basename2(n.file)} [${n.severity}] @ ${n.timestamp}
-  ${n.message}`
-          ).join("\n") : "(none)")
-        },
-        {
-          type: "json",
-          json: this.state.nudges
-        }
-      ]
-    };
-  }
-  getCurrentIssues() {
-    return {
-      content: [{
-        type: "text",
-        text: `[L] **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 existsSync5 } from "fs";
-import { join as join3, extname as extname5, isAbsolute as isAbsolute4, resolve as resolve4, basename as basename3 } from "path";
-
-// 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(request2) {
-  const { type, query, context = {} } = request2;
-  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 TrieAgentTool = class {
-  agentRegistry = getSkillRegistry();
-  customSkillsLoaded = false;
-  /**
-   * Ensure custom skills are loaded before using the registry
-   */
-  async ensureCustomSkillsLoaded() {
-    if (!this.customSkillsLoaded) {
-      await this.agentRegistry.loadCustomSkills();
-      this.customSkillsLoaded = true;
-    }
-  }
-  async execute(args) {
-    const { agent, files, directory, depth: _depth = "standard", lookup, output = "full" } = args;
-    if (lookup) {
-      return this.handleKnowledgeLookup(lookup);
-    }
-    await this.ensureCustomSkillsLoaded();
-    if (!agent) {
-      return this.listSkills();
-    }
-    const agentInstance = this.agentRegistry.getSkill(agent);
-    if (!agentInstance) {
-      return {
-        content: [{
-          type: "text",
-          text: `Skill not found: ${agent}
-
-Available skills:
-${this.agentRegistry.getSkillNames().map((n) => `- ${n}`).join("\n")}`
-        }]
-      };
-    }
-    const workDir = getWorkingDirectory(directory);
-    let filesToScan = files || [];
-    if (!filesToScan.length) {
-      console.error(`
-Discovering files in: ${workDir}`);
-      filesToScan = await this.discoverFiles(workDir);
-      console.error(`   Found ${filesToScan.length} files
-`);
-    } else {
-      filesToScan = filesToScan.map(
-        (f) => isAbsolute4(f) ? f : resolve4(workDir, f)
-      );
-    }
-    const validFiles = filesToScan.filter((f) => existsSync5(f));
-    if (validFiles.length === 0) {
-      return {
-        content: [{
-          type: "text",
-          text: `No valid files found to scan.`
-        }]
-      };
-    }
-    const startTime = Date.now();
-    return this.runSkillScan(agentInstance, validFiles, startTime, output);
-  }
-  /**
-   * Run agent scan using the new hybrid AI system
-   * All agents now use scan() which has pattern detection + optional AI enhancement
-   */
-  async runSkillScan(agentInstance, files, startTime, _outputMode) {
-    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(`Running ${agentInstance.name.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(`${agentInstance.description}`);
-    console.error(`\u{1F4C2} Scanning ${files.length} files...`);
-    console.error(`   (Pattern detection + AI enhancement if API key is set)
-`);
-    try {
-      const result = await agentInstance.scan(files, { workingDir: getWorkingDirectory(void 0, true) });
-      const executionTime = Date.now() - startTime;
-      return {
-        content: [{
-          type: "text",
-          text: await this.formatSkillResult(agentInstance.name, result.issues, files, executionTime)
-        }]
-      };
-    } catch (error) {
-      return {
-        content: [{
-          type: "text",
-          text: `Skill error: ${error instanceof Error ? error.message : String(error)}`
-        }]
-      };
-    }
-  }
-  handleKnowledgeLookup(lookup) {
-    const result = lookupKnowledge({
-      type: lookup.type,
-      query: lookup.query,
-      context: lookup.context ?? {}
-    });
-    return {
-      content: [{
-        type: "text",
-        text: result
-      }]
-    };
-  }
-  listSkills() {
-    const skills = this.agentRegistry.getSkillDescriptions();
-    const skillList = skills.map((a) => {
-      const command = this.getSkillCommand(a.name);
-      return `| \`${command}\` | [PATTERN+AI] ${a.name} | ${a.description} |`;
-    }).join("\n");
-    return {
-      content: [{
-        type: "text",
-        text: `# \u{1F916} Available Skills
-
-| Command | Skill | Description |
-|---------|-------|-------------|
-${skillList}
-
-**Legend:** [PATTERN+AI] = Pattern detection + AI enhancement (if ANTHROPIC_API_KEY is set)
-
-## Usage
-
-### Run a specific skill:
-\`\`\`
-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 skills:
-\`\`\`
-trie_scan                        # Full scan with smart triaging
-\`\`\``
-      }]
-    };
-  }
-  getSkillCommand(agentName) {
-    const commandMap = {
-      "security": "trie_security",
-      "privacy": "trie_privacy",
-      "legal": "trie_legal",
-      "accessibility": "trie_accessibility",
-      "design-engineer": "trie_design",
-      "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 --skill ${agentName}`;
-  }
-  async formatSkillResult(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.getSkillEmoji(agentName);
-    let output = `
-`;
-    output += `# ${agentEmoji} ${agentName.toUpperCase()} SCAN
-
-`;
-    output += `**Files:** ${files.length} | **Time:** ${(executionTime / 1e3).toFixed(2)}s
-
-`;
-    if (issues.length === 0) {
-      output += `## No Issues Found
-
-`;
-      output += `Your code passed all ${agentName} checks.
-
-`;
-      return output;
-    }
-    output += `## ${issues.length} Issues Found
-
-`;
-    if (critical > 0) output += `[!] ${critical} Critical `;
-    if (serious > 0) output += `[!] ${serious} Serious `;
-    if (moderate > 0) output += `[~] ${moderate} Moderate `;
-    if (low > 0) output += `[-] ${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: "[!]", serious: "[!]", moderate: "[~]", low: "[-]" }[issue.severity];
-      output += `---
-
-`;
-      output += `${icon} **${issue.issue}**
-
-`;
-      output += `\`${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>Prompt to fix this</summary>
-
-`;
-      output += `\`\`\`
-Fix the ${issue.issue.toLowerCase()} in ${basename3(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 || !existsSync5(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;
-    }
-  }
-  getSkillEmoji(agentName) {
-    const emojis = {
-      "security": "[SEC]",
-      "privacy": "[PRIV]",
-      "legal": "[LEGAL]",
-      "accessibility": "[A11Y]",
-      "design-engineer": "[DESIGN]",
-      "software-architect": "[ARCH]",
-      "bug-finding": "[BUG]",
-      "user-testing": "[TEST]",
-      "typecheck": "[TYPE]",
-      "devops": "[OPS]",
-      "comprehension": "[DOC]",
-      "test": "[TEST]"
-    };
-    return emojis[agentName] || "[?]";
-  }
-  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 existsSync6 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { join as join4, basename as basename4, 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 (!existsSync6(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 || basename4(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 `
-**Document Parsed Successfully**
-
-${"\u2501".repeat(50)}
-
-**Creating Skill:** \`${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_skill\` to save the custom skill.
-
-${"\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 skill: ${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(getTrieDirectory(getWorkingDirectory(void 0, true)), "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 `
-**Custom Skill Created Successfully**
-
-${"\u2501".repeat(50)}
-
-**Skill Name:** \`${config.name}\`
-**Display Name:** ${config.displayName}
-**Category:** ${config.category}
-**Config Saved To:** \`${configPath}\`
-
-**Statistics:**
-   - Core concepts: ${config.knowledge.coreConcepts.length}
-   - Best practices: ${config.knowledge.bestPractices.length}
-   - Anti-patterns: ${config.knowledge.antiPatterns.length}
-   - Detection rules: ${config.patterns.length}
-
-**Next Steps:**
-   1. The skill is now registered and will activate during scans
-   2. Run \`trie_scan\` to test the new skill
-   3. Edit \`${configPath}\` to customize detection rules
-
-**Usage:**
-   The skill will automatically activate when scanning code that matches its patterns.
-   Use \`trie_list_skills\` to see all registered skills.
-`.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: [
+  ${n.message}`
+          ).join("\n") : "(none)")
+        },
         {
-          type: "text",
-          text: `\u274C **Error:** ${message}`
+          type: "json",
+          json: this.state.nudges
         }
-      ],
-      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 ? [
-        // Security & Compliance
-        { name: "security", displayName: "Security Agent", category: "security", isCustom: false },
-        { name: "privacy", displayName: "Privacy Agent", category: "privacy", isCustom: false },
-        { name: "soc2", displayName: "SOC 2 Agent", category: "compliance", isCustom: false },
-        { name: "legal", displayName: "Legal Agent", category: "compliance", isCustom: false },
-        // Code Quality
-        { name: "software-architect", displayName: "Architecture Agent", category: "architecture", isCustom: false },
-        { name: "bug-finding", displayName: "Bug Finding Agent", category: "quality", isCustom: false },
-        { name: "typecheck", displayName: "TypeCheck Agent", category: "quality", isCustom: false },
-        { name: "trie-clean", displayName: "Clean Agent", category: "ai-code", isCustom: false },
-        { name: "data-flow", displayName: "Data Flow Agent", category: "quality", isCustom: false },
-        // Design & UX
-        { name: "design-engineer", displayName: "Design Engineer Agent", category: "design", isCustom: false },
-        { name: "accessibility", displayName: "Accessibility Agent", category: "accessibility", isCustom: false },
-        { name: "user-testing", displayName: "UX Agent", category: "ux", isCustom: false },
-        { name: "visual-qa", displayName: "Visual QA Agent", category: "visual", isCustom: false },
-        // DevOps & Testing
-        { name: "devops", displayName: "DevOps Agent", category: "devops", isCustom: false },
-        { name: "test", displayName: "Test Agent", category: "testing", isCustom: false },
-        { name: "e2e", displayName: "E2E Agent", category: "testing", isCustom: false },
-        { name: "performance", displayName: "Performance Agent", category: "performance", isCustom: false },
-        // Review & Explanation
-        { name: "super-reviewer", displayName: "Super Reviewer", category: "review", isCustom: false },
-        { name: "agent-smith", displayName: "Agent Smith", category: "review", isCustom: false },
-        { name: "comprehension", displayName: "Comprehension Agent", category: "communication", isCustom: false }
-      ] : [];
-      let response = `# Registered Agents & Skills
-
-`;
-      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 Skills (${validCustomAgents.length})
-
-`;
-      if (validCustomAgents.length === 0) {
-        response += `_No custom skills created yet._
+  getCurrentIssues() {
+    return {
+      content: [{
+        type: "text",
+        text: `[L] **Issues Found This Session**
 
-`;
-        response += `Create one with: \`trie_create_skill\`
-`;
-        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}
+Total issues: ${this.state.totalIssuesFound}
+Files scanned: ${this.state.filesScanned}
 
-`;
-          }
-        }
-      }
-      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
-      };
-    }
+To get a full report, run \`trie_scan\` on your codebase.`
+      }]
+    };
   }
 };
 
 // src/tools/pr-review.ts
 import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join5, basename as basename5, resolve as resolve5, isAbsolute as isAbsolute5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join3, basename as basename3, resolve as resolve4, isAbsolute as isAbsolute4 } from "path";
+
+// src/skills/built-in/super-reviewer.ts
+var CRITICAL_REVIEW_CHECKLIST = {
+  stateAndLifecycle: [
+    "Uninitialized state accessed before setup",
+    "Missing cleanup on unmount/dispose",
+    "State mutations in wrong lifecycle phase"
+  ],
+  edgeCasesAndRaces: [
+    "Race conditions in async operations",
+    "Missing error handling for edge cases",
+    "Unhandled promise rejections"
+  ],
+  missingPieces: [
+    "Missing input validation",
+    "Missing error handling",
+    "Missing logging/monitoring"
+  ]
+};
+var SuperReviewerAgent = class {
+  async review(_files) {
+    return { issues: [] };
+  }
+  async buildReviewWorkflow(files, context) {
+    return { files, context };
+  }
+};
+
+// src/tools/pr-review.ts
 var TriePRReviewTool = class {
-  agent = new SuperReviewerSkill();
+  agent = new SuperReviewerAgent();
   exec(command, cwd, maxBuffer) {
     const opts = {
       captureOutput: false,
@@ -4319,15 +3734,15 @@ Usage:
    */
   async getPRInfo(pr, worktree) {
     if (worktree) {
-      const worktreePath = isAbsolute5(worktree) ? worktree : resolve5(getWorkingDirectory(void 0, true), worktree);
-      if (!existsSync7(worktreePath)) {
+      const worktreePath = isAbsolute4(worktree) ? worktree : resolve4(getWorkingDirectory(void 0, true), worktree);
+      if (!existsSync5(worktreePath)) {
         return { success: false, error: `Worktree not found: ${worktreePath}` };
       }
       return {
         success: true,
         type: "worktree",
         path: worktreePath,
-        title: `Local changes in ${basename5(worktreePath)}`,
+        title: `Local changes in ${basename3(worktreePath)}`,
         author: this.getGitUser(),
         baseBranch: "HEAD~1",
         headBranch: "HEAD"
@@ -4431,7 +3846,7 @@ Usage:
           deletions++;
         }
       }
-      files.push({ path: path3, diff, additions, deletions });
+      files.push({ path: path3, diff, additions, deletions, status: "modified" });
     }
     return files;
   }
@@ -4453,8 +3868,8 @@ Usage:
       "rfcs"
     ];
     for (const docPath of designDocPaths) {
-      const fullPath = join5(cwd, docPath);
-      if (existsSync7(fullPath)) {
+      const fullPath = join3(cwd, docPath);
+      if (existsSync5(fullPath)) {
       }
     }
     return designDocs;
@@ -4467,8 +3882,8 @@ Usage:
     const cwd = getWorkingDirectory(void 0, true);
     await Promise.all(filePaths.map(async (filePath) => {
       try {
-        const fullPath = isAbsolute5(filePath) ? filePath : join5(cwd, filePath);
-        if (existsSync7(fullPath)) {
+        const fullPath = isAbsolute4(filePath) ? filePath : join3(cwd, filePath);
+        if (existsSync5(fullPath)) {
           const content = await readFile5(fullPath, "utf-8");
           contents.set(filePath, content);
         }
@@ -5379,6 +4794,20 @@ var TrieTellTool = class {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const change = (await graph.getRecentChanges(1))[0];
       const linkedFiles = /* @__PURE__ */ new Set();
+      console.log("\n\u{1F9E0} Processing incident with signal extraction...");
+      let extractedSignal = null;
+      try {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        const options = {
+          workingDirectory: projectPath
+        };
+        if (apiKey) {
+          options.anthropicApiKey = apiKey;
+        }
+        extractedSignal = await processIncident(description, options);
+      } catch (error) {
+        console.warn("\u26A0\uFE0F  Signal extraction failed, continuing with basic incident tracking:", error);
+      }
       const incident = await graph.addNode("incident", {
         description,
         severity: "major",
@@ -5407,13 +4836,32 @@ var TrieTellTool = class {
       }
       const mentionedFiles = extractFilePathsFromDescription(description);
       mentionedFiles.forEach((f) => linkedFiles.add(f));
+      if (extractedSignal) {
+        for (const decision of extractedSignal.decisions) {
+          decision.files.forEach((f) => linkedFiles.add(f));
+        }
+      }
       const incidentIndex = new IncidentIndex(graph, projectPath);
       incidentIndex.addIncidentToTrie(incident, Array.from(linkedFiles));
       await exportToJson(graph);
+      let responseText = `Incident recorded${change ? ` and linked to change ${change.id}` : ""}.`;
+      if (extractedSignal) {
+        const counts = [
+          extractedSignal.decisions.length > 0 ? `${extractedSignal.decisions.length} decision(s)` : null,
+          extractedSignal.facts.length > 0 ? `${extractedSignal.facts.length} fact(s)` : null,
+          extractedSignal.blockers.length > 0 ? `${extractedSignal.blockers.length} blocker(s)` : null,
+          extractedSignal.questions.length > 0 ? `${extractedSignal.questions.length} question(s)` : null
+        ].filter(Boolean).join(", ");
+        if (counts) {
+          responseText += `
+
+\u{1F4CA} Extracted and stored: ${counts}`;
+        }
+      }
       return {
         content: [{
           type: "text",
-          text: `Incident recorded${change ? ` and linked to change ${change.id}` : ""}.`
+          text: responseText
         }]
       };
     } catch (error) {
@@ -5535,6 +4983,178 @@ var LinearSyncTool = class {
   }
 };
 
+// src/tools/query-tools.ts
+var TrieGetDecisionsTool = class {
+  async execute(input) {
+    const workDir = input.directory || getWorkingDirectory(void 0, true);
+    const storage = getStorage(workDir);
+    await storage.initialize();
+    let timeWindow;
+    if (input.since) {
+      const now = /* @__PURE__ */ new Date();
+      if (input.since.endsWith("d")) {
+        const days = parseInt(input.since);
+        const start = new Date(now);
+        start.setDate(start.getDate() - days);
+        timeWindow = { start: start.toISOString() };
+      } else {
+        timeWindow = { start: input.since };
+      }
+    }
+    const query = {
+      limit: input.limit || 10
+    };
+    if (input.relatedTo) query.relatedTo = input.relatedTo;
+    if (input.tags) query.tags = input.tags;
+    if (timeWindow) query.timeWindow = timeWindow;
+    const decisions = await storage.queryDecisions(query);
+    return {
+      content: [{
+        type: "text",
+        text: this.formatDecisions(decisions)
+      }]
+    };
+  }
+  formatDecisions(decisions) {
+    if (decisions.length === 0) {
+      return "No decisions found matching query.";
+    }
+    let output = `Found ${decisions.length} decision(s):
+
+`;
+    for (const dec of decisions) {
+      const when = new Date(dec.when).toLocaleDateString();
+      output += `\u{1F4CB} ${dec.decision}
+`;
+      output += `   Context: ${dec.context}
+`;
+      if (dec.reasoning) {
+        output += `   Reasoning: ${dec.reasoning}
+`;
+      }
+      if (dec.tradeoffs && dec.tradeoffs.length > 0) {
+        output += `   Tradeoffs considered: ${dec.tradeoffs.join(", ")}
+`;
+      }
+      output += `   When: ${when}
+`;
+      if (dec.files.length > 0) {
+        output += `   Files: ${dec.files.join(", ")}
+`;
+      }
+      output += `   Tags: ${dec.tags.join(", ")}
+`;
+      output += `
+`;
+    }
+    return output;
+  }
+};
+var TrieGetBlockersTool = class {
+  async execute(input) {
+    const workDir = input.directory || getWorkingDirectory(void 0, true);
+    const storage = getStorage(workDir);
+    await storage.initialize();
+    const query = {
+      limit: input.limit || 5
+    };
+    if (input.tags) query.tags = input.tags;
+    const blockers = await storage.queryBlockers(query);
+    return {
+      content: [{
+        type: "text",
+        text: this.formatBlockers(blockers)
+      }]
+    };
+  }
+  formatBlockers(blockers) {
+    if (blockers.length === 0) {
+      return "\u2705 No active blockers found.";
+    }
+    let output = `\u26A0\uFE0F  Found ${blockers.length} active blocker(s):
+
+`;
+    for (const blocker of blockers) {
+      const impact = blocker.impact.toUpperCase();
+      const emoji = blocker.impact === "critical" ? "\u{1F534}" : blocker.impact === "high" ? "\u{1F7E0}" : blocker.impact === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      output += `${emoji} [${impact}] ${blocker.blocker}
+`;
+      if (blocker.affectedAreas.length > 0) {
+        output += `   Affects: ${blocker.affectedAreas.join(", ")}
+`;
+      }
+      output += `   Since: ${new Date(blocker.when).toLocaleDateString()}
+`;
+      output += `
+`;
+    }
+    return output;
+  }
+};
+var TrieGetRelatedDecisionsTool = class {
+  async execute(input) {
+    const workDir = input.directory || getWorkingDirectory(void 0, true);
+    const storage = getStorage(workDir);
+    await storage.initialize();
+    const query = {
+      limit: input.limit || 5
+    };
+    const relatedTo = input.file || input.topic;
+    if (relatedTo) query.relatedTo = relatedTo;
+    const decisions = await storage.queryDecisions(query);
+    return {
+      content: [{
+        type: "text",
+        text: new TrieGetDecisionsTool().formatDecisions(decisions)
+      }]
+    };
+  }
+};
+var TrieQueryContextTool = class {
+  async execute(input) {
+    const workDir = input.directory || getWorkingDirectory(void 0, true);
+    const storage = getStorage(workDir);
+    await storage.initialize();
+    const keywords = input.query.toLowerCase().split(/\s+/);
+    let output = `Query: "${input.query}"
+
+`;
+    if (!input.type || input.type === "decisions" || input.type === "all") {
+      const decisions = await storage.queryDecisions({ limit: input.limit || 5 });
+      const matches = decisions.filter(
+        (d) => keywords.some(
+          (kw) => d.decision.toLowerCase().includes(kw) || d.context.toLowerCase().includes(kw) || d.tags.some((t) => t.toLowerCase().includes(kw))
+        )
+      );
+      if (matches.length > 0) {
+        output += `\u{1F4CB} DECISIONS (${matches.length}):
+`;
+        output += new TrieGetDecisionsTool().formatDecisions(matches);
+        output += "\n";
+      }
+    }
+    if (!input.type || input.type === "blockers" || input.type === "all") {
+      const blockers = await storage.queryBlockers({ limit: input.limit || 5 });
+      const matches = blockers.filter(
+        (b) => keywords.some(
+          (kw) => b.blocker.toLowerCase().includes(kw) || b.tags.some((t) => t.toLowerCase().includes(kw))
+        )
+      );
+      if (matches.length > 0) {
+        output += `\u26A0\uFE0F  BLOCKERS (${matches.length}):
+`;
+        output += new TrieGetBlockersTool().formatBlockers(matches);
+      }
+    }
+    return {
+      content: [{
+        type: "text",
+        text: output.trim() || "No matches found."
+      }]
+    };
+  }
+};
+
 // src/server/tool-registry.ts
 var TrieCheckpointTool = class {
   async execute(input) {
@@ -5559,15 +5179,7 @@ var ToolRegistry = class {
     this.tools.set("fix", new TrieFixTool());
     this.tools.set("explain", new TrieExplainTool());
     this.tools.set("test", new TrieTestTool());
-    this.tools.set("register_agent", new TrieRegisterAgentTool());
     this.tools.set("watch", new TrieWatchTool());
-    this.tools.set("agent", new TrieAgentTool());
-    this.tools.set("create_skill", new TrieCreateAgentTool());
-    this.tools.set("create_agent", new TrieCreateAgentTool());
-    this.tools.set("save_skill", new TrieSaveAgentTool());
-    this.tools.set("save_agent", new TrieSaveAgentTool());
-    this.tools.set("list_skills", new TrieListAgentsTool());
-    this.tools.set("list_agents", new TrieListAgentsTool());
     this.tools.set("pr_review", new TriePRReviewTool());
     this.tools.set("project", new TrieProjectInfoTool());
     this.tools.set("init", new TrieInitTool());
@@ -5581,6 +5193,10 @@ var ToolRegistry = class {
     this.tools.set("ok", new TrieFeedbackTool());
     this.tools.set("bad", new TrieFeedbackTool());
     this.tools.set("linear_sync", new LinearSyncTool());
+    this.tools.set("get_decisions", new TrieGetDecisionsTool());
+    this.tools.set("get_blockers", new TrieGetBlockersTool());
+    this.tools.set("get_related_decisions", new TrieGetRelatedDecisionsTool());
+    this.tools.set("query_context", new TrieQueryContextTool());
   }
   defineToolSchemas() {
     this.definitions = [
@@ -5667,7 +5283,7 @@ var ToolRegistry = class {
           properties: {
             action: {
               type: "string",
-              description: "Optional quick action: scan, security, privacy, bugs, types, devops, architecture, ux, clean, soc2, performance, e2e, visual_qa, data_flow, agent_smith, pr_review, watch, fix, explain"
+              description: "Optional quick action: scan, security, legal, bugs, types, devops, architecture, ux, clean, soc2, performance, e2e, visual_qa, data_flow, agent_smith, pr_review, watch, fix, explain"
             },
             agent: {
               type: "string",
@@ -5847,31 +5463,6 @@ var ToolRegistry = class {
           required: ["action"]
         }
       },
-      {
-        name: "trie_register_agent",
-        description: "Register an agent by name and path. Alias: register_agent",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: { type: "string", description: "Name of the agent" },
-            path: { type: "string", description: "Path to the agent implementation" }
-          },
-          required: ["name", "path"]
-        }
-      },
-      {
-        name: "trie_list_skills",
-        description: "List all skills (external and custom). Alias: list_skills, list_agents",
-        inputSchema: {
-          type: "object",
-          properties: {
-            includeBuiltin: {
-              type: "boolean",
-              description: "Include built-in agents (default true)"
-            }
-          }
-        }
-      },
       {
         name: "trie_project",
         description: "View and manage project information (.trie/PROJECT.md). Store project context for AI assistants. Alias: project",
@@ -6009,105 +5600,9 @@ var ToolRegistry = class {
         }
       },
       // Add remaining tool definitions...
-      this.createAgentToolDefinitions(),
-      this.createCustomSkillDefinitions(),
       this.createSpecialAgentDefinitions()
     ].flat();
   }
-  createAgentToolDefinitions() {
-    const agentTypes = [
-      { name: "security", desc: "detect vulnerabilities, injection risks, auth issues, hardcoded secrets" },
-      { name: "privacy", desc: "PII handling, GDPR/HIPAA compliance, data encryption" },
-      { name: "legal", desc: "GDPR, CCPA, consent patterns, data retention compliance" },
-      { name: "accessibility", desc: "WCAG 2.1 compliance, keyboard nav, screen readers, color contrast" },
-      { name: "design", desc: "Awwwards-level polish, design systems, motion design, creative CSS" },
-      { name: "architecture", desc: "code organization, SOLID principles, N+1 queries, scalability" },
-      { name: "bugs", desc: "null safety, edge cases, common bugs, async issues" },
-      { name: "ux", desc: "simulate happy path, security tester, confused user, impatient user" },
-      { name: "types", desc: "type errors, missing annotations, null checks" },
-      { name: "devops", desc: "config issues, logging, environment variables, deployment patterns" },
-      { name: "clean", desc: "\u{1F9F9} Clean up AI-generated code: find common mistakes, bad patterns, and quick fixes" },
-      { name: "soc2", desc: "SOC 2 compliance: access controls, secrets management, encryption, logging, change management" }
-    ];
-    return agentTypes.map((agent) => ({
-      name: `trie_${agent.name}`,
-      description: `Run ${agent.name} agent: ${agent.desc}. Alias: ${agent.name}`,
-      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)"
-          }
-        }
-      }
-    }));
-  }
-  createCustomSkillDefinitions() {
-    return [
-      {
-        name: "trie_create_skill",
-        description: "Create a custom skill from a document. Returns extraction prompt for Claude to process. Alias: create_skill, create_agent",
-        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 content). Use this OR filePath."
-            },
-            skillName: {
-              type: "string",
-              description: 'Name for the new skill (e.g., "react-fundamentals")'
-            },
-            displayName: { type: "string", description: "Optional display name" },
-            description: { type: "string", description: "Optional description" },
-            category: { type: "string", description: 'Optional category (e.g., "security", "react")' }
-          },
-          required: ["skillName"]
-        }
-      },
-      {
-        name: "trie_save_skill",
-        description: "Save a custom skill config after Claude extracts knowledge. Alias: save_skill, save_agent",
-        inputSchema: {
-          type: "object",
-          properties: {
-            skillConfig: {
-              type: "object",
-              description: "Skill configuration",
-              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" },
-            detectionRules: { type: "array", description: "Detection rules array" },
-            prompts: {
-              type: "object",
-              properties: {
-                systemPrompt: { type: "string" },
-                analysisPrompt: { type: "string" },
-                fixPrompt: { type: "string" }
-              },
-              required: ["systemPrompt", "analysisPrompt", "fixPrompt"]
-            }
-          },
-          required: ["skillConfig", "knowledge", "detectionRules", "prompts"]
-        }
-      }
-    ];
-  }
   createSpecialAgentDefinitions() {
     return [
       {
@@ -6153,76 +5648,72 @@ var ToolRegistry = class {
         }
       },
       {
-        name: "trie_agent_smith",
-        description: '\u{1F574}\uFE0F Agent Smith: Relentless pattern hunter. "It is... inevitable." Alias: agent_smith',
+        name: "trie_linear_sync",
+        description: "Sync active Linear tickets to build context for JIT defect prediction. Alias: linear_sync",
         inputSchema: {
           type: "object",
           properties: {
-            files: {
-              type: "array",
-              items: { type: "string" },
-              description: "Files to scan (defaults to entire codebase)"
-            },
-            directory: {
-              type: "string",
-              description: "Directory to scan. Pass the workspace/project root path for accurate results."
-            },
-            clear_memory: {
-              type: "boolean",
-              description: "Clear Agent Smith's memory bank"
-            },
-            show_stats: {
-              type: "boolean",
-              description: "Show memory statistics"
-            }
+            directory: { type: "string", description: "Project directory" }
           }
         }
       },
       {
-        name: "trie_smith",
-        description: "\u{1F574}\uFE0F Agent Smith (alias): Hunt AI-generated code anti-patterns. 43 specialized hunters. Alias: smith",
+        name: "trie_get_decisions",
+        description: "Query decisions from decision ledger with targeted retrieval. Prevents context pollution by returning only relevant decisions.",
         inputSchema: {
           type: "object",
           properties: {
-            files: {
-              type: "array",
-              items: { type: "string" },
-              description: "Files to scan (defaults to entire codebase)"
-            },
-            directory: {
-              type: "string",
-              description: "Directory to scan. Pass the workspace/project root path for accurate results."
-            }
+            relatedTo: { type: "string", description: "File path or topic to find related decisions" },
+            tags: { type: "array", items: { type: "string" }, description: "Filter by tags" },
+            since: { type: "string", description: 'Time filter: ISO date or "7d", "30d", "90d"' },
+            limit: { type: "number", description: "Max results (default 10)" },
+            directory: { type: "string", description: "Working directory" }
           }
         }
       },
       {
-        name: "trie_linear_sync",
-        description: "Sync active Linear tickets to build context for JIT defect prediction. Alias: linear_sync",
+        name: "trie_get_blockers",
+        description: "Get active blockers from decision ledger. Returns only unresolved blockers to avoid noise.",
         inputSchema: {
           type: "object",
           properties: {
-            directory: { type: "string", description: "Project directory" }
+            tags: { type: "array", items: { type: "string" }, description: "Filter by tags" },
+            limit: { type: "number", description: "Max results (default 5)" },
+            directory: { type: "string", description: "Working directory" }
           }
         }
       },
       {
-        name: "trie_super_reviewer",
-        description: "\u{1F50D} Super Reviewer: Interactive PR review with cross-examination. Walks through changes file-by-file.",
+        name: "trie_get_related_decisions",
+        description: "Find decisions related to a specific decision, file, or topic. Targeted context retrieval.",
         inputSchema: {
           type: "object",
           properties: {
-            files: {
-              type: "array",
-              items: { type: "string" },
-              description: "Files to review (defaults to changed files)"
-            },
-            directory: {
-              type: "string",
-              description: "Directory to review. Pass the workspace/project root path."
-            }
+            decisionId: { type: "string", description: "Decision ID to find related decisions" },
+            file: { type: "string", description: "File path to find related decisions" },
+            topic: { type: "string", description: "Topic to find related decisions" },
+            limit: { type: "number", description: "Max results (default 5)" },
+            directory: { type: "string", description: "Working directory" }
           }
         }
+      },
+      {
+        name: "trie_query_context",
+        description: "Query decision ledger with natural language. Returns targeted signal, not full dump.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Natural language query" },
+            type: {
+              type: "string",
+              enum: ["decisions", "blockers", "facts", "questions", "all"],
+              description: "Type of context to query (default: all)"
+            },
+            limit: { type: "number", description: "Max results per type (default 5)" },
+            directory: { type: "string", description: "Working directory" }
+          },
+          required: ["query"]
+        }
       }
     ];
   }
@@ -6241,9 +5732,9 @@ var ToolRegistry = class {
 };
 
 // src/server/resource-manager.ts
-import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { readdir, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var UI_APPS = {
   "scan-dashboard": {
@@ -6357,8 +5848,8 @@ var ResourceManager = class {
   }
   async getScanReportResources() {
     try {
-      const reportsDir = join6(getWorkingDirectory(void 0, true), "trie-reports");
-      const files = await readdir2(reportsDir);
+      const reportsDir = join4(getWorkingDirectory(void 0, true), "trie-reports");
+      const files = await readdir(reportsDir);
       const reportFiles = files.filter((f) => f.endsWith(".txt") || f.endsWith(".json"));
       return reportFiles.slice(0, 10).map((file) => ({
         uri: `trie://reports/${file}`,
@@ -6457,10 +5948,10 @@ var ResourceManager = class {
   async getUIAppResource(uri, appId) {
     const currentFile = fileURLToPath(import.meta.url);
     const distDir = dirname2(dirname2(currentFile));
-    const uiDir = join6(distDir, "ui");
-    const htmlPath = join6(uiDir, `${appId}.html`);
+    const uiDir = join4(distDir, "ui");
+    const htmlPath = join4(uiDir, `${appId}.html`);
     try {
-      if (!existsSync8(htmlPath)) {
+      if (!existsSync6(htmlPath)) {
         return {
           contents: [{
             uri,
@@ -6650,9 +6141,9 @@ var ResourceManager = class {
     } catch {
     }
     summary.push("---", "", "# Detailed Context", "");
-    const agentsMdPath = join6(getTrieDirectory(workDir), "AGENTS.md");
+    const agentsMdPath = join4(getTrieDirectory(workDir), "AGENTS.md");
     try {
-      if (existsSync8(agentsMdPath)) {
+      if (existsSync6(agentsMdPath)) {
         const agentsContent = await readFile6(agentsMdPath, "utf-8");
         summary.push(agentsContent);
       } else {
@@ -6778,7 +6269,7 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getCacheStatsResource(uri) {
     try {
-      const cachePath = join6(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
+      const cachePath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
       const cacheContent = await readFile6(cachePath, "utf-8");
       const cache = JSON.parse(cacheContent);
       const fileCount = Object.keys(cache.files || {}).length;
@@ -6813,8 +6304,8 @@ This information is automatically available to Claude Code, Cursor, and other AI
     }
   }
   async getSignaturesResource(uri) {
-    const { getVulnerabilityStats } = await import("./vulnerability-signatures-ZKVLMBRG.js");
-    const { getVibeCodeStats } = await import("./vibe-code-signatures-K4UIWKJZ.js");
+    const { getVulnerabilityStats } = await import("./vulnerability-signatures-EIJQX2TS.js");
+    const { getVibeCodeStats } = await import("./vibe-code-signatures-ELEWJFGZ.js");
     const vulnStats = getVulnerabilityStats();
     const vibeStats = getVibeCodeStats();
     return {
@@ -6858,7 +6349,7 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getScanReportResource(uri, parsedUri) {
     const fileName = parsedUri.replace("reports/", "");
-    const reportPath = join6(getWorkingDirectory(void 0, true), "trie-reports", fileName);
+    const reportPath = join4(getWorkingDirectory(void 0, true), "trie-reports", fileName);
     try {
       const content = await readFile6(reportPath, "utf-8");
       return {
@@ -7007,32 +6498,32 @@ async function findOpenPort() {
   return portChecks.find((port) => port !== null) || null;
 }
 async function checkPort(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     const testServer = createServer();
     let portInUse = false;
     testServer.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
         portInUse = true;
-        testHttpPort(port).then(resolve6).catch(() => resolve6(false));
+        testHttpPort(port).then(resolve5).catch(() => resolve5(false));
       } else {
-        resolve6(false);
+        resolve5(false);
       }
     });
     testServer.once("listening", () => {
       testServer.close();
-      resolve6(false);
+      resolve5(false);
     });
     setTimeout(() => {
       if (!portInUse) {
         testServer.close();
-        resolve6(false);
+        resolve5(false);
       }
     }, 1e3);
     testServer.listen(port, "127.0.0.1");
   });
 }
 async function testHttpPort(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     const req = request({
       hostname: "localhost",
       port,
@@ -7040,18 +6531,18 @@ async function testHttpPort(port) {
       method: "GET",
       timeout: 2e3
     }, (res) => {
-      resolve6(res.statusCode !== void 0);
+      resolve5(res.statusCode !== void 0);
       res.on("data", () => {
       });
       res.on("end", () => {
       });
     });
     req.on("error", () => {
-      resolve6(false);
+      resolve5(false);
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve6(false);
+      resolve5(false);
     });
     req.end();
   });
@@ -7339,8 +6830,6 @@ var RequestHandlers = class {
         // Individual agent commands
         case "security":
           return await this.toolRegistry.getTool("agent").execute({ ...args, agent: "security" });
-        case "privacy":
-          return await this.toolRegistry.getTool("agent").execute({ ...args, agent: "privacy" });
         case "legal":
           return await this.toolRegistry.getTool("agent").execute({ ...args, agent: "legal" });
         case "accessibility":
@@ -7535,7 +7024,7 @@ npx playwright install chromium
           '- `action: "visual_qa_browser"` \u2014 screenshots for visual QA',
           "",
           "**Built-in skills:**",
-          "`security`, `privacy`, `legal`, `accessibility`, `design`, `architecture`, `bugs`, `ux`, `types`, `devops`, `clean`, `soc2`, `performance`, `e2e`, `visual_qa`, `data_flow`",
+          "`security`, `legal`, `accessibility`, `design`, `architecture`, `bugs`, `ux`, `types`, `devops`, `clean`, `soc2`, `performance`, `e2e`, `visual_qa`, `data_flow`",
           "",
           "**Special skills:**",
           "`agent_smith` \u2014 35 vibe code hunters with cross-file detection",
@@ -7546,37 +7035,23 @@ npx playwright install chromium
       }]
     };
   }
-  async handleAgentSmith(smithArgs) {
-    const { AgentSmithSkill } = await import("./agent-smith-QYDXPFPJ.js");
-    if (smithArgs.clear_memory) {
-      const smith = new AgentSmithSkill();
-      const result = await smith.clearMemory();
-      return {
-        content: [{ type: "text", text: result.message }]
-      };
-    }
-    if (smithArgs.show_stats) {
-      const smith = new AgentSmithSkill();
-      const stats = await smith.getMemoryStats();
-      return {
-        content: [{
-          type: "text",
-          text: [
-            "\u{1F574}\uFE0F Agent Smith Memory Statistics",
-            "\u2550".repeat(40),
-            `Tracked issues: ${stats.issueCount}`,
-            `Dismissed issues: ${stats.dismissedCount}`,
-            `Resurrected issues: ${stats.resurrectedCount}`,
-            `Oldest issue: ${stats.oldestIssue ? new Date(stats.oldestIssue).toLocaleDateString() : "N/A"}`,
-            `Memory file size: ${stats.fileSizeKB} KB`,
-            "",
-            "To clear memory: trie_agent_smith with clear_memory:true"
-          ].join("\n")
-        }]
-      };
-    }
-    const agentSmithRunner = await import("./agent-smith-runner-GXGDJTSR.js");
-    return await agentSmithRunner.runAgentSmith(smithArgs);
+  async handleAgentSmith(_smithArgs) {
+    return {
+      content: [{
+        type: "text",
+        text: [
+          "\u{1F916} Agent Smith functionality has been integrated into the decision ledger.",
+          "",
+          "The autonomous agent now:",
+          "- Extracts patterns automatically via `trie watch`",
+          "- Builds decision ledger from every change",
+          "- Predicts problems via `trie gotcha`",
+          "",
+          "Start the agent: `trie_watch start`",
+          "Query the ledger: `trie_gotcha`"
+        ].join("\n")
+      }]
+    };
   }
 };