@triedotdev/mcp 1.0.28 → 1.0.30

package/dist/index.js

@@ -5,12 +5,9 @@ import {
   parseDocument
 } from "./chunk-PG3GMCGH.js";
 import {
-  TrieFixTool,
   TrieScanTool,
-  getPrompt,
-  getSystemPrompt,
   loadConfig
-} from "./chunk-BICD36UW.js";
+} from "./chunk-B6MTR6IG.js";
 import {
   CRITICAL_REVIEW_CHECKLIST,
   SuperReviewerAgent,
@@ -102,10 +99,1275 @@ function detectAITool() {
   };
 }
 
-// src/tools/explain.ts
+// src/tools/fix.ts
 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`
+  },
+  privacy: {
+    system: `You are a data privacy officer and GDPR/HIPAA compliance expert.
+Analyze code for privacy violations and data protection issues.
+
+Key regulations to enforce:
+- GDPR (EU data protection)
+- CCPA (California privacy)
+- HIPAA (health data)
+- COPPA (children's privacy)
+- PCI DSS (payment data)
+
+Look for:
+- PII without encryption
+- Missing consent mechanisms
+- Data retention violations
+- Cross-border data transfer issues
+- Third-party data sharing without disclosure`,
+    analysis: `## Privacy Compliance Audit
+
+Analyze this code for privacy/compliance issues:
+
+\`\`\`{{language}}
+{{code}}
+\`\`\`
+
+**File:** {{filePath}}
+**Data Types Detected:** {{dataTypes}}
+
+For each issue:
+1. Regulation violated (e.g., GDPR Article 32)
+2. Specific requirement not met
+3. Risk level and potential fine exposure
+4. Remediation steps with code examples
+5. Documentation requirements
+
+Reference current regulatory guidance when applicable.`
+  },
+  legal: {
+    system: `You are a tech-focused legal compliance analyst.
+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}}
+### \u26A0\uFE0F 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: `## \u{1F3AF} 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 sub-agents 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 sub-agents 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) {
+    const { issueIds, file, line, issue, fix, autoApprove = false, dryRun = false } = args || {};
+    if (issueIds && issueIds.length > 0) {
+      return this.fixByIds(issueIds, autoApprove, dryRun);
+    }
+    if (file && fix) {
+      return this.applyFix(file, line || 1, issue || "User-specified fix", fix, dryRun);
+    }
+    if (pendingFixes.size > 0) {
+      return this.showPendingFixes();
+    }
+    if (file && issue) {
+      return this.generateFixPrompt(file, line || 1, issue);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: this.getHelpText()
+      }]
+    };
+  }
+  async fixByIds(issueIds, autoApprove, dryRun) {
+    const results = [];
+    let fixed = 0;
+    let failed = 0;
+    for (const id of issueIds) {
+      const pendingFix = pendingFixes.get(id);
+      if (!pendingFix) {
+        results.push(`\u274C Issue ${id}: Not found in pending fixes`);
+        failed++;
+        continue;
+      }
+      if (pendingFix.confidence < 0.8 && !autoApprove) {
+        results.push(`\u26A0\uFE0F Issue ${id}: Confidence too low (${(pendingFix.confidence * 100).toFixed(0)}%) - use autoApprove:true to override`);
+        continue;
+      }
+      if (dryRun) {
+        results.push(`\u{1F50D} Issue ${id}: Would fix "${pendingFix.issue}" in ${pendingFix.file}:${pendingFix.line}`);
+        continue;
+      }
+      try {
+        results.push(`\u2705 Issue ${id}: Fix prepared for ${pendingFix.file}:${pendingFix.line}`);
+        results.push(`   Issue: ${pendingFix.issue}`);
+        results.push(`   Fix: ${pendingFix.suggestedFix}`);
+        pendingFix.status = "applied";
+        fixed++;
+      } catch (error) {
+        results.push(`\u274C Issue ${id}: Failed to apply - ${error}`);
+        failed++;
+      }
+    }
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX RESULTS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += results.join("\n");
+    output += `
+
+**Summary:** ${fixed} fixed, ${failed} failed, ${issueIds.length - fixed - failed} skipped
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async applyFix(file, line, issue, fix, dryRun) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const filePath = isAbsolute(file) ? file : resolve(workDir, file);
+    if (!existsSync(filePath)) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C File not found: ${filePath}`
+        }]
+      };
+    }
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const language = this.detectLanguage(filePath);
+    const contextStart = Math.max(0, line - 10);
+    const contextEnd = Math.min(lines.length, line + 10);
+    const contextLines = lines.slice(contextStart, contextEnd);
+    const prompt = getPrompt("fix", "apply", {
+      issue,
+      fix,
+      language,
+      code: contextLines.join("\n"),
+      filePath: relative(workDir, filePath),
+      line: String(line)
+    });
+    const systemPrompt = getSystemPrompt("fix");
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX APPLICATION REQUEST
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4CD} Target
+
+`;
+    output += `- **File:** \`${relative(workDir, filePath)}\`
+`;
+    output += `- **Line:** ${line}
+`;
+    output += `- **Issue:** ${issue}
+`;
+    output += `- **Requested Fix:** ${fix}
+
+`;
+    output += `## \u{1F4C4} Current Code Context
+
+`;
+    output += `\`\`\`${language}
+`;
+    for (let i = 0; i < contextLines.length; i++) {
+      const lineNum = contextStart + i + 1;
+      const marker = lineNum === line ? "\u2192 " : "  ";
+      output += `${marker}${lineNum.toString().padStart(4)} | ${contextLines[i]}
+`;
+    }
+    output += `\`\`\`
+
+`;
+    if (dryRun) {
+      output += `## \u{1F50D} Dry Run Mode
+
+`;
+      output += `No changes will be made. Review the fix below:
+
+`;
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F9E0} Fix Request for AI
+
+`;
+    output += `**Role:** ${systemPrompt.split("\n")[0]}
+
+`;
+    output += prompt;
+    output += `
+${"\u2500".repeat(60)}
+`;
+    output += `
+### After generating the fix, apply it with:
+
+`;
+    output += `\`\`\`
+`;
+    output += `Use the edit_file tool to apply the generated code changes
+`;
+    output += `\`\`\`
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async generateFixPrompt(file, line, issue) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const filePath = isAbsolute(file) ? file : resolve(workDir, file);
+    if (!existsSync(filePath)) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C File not found: ${filePath}`
+        }]
+      };
+    }
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const language = this.detectLanguage(filePath);
+    const contextStart = Math.max(0, line - 20);
+    const contextEnd = Math.min(lines.length, line + 20);
+    const contextLines = lines.slice(contextStart, contextEnd);
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX GENERATION REQUEST
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4CD} Issue Details
+
+`;
+    output += `- **File:** \`${relative(workDir, filePath)}\`
+`;
+    output += `- **Line:** ${line}
+`;
+    output += `- **Issue:** ${issue}
+
+`;
+    output += `## \u{1F4C4} Code Context
+
+`;
+    output += `\`\`\`${language}
+`;
+    for (let i = 0; i < contextLines.length; i++) {
+      const lineNum = contextStart + i + 1;
+      const marker = lineNum === line ? "\u2192 " : "  ";
+      output += `${marker}${lineNum.toString().padStart(4)} | ${contextLines[i]}
+`;
+    }
+    output += `\`\`\`
+
+`;
+    output += `## \u{1F9E0} Analysis Request
+
+`;
+    output += `Please analyze this issue and provide:
+
+`;
+    output += `1. **Root cause** - Why does this issue occur?
+`;
+    output += `2. **Impact** - What could go wrong if unfixed?
+`;
+    output += `3. **Fix** - The exact code change needed
+`;
+    output += `4. **Verification** - How to test the fix works
+
+`;
+    output += `After analysis, you can apply the fix using the edit_file tool.
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  showPendingFixes() {
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} PENDING FIXES
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    if (pendingFixes.size === 0) {
+      output += `No pending fixes. Run \`trie_scan\` first to detect issues.
+`;
+      return { content: [{ type: "text", text: output }] };
+    }
+    const fixes = Array.from(pendingFixes.values());
+    const byStatus = {
+      pending: fixes.filter((f) => f.status === "pending"),
+      applied: fixes.filter((f) => f.status === "applied"),
+      rejected: fixes.filter((f) => f.status === "rejected")
+    };
+    if (byStatus.pending.length > 0) {
+      output += `## \u23F3 Pending (${byStatus.pending.length})
+
+`;
+      output += `| ID | File | Line | Issue | Confidence |
+`;
+      output += `|----|------|------|-------|------------|
+`;
+      for (const fix of byStatus.pending) {
+        const conf = `${(fix.confidence * 100).toFixed(0)}%`;
+        const shortFile = fix.file.split("/").slice(-2).join("/");
+        output += `| ${fix.id} | ${shortFile} | ${fix.line} | ${fix.issue.slice(0, 40)}... | ${conf} |
+`;
+      }
+      output += "\n";
+    }
+    output += `### Commands
+
+`;
+    output += `- Fix all high-confidence: \`trie_fix autoApprove:true\`
+`;
+    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 || {};
@@ -140,10 +1402,10 @@ var TrieExplainTool = class {
     let filePath;
     let language;
     const workDir = getWorkingDirectory(void 0, true);
-    const resolvedPath = isAbsolute(target) ? target : resolve(workDir, target);
-    if (existsSync(resolvedPath)) {
-      code = await readFile(resolvedPath, "utf-8");
-      filePath = relative(workDir, resolvedPath);
+    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;
@@ -250,8 +1512,8 @@ ${"\u2500".repeat(60)}
     else if (/moderate|warning/i.test(issue)) severity = "moderate";
     else severity = "low";
     let codeContext = "";
-    if (file && existsSync(file)) {
-      const content = await readFile(file, "utf-8");
+    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);
@@ -354,7 +1616,7 @@ ${"\u2501".repeat(60)}
   }
   async explainRisk(target, context) {
     const workDir = getWorkingDirectory(void 0, true);
-    const resolvedPath = isAbsolute(target) ? target : resolve(workDir, target);
+    const resolvedPath = isAbsolute2(target) ? target : resolve2(workDir, target);
     let output = `
 ${"\u2501".repeat(60)}
 `;
@@ -363,9 +1625,9 @@ ${"\u2501".repeat(60)}
     output += `${"\u2501".repeat(60)}
 
 `;
-    if (existsSync(resolvedPath)) {
-      const code = await readFile(resolvedPath, "utf-8");
-      const filePath = relative(workDir, resolvedPath);
+    if (existsSync2(resolvedPath)) {
+      const code = await readFile2(resolvedPath, "utf-8");
+      const filePath = relative2(workDir, resolvedPath);
       const riskIndicators = this.detectRiskIndicators(code);
       output += `## \u{1F4C2} Target
 
@@ -506,7 +1768,7 @@ ${"\u2500".repeat(60)}
     return [...new Set(functions)];
   }
   detectLanguage(filePath) {
-    const ext = extname(filePath).toLowerCase();
+    const ext = extname2(filePath).toLowerCase();
     const langMap = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -589,9 +1851,9 @@ trie_explain type:"risk" target:"Adding Stripe integration for payments"
 };
 
 // src/tools/test.ts
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2, dirname, basename, join } from "path";
+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";
 var TrieTestTool = class {
   async execute(args) {
     const { action, files, framework, style = "unit" } = args || {};
@@ -644,15 +1906,15 @@ ${"\u2501".repeat(60)}
     const workDir = getWorkingDirectory(void 0, true);
     const allUnits = [];
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
+      if (!existsSync3(resolvedPath)) {
         output += `\u26A0\uFE0F File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
+      const code = await readFile3(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative2(workDir, resolvedPath);
+      const relativePath = relative3(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       allUnits.push({ file: relativePath, units });
       output += `### \u{1F4C4} ${relativePath}
@@ -683,7 +1945,7 @@ ${"\u2501".repeat(60)}
 `;
     for (const { file, units } of allUnits) {
       if (units.length === 0) continue;
-      const code = await readFile2(resolve2(workDir, file), "utf-8");
+      const code = await readFile3(resolve3(workDir, file), "utf-8");
       const language = this.detectLanguage(file);
       const prompt = getPrompt("test", "generate", {
         code,
@@ -728,21 +1990,21 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
+      if (!existsSync3(resolvedPath)) {
         output += `\u26A0\uFE0F File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
+      const code = await readFile3(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative2(workDir, resolvedPath);
+      const relativePath = relative3(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       const testFile = await this.findTestFile(resolvedPath);
       let testCode = "";
       let testedUnits = [];
       if (testFile) {
-        testCode = await readFile2(testFile, "utf-8");
+        testCode = await readFile3(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;
@@ -753,7 +2015,7 @@ ${"\u2501".repeat(60)}
       output += `**Coverage:** ${coverageIcon} ${coverage}% (${testedUnits.length}/${units.length} units)
 `;
       if (testFile) {
-        output += `**Test file:** \`${relative2(workDir, testFile)}\`
+        output += `**Test file:** \`${relative3(workDir, testFile)}\`
 `;
       } else {
         output += `**Test file:** \u274C Not found
@@ -810,14 +2072,14 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      const resolvedPath = isAbsolute3(file) ? file : resolve3(workDir, file);
+      if (!existsSync3(resolvedPath)) {
         output += `\u26A0\uFE0F File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
-      const relativePath = relative2(workDir, resolvedPath);
+      const code = await readFile3(resolvedPath, "utf-8");
+      const relativePath = relative3(workDir, resolvedPath);
       const patterns = this.detectTestablePatterns(code);
       output += `### \u{1F4C4} ${relativePath}
 
@@ -1053,8 +2315,8 @@ ${"\u2501".repeat(60)}
   }
   async findTestFile(sourcePath) {
     const dir = dirname(sourcePath);
-    const base = basename(sourcePath, extname2(sourcePath));
-    const ext = extname2(sourcePath);
+    const base = basename(sourcePath, extname3(sourcePath));
+    const ext = extname3(sourcePath);
     const patterns = [
       `${base}.test${ext}`,
       `${base}.spec${ext}`,
@@ -1063,15 +2325,15 @@ ${"\u2501".repeat(60)}
     ];
     for (const pattern of patterns) {
       const testPath = join(dir, pattern);
-      if (existsSync2(testPath)) {
+      if (existsSync3(testPath)) {
         return testPath;
       }
     }
     const testsDir = join(dir, "__tests__");
-    if (existsSync2(testsDir)) {
+    if (existsSync3(testsDir)) {
       for (const pattern of patterns) {
         const testPath = join(testsDir, pattern);
-        if (existsSync2(testPath)) {
+        if (existsSync3(testPath)) {
           return testPath;
         }
       }
@@ -1118,10 +2380,10 @@ ${"\u2501".repeat(60)}
   }
   async detectTestFramework() {
     const workDir = getWorkingDirectory(void 0, true);
-    const packagePath = resolve2(workDir, "package.json");
-    if (existsSync2(packagePath)) {
+    const packagePath = resolve3(workDir, "package.json");
+    if (existsSync3(packagePath)) {
       try {
-        const pkg = JSON.parse(await readFile2(packagePath, "utf-8"));
+        const pkg = JSON.parse(await readFile3(packagePath, "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (deps.vitest) return "vitest";
         if (deps.jest) return "jest";
@@ -1129,13 +2391,13 @@ ${"\u2501".repeat(60)}
       } catch {
       }
     }
-    if (existsSync2(resolve2(workDir, "pytest.ini")) || existsSync2(resolve2(workDir, "pyproject.toml"))) {
+    if (existsSync3(resolve3(workDir, "pytest.ini")) || existsSync3(resolve3(workDir, "pyproject.toml"))) {
       return "pytest";
     }
     return "jest";
   }
   detectLanguage(filePath) {
-    const ext = extname2(filePath).toLowerCase();
+    const ext = extname3(filePath).toLowerCase();
     const langMap = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -1207,8 +2469,8 @@ TODO: Implement register agent functionality`
 // src/tools/watch.ts
 import { watch } from "fs";
 import { stat } from "fs/promises";
-import { join as join2, extname as extname3, basename as basename2 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { join as join2, extname as extname4, basename as basename2 } from "path";
+import { existsSync as existsSync4 } from "fs";
 var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -1235,42 +2497,37 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 var TrieWatchTool = class {
   scanTool = new TrieScanTool();
-  fixTool = new TrieFixTool();
   state = {
     isRunning: false,
-    yoloMode: false,
     lastScan: /* @__PURE__ */ new Map(),
     pendingFiles: /* @__PURE__ */ new Set(),
     scanDebounceTimer: null,
     issueCache: /* @__PURE__ */ new Map(),
     totalIssuesFound: 0,
-    totalIssuesFixed: 0,
     filesScanned: 0
   };
   watchers = /* @__PURE__ */ new Map();
   async execute(args) {
-    const { action, directory, debounceMs = 1e3, yolo = false } = args;
+    const { action, directory, debounceMs = 1e3 } = args;
     switch (action) {
       case "start":
-        return this.startWatching(getWorkingDirectory(directory), debounceMs, yolo);
+        return this.startWatching(getWorkingDirectory(directory), debounceMs);
       case "stop":
         return this.stopWatching();
       case "status":
         return this.getStatus();
       case "issues":
         return this.getCurrentIssues();
-      case "yolo":
-        return this.toggleYoloMode();
       default:
         return {
           content: [{
             type: "text",
-            text: `Unknown action: ${action}. Use 'start', 'stop', 'status', 'issues', or 'yolo'.`
+            text: `Unknown action: ${action}. Use 'start', 'stop', 'status', or 'issues'.`
           }]
         };
     }
   }
-  async startWatching(directory, debounceMs, yoloMode) {
+  async startWatching(directory, debounceMs) {
     if (this.state.isRunning) {
       return {
         content: [{
@@ -1280,57 +2537,36 @@ var TrieWatchTool = class {
       };
     }
     this.state.isRunning = true;
-    this.state.yoloMode = yoloMode;
     this.state.issueCache.clear();
     this.state.totalIssuesFound = 0;
-    this.state.totalIssuesFixed = 0;
     this.state.filesScanned = 0;
-    const modeEmoji = yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
-    const modeName = yoloMode ? "YOLO MODE" : "WATCH MODE";
     console.error("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
-    console.error(`${modeEmoji}  TRIE AGENT - AUTONOMOUS ${modeName}`);
+    console.error("\u{1F441}\uFE0F  TRIE AGENT - AUTONOMOUS WATCH MODE");
     console.error("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
     console.error(`\u{1F4C2} Watching: ${directory}`);
     console.error(`\u23F1\uFE0F  Debounce: ${debounceMs}ms`);
-    if (yoloMode) {
-      console.error("\u{1F525} YOLO MODE: Auto-fixing issues as they occur!");
-    }
     console.error("");
     await this.watchDirectory(directory, debounceMs);
     console.error("\u{1F50D} Running initial scan...\n");
-    const initialResult = await this.scanTool.execute({ directory, yoloMode: this.state.yoloMode });
-    const yoloMessage = yoloMode ? `
-### \u{1F525} YOLO MODE ENABLED
-Issues will be **automatically fixed** as they're detected!
-- High-confidence fixes applied immediately
-- No confirmation needed
-- Living on the edge \u{1F680}
-
-` : `
-### \u{1F4A1} Want auto-fixes?
-Run \`trie_watch yolo\` to enable YOLO mode and auto-fix issues as they occur!
-
-`;
+    const initialResult = await this.scanTool.execute({ directory });
     return {
       content: [{
         type: "text",
-        text: `${modeEmoji} **AUTONOMOUS ${modeName} ACTIVATED**
+        text: `\u{1F441}\uFE0F **AUTONOMOUS WATCH MODE ACTIVATED**
 
 Trie Agent is now watching for file changes and will automatically scan them.
 
 **Watching:** \`${directory}\`
 **Debounce:** ${debounceMs}ms (waits for you to stop typing)
-**YOLO Mode:** ${yoloMode ? "\u{1F525} ON - Auto-fixing!" : "\u274C OFF"}
 
 ### How it works:
 1. \u{1F4DD} You write/edit code
 2. \u{1F441}\uFE0F Trie detects the change
 3. \u{1F50D} Automatically scans the modified file
-4. ${yoloMode ? "\u{1F527} Auto-fixes issues immediately!" : "\u{1F6A8} Reports issues immediately"}
-${yoloMessage}
+4. \u{1F6A8} Reports issues immediately
+
 ### Commands:
 - \`trie_watch status\` - See current watch status
-- \`trie_watch yolo\` - Toggle YOLO mode (auto-fix)
 - \`trie_watch issues\` - Get all issues found so far  
 - \`trie_watch stop\` - Stop autonomous mode
 
@@ -1340,52 +2576,8 @@ ${initialResult.content?.[0]?.text || "Initial scan complete."}`
       }]
     };
   }
-  toggleYoloMode() {
-    if (!this.state.isRunning) {
-      return {
-        content: [{
-          type: "text",
-          text: `\u26A0\uFE0F Watch mode is not running. Start it first with:
-          
-\`trie_watch start\` - Normal mode
-\`trie_watch start yolo:true\` - YOLO mode from the start`
-        }]
-      };
-    }
-    this.state.yoloMode = !this.state.yoloMode;
-    if (this.state.yoloMode) {
-      console.error("\n\u{1F525} YOLO MODE ACTIVATED! Auto-fixing issues as they occur...\n");
-      return {
-        content: [{
-          type: "text",
-          text: `\u{1F525} **YOLO MODE ACTIVATED**
-
-Issues will now be **automatically fixed** as they're detected!
-
-\u26A0\uFE0F **Warning:** This will modify your files without confirmation.
-- High-confidence fixes only
-- Backs up original code in memory
-- You can always undo with git
-
-Run \`trie_watch yolo\` again to disable.`
-        }]
-      };
-    } else {
-      console.error("\n\u{1F441}\uFE0F YOLO mode disabled. Back to watch-only mode.\n");
-      return {
-        content: [{
-          type: "text",
-          text: `\u{1F441}\uFE0F **YOLO MODE DISABLED**
-
-Back to normal watch mode. Issues will be reported but not auto-fixed.
-
-Run \`trie_watch yolo\` to re-enable.`
-        }]
-      };
-    }
-  }
   async watchDirectory(dir, debounceMs) {
-    if (!existsSync3(dir)) return;
+    if (!existsSync4(dir)) return;
     try {
       const dirStat = await stat(dir);
       if (!dirStat.isDirectory()) return;
@@ -1394,9 +2586,9 @@ Run \`trie_watch yolo\` to re-enable.`
       const watcher = watch(dir, { persistent: true }, async (_eventType, filename) => {
         if (!filename) return;
         const fullPath = join2(dir, filename);
-        const ext = extname3(filename).toLowerCase();
+        const ext = extname4(filename).toLowerCase();
         if (!WATCH_EXTENSIONS.has(ext)) return;
-        if (!existsSync3(fullPath)) return;
+        if (!existsSync4(fullPath)) return;
         this.state.pendingFiles.add(fullPath);
         if (this.state.scanDebounceTimer) {
           clearTimeout(this.state.scanDebounceTimer);
@@ -1420,15 +2612,14 @@ Run \`trie_watch yolo\` to re-enable.`
     if (this.state.pendingFiles.size === 0) return;
     const files = Array.from(this.state.pendingFiles);
     this.state.pendingFiles.clear();
-    const modeEmoji = this.state.yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
     console.error(`
-${modeEmoji} Detected changes in ${files.length} file(s):`);
+\u{1F441}\uFE0F Detected changes in ${files.length} file(s):`);
     for (const file of files) {
       console.error(`   \u2022 ${basename2(file)}`);
     }
     console.error("");
     try {
-      const result = await this.scanTool.execute({ files, yoloMode: this.state.yoloMode });
+      const result = await this.scanTool.execute({ files });
       const resultText = result.content?.[0]?.text || "";
       this.state.filesScanned += files.length;
       const issueMatch = resultText.match(/(\d+) total/);
@@ -1450,12 +2641,6 @@ ${modeEmoji} Detected changes in ${files.length} file(s):`);
           if (moderateMatch) {
             console.error(`   \u{1F7E1} ${moderateMatch[1]} moderate issues`);
           }
-          if (this.state.yoloMode) {
-            console.error("\n\u{1F525} YOLO MODE: Attempting auto-fix...");
-            await this.autoFixIssues(files);
-          } else {
-            console.error("\n\u{1F4A1} Run `trie_watch yolo` to auto-fix issues");
-          }
         } else {
           console.error("   \u2705 No issues found - code looks good!");
         }
@@ -1467,30 +2652,6 @@ ${modeEmoji} Detected changes in ${files.length} file(s):`);
       console.error(`\u274C Scan error: ${error}`);
     }
   }
-  async autoFixIssues(files) {
-    try {
-      const fixResult = await this.fixTool.execute({
-        files,
-        autoApprove: true,
-        minConfidence: 0.8
-        // Only fix high-confidence issues
-      });
-      const fixText = fixResult.content?.[0]?.text || "";
-      const fixedMatch = fixText.match(/(\d+) issues? fixed/i);
-      if (fixedMatch?.[1] !== void 0) {
-        const fixed = parseInt(fixedMatch[1], 10);
-        this.state.totalIssuesFixed += fixed;
-        console.error(`   \u2705 Auto-fixed ${fixed} issues!`);
-      } else if (fixText.includes("No issues")) {
-        console.error("   \u2139\uFE0F  No auto-fixable issues found");
-      } else {
-        const firstLine = fixText.split("\n")[0];
-        console.error(`   \u{1F527} ${firstLine}`);
-      }
-    } catch (error) {
-      console.error(`   \u26A0\uFE0F Auto-fix error: ${error}`);
-    }
-  }
   stopWatching() {
     if (!this.state.isRunning) {
       return {
@@ -1507,29 +2668,19 @@ ${modeEmoji} Detected changes in ${files.length} file(s):`);
     if (this.state.scanDebounceTimer) {
       clearTimeout(this.state.scanDebounceTimer);
     }
-    const wasYolo = this.state.yoloMode;
     this.state.isRunning = false;
-    this.state.yoloMode = false;
-    const modeEmoji = wasYolo ? "\u{1F525}" : "\u{1F441}\uFE0F";
-    console.error(`
-${modeEmoji} Watch mode stopped.
-`);
-    const yoloStats = wasYolo ? `
-- \u{1F525} **Issues auto-fixed: ${this.state.totalIssuesFixed}**` : "";
+    console.error("\n\u{1F441}\uFE0F Watch mode stopped.\n");
     return {
       content: [{
         type: "text",
-        text: `${modeEmoji} **AUTONOMOUS MODE STOPPED**
+        text: `\u{1F441}\uFE0F **AUTONOMOUS WATCH MODE STOPPED**
 
 ### Session Summary:
 - Files scanned: ${this.state.filesScanned}
-- Total issues found: ${this.state.totalIssuesFound}${yoloStats}
+- Total issues found: ${this.state.totalIssuesFound}
 - Directories watched: ${this.watchers.size}
-${wasYolo ? `
-\u{1F525} YOLO mode was ON - issues were auto-fixed as they occurred!` : ""}
 
-Use \`trie_watch start\` to start watching again.
-Use \`trie_watch start yolo:true\` for YOLO mode.`
+Use \`trie_watch start\` to start watching again.`
       }]
     };
   }
@@ -1540,36 +2691,29 @@ Use \`trie_watch start yolo:true\` for YOLO mode.`
           type: "text",
           text: `\u{1F441}\uFE0F **Watch Mode Status: STOPPED**
 
-Use \`trie_watch start\` to begin autonomous scanning.
-Use \`trie_watch start yolo:true\` for YOLO mode (auto-fix).`
+Use \`trie_watch start\` to begin autonomous scanning.`
         }]
       };
     }
-    const modeEmoji = this.state.yoloMode ? "\u{1F525}" : "\u{1F441}\uFE0F";
-    const modeName = this.state.yoloMode ? "YOLO MODE" : "WATCH MODE";
     const recentScans = Array.from(this.state.lastScan.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([file, time]) => {
       const ago = Math.round((Date.now() - time) / 1e3);
       return `- \`${basename2(file)}\` (${ago}s ago)`;
     }).join("\n");
-    const yoloStats = this.state.yoloMode ? `
-- \u{1F525} Issues auto-fixed: ${this.state.totalIssuesFixed}` : "";
     return {
       content: [{
         type: "text",
-        text: `${modeEmoji} **${modeName} Status: RUNNING**
+        text: `\u{1F441}\uFE0F **WATCH MODE Status: RUNNING**
 
 ### Stats:
 - Directories watched: ${this.watchers.size}
 - Files scanned this session: ${this.state.filesScanned}
-- Total issues found: ${this.state.totalIssuesFound}${yoloStats}
+- Total issues found: ${this.state.totalIssuesFound}
 - Pending files: ${this.state.pendingFiles.size}
-- YOLO Mode: ${this.state.yoloMode ? "\u{1F525} ON" : "\u274C OFF"}
 
 ### Recently Scanned:
 ${recentScans || "(none yet)"}
 
 ### Commands:
-- \`trie_watch yolo\` - ${this.state.yoloMode ? "Disable" : "Enable"} YOLO mode
 - \`trie_watch issues\` - Get all issues found
 - \`trie_watch stop\` - Stop watching`
       }]
@@ -1591,9 +2735,9 @@ To get a full report, run \`trie_scan\` on your codebase.`
 };
 
 // src/tools/agent.ts
-import { readdir, readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join3, extname as extname4, isAbsolute as isAbsolute3, resolve as resolve3, basename as basename3 } from "path";
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join3, extname as extname5, isAbsolute as isAbsolute4, resolve as resolve4, basename as basename3 } from "path";
 
 // src/knowledge/index.ts
 var SECURITY_SOURCES = [
@@ -1942,10 +3086,10 @@ ${this.agentRegistry.getAgentNames().map((n) => `- ${n}`).join("\n")}`
 `);
     } else {
       filesToScan = filesToScan.map(
-        (f) => isAbsolute3(f) ? f : resolve3(workDir, f)
+        (f) => isAbsolute4(f) ? f : resolve4(workDir, f)
       );
     }
-    const validFiles = filesToScan.filter((f) => existsSync4(f));
+    const validFiles = filesToScan.filter((f) => existsSync5(f));
     if (validFiles.length === 0) {
       return {
         content: [{
@@ -2179,9 +3323,9 @@ ${issue.fix}
    * Get a code snippet around a specific line
    */
   async getCodeSnippet(filePath, line) {
-    if (!line || !existsSync4(filePath)) return null;
+    if (!line || !existsSync5(filePath)) return null;
     try {
-      const content = await readFile3(filePath, "utf-8");
+      const content = await readFile4(filePath, "utf-8");
       const lines = content.split("\n");
       const start = Math.max(0, line - 3);
       const end = Math.min(lines.length, line + 2);
@@ -2225,7 +3369,7 @@ ${issue.fix}
               await walk(fullPath);
             }
           } else if (entry.isFile()) {
-            const ext = extname4(entry.name).toLowerCase();
+            const ext = extname5(entry.name).toLowerCase();
             if (SCANNABLE_EXTENSIONS.has(ext)) {
               files.push(fullPath);
             }
@@ -2240,9 +3384,9 @@ ${issue.fix}
 };
 
 // src/tools/create-agent.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { join as join4, basename as basename4, extname as extname5 } from "path";
+import { join as join4, basename as basename4, extname as extname6 } from "path";
 var TrieCreateAgentTool = class {
   async execute(args) {
     const { filePath, documentContent, agentName, displayName, description, category } = args;
@@ -2259,7 +3403,7 @@ var TrieCreateAgentTool = class {
       let title = agentName;
       let wordCount = 0;
       if (filePath) {
-        if (!existsSync5(filePath)) {
+        if (!existsSync6(filePath)) {
           return this.errorResponse(`File not found: ${filePath}`);
         }
         const ext = filePath.toLowerCase().split(".").pop();
@@ -2271,7 +3415,7 @@ Supported types: .pdf, .txt, .md, .rtf`
         }
         const document = await parseDocument(filePath);
         rawText = document.rawText;
-        title = document.metadata.title || basename4(filePath, extname5(filePath));
+        title = document.metadata.title || basename4(filePath, extname6(filePath));
         wordCount = document.metadata.wordCount;
       } else {
         rawText = documentContent;
@@ -2799,9 +3943,9 @@ var TrieListAgentsTool = class {
 };
 
 // src/tools/pr-review.ts
-import { readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join5, basename as basename5, resolve as resolve4, isAbsolute as isAbsolute4 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join5, basename as basename5, resolve as resolve5, isAbsolute as isAbsolute5 } from "path";
 import { execSync } from "child_process";
 var TriePRReviewTool = class {
   agent = new SuperReviewerAgent();
@@ -2872,8 +4016,8 @@ Usage:
    */
   async getPRInfo(pr, worktree) {
     if (worktree) {
-      const worktreePath = isAbsolute4(worktree) ? worktree : resolve4(getWorkingDirectory(void 0, true), worktree);
-      if (!existsSync6(worktreePath)) {
+      const worktreePath = isAbsolute5(worktree) ? worktree : resolve5(getWorkingDirectory(void 0, true), worktree);
+      if (!existsSync7(worktreePath)) {
         return { success: false, error: `Worktree not found: ${worktreePath}` };
       }
       return {
@@ -3023,7 +4167,7 @@ Usage:
     ];
     for (const docPath of designDocPaths) {
       const fullPath = join5(cwd, docPath);
-      if (existsSync6(fullPath)) {
+      if (existsSync7(fullPath)) {
       }
     }
     return designDocs;
@@ -3036,9 +4180,9 @@ Usage:
     const cwd = getWorkingDirectory(void 0, true);
     await Promise.all(filePaths.map(async (filePath) => {
       try {
-        const fullPath = isAbsolute4(filePath) ? filePath : join5(cwd, filePath);
-        if (existsSync6(fullPath)) {
-          const content = await readFile4(fullPath, "utf-8");
+        const fullPath = isAbsolute5(filePath) ? filePath : join5(cwd, filePath);
+        if (existsSync7(fullPath)) {
+          const content = await readFile5(fullPath, "utf-8");
           contents.set(filePath, content);
         }
       } catch {
@@ -3601,7 +4745,7 @@ var ToolRegistry = class {
 };
 
 // src/server/resource-manager.ts
-import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
 import { join as join6 } from "path";
 var ResourceManager = class {
   agentRegistry = getAgentRegistry();
@@ -3742,7 +4886,7 @@ var ResourceManager = class {
   async getCacheStatsResource(uri) {
     try {
       const cachePath = join6(getWorkingDirectory(void 0, true), ".trie", ".trie-cache.json");
-      const cacheContent = await readFile5(cachePath, "utf-8");
+      const cacheContent = await readFile6(cachePath, "utf-8");
       const cache = JSON.parse(cacheContent);
       const fileCount = Object.keys(cache.files || {}).length;
       const totalVulns = Object.values(cache.files || {}).reduce((acc, file) => {
@@ -3796,7 +4940,7 @@ var ResourceManager = class {
     const fileName = parsedUri.replace("reports/", "");
     const reportPath = join6(getWorkingDirectory(void 0, true), "trie-reports", fileName);
     try {
-      const content = await readFile5(reportPath, "utf-8");
+      const content = await readFile6(reportPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -3832,18 +4976,18 @@ async function findOpenPort() {
   return null;
 }
 async function checkPort(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve5(true);
+        resolve6(true);
       } else {
-        resolve5(false);
+        resolve6(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve5(false);
+      resolve6(false);
     });
     server.listen(port, "127.0.0.1");
   });
@@ -4179,9 +5323,9 @@ var RequestHandlers = class {
           "- `security`, `privacy`, `legal`, `bugs`, `types`, `devops`, `architecture`, `ux`, `clean`, `soc2`, `performance`, `e2e`, `visual_qa`, `data_flow`",
           "",
           "**Tools:**",
-          "- `fix`: Apply high-confidence fixes",
+          "- `fix`: Generate high-confidence fix prompts",
           "- `explain`: Explain code/issues/risks",
-          "- `watch`: Watch mode (scan on change)",
+          "- `watch`: Watch mode (generate reports on change)",
           "- `visual_qa_browser`: Screenshot app for vision analysis",
           "",
           "**Custom Agents:**",