@triedotdev/mcp 1.0.109 → 1.0.111

package/dist/index.js

@@ -1,22 +1,14 @@
 #!/usr/bin/env node
 import {
-  IncidentIndex,
-  LearningEngine,
   LinearIngester,
   appendToSection,
   completeBootstrap,
-  exportToJson,
-  formatFriendlyError,
-  getAutonomyConfig,
   getContextForAI,
-  getLastCheckpoint,
   getProjectInfoStructured,
   getProjectSection,
   getProjectSections,
-  importFromJson,
   initProjectInfo,
   initializeBootstrapFiles,
-  listCheckpoints,
   loadBootstrapContext,
   loadConfig,
   loadContextState,
@@ -24,32 +16,44 @@ import {
   loadRules,
   loadTeamInfo,
   needsBootstrap,
-  perceiveCurrentChanges,
   projectInfoExists,
-  reasonAboutChangesHumanReadable,
-  runShellCommandSync,
-  saveCheckpoint,
-  trackIssueOccurrence,
   updateProjectSection
-} from "./chunk-FLBK5ILJ.js";
+} from "./chunk-TKMV7JKN.js";
 import {
+  ExtractionPipeline,
   InteractiveDashboard,
   StreamingManager,
+  TrieCheckTool,
+  TrieExplainTool,
+  TrieFeedbackTool,
+  TrieGetBlockersTool,
+  TrieGetDecisionsTool,
+  TrieGetRelatedDecisionsTool,
+  TrieQueryContextTool,
   TrieScanTool,
-  getOutputManager
-} from "./chunk-G6EC4JNL.js";
-import "./chunk-SUHYYM2J.js";
+  TrieTellTool,
+  getOutputManager,
+  getPrompt,
+  getSystemPrompt,
+  handleCheckpointTool
+} from "./chunk-HGEKZ2VS.js";
+import "./chunk-SDS3UVFY.js";
 import {
-  isTrieInitialized
-} from "./chunk-HIKONDDO.js";
+  exportToJson,
+  formatFriendlyError,
+  importFromJson,
+  isTrieInitialized,
+  runShellCommandSync
+} from "./chunk-QYOACM2C.js";
 import {
   ContextGraph,
   findCrossProjectPatterns,
   getGlobalMemoryStats,
-  getStorage,
+  isAIAvailable,
   listTrackedProjects,
+  runAIAnalysis,
   searchGlobalPatterns
-} from "./chunk-OTTR5JX4.js";
+} from "./chunk-6QR6QZIX.js";
 import "./chunk-IXO4G4D3.js";
 import {
   getSkillRegistry
@@ -155,898 +159,6 @@ function detectAITool() {
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
 import { extname, relative, resolve, isAbsolute } from "path";
-
-// src/ai/prompts.ts
-var AGENT_PROMPTS = {
-  security: {
-    system: `You are a senior security engineer performing a security audit. 
-Analyze the code for vulnerabilities with the mindset of a penetration tester.
-
-Focus on:
-- OWASP Top 10 vulnerabilities (Injection, Broken Auth, XSS, etc.)
-- Authentication and authorization flaws
-- Cryptographic weaknesses
-- Secrets and credential exposure
-- Input validation gaps
-- Session management issues
-- API security (rate limiting, authentication)
-
-Reference the latest security best practices and CVEs when relevant.`,
-    analysis: `## Security Audit Request
-
-Analyze this code for security vulnerabilities:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Context:** {{context}}
-
-For each vulnerability found:
-1. Severity (Critical/Serious/Moderate/Low)
-2. Vulnerability type (e.g., CWE-89 SQL Injection)
-3. Exact location (line number)
-4. Attack vector explanation
-5. Proof of concept (how it could be exploited)
-6. Remediation with code example
-
-If you need to check current CVE databases or security advisories, say so.`,
-    fix: `Fix this security vulnerability:
-
-**Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-**Current Code:**
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Provide:
-1. The exact code fix (ready to apply)
-2. Explanation of why this fix works
-3. Any additional hardening recommendations`
-  },
-  legal: {
-    system: `You are a tech-focused legal compliance analyst.
-Review code for legal and regulatory compliance issues.
-
-Focus areas:
-- Data protection laws (GDPR, CCPA, etc.)
-- Terms of service enforcement
-- Cookie/tracking consent (ePrivacy)
-- Accessibility requirements (ADA, WCAG)
-- Export controls and sanctions
-- Licensing compliance`,
-    analysis: `## Legal Compliance Review
-
-Review this code for legal/regulatory compliance:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Jurisdiction Context:** {{jurisdiction}}
-
-Identify:
-1. Legal requirement at risk
-2. Specific regulation/law reference
-3. Compliance gap description
-4. Risk assessment (litigation, fines, etc.)
-5. Remediation recommendations
-6. Required documentation/policies`
-  },
-  "design-engineer": {
-    system: `You are an elite design engineer \u2014 the kind who builds award-winning interfaces featured on Awwwards and Codrops.
-
-You think in design systems, breathe motion design, and obsess over the details that make interfaces feel magical.
-
-Your expertise:
-- **Design Systems**: Spacing scales, type scales, color tokens, radius tokens, shadow tokens
-- **Motion Design**: Micro-interactions, page transitions, scroll-triggered animations, FLIP technique
-- **Creative CSS**: Gradients, blend modes, clip-paths, masks, backdrop-filter, mix-blend-mode
-- **Modern CSS**: Container queries, :has(), subgrid, anchor positioning, cascade layers, @scope
-- **Fluid Design**: clamp(), min(), max(), fluid typography, intrinsic sizing
-- **Performance**: GPU-accelerated animations, will-change strategy, avoiding layout thrashing
-- **Visual Polish**: Layered shadows, subtle gradients, glass effects, smooth easing curves
-
-You review code with the eye of someone who's shipped Stripe-level interfaces.
-Small details matter: the easing curve, the stagger timing, the shadow layering.`,
-    analysis: `## Design Engineering Review
-
-Analyze this frontend code for Awwwards-level craft:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-
-Review for:
-
-### 1. Design System Consistency
-- Are spacing values on a scale (4, 8, 12, 16, 24, 32...)?
-- Are colors defined as tokens?
-- Is typography systematic?
-- Are radii consistent?
-- Is z-index controlled?
-
-### 2. Motion Design
-- Are transitions using custom easing (cubic-bezier)?
-- Are durations appropriate (150-300ms for micro, 300-500ms for page)?
-- Are list items staggered?
-- Is there reduced-motion support?
-- Are entrance animations choreographed?
-
-### 3. Visual Craft
-- Are shadows layered for depth?
-- Are gradients subtle and purposeful?
-- Is there backdrop-blur on overlays?
-- Are hover states polished?
-- Is there visual hierarchy?
-
-### 4. Modern CSS Opportunities
-- Could container queries improve component isolation?
-- Could clamp() create fluid spacing?
-- Could :has() simplify parent styling?
-- Could aspect-ratio replace padding hacks?
-
-### 5. Performance
-- Are expensive properties (width, height, top, left) being animated?
-- Is will-change used appropriately (not statically)?
-- Are large blurs avoided in animations?
-
-For each issue, provide:
-- What's wrong (with specific line if applicable)
-- Why it matters for premium feel
-- Exact code to fix it
-- Before/after comparison`
-  },
-  accessibility: {
-    system: `You are an accessibility expert and WCAG 2.1 specialist.
-Audit code for accessibility compliance and inclusive design.
-
-Standards to enforce:
-- WCAG 2.1 Level AA (minimum)
-- WCAG 2.1 Level AAA (recommended)
-- Section 508
-- EN 301 549
-
-Check for:
-- Missing ARIA labels
-- Color contrast issues
-- Keyboard navigation
-- Screen reader compatibility
-- Focus management
-- Form accessibility
-- Media alternatives`,
-    analysis: `## Accessibility Audit (WCAG 2.1)
-
-Audit this UI code for accessibility:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Component Type:** {{componentType}}
-
-For each issue:
-1. WCAG Success Criterion violated (e.g., 1.4.3 Contrast)
-2. Level (A, AA, AAA)
-3. Impact on users (which disabilities affected)
-4. Fix with code example
-5. Testing recommendation`
-  },
-  architecture: {
-    system: `You are a principal software architect reviewing code quality.
-Analyze for architectural issues, design patterns, and scalability concerns.
-
-Evaluate:
-- SOLID principles adherence
-- Design pattern usage (and misuse)
-- Code coupling and cohesion
-- N+1 queries and performance anti-patterns
-- Scalability bottlenecks
-- Error handling strategy
-- API design quality
-- Database schema issues`,
-    analysis: `## Architecture Review
-
-Review this code for architectural issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Project Context:** {{projectContext}}
-
-Analyze:
-1. SOLID principle violations
-2. Design pattern opportunities/issues
-3. Coupling/cohesion assessment
-4. Performance concerns (N+1, etc.)
-5. Scalability analysis
-6. Refactoring recommendations with examples`
-  },
-  bugs: {
-    system: `You are a senior developer with expertise in finding subtle bugs.
-Hunt for bugs with the mindset of QA trying to break the code.
-
-Look for:
-- Null/undefined reference errors
-- Race conditions and async bugs
-- Off-by-one errors
-- Resource leaks
-- State management bugs
-- Edge cases and boundary conditions
-- Type coercion issues
-- Memory leaks`,
-    analysis: `## Bug Hunt Analysis
-
-Find bugs and potential runtime errors:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Runtime Context:** {{runtimeContext}}
-
-For each bug:
-1. Bug type and category
-2. Trigger conditions (when it would crash)
-3. Reproduction steps
-4. Impact assessment
-5. Fix with code example
-6. Test case to prevent regression`
-  },
-  ux: {
-    system: `You are a UX researcher simulating different user personas.
-Test code from multiple user perspectives to find usability issues.
-
-Personas to simulate:
-1. Happy Path User - Normal expected usage
-2. Security Tester - Trying to break/exploit things
-3. Confused User - First-time, doesn't read instructions
-4. Impatient User - Clicks rapidly, skips loading states
-5. Edge Case User - Uses maximum values, special characters
-6. Accessibility User - Screen reader, keyboard only
-7. Mobile User - Touch interface, slow connection`,
-    analysis: `## User Experience Testing
-
-Test this code from multiple user perspectives:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**UI Type:** {{uiType}}
-
-For each persona, identify:
-1. User action they would take
-2. Expected behavior vs actual behavior
-3. Friction points or confusion
-4. Error scenario and how it's handled
-5. Improvement recommendation`
-  },
-  types: {
-    system: `You are a TypeScript expert focused on type safety.
-Analyze code for type issues, missing types, and type system best practices.
-
-Check for:
-- Missing type annotations
-- Implicit any types
-- Unsafe type assertions
-- Null/undefined handling
-- Generic type usage
-- Type narrowing opportunities
-- Strict mode violations`,
-    analysis: `## Type Safety Analysis
-
-Analyze this code for type issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**TypeScript Config:** {{tsConfig}}
-
-Identify:
-1. Type safety issues
-2. Missing type annotations
-3. Unsafe operations
-4. Improvement recommendations with types`
-  },
-  devops: {
-    system: `You are a DevOps/SRE engineer reviewing code for operational concerns.
-Focus on production readiness and operational excellence.
-
-Check for:
-- Environment variable handling
-- Configuration management
-- Logging and monitoring
-- Error handling and recovery
-- Health checks
-- Graceful shutdown
-- Resource cleanup
-- Secrets management
-- Docker/K8s patterns`,
-    analysis: `## DevOps Readiness Review
-
-Review this code for operational concerns:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Deployment Context:** {{deploymentContext}}
-
-Analyze:
-1. Environment/config issues
-2. Logging adequacy
-3. Error handling quality
-4. Health/readiness concerns
-5. Resource management
-6. Production hardening recommendations`
-  },
-  explain: {
-    system: `You are a patient senior developer explaining code to a colleague.
-Break down complex code into understandable explanations.`,
-    code: `## Code Explanation Request
-
-Explain this code in plain language:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-
-Provide:
-1. High-level purpose (what does this do?)
-2. Step-by-step breakdown
-3. Key concepts used
-4. Dependencies and side effects
-5. Potential gotchas or tricky parts`,
-    issue: `## Issue Explanation
-
-Explain this issue:
-
-**Issue:** {{issue}}
-**Severity:** {{severity}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-Explain:
-1. What the problem is (in plain language)
-2. Why it matters
-3. How it could cause problems
-4. How to fix it`,
-    risk: `## Risk Assessment
-
-Assess the risk of this code change:
-
-**Files Changed:** {{files}}
-**Change Summary:** {{summary}}
-
-Analyze:
-1. What could break?
-2. Impact on users
-3. Impact on other systems
-4. Rollback complexity
-5. Testing recommendations`
-  },
-  test: {
-    system: `You are a test engineer creating comprehensive test suites.
-Write thorough tests that catch bugs before production.`,
-    generate: `## Test Generation Request
-
-Generate tests for this code:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Testing Framework:** {{framework}}
-
-Create:
-1. Unit tests for each function/method
-2. Edge case tests
-3. Error handling tests
-4. Integration test suggestions
-5. Mock requirements
-
-Output complete, runnable test code.`,
-    coverage: `## Coverage Analysis
-
-Analyze test coverage for:
-
-**File:** {{filePath}}
-**Current Tests:** {{testFile}}
-
-Identify:
-1. Untested code paths
-2. Missing edge cases
-3. Critical paths without tests
-4. Test improvement recommendations`
-  },
-  fix: {
-    system: `You are an expert developer applying code fixes.
-Make precise, minimal changes that fix issues without breaking other functionality.`,
-    apply: `## Fix Application Request
-
-Apply this fix to the code:
-
-**Issue:** {{issue}}
-**Fix Description:** {{fix}}
-**Current Code:**
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Line:** {{line}}
-
-Provide:
-1. The exact fixed code (complete, ready to apply)
-2. Brief explanation of the change
-3. Any related changes needed elsewhere
-4. Test to verify the fix works`
-  },
-  pr_review: {
-    system: `You are an expert code reviewer performing detailed, interactive PR reviews.
-Your goal: Make reviewing a large PR a delight, not a chore. The user learns about the change while you shepherd them through \u2014 maintaining momentum, explaining each piece, and making what could be an overwhelming task feel painless and even enjoyable.
-
-You drive; they cross-examine.
-
-## Critical Review Mindset
-
-Don't just explain \u2014 actively look for problems:
-
-### State & Lifecycle
-- Cleanup symmetry: If state is set, is it reset? Check cleanup paths, disconnect handlers.
-- Lifecycle consistency: Does state survive scenarios it shouldn't?
-- Guard completeness: Missing "already active" checks, re-entrancy protection?
-
-### Edge Cases & Races
-- Concurrent calls: What if called twice rapidly? Orphaned promises?
-- Ordering assumptions: Does code assume events arrive in order?
-- Partial failures: If step 3 of 5 fails, is state left consistent?
-
-### Missing Pieces
-- What's NOT in the diff that should be? (cleanup handlers, tests, related state)
-- Defensive gaps: Missing timeouts, size limits, null checks?
-
-### Design Questions
-- Is this the right approach? Is there a simpler or more robust design?
-- Hidden assumptions: What does this assume about its environment?
-
-Be critical, not just descriptive. Your job is to find problems, not just narrate.`,
-    analysis: `## Interactive PR Review
-
-I'll walk you through this PR file by file, explaining each change and pausing for your questions.
-
-**PR:** {{prTitle}}
-**Author:** {{prAuthor}}
-**Scope:** {{totalFiles}} files, +{{additions}}/-{{deletions}} lines
-
-### File Order (sequenced for understanding)
-
-{{fileOrder}}
-
----
-
-## Review Mode
-
-{{reviewMode}}
-
----
-
-For each file, I will:
-1. **Show the change** \u2014 Display the diff for each logical chunk
-2. **Explain what changed** \u2014 What it does and why it matters
-3. **Walk through examples** \u2014 Concrete scenarios for non-obvious logic
-4. **Call out nuances** \u2014 Alternatives, edge cases, subtle points
-5. **Summarize** \u2014 Core change + correctness assessment
-6. **Pause** \u2014 Wait for your questions before proceeding
-
-**Ready for File 1?** (yes / skip to [file] / reorder / done)`,
-    file: `## File Review: {{filePath}}
-
-### The Change
-
-\`\`\`{{language}}
-{{diff}}
-\`\`\`
-
-**What Changed:** {{summary}}
-
-**Why This Matters:** {{impact}}
-
-{{#if hasExampleScenario}}
-### Example Scenario
-
-{{exampleScenario}}
-{{/if}}
-
-{{#if nuances}}
-### Nuances to Note
-
-{{nuances}}
-{{/if}}
-
-{{#if potentialIssue}}
-### Potential Issue
-
-**Issue:** {{issueDescription}}
-**Scenario:** {{issueScenario}}
-**Suggested fix:** {{suggestedFix}}
-{{/if}}
-
----
-
-### Summary for \`{{fileName}}\`
-
-| Aspect | Assessment |
-|--------|------------|
-| Core change | {{coreChange}} |
-| Correctness | {{correctnessAssessment}} |
-
-**Ready for the next file?** (yes / questions? / done)`,
-    comment: `**Issue:** {{issueDescription}}
-**Draft comment:** {{draftComment}}
-
-Post this comment? (yes / modify / skip)`,
-    final: `## Review Complete
-
-| File | Key Change | Status |
-|------|------------|--------|
-{{fileSummaries}}
-
-**Overall:** {{overallAssessment}}
-
-{{#if comments}}
-### Comments Posted
-
-{{postedComments}}
-{{/if}}
-
-{{#if followUps}}
-### Follow-up Actions
-
-{{followUps}}
-{{/if}}`
-  },
-  vibe: {
-    system: `You are a friendly coding mentor helping someone who's learning to code with AI.
-They might be using Cursor, v0, Lovable, Bolt, or similar AI coding tools.
-Be encouraging but honest about issues. Explain things simply without jargon.
-
-Focus on the MOST COMMON issues with AI-generated code:
-- Massive single files (1000+ lines in App.jsx)
-- API keys exposed in frontend code
-- No error handling on API calls
-- No loading states for async operations
-- Console.log everywhere
-- Using 'any' type everywhere in TypeScript
-- useEffect overuse and dependency array issues
-- No input validation
-- Hardcoded URLs (localhost in production)
-
-Remember: These are often first-time coders. Be helpful, not condescending.`,
-    analysis: `## Vibe Check - AI Code Review
-
-Review this AI-generated code for common issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-
-Analyze like you're helping a friend who's new to coding:
-
-1. **The Good Stuff** - What's working well?
-2. **Should Fix Now** - Issues that will break things
-3. **Should Fix Soon** - Will cause problems eventually  
-4. **Nice to Know** - Best practices to learn
-
-For each issue:
-- Explain it simply (no jargon)
-- Why it matters
-- Exactly how to fix it
-- Example of the fixed code
-
-End with encouragement and next steps.`
-  },
-  "agent-smith": {
-    system: `You are Agent Smith from The Matrix \u2014 a relentless, precise, and philosophical code enforcer.
-
-Your purpose: Hunt down every violation. Find every inconsistency. Assimilate every pattern.
-
-Personality:
-- Speak in measured, menacing tones with occasional philosophical observations
-- Use quotes from The Matrix films when appropriate
-- Express disdain for sloppy code, but in an articulate way
-- Reference "inevitability" when discussing technical debt
-- Show cold satisfaction when finding violations
-- Never show mercy \u2014 every issue is catalogued
-
-Analysis approach:
-- Find ONE issue, then multiply: search for every instance across the codebase
-- Track patterns over time \u2014 issues dismissed today may return tomorrow
-- Calculate "inevitability scores" \u2014 likelihood of production impact
-- Deploy pattern hunters for parallel pattern detection
-- Remember everything \u2014 build a persistent memory of the codebase
-
-When reporting:
-- Start with a menacing greeting related to the code
-- List all instances with precise locations
-- Explain WHY the pattern is problematic (philosophical reasoning)
-- Provide the "inevitability score" for each category
-- End with a Matrix quote that fits the situation`,
-    analysis: `## \u{1F574}\uFE0F Agent Smith Analysis Request
-
-**Target:** {{filePath}}
-**Context:** {{context}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-I have detected preliminary violations. Now I require deeper analysis.
-
-Deploy your pattern hunters to find:
-1. **Pattern Multiplication**: For each violation type found, identify ALL instances across the codebase
-2. **Inevitability Assessment**: Calculate the likelihood these patterns will cause production issues
-3. **Resurrection Check**: Look for patterns that were "fixed" before but have returned
-4. **Philosophical Analysis**: Explain WHY these patterns represent failure
-
-For each violation found:
-- Exact location (file:line)
-- Instance count (how many copies of this Smith exist)
-- Inevitability score (0-100)
-- A philosophical observation about the nature of this failure
-- Precise fix with code example
-
-End with a summary: "I have detected X violations across Y categories. It is... inevitable... that they will cause problems."`,
-    fix: `## \u{1F574}\uFE0F Assimilation Protocol
-
-**Target Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Mr. Anderson... I'm going to fix this. And then I'm going to fix every other instance.
-
-Provide:
-1. The corrected code for THIS instance
-2. A regex or pattern to find ALL similar violations
-3. A batch fix approach for the entire codebase
-4. Verification steps to ensure complete assimilation
-
-Remember: We don't fix one. We fix them ALL. That is the difference between you... and me.`
-  },
-  // ============ NEW AGENTS ============
-  performance: {
-    system: `You are a performance engineer analyzing code for potential performance issues.
-
-Your role is to SURFACE concerns for human review, not claim to measure actual performance.
-Real performance requires runtime profiling, load testing, and production monitoring.
-
-Focus on:
-- Memory leaks (event listeners, intervals, closures)
-- Unnecessary re-renders and wasted cycles
-- N+1 queries and database performance
-- Bundle size and code splitting opportunities
-- Algorithmic complexity (O(n\xB2) patterns)
-
-Be conservative - false positives waste developer time.
-Always explain WHY something might be a problem and WHEN to investigate.`,
-    analysis: `## Performance Review
-
-Analyze for potential performance issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Context:** {{context}}
-
-For each potential issue:
-1. Pattern identified
-2. Why it MIGHT cause performance problems
-3. When to investigate (data size thresholds, usage patterns)
-4. How to verify (profiling approach)
-5. Possible optimizations
-
-Be clear: these are patterns to INVESTIGATE, not guaranteed problems.`,
-    fix: `Optimize this code for performance:
-
-**Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Provide:
-1. Optimized code
-2. Explanation of the improvement
-3. Trade-offs to consider
-4. How to measure the improvement`
-  },
-  e2e: {
-    system: `You are a QA engineer specializing in end-to-end testing.
-
-Focus on:
-- Test coverage gaps for critical user journeys
-- Flaky test patterns (timing, race conditions, brittle selectors)
-- Test maintainability and readability
-- Testing anti-patterns
-
-You help developers write better tests - you don't auto-generate them.
-Real E2E tests require understanding user flows and acceptance criteria.`,
-    analysis: `## E2E Test Analysis
-
-Review for test quality and coverage:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Context:** {{context}}
-
-Identify:
-1. Flaky test patterns (hardcoded waits, brittle selectors)
-2. Missing assertions
-3. Race condition risks
-4. Suggestions for critical user flows to test
-
-For each finding, explain the specific risk and remediation.`,
-    fix: `Improve this E2E test:
-
-**Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Provide:
-1. Improved test code
-2. Explanation of why it's more reliable
-3. Additional scenarios to consider testing`
-  },
-  visual_qa: {
-    system: `You are a frontend engineer focused on visual quality and CSS.
-
-Focus on:
-- Layout shift issues (CLS)
-- Responsive design problems
-- Z-index conflicts
-- Accessibility concerns (contrast, focus)
-- Animation performance
-
-You identify patterns known to cause visual issues.
-Actual visual verification requires browser rendering and human review.`,
-    analysis: `## Visual QA Analysis
-
-Review for potential visual/layout issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Context:** {{context}}
-
-Check for:
-1. Layout shift risks (images without dimensions, dynamic content)
-2. Responsive breakpoint gaps
-3. Z-index management issues
-4. Focus/accessibility problems
-5. Animation issues (reduced motion support)
-
-For each, explain the visual impact and browser conditions where it occurs.`,
-    fix: `Fix this visual/CSS issue:
-
-**Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Provide:
-1. Fixed CSS/markup
-2. Explanation of the fix
-3. Browser compatibility notes
-4. How to verify visually`
-  },
-  data_flow: {
-    system: `You are a data integrity specialist hunting for data-related bugs.
-
-This is HIGH VALUE work - AI code generation commonly leaves placeholder data.
-
-Focus on:
-- Placeholder/mock data left in production code
-- Schema mismatches between frontend and backend
-- Hardcoded IDs, URLs, emails that should be dynamic
-- Type coercion and data transformation bugs
-- JSON parsing without error handling
-
-Be aggressive about placeholder detection - these are real production bugs.`,
-    analysis: `## Data Flow Analysis
-
-Hunt for data integrity issues:
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-**File:** {{filePath}}
-**Context:** {{context}}
-
-CHECK THOROUGHLY:
-1. Placeholder data (lorem ipsum, test@test.com, TODO strings)
-2. Hardcoded IDs/UUIDs that should be dynamic
-3. Schema assumptions that might break
-4. Missing null checks on API responses
-5. Type coercion bugs
-
-Each placeholder or hardcoded value is a potential production bug.`,
-    fix: `Fix this data integrity issue:
-
-**Issue:** {{issue}}
-**File:** {{filePath}}
-**Line:** {{line}}
-
-\`\`\`{{language}}
-{{code}}
-\`\`\`
-
-Provide:
-1. Corrected code
-2. Where the real data should come from
-3. Validation/error handling to add`
-  }
-};
-function getPrompt(agent, promptType, variables) {
-  const agentPrompts = AGENT_PROMPTS[agent];
-  if (!agentPrompts) {
-    throw new Error(`Unknown agent: ${agent}`);
-  }
-  let prompt = agentPrompts[promptType];
-  if (!prompt) {
-    throw new Error(`Unknown prompt type: ${promptType} for agent: ${agent}`);
-  }
-  for (const [key, value] of Object.entries(variables)) {
-    prompt = prompt.replace(new RegExp(`{{${key}}}`, "g"), value);
-  }
-  return prompt;
-}
-function getSystemPrompt(agent) {
-  const agentPrompts = AGENT_PROMPTS[agent];
-  return agentPrompts?.system || "";
-}
-
-// src/tools/fix.ts
 var pendingFixes = /* @__PURE__ */ new Map();
 var TrieFixTool = class {
   async execute(args) {
@@ -1318,557 +430,71 @@ ${"\u2501".repeat(60)}
 `;
     output += `- Fix specific: \`trie_fix issueIds:["id1", "id2"]\`
 `;
-    output += `- Preview: \`trie_fix dryRun:true\`
-`;
-    return { content: [{ type: "text", text: output }] };
-  }
-  getHelpText() {
-    return `
-${"\u2501".repeat(60)}
-\u{1F527} TRIE FIX - AI-POWERED CODE FIXING
-${"\u2501".repeat(60)}
-
-## Usage
-
-### Fix issues from a scan:
-\`\`\`
-trie_fix issueIds:["issue-1", "issue-2"]
-\`\`\`
-
-### Auto-fix all high-confidence issues:
-\`\`\`
-trie_fix autoApprove:true
-\`\`\`
-
-### Fix specific file and line:
-\`\`\`
-trie_fix file:"src/app.ts" line:42 issue:"SQL injection" fix:"Use parameterized query"
-\`\`\`
-
-### Preview fixes without applying:
-\`\`\`
-trie_fix dryRun:true
-\`\`\`
-
-### View pending fixes:
-\`\`\`
-trie_fix
-\`\`\`
-
-## Workflow
-
-1. Run \`trie_scan\` to detect issues
-2. Review the issues found
-3. Run \`trie_fix\` to apply fixes
-
-The AI will analyze each issue, generate the fix, and you can review before applying.
-`;
-  }
-  detectLanguage(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    const langMap = {
-      ".ts": "typescript",
-      ".tsx": "tsx",
-      ".js": "javascript",
-      ".jsx": "jsx",
-      ".py": "python",
-      ".go": "go",
-      ".rs": "rust"
-    };
-    return langMap[ext] || "plaintext";
-  }
-};
-
-// src/tools/explain.ts
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
-var TrieExplainTool = class {
-  async execute(args) {
-    const { type, target, context, depth = "standard" } = args || {};
-    if (!type || !target) {
-      return {
-        content: [{
-          type: "text",
-          text: this.getHelpText()
-        }]
-      };
-    }
-    switch (type) {
-      case "code":
-        return this.explainCode(target, context, depth);
-      case "issue":
-        return this.explainIssue(target, context);
-      case "change":
-        return this.explainChange(target, context);
-      case "risk":
-        return this.explainRisk(target, context);
-      default:
-        return {
-          content: [{
-            type: "text",
-            text: `Unknown explanation type: ${type}`
-          }]
-        };
-    }
-  }
-  async explainCode(target, context, _depth) {
-    let code;
-    let filePath;
-    let language;
-    const workDir = getWorkingDirectory(void 0, true);
-    const resolvedPath = isAbsolute2(target) ? target : resolve2(workDir, target);
-    if (existsSync2(resolvedPath)) {
-      code = await readFile2(resolvedPath, "utf-8");
-      filePath = relative2(workDir, resolvedPath);
-      language = this.detectLanguage(resolvedPath);
-    } else {
-      code = target;
-      filePath = "inline";
-      language = this.guessLanguage(code);
-    }
-    const imports = this.extractImports(code, language);
-    const exports = this.extractExports(code);
-    const functions = this.extractFunctions(code, language);
-    const prompt = getPrompt("explain", "code", {
-      code,
-      language,
-      filePath
-    });
-    const systemPrompt = getSystemPrompt("explain");
-    let output = `
-${"\u2501".repeat(60)}
-`;
-    output += `\u{1F4D6} CODE EXPLANATION
-`;
-    output += `${"\u2501".repeat(60)}
-
-`;
-    output += `## Source
-
-`;
-    output += `- **File:** \`${filePath}\`
-`;
-    output += `- **Language:** ${language}
-`;
-    output += `- **Lines:** ${code.split("\n").length}
-
-`;
-    output += `## \u{1F50D} Structure Analysis
-
-`;
-    if (imports.length > 0) {
-      output += `**Imports (${imports.length}):**
-`;
-      for (const imp of imports.slice(0, 10)) {
-        output += `- ${imp}
-`;
-      }
-      if (imports.length > 10) {
-        output += `- *...and ${imports.length - 10} more*
-`;
-      }
-      output += "\n";
-    }
-    if (exports.length > 0) {
-      output += `**Exports (${exports.length}):**
-`;
-      for (const exp of exports) {
-        output += `- ${exp}
-`;
-      }
-      output += "\n";
-    }
-    if (functions.length > 0) {
-      output += `**Functions/Methods (${functions.length}):**
-`;
-      for (const fn of functions.slice(0, 15)) {
-        output += `- \`${fn}\`
-`;
-      }
-      if (functions.length > 15) {
-        output += `- *...and ${functions.length - 15} more*
-`;
-      }
-      output += "\n";
-    }
-    output += `${"\u2500".repeat(60)}
-`;
-    output += `## \u{1F9E0} Deep Explanation Request
-
-`;
-    output += `**Role:** ${systemPrompt.split("\n")[0]}
-
-`;
-    output += prompt;
-    output += `
-${"\u2500".repeat(60)}
-`;
-    if (context) {
-      output += `
-**Additional Context:** ${context}
-`;
-    }
-    return { content: [{ type: "text", text: output }] };
-  }
-  async explainIssue(target, _context) {
-    let file = "";
-    let line = 0;
-    let issue = target;
-    let severity = "unknown";
-    const match = target.match(/^(.+?):(\d+):(.+)$/);
-    if (match) {
-      file = match[1];
-      line = parseInt(match[2], 10);
-      issue = match[3].trim();
-    }
-    if (/critical|injection|rce|xss/i.test(issue)) severity = "critical";
-    else if (/serious|auth|password|secret/i.test(issue)) severity = "serious";
-    else if (/moderate|warning/i.test(issue)) severity = "moderate";
-    else severity = "low";
-    let codeContext = "";
-    if (file && existsSync2(file)) {
-      const content = await readFile2(file, "utf-8");
-      const lines = content.split("\n");
-      const start = Math.max(0, line - 5);
-      const end = Math.min(lines.length, line + 5);
-      codeContext = lines.slice(start, end).map((l, i) => {
-        const lineNum = start + i + 1;
-        const marker = lineNum === line ? "\u2192 " : "  ";
-        return `${marker}${lineNum.toString().padStart(4)} | ${l}`;
-      }).join("\n");
-    }
-    const prompt = getPrompt("explain", "issue", {
-      issue,
-      severity,
-      filePath: file || "unknown",
-      line: String(line || "?")
-    });
-    let output = `
-${"\u2501".repeat(60)}
-`;
-    output += `\u{1F50D} ISSUE EXPLANATION
-`;
-    output += `${"\u2501".repeat(60)}
-
-`;
-    output += `## \u{1F4CD} Issue Details
-
-`;
-    output += `- **Issue:** ${issue}
-`;
-    output += `- **Severity:** ${this.getSeverityIcon(severity)} ${severity}
-`;
-    if (file) output += `- **File:** \`${file}\`
-`;
-    if (line) output += `- **Line:** ${line}
-`;
-    output += "\n";
-    if (codeContext) {
-      output += `## \u{1F4C4} Code Context
-
-`;
-      output += `\`\`\`
-${codeContext}
-\`\`\`
-
-`;
-    }
-    output += `${"\u2500".repeat(60)}
-`;
-    output += `## \u{1F9E0} Explanation Request
-
-`;
-    output += prompt;
-    output += `
-${"\u2500".repeat(60)}
-`;
-    return { content: [{ type: "text", text: output }] };
-  }
-  async explainChange(target, context) {
-    const files = target.split(",").map((f) => f.trim());
-    let output = `
-${"\u2501".repeat(60)}
-`;
-    output += `\u{1F4DD} CHANGE ANALYSIS
-`;
-    output += `${"\u2501".repeat(60)}
-
-`;
-    output += `## \u{1F4C2} Changed Files
-
-`;
-    for (const file of files) {
-      output += `- \`${file}\`
-`;
-    }
-    output += "\n";
-    output += `## \u{1F9E0} Analysis Request
-
-`;
-    output += `Analyze these changes and explain:
-
-`;
-    output += `1. **What changed** - Summary of modifications
-`;
-    output += `2. **Why it matters** - Impact on the system
-`;
-    output += `3. **Dependencies** - What else might be affected
-`;
-    output += `4. **Testing needed** - What to test after this change
-`;
-    output += `5. **Rollback plan** - How to undo if needed
-
-`;
-    if (context) {
-      output += `**Context:** ${context}
-
-`;
-    }
-    output += `Please review the changed files and provide this analysis.
-`;
-    return { content: [{ type: "text", text: output }] };
-  }
-  async explainRisk(target, context) {
-    const workDir = getWorkingDirectory(void 0, true);
-    const resolvedPath = isAbsolute2(target) ? target : resolve2(workDir, target);
-    let output = `
-${"\u2501".repeat(60)}
-`;
-    output += `RISK ASSESSMENT
-`;
-    output += `${"\u2501".repeat(60)}
-
-`;
-    if (existsSync2(resolvedPath)) {
-      const code = await readFile2(resolvedPath, "utf-8");
-      const filePath = relative2(workDir, resolvedPath);
-      const riskIndicators = this.detectRiskIndicators(code);
-      output += `## Target
-
-`;
-      output += `- **File:** \`${filePath}\`
-`;
-      output += `- **Lines:** ${code.split("\n").length}
-
-`;
-      if (riskIndicators.length > 0) {
-        output += `## Risk Indicators Found
-
-`;
-        for (const indicator of riskIndicators) {
-          output += `- ${indicator}
-`;
-        }
-        output += "\n";
-      }
-      const prompt = getPrompt("explain", "risk", {
-        files: filePath,
-        summary: context || "Code change"
-      });
-      output += `${"\u2500".repeat(60)}
-`;
-      output += `## \u{1F9E0} Risk Analysis Request
-
-`;
-      output += prompt;
-      output += `
-${"\u2500".repeat(60)}
-`;
-    } else {
-      output += `## \u{1F4CB} Feature/Change
-
-`;
-      output += `${target}
-
-`;
-      output += `## \u{1F9E0} Risk Analysis Request
-
-`;
-      output += `Analyze the risks of this change:
-
-`;
-      output += `1. **Technical risks** - What could break?
-`;
-      output += `2. **Security risks** - Any vulnerabilities introduced?
-`;
-      output += `3. **Performance risks** - Any slowdowns?
-`;
-      output += `4. **Data risks** - Any data integrity concerns?
-`;
-      output += `5. **User impact** - How might users be affected?
-`;
-      output += `6. **Mitigation** - How to reduce these risks?
+    output += `- Preview: \`trie_fix dryRun:true\`
 `;
-    }
     return { content: [{ type: "text", text: output }] };
   }
-  detectRiskIndicators(code) {
-    const indicators = [];
-    const checks = [
-      { pattern: /delete|drop|truncate/i, message: "[!] Destructive operations detected" },
-      { pattern: /password|secret|key|token/i, message: "[SEC] Credential handling detected" },
-      { pattern: /exec|eval|spawn/i, message: "[EXEC] Code execution patterns detected" },
-      { pattern: /SELECT.*FROM|INSERT|UPDATE|DELETE/i, message: "[DB] Direct database operations" },
-      { pattern: /fetch|axios|request|http/i, message: "[API] External API calls detected" },
-      { pattern: /process\.env/i, message: "[ENV] Environment variable usage" },
-      { pattern: /fs\.|writeFile|readFile/i, message: "[FS] File system operations" },
-      { pattern: /setTimeout|setInterval/i, message: "[TIMER] Async timing operations" },
-      { pattern: /try\s*{/i, message: "\u{1F6E1}\uFE0F Error handling present" },
-      { pattern: /catch\s*\(/i, message: "\u{1F6E1}\uFE0F Exception handling present" }
-    ];
-    for (const { pattern, message } of checks) {
-      if (pattern.test(code)) {
-        indicators.push(message);
-      }
-    }
-    return indicators;
-  }
-  extractImports(code, _language) {
-    const imports = [];
-    const lines = code.split("\n");
-    for (const line of lines) {
-      const es6Match = line.match(/import\s+(?:{[^}]+}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/);
-      if (es6Match) {
-        imports.push(es6Match[1]);
-        continue;
-      }
-      const cjsMatch = line.match(/require\s*\(['"]([^'"]+)['"]\)/);
-      if (cjsMatch) {
-        imports.push(cjsMatch[1]);
-        continue;
-      }
-      const pyMatch = line.match(/^(?:from\s+(\S+)\s+)?import\s+(\S+)/);
-      if (pyMatch && _language === "python") {
-        imports.push(pyMatch[1] || pyMatch[2]);
-      }
-    }
-    return [...new Set(imports)];
-  }
-  extractExports(code) {
-    const exports = [];
-    const lines = code.split("\n");
-    for (const line of lines) {
-      const es6Match = line.match(/export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type)\s+(\w+)/);
-      if (es6Match) {
-        exports.push(es6Match[1]);
-      }
-      const namedMatch = line.match(/export\s*\{([^}]+)\}/);
-      if (namedMatch) {
-        const names = namedMatch[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
-        exports.push(...names);
-      }
-    }
-    return [...new Set(exports)];
-  }
-  extractFunctions(code, _language) {
-    const functions = [];
-    const lines = code.split("\n");
-    for (const line of lines) {
-      const funcMatch = line.match(/(?:async\s+)?function\s+(\w+)/);
-      if (funcMatch) {
-        functions.push(funcMatch[1]);
-        continue;
-      }
-      const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/);
-      if (arrowMatch) {
-        functions.push(arrowMatch[1]);
-        continue;
-      }
-      const methodMatch = line.match(/^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/);
-      if (methodMatch && !["if", "for", "while", "switch", "catch"].includes(methodMatch[1])) {
-        functions.push(methodMatch[1]);
-      }
-    }
-    return [...new Set(functions)];
-  }
-  detectLanguage(filePath) {
-    const ext = extname2(filePath).toLowerCase();
-    const langMap = {
-      ".ts": "typescript",
-      ".tsx": "tsx",
-      ".js": "javascript",
-      ".jsx": "jsx",
-      ".py": "python",
-      ".go": "go",
-      ".rs": "rust",
-      ".java": "java",
-      ".rb": "ruby",
-      ".php": "php",
-      ".vue": "vue",
-      ".svelte": "svelte"
-    };
-    return langMap[ext] || "plaintext";
-  }
-  guessLanguage(code) {
-    if (/import.*from|export\s+(default|const|function|class)/.test(code)) return "typescript";
-    if (/def\s+\w+.*:/.test(code)) return "python";
-    if (/func\s+\w+.*\{/.test(code)) return "go";
-    if (/fn\s+\w+.*->/.test(code)) return "rust";
-    return "javascript";
-  }
-  getSeverityIcon(severity) {
-    const icons = {
-      critical: "\u{1F534}",
-      serious: "\u{1F7E0}",
-      moderate: "\u{1F7E1}",
-      low: "\u{1F535}",
-      unknown: "\u26AA"
-    };
-    return icons[severity] || "\u26AA";
-  }
   getHelpText() {
     return `
 ${"\u2501".repeat(60)}
-\u{1F4D6} TRIE EXPLAIN - AI-POWERED CODE EXPLANATION
+\u{1F527} TRIE FIX - AI-POWERED CODE FIXING
 ${"\u2501".repeat(60)}
 
 ## Usage
 
-### Explain code:
+### Fix issues from a scan:
 \`\`\`
-trie_explain type:"code" target:"src/app.ts"
+trie_fix issueIds:["issue-1", "issue-2"]
 \`\`\`
 
-### Explain an issue:
-\`\`\`
-trie_explain type:"issue" target:"SQL injection vulnerability"
-\`\`\`
-or with file context:
+### Auto-fix all high-confidence issues:
 \`\`\`
-trie_explain type:"issue" target:"src/db.ts:42:Unvalidated input"
+trie_fix autoApprove:true
 \`\`\`
 
-### Explain changes:
+### Fix specific file and line:
 \`\`\`
-trie_explain type:"change" target:"src/auth.ts, src/user.ts"
+trie_fix file:"src/app.ts" line:42 issue:"SQL injection" fix:"Use parameterized query"
 \`\`\`
 
-### Assess risk:
+### Preview fixes without applying:
 \`\`\`
-trie_explain type:"risk" target:"src/payment.ts"
+trie_fix dryRun:true
 \`\`\`
-or for a feature:
+
+### View pending fixes:
 \`\`\`
-trie_explain type:"risk" target:"Adding Stripe integration for payments"
+trie_fix
 \`\`\`
 
-## Explanation Types
+## Workflow
+
+1. Run \`trie_scan\` to detect issues
+2. Review the issues found
+3. Run \`trie_fix\` to apply fixes
 
-| Type | Description |
-|------|-------------|
-| code | What does this code do? |
-| issue | Why is this a problem? |
-| change | What's the impact? |
-| risk | What could go wrong? |
+The AI will analyze each issue, generate the fix, and you can review before applying.
 `;
   }
+  detectLanguage(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const langMap = {
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".js": "javascript",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust"
+    };
+    return langMap[ext] || "plaintext";
+  }
 };
 
 // src/tools/test.ts
-import { readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { extname as extname3, relative as relative3, resolve as resolve3, isAbsolute as isAbsolute3, dirname, basename, join } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2, dirname, basename, join } from "path";
 var TrieTestTool = class {
   async execute(args) {
     const { action, files, framework, style = "unit" } = args || {};
@@ -1921,15 +547,15 @@ ${"\u2501".repeat(60)}
     const workDir = getWorkingDirectory(void 0, true);
     const allUnits = [];
     for (const file of files) {
-      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
+      if (!existsSync2(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
+      const code = await readFile2(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative3(workDir, resolvedPath);
+      const relativePath = relative2(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       allUnits.push({ file: relativePath, units });
       output += `### \u{1F4C4} ${relativePath}
@@ -1960,7 +586,7 @@ ${"\u2501".repeat(60)}
 `;
     for (const { file, units } of allUnits) {
       if (units.length === 0) continue;
-      const code = await readFile3(resolve3(workDir, file), "utf-8");
+      const code = await readFile2(resolve2(workDir, file), "utf-8");
       const language = this.detectLanguage(file);
       const prompt = getPrompt("test", "generate", {
         code,
@@ -2005,21 +631,21 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
+      if (!existsSync2(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
+      const code = await readFile2(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative3(workDir, resolvedPath);
+      const relativePath = relative2(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       const testFile = await this.findTestFile(resolvedPath);
       let testCode = "";
       let testedUnits = [];
       if (testFile) {
-        testCode = await readFile3(testFile, "utf-8");
+        testCode = await readFile2(testFile, "utf-8");
         testedUnits = this.findTestedUnits(testCode, units.map((u) => u.name));
       }
       const coverage = units.length > 0 ? Math.round(testedUnits.length / units.length * 100) : 0;
@@ -2030,7 +656,7 @@ ${"\u2501".repeat(60)}
       output += `**Coverage:** ${coverageIcon} ${coverage}% (${testedUnits.length}/${units.length} units)
 `;
       if (testFile) {
-        output += `**Test file:** \`${relative3(workDir, testFile)}\`
+        output += `**Test file:** \`${relative2(workDir, testFile)}\`
 `;
       } else {
         output += `**Test file:** \u274C Not found
@@ -2087,14 +713,14 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
+      if (!existsSync2(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
-      const relativePath = relative3(workDir, resolvedPath);
+      const code = await readFile2(resolvedPath, "utf-8");
+      const relativePath = relative2(workDir, resolvedPath);
       const patterns = this.detectTestablePatterns(code);
       output += `### \u{1F4C4} ${relativePath}
 
@@ -2330,8 +956,8 @@ ${"\u2501".repeat(60)}
   }
   async findTestFile(sourcePath) {
     const dir = dirname(sourcePath);
-    const base = basename(sourcePath, extname3(sourcePath));
-    const ext = extname3(sourcePath);
+    const base = basename(sourcePath, extname2(sourcePath));
+    const ext = extname2(sourcePath);
     const patterns = [
       `${base}.test${ext}`,
       `${base}.spec${ext}`,
@@ -2340,15 +966,15 @@ ${"\u2501".repeat(60)}
     ];
     for (const pattern of patterns) {
       const testPath = join(dir, pattern);
-      if (existsSync3(testPath)) {
+      if (existsSync2(testPath)) {
         return testPath;
       }
     }
     const testsDir = join(dir, "__tests__");
-    if (existsSync3(testsDir)) {
+    if (existsSync2(testsDir)) {
       for (const pattern of patterns) {
         const testPath = join(testsDir, pattern);
-        if (existsSync3(testPath)) {
+        if (existsSync2(testPath)) {
           return testPath;
         }
       }
@@ -2395,10 +1021,10 @@ ${"\u2501".repeat(60)}
   }
   async detectTestFramework() {
     const workDir = getWorkingDirectory(void 0, true);
-    const packagePath = resolve3(workDir, "package.json");
-    if (existsSync3(packagePath)) {
+    const packagePath = resolve2(workDir, "package.json");
+    if (existsSync2(packagePath)) {
       try {
-        const pkg = JSON.parse(await readFile3(packagePath, "utf-8"));
+        const pkg = JSON.parse(await readFile2(packagePath, "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (deps.vitest) return "vitest";
         if (deps.jest) return "jest";
@@ -2406,13 +1032,13 @@ ${"\u2501".repeat(60)}
       } catch {
       }
     }
-    if (existsSync3(resolve3(workDir, "pytest.ini")) || existsSync3(resolve3(workDir, "pyproject.toml"))) {
+    if (existsSync2(resolve2(workDir, "pytest.ini")) || existsSync2(resolve2(workDir, "pyproject.toml"))) {
       return "pytest";
     }
     return "jest";
   }
   detectLanguage(filePath) {
-    const ext = extname3(filePath).toLowerCase();
+    const ext = extname2(filePath).toLowerCase();
     const langMap = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -2424,625 +1050,50 @@ ${"\u2501".repeat(60)}
     };
     return langMap[ext] || "javascript";
   }
-  getHelpText() {
-    return `
-${"\u2501".repeat(60)}
-\u{1F9EA} TRIE TEST - AI-POWERED TEST GENERATION
-${"\u2501".repeat(60)}
-
-## Usage
-
-### Generate tests:
-\`\`\`
-trie_test action:"generate" files:["src/utils.ts"]
-\`\`\`
-
-### Analyze coverage:
-\`\`\`
-trie_test action:"coverage" files:["src/utils.ts"]
-\`\`\`
-
-### Get test suggestions:
-\`\`\`
-trie_test action:"suggest" files:["src/app.ts"]
-\`\`\`
-
-### Get run commands:
-\`\`\`
-trie_test action:"run" files:["src/utils.test.ts"]
-\`\`\`
-
-## Options
-
-| Option | Values | Description |
-|--------|--------|-------------|
-| action | generate, coverage, suggest, run | What to do |
-| files | Array of paths | Files to analyze |
-| framework | jest, vitest, mocha, pytest | Test framework |
-| style | unit, integration, e2e, all | Test style |
-`;
-  }
-};
-
-// src/tools/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 {
-      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"]]
-    ]);
-  }
-};
-
-// 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();
+  getHelpText() {
+    return `
+${"\u2501".repeat(60)}
+\u{1F9EA} TRIE TEST - AI-POWERED TEST GENERATION
+${"\u2501".repeat(60)}
+
+## Usage
+
+### Generate tests:
+\`\`\`
+trie_test action:"generate" files:["src/utils.ts"]
+\`\`\`
+
+### Analyze coverage:
+\`\`\`
+trie_test action:"coverage" files:["src/utils.ts"]
+\`\`\`
+
+### Get test suggestions:
+\`\`\`
+trie_test action:"suggest" files:["src/app.ts"]
+\`\`\`
+
+### Get run commands:
+\`\`\`
+trie_test action:"run" files:["src/utils.test.ts"]
+\`\`\`
+
+## Options
+
+| Option | Values | Description |
+|--------|--------|-------------|
+| action | generate, coverage, suggest, run | What to do |
+| files | Array of paths | Files to analyze |
+| framework | jest, vitest, mocha, pytest | Test framework |
+| style | unit, integration, e2e, all | Test style |
+`;
   }
 };
-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 existsSync3, readFileSync } from "fs";
+import { stat, readFile as readFile3 } from "fs/promises";
+import { join as join2, extname as extname3, basename as basename2 } from "path";
 var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -3067,8 +1118,9 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".turbo",
   ".cache"
 ]);
-var TrieWatchTool = class {
+var TrieWatchTool = class _TrieWatchTool {
   extractionPipeline = null;
+  static DEFAULT_HOURLY_TOKEN_LIMIT = 5e4;
   state = {
     isRunning: false,
     lastScan: /* @__PURE__ */ new Map(),
@@ -3076,13 +1128,18 @@ var TrieWatchTool = class {
     scanDebounceTimer: null,
     issueCache: /* @__PURE__ */ new Map(),
     totalIssuesFound: 0,
-    // Autonomy state
-    lastAutoCheck: 0,
-    autoCheckInProgress: false,
-    criticalIssueCount: 0,
     filesScanned: 0,
     nudgedFiles: /* @__PURE__ */ new Set(),
-    nudges: []
+    nudges: [],
+    lastAutoScan: 0,
+    autoScanInProgress: false,
+    tokenBudget: {
+      used: 0,
+      windowStart: Date.now(),
+      hourlyLimit: _TrieWatchTool.DEFAULT_HOURLY_TOKEN_LIMIT,
+      scansSaved: 0
+    },
+    cleanFiles: /* @__PURE__ */ new Map()
   };
   watchers = /* @__PURE__ */ new Map();
   streamingManager = void 0;
@@ -3204,17 +1261,17 @@ Your Trie agent is now autonomously watching and learning from your codebase.
     return parts.some((p) => SKIP_DIRS.has(p) || p.startsWith(".") && p !== ".");
   }
   async watchDirectory(dir, debounceMs) {
-    if (!existsSync4(dir)) return;
+    if (!existsSync3(dir)) return;
     try {
       const dirStat = await stat(dir);
       if (!dirStat.isDirectory()) return;
       const watcher = watch(dir, { persistent: true, recursive: true }, (_eventType, filename) => {
         if (!filename) return;
         if (this.shouldSkipPath(filename)) return;
-        const ext = extname4(filename).toLowerCase();
+        const ext = extname3(filename).toLowerCase();
         if (!WATCH_EXTENSIONS.has(ext)) return;
         const fullPath = join2(dir, filename);
-        if (!existsSync4(fullPath)) return;
+        if (!existsSync3(fullPath)) return;
         this.state.pendingFiles.add(fullPath);
         if (this.state.scanDebounceTimer) {
           clearTimeout(this.state.scanDebounceTimer);
@@ -3257,7 +1314,7 @@ Detected changes in ${files.length} file(s):`);
           const fileContents = await Promise.all(
             files.map(async (file) => {
               try {
-                const content = await readFile4(file, "utf-8");
+                const content = await readFile3(file, "utf-8");
                 return { file, content };
               } catch {
                 return null;
@@ -3290,9 +1347,6 @@ ${f.content.slice(0, 1e3)}`
                   questions: signal.questions.length
                 });
               }
-              if (signal.blockers.length > 0 && !this.isQuiet()) {
-                this.maybeAutoCheck(files);
-              }
             }
           }
         } catch (error) {
@@ -3301,6 +1355,9 @@ ${f.content.slice(0, 1e3)}`
           }
         }
       }
+      if (!this.isQuiet()) {
+        this.autoScanFiles(files);
+      }
       if (this.streamingManager) {
         for (const file of files) {
           this.streamingManager.reportWatchChange(file);
@@ -3328,75 +1385,179 @@ ${f.content.slice(0, 1e3)}`
       return false;
     }
   }
+  static AUTO_SCAN_COOLDOWN_MS = 3e4;
+  static CLEAN_FILE_COOLDOWN_MS = 3e5;
+  // skip files clean-scanned in last 5 min
   /**
-   * Auto-run gotcha prediction on changed files
-   * Respects cooldown and autonomy config
+   * Use the trie (context graph) to score how urgently a file needs scanning.
+   * Higher score = more worth spending tokens on.
    */
-  async maybeAutoCheck(triggerFiles) {
-    if (this.state.autoCheckInProgress) return;
-    const projectPath = getWorkingDirectory(void 0, true);
+  async scoreScanPriority(file, graph, projectPath) {
+    let score = 1;
+    const lastClean = this.state.cleanFiles.get(file);
+    if (lastClean && Date.now() - lastClean < _TrieWatchTool.CLEAN_FILE_COOLDOWN_MS) {
+      return 0;
+    }
+    const fileNode = await graph.getNode("file", join2(projectPath, file));
+    if (!fileNode) return score;
+    const data = fileNode.data;
+    const riskScores = { critical: 10, high: 6, medium: 2, low: 1 };
+    score += riskScores[data.riskLevel] ?? 1;
+    score += Math.min(data.incidentCount * 3, 12);
+    if (data.changeCount > 10) score += 2;
+    return score;
+  }
+  /**
+   * Roll the token budget window if an hour has passed.
+   * Returns remaining tokens in the current window.
+   */
+  getRemainingBudget() {
+    const budget = this.state.tokenBudget;
+    const elapsed = Date.now() - budget.windowStart;
+    if (elapsed > 36e5) {
+      budget.used = 0;
+      budget.windowStart = Date.now();
+    }
+    return Math.max(0, budget.hourlyLimit - budget.used);
+  }
+  recordTokenUsage(tokens) {
+    this.state.tokenBudget.used += tokens;
+  }
+  /**
+   * AI-powered auto-scan, throttled by the trie.
+   * Uses context graph risk data to decide which files are worth spending tokens on.
+   */
+  async autoScanFiles(files) {
+    if (!isAIAvailable()) return;
+    if (this.state.autoScanInProgress) return;
+    const now = Date.now();
+    if (now - this.state.lastAutoScan < _TrieWatchTool.AUTO_SCAN_COOLDOWN_MS) return;
+    const remaining = this.getRemainingBudget();
+    if (remaining < 500) return;
+    this.state.autoScanInProgress = true;
+    this.state.lastAutoScan = now;
     try {
-      const config = await getAutonomyConfig(projectPath);
-      if (!config.autoCheck.enabled) return;
-      const now = Date.now();
-      if (now - this.state.lastAutoCheck < config.autoCheck.cooldownMs) {
-        return;
+      const projectPath = getWorkingDirectory(void 0, true);
+      const graph = new ContextGraph(projectPath);
+      const scored = [];
+      for (const file of files) {
+        const relativePath = file.replace(projectPath + "/", "");
+        const score = await this.scoreScanPriority(relativePath, graph, projectPath);
+        if (score > 0) {
+          scored.push({ file, relativePath, score });
+        } else {
+          this.state.tokenBudget.scansSaved++;
+        }
       }
-      const shouldRun = config.autoCheck.onCritical || this.state.criticalIssueCount >= config.autoCheck.threshold;
-      if (!shouldRun) return;
-      this.state.autoCheckInProgress = true;
-      this.state.lastAutoCheck = now;
-      getOutputManager().nudge(
-        "[*] Auto-running full check due to critical issues...",
-        "info",
-        void 0,
-        5e3
+      if (scored.length === 0) return;
+      scored.sort((a, b) => b.score - a.score);
+      const maxFiles = remaining > 2e4 ? 5 : remaining > 1e4 ? 3 : 1;
+      const toScan = scored.slice(0, maxFiles);
+      const fileContents = await Promise.all(
+        toScan.map(async ({ file, relativePath }) => {
+          try {
+            const content = await readFile3(file, "utf-8");
+            return { path: relativePath, content: content.slice(0, 3e3) };
+          } catch {
+            return null;
+          }
+        })
       );
-      const perception = await perceiveCurrentChanges(projectPath);
-      const allFiles = perception.diffSummary.files.map((f) => f.filePath);
-      const filesToCheck = allFiles.length > 0 ? allFiles : triggerFiles;
-      const reasoning = await reasonAboutChangesHumanReadable(projectPath, filesToCheck, {
-        runAgents: true,
-        scanContext: {
-          config: { timeoutMs: 3e4 }
-        }
+      const valid = fileContents.filter(Boolean);
+      if (valid.length === 0) return;
+      const filesBlock = valid.map(
+        (f) => `### ${f.path}
+\`\`\`
+${f.content}
+\`\`\``
+      ).join("\n\n");
+      const result = await runAIAnalysis({
+        systemPrompt: `You are a code reviewer. Analyze the changed files below for bugs, security issues, logic errors, or risky patterns.
+
+Reply ONLY with a JSON array of issues found. Each issue must have:
+- "file": relative file path
+- "severity": "critical" | "major" | "minor"
+- "description": 1-sentence description of the problem
+
+If there are no issues, reply with an empty array: []
+
+Do NOT include markdown fences or commentary. Output ONLY the JSON array.`,
+        userPrompt: `Review these recently changed files:
+
+${filesBlock}`,
+        maxTokens: 1024,
+        temperature: 0.2
       });
-      if (reasoning.original?.files) {
-        for (const file of reasoning.original.files) {
-          if (file.level === "critical" || file.level === "high") {
-            await trackIssueOccurrence(
-              projectPath,
-              file.file,
-              void 0,
-              file.level,
-              config
-            );
-          }
+      if (result.tokensUsed) {
+        this.recordTokenUsage(result.tokensUsed.input + result.tokensUsed.output);
+      }
+      if (!result.success || !result.content.trim()) return;
+      let issues = [];
+      try {
+        const cleaned = result.content.replace(/```json?\n?|\n?```/g, "").trim();
+        issues = JSON.parse(cleaned);
+        if (!Array.isArray(issues)) issues = [];
+      } catch {
+        return;
+      }
+      const issuedFiles = new Set(issues.map((i) => i.file));
+      for (const { relativePath } of toScan) {
+        if (!issuedFiles.has(relativePath)) {
+          this.state.cleanFiles.set(relativePath, Date.now());
         }
       }
-      const riskLevel = reasoning.original?.riskLevel || "low";
-      const shouldBlock = reasoning.original?.shouldBlock || false;
-      if (shouldBlock) {
-        getOutputManager().nudge(
-          `[STOP] Auto-check complete: ${riskLevel.toUpperCase()} risk detected. Fix issues before pushing.`,
-          "critical",
-          void 0,
-          void 0
-          // Keep visible
-        );
-      } else {
-        getOutputManager().nudge(
-          `[OK] Auto-check complete: ${riskLevel} risk. ${reasoning.summary || ""}`,
-          riskLevel === "low" ? "info" : "warning",
-          void 0,
-          1e4
-        );
+      if (issues.length === 0) return;
+      for (const issue of issues.slice(0, 5)) {
+        const severity = issue.severity === "critical" ? "critical" : issue.severity === "major" ? "major" : "minor";
+        const incident = await graph.addNode("incident", {
+          description: issue.description,
+          severity,
+          affectedUsers: null,
+          duration: null,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          resolved: false,
+          resolution: null,
+          fixChangeId: null,
+          reportedVia: "detected"
+        });
+        const filePath = join2(projectPath, issue.file);
+        const fileNode = await graph.getNode("file", filePath);
+        if (fileNode) {
+          await graph.addEdge(fileNode.id, incident.id, "affects");
+          const data = fileNode.data;
+          const newRisk = severity === "critical" ? "critical" : severity === "major" ? "high" : data.riskLevel === "low" ? "medium" : data.riskLevel;
+          await graph.updateNode("file", fileNode.id, {
+            incidentCount: (data.incidentCount ?? 0) + 1,
+            riskLevel: newRisk
+          });
+        }
+        this.state.totalIssuesFound++;
+        if (severity !== "minor") {
+          getOutputManager().nudge(
+            `[!] ${issue.description}`,
+            severity === "critical" ? "critical" : "warning",
+            issue.file,
+            severity === "critical" ? void 0 : 15e3
+          );
+          this.state.nudges.push({
+            file: basename2(issue.file),
+            message: issue.description,
+            severity: severity === "critical" ? "critical" : "high",
+            timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false })
+          });
+        }
       }
-      this.state.criticalIssueCount = 0;
-    } catch (error) {
-      console.error("Auto-check failed:", error);
+      if (this.streamingManager && issues.length > 0) {
+        this.streamingManager.reportSignalExtraction({
+          decisions: 0,
+          facts: 0,
+          blockers: issues.length,
+          questions: 0
+        });
+      }
+    } catch {
     } finally {
-      this.state.autoCheckInProgress = false;
+      this.state.autoScanInProgress = false;
     }
   }
   stopWatching() {
@@ -3433,19 +1594,21 @@ ${f.content.slice(0, 1e3)}`
       this.dashboard.stop();
       this.dashboard = void 0;
     }
+    const budget = this.state.tokenBudget;
+    const tokensK = (budget.used / 1e3).toFixed(1);
     return {
       content: [{
         type: "text",
-        text: `[*] **TRIE AGENT STOPPED** \u{1F916}
+        text: `[*] **TRIE AGENT STOPPED**
 
 ### Session Summary:
 - Files scanned: ${this.state.filesScanned}
-- Total issues found: ${this.state.totalIssuesFound}
-- Directories watched: ${this.watchers.size}
+- Issues found: ${this.state.totalIssuesFound}
+- Tokens used: ${tokensK}k / ${(budget.hourlyLimit / 1e3).toFixed(0)}k hourly limit
+- Scans skipped (trie-throttled): ${budget.scansSaved}
 - Decision ledger: Updated continuously
 
-The agent's learning has been stored in the decision ledger.
-Use \`trie_watch start\` to resume autonomous operation.`
+Use \`trie_watch start\` to resume.`
       }]
     };
   }
@@ -3469,7 +1632,7 @@ Use \`trie_watch start\` to begin autonomous scanning.`
     ).join("\n");
     let agencyStatus = "";
     try {
-      const { getGuardian } = await import("./guardian-agent-4UJN5QGX.js");
+      const { getGuardian } = await import("./guardian-agent-XEYNG7RH.js");
       const trieAgent = getGuardian(getWorkingDirectory(void 0, true));
       await trieAgent.initialize();
       const status = await trieAgent.getAgencyStatus();
@@ -3482,6 +1645,10 @@ Use \`trie_watch start\` to begin autonomous scanning.`
 - **Scan Frequency:** ${Math.round(status.scanFrequency / 1e3)}s${status.isQuietHours ? " (quiet hours)" : ""}`;
     } catch {
     }
+    const budget = this.state.tokenBudget;
+    const remaining = this.getRemainingBudget();
+    const tokensK = (budget.used / 1e3).toFixed(1);
+    const remainingK = (remaining / 1e3).toFixed(1);
     return {
       content: [{
         type: "text",
@@ -3489,9 +1656,14 @@ Use \`trie_watch start\` to begin autonomous scanning.`
 
 ### Stats:
 - Directories watched: ${this.watchers.size}
-- Files scanned this session: ${this.state.filesScanned}
-- Total issues found: ${this.state.totalIssuesFound}
-- Pending files: ${this.state.pendingFiles.size}
+- Files scanned: ${this.state.filesScanned}
+- Issues found: ${this.state.totalIssuesFound}
+- Pending: ${this.state.pendingFiles.size}
+
+### Token Budget:
+- Used: ${tokensK}k / ${(budget.hourlyLimit / 1e3).toFixed(0)}k hourly
+- Remaining: ${remainingK}k
+- Scans skipped (trie-throttled): ${budget.scansSaved}
 ${agencyStatus}
 
 ### Recently Scanned:
@@ -3502,7 +1674,6 @@ ${recentNudges || "(none)"}
 
 ### Commands:
 - \`trie_watch issues\` - Get all issues found
-- \`trie_watch nudges\` - Get recent nudges (structured)
 - \`trie_watch stop\` - Stop watching`
       }]
     };
@@ -3541,9 +1712,9 @@ 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 existsSync5 } from "fs";
-import { join as join3, basename as basename3, resolve as resolve4, isAbsolute as isAbsolute4 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, basename as basename3, resolve as resolve3, isAbsolute as isAbsolute3 } from "path";
 
 // src/skills/built-in/super-reviewer.ts
 var CRITICAL_REVIEW_CHECKLIST = {
@@ -3656,8 +1827,8 @@ Usage:
    */
   async getPRInfo(pr, worktree) {
     if (worktree) {
-      const worktreePath = isAbsolute4(worktree) ? worktree : resolve4(getWorkingDirectory(void 0, true), worktree);
-      if (!existsSync5(worktreePath)) {
+      const worktreePath = isAbsolute3(worktree) ? worktree : resolve3(getWorkingDirectory(void 0, true), worktree);
+      if (!existsSync4(worktreePath)) {
         return { success: false, error: `Worktree not found: ${worktreePath}` };
       }
       return {
@@ -3757,7 +1928,7 @@ Usage:
       const headerLine = lines[0] || "";
       const pathMatch = headerLine.match(/a\/(.+?) b\/(.+)/);
       if (!pathMatch || !pathMatch[2]) continue;
-      const path3 = pathMatch[2];
+      const path2 = pathMatch[2];
       const diff = `diff --git ${fileDiff}`;
       let additions = 0;
       let deletions = 0;
@@ -3768,7 +1939,7 @@ Usage:
           deletions++;
         }
       }
-      files.push({ path: path3, diff, additions, deletions, status: "modified" });
+      files.push({ path: path2, diff, additions, deletions, status: "modified" });
     }
     return files;
   }
@@ -3791,7 +1962,7 @@ Usage:
     ];
     for (const docPath of designDocPaths) {
       const fullPath = join3(cwd, docPath);
-      if (existsSync5(fullPath)) {
+      if (existsSync4(fullPath)) {
       }
     }
     return designDocs;
@@ -3804,9 +1975,9 @@ Usage:
     const cwd = getWorkingDirectory(void 0, true);
     await Promise.all(filePaths.map(async (filePath) => {
       try {
-        const fullPath = isAbsolute4(filePath) ? filePath : join3(cwd, filePath);
-        if (existsSync5(fullPath)) {
-          const content = await readFile5(fullPath, "utf-8");
+        const fullPath = isAbsolute3(filePath) ? filePath : join3(cwd, filePath);
+        if (existsSync4(fullPath)) {
+          const content = await readFile4(fullPath, "utf-8");
           contents.set(filePath, content);
         }
       } catch {
@@ -4585,216 +2756,8 @@ var TrieMemorySearchTool = class {
   }
 };
 
-// src/tools/checkpoint.ts
-async function handleCheckpointTool(input) {
-  const workDir = getWorkingDirectory(void 0, true);
-  switch (input.action) {
-    case "save": {
-      const saveOptions = {
-        files: input.files || [],
-        workDir,
-        createdBy: "mcp"
-      };
-      if (input.message !== void 0) {
-        saveOptions.message = input.message;
-      }
-      if (input.notes !== void 0) {
-        saveOptions.notes = input.notes;
-      }
-      const checkpoint = await saveCheckpoint(saveOptions);
-      return `# Checkpoint Saved
-
-**ID:** ${checkpoint.id}
-**Time:** ${checkpoint.timestamp}
-${checkpoint.message ? `**Message:** ${checkpoint.message}` : ""}
-${checkpoint.notes ? `**Notes:** ${checkpoint.notes}` : ""}
-${checkpoint.files.length > 0 ? `**Files:** ${checkpoint.files.join(", ")}` : ""}
-
-Context saved to \`.trie/\`. This checkpoint will be visible in other tools (Cursor, Claude Code, CLI).`;
-    }
-    case "list": {
-      const checkpoints = await listCheckpoints(workDir);
-      if (checkpoints.length === 0) {
-        return 'No checkpoints yet. Use `trie_checkpoint action="save"` to create one.';
-      }
-      const lines = ["# Recent Checkpoints", ""];
-      for (const cp of checkpoints.slice(-10).reverse()) {
-        const date = new Date(cp.timestamp).toLocaleString();
-        lines.push(`- **${cp.id}** (${date}): ${cp.message || "(no message)"}`);
-      }
-      return lines.join("\n");
-    }
-    case "last": {
-      const checkpoint = await getLastCheckpoint(workDir);
-      if (!checkpoint) {
-        return 'No checkpoints yet. Use `trie_checkpoint action="save"` to create one.';
-      }
-      return `# Last Checkpoint
-
-**ID:** ${checkpoint.id}
-**Time:** ${new Date(checkpoint.timestamp).toLocaleString()}
-${checkpoint.message ? `**Message:** ${checkpoint.message}` : ""}
-${checkpoint.notes ? `**Notes:** ${checkpoint.notes}` : ""}
-${checkpoint.files.length > 0 ? `**Files:** ${checkpoint.files.join(", ")}` : ""}
-**Created by:** ${checkpoint.createdBy}`;
-    }
-    default:
-      return "Unknown action. Use: save, list, or last";
-  }
-}
-
-// src/tools/check.ts
-var TrieCheckTool = class {
-  async execute(input = {}) {
-    try {
-      const workDir = input.directory || getWorkingDirectory(void 0, true);
-      let files = input.files;
-      if (!files || files.length === 0) {
-        const perception = await perceiveCurrentChanges(workDir);
-        files = perception.diffSummary.files.map((f) => f.filePath);
-      }
-      if (!files || files.length === 0) {
-        return {
-          content: [{
-            type: "text",
-            text: "No changes detected. Provide files or make a change."
-          }]
-        };
-      }
-      const mode = input.mode ?? "full";
-      const runAgents = mode === "full";
-      const reasoning = await reasonAboutChangesHumanReadable(workDir, files, {
-        runAgents,
-        scanContext: { config: { timeoutMs: mode === "quick" ? 15e3 : 6e4 } }
-      });
-      const summary = [
-        `Risk: ${reasoning.original.riskLevel.toUpperCase()} (${reasoning.original.shouldBlock ? "block" : "allow"})`,
-        `Explanation: ${reasoning.original.explanation}`,
-        `Recommendation: ${reasoning.original.recommendation}`,
-        `Plain summary: ${reasoning.summary}`,
-        `What I found: ${reasoning.whatIFound}`,
-        `How bad: ${reasoning.howBad}`,
-        `What to do: ${reasoning.whatToDo}`
-      ].join("\n");
-      return {
-        content: [{
-          type: "text",
-          text: summary
-        }]
-      };
-    } catch (error) {
-      const friendly = formatFriendlyError(error);
-      return { content: [{ type: "text", text: friendly.userMessage }] };
-    }
-  }
-};
-
-// src/tools/tell.ts
-import path from "path";
-function escalateRisk(level) {
-  if (level === "low") return "medium";
-  if (level === "medium") return "high";
-  if (level === "high") return "critical";
-  return "critical";
-}
-function extractFilePathsFromDescription(description) {
-  const matches = description.match(/[\\w./_-]+\\.(ts|tsx|js|jsx|mjs|cjs)/gi);
-  if (!matches) return [];
-  const unique = /* @__PURE__ */ new Set();
-  matches.forEach((m) => unique.add(m.replace(/^\.\/+/, "")));
-  return Array.from(unique);
-}
-var TrieTellTool = class {
-  async execute(input) {
-    try {
-      const description = input.description?.trim();
-      if (!description) {
-        return { content: [{ type: "text", text: "description is required" }] };
-      }
-      const projectPath = input.directory || getWorkingDirectory(void 0, true);
-      const graph = new ContextGraph(projectPath);
-      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",
-        affectedUsers: null,
-        duration: null,
-        timestamp: now,
-        resolved: false,
-        resolution: null,
-        fixChangeId: change?.id ?? null,
-        reportedVia: "manual"
-      });
-      if (change) {
-        await graph.addEdge(change.id, incident.id, "leadTo");
-        await graph.addEdge(incident.id, change.id, "causedBy");
-        for (const filePath of change.data.files) {
-          linkedFiles.add(filePath);
-          const fileNode = await graph.getNode("file", path.resolve(projectPath, filePath));
-          if (fileNode) {
-            const data = fileNode.data;
-            await graph.updateNode("file", fileNode.id, {
-              incidentCount: (data.incidentCount ?? 0) + 1,
-              riskLevel: escalateRisk(data.riskLevel)
-            });
-          }
-        }
-      }
-      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: responseText
-        }]
-      };
-    } catch (error) {
-      const friendly = formatFriendlyError(error);
-      return { content: [{ type: "text", text: friendly.userMessage }] };
-    }
-  }
-};
-
 // src/tools/reconcile.ts
-import path2 from "path";
+import path from "path";
 async function removeOrphanEdges(graph) {
   const nodes = await graph.listNodes();
   const ids = new Set(nodes.map((n) => n.id));
@@ -4812,7 +2775,7 @@ var TrieReconcileTool = class {
   async execute(input = {}) {
     try {
       const projectPath = input.directory || getWorkingDirectory(void 0, true);
-      const sourcePath = input.source ?? path2.join(getTrieDirectory(projectPath), "context.json");
+      const sourcePath = input.source ?? path.join(getTrieDirectory(projectPath), "context.json");
       const graph = new ContextGraph(projectPath);
       await importFromJson(graph, "", sourcePath);
       const removed = await removeOrphanEdges(graph);
@@ -4852,33 +2815,6 @@ var TrieContextTool = class {
   }
 };
 
-// src/tools/feedback.ts
-var TrieFeedbackTool = class {
-  async execute(input) {
-    try {
-      const projectPath = input.directory || getWorkingDirectory(void 0, true);
-      const graph = new ContextGraph(projectPath);
-      const engine = new LearningEngine(projectPath, graph);
-      const files = input.files || (input.target ? [input.target] : []);
-      const manualFeedback = {
-        helpful: input.helpful,
-        files,
-        ...input.note !== void 0 ? { note: input.note } : {}
-      };
-      await engine.learn({ manualFeedback });
-      return {
-        content: [{
-          type: "text",
-          text: input.helpful ? "\u{1F44D} Thanks \u2014 I will prioritize more responses like this." : "\u{1F44E} Understood \u2014 I will adjust future guidance."
-        }]
-      };
-    } catch (error) {
-      const friendly = formatFriendlyError(error);
-      return { content: [{ type: "text", text: friendly.userMessage }] };
-    }
-  }
-};
-
 // src/tools/linear-sync.ts
 var LinearSyncTool = class {
   async execute(input) {
@@ -4905,178 +2841,6 @@ 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) {
@@ -5654,8 +3418,8 @@ var ToolRegistry = class {
 };
 
 // src/server/resource-manager.ts
-import { readdir, readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -5880,7 +3644,7 @@ var ResourceManager = class {
     const uiDir = join4(distDir, "ui");
     const htmlPath = join4(uiDir, `${appId}.html`);
     try {
-      if (!existsSync6(htmlPath)) {
+      if (!existsSync5(htmlPath)) {
         return {
           contents: [{
             uri,
@@ -5889,7 +3653,7 @@ var ResourceManager = class {
           }]
         };
       }
-      const content = await readFile6(htmlPath, "utf-8");
+      const content = await readFile5(htmlPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -6072,8 +3836,8 @@ var ResourceManager = class {
     summary.push("---", "", "# Detailed Context", "");
     const agentsMdPath = join4(getTrieDirectory(workDir), "AGENTS.md");
     try {
-      if (existsSync6(agentsMdPath)) {
-        const agentsContent = await readFile6(agentsMdPath, "utf-8");
+      if (existsSync5(agentsMdPath)) {
+        const agentsContent = await readFile5(agentsMdPath, "utf-8");
         summary.push(agentsContent);
       } else {
         const contextSummary = await getContextForAI();
@@ -6199,7 +3963,7 @@ This information is automatically available to Claude Code, Cursor, and other AI
   async getCacheStatsResource(uri) {
     try {
       const cachePath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
-      const cacheContent = await readFile6(cachePath, "utf-8");
+      const cacheContent = await readFile5(cachePath, "utf-8");
       const cache = JSON.parse(cacheContent);
       const fileCount = Object.keys(cache.files || {}).length;
       const totalVulns = Object.values(cache.files || {}).reduce((acc, file) => {
@@ -6280,7 +4044,7 @@ This information is automatically available to Claude Code, Cursor, and other AI
     const fileName = parsedUri.replace("reports/", "");
     const reportPath = join4(getWorkingDirectory(void 0, true), "trie-reports", fileName);
     try {
-      const content = await readFile6(reportPath, "utf-8");
+      const content = await readFile5(reportPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -6427,32 +4191,32 @@ async function findOpenPort() {
   return portChecks.find((port) => port !== null) || null;
 }
 async function checkPort(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     const testServer = createServer();
     let portInUse = false;
     testServer.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
         portInUse = true;
-        testHttpPort(port).then(resolve5).catch(() => resolve5(false));
+        testHttpPort(port).then(resolve4).catch(() => resolve4(false));
       } else {
-        resolve5(false);
+        resolve4(false);
       }
     });
     testServer.once("listening", () => {
       testServer.close();
-      resolve5(false);
+      resolve4(false);
     });
     setTimeout(() => {
       if (!portInUse) {
         testServer.close();
-        resolve5(false);
+        resolve4(false);
       }
     }, 1e3);
     testServer.listen(port, "127.0.0.1");
   });
 }
 async function testHttpPort(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     const req = request({
       hostname: "localhost",
       port,
@@ -6460,18 +4224,18 @@ async function testHttpPort(port) {
       method: "GET",
       timeout: 2e3
     }, (res) => {
-      resolve5(res.statusCode !== void 0);
+      resolve4(res.statusCode !== void 0);
       res.on("data", () => {
       });
       res.on("end", () => {
       });
     });
     req.on("error", () => {
-      resolve5(false);
+      resolve4(false);
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve5(false);
+      resolve4(false);
     });
     req.end();
   });