@triedotdev/mcp 1.0.50 → 1.0.51

package/dist/{chunk-37U65YW7.js → chunk-TOE75CFZ.js}

@@ -1,24 +1,235 @@
-import {
-  listInstalledSkills,
-  parseSkillMd,
-  recordSkillUsage
-} from "./chunk-PZDQIFKO.js";
 import {
   checkFileLevelIssues,
   getVibeCodeTrie,
   scanForVibeCodeIssues
 } from "./chunk-3CS6Z2SL.js";
 import {
-  AgentSmithAgent,
-  BaseAgent,
+  AgentSmithSkill,
+  BaseSkill,
   isAIAvailable,
   runAIAnalysis
-} from "./chunk-3SQK2RKF.js";
+} from "./chunk-A43476GB.js";
 import {
   getWorkingDirectory
-} from "./chunk-IMFD4SJC.js";
+} from "./chunk-ASGSTVVF.js";
+
+// src/utils/project-info.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+var PROJECT_MD_PATH = ".trie/PROJECT.md";
+function getProjectTemplate() {
+  return `# Project Information
+
+> This file stores important project context for AI assistants.
+> Edit freely - this file is yours, not auto-generated.
+> Available via MCP resource: \`trie://project\`
+
+---
+
+## Project Overview
+
+<!-- Describe your project's purpose and goals -->
+
+[Add project description here]
+
+---
+
+## Technology Stack
+
+<!-- List frameworks, languages, databases, cloud services, etc. -->
+
+- **Language:** 
+- **Framework:** 
+- **Database:** 
+- **Hosting:** 
+
+---
+
+## Architecture
+
+<!-- Key patterns, architectural decisions, and system design -->
+
+[Describe your architecture here]
+
+---
+
+## Coding Conventions
 
-// src/agents/security.ts
+<!-- Style guidelines, naming conventions, patterns to follow -->
+
+- 
+- 
+- 
+
+---
+
+## Environment
+
+<!-- URLs, API endpoints, deployment info -->
+
+| Environment | URL | Notes |
+|-------------|-----|-------|
+| Development | | |
+| Staging | | |
+| Production | | |
+
+---
+
+## Team
+
+<!-- Ownership, contacts, responsibilities -->
+
+- **Owner:** 
+- **Team:** 
+
+---
+
+## Compliance
+
+<!-- HIPAA, SOC2, GDPR, PCI-DSS requirements if applicable -->
+
+- [ ] GDPR
+- [ ] SOC2
+- [ ] HIPAA
+- [ ] PCI-DSS
+
+---
+
+## AI Instructions
+
+<!-- Special instructions for AI assistants working on this project -->
+
+When working on this project, AI assistants should:
+
+1. 
+2. 
+3. 
+
+---
+
+*This file is read by Trie agents and exposed via \`trie://project\` MCP resource.*
+*Edit this file to provide context to Claude Code, Cursor, GitHub Actions, and other AI tools.*
+`;
+}
+function projectInfoExists(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(dir, PROJECT_MD_PATH);
+  return existsSync(projectPath);
+}
+async function loadProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(dir, PROJECT_MD_PATH);
+  try {
+    if (!existsSync(projectPath)) {
+      return null;
+    }
+    return await readFile(projectPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function saveProjectInfo(content, workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = join(dir, ".trie");
+  const projectPath = join(dir, PROJECT_MD_PATH);
+  await mkdir(trieDir, { recursive: true });
+  await writeFile(projectPath, content, "utf-8");
+}
+async function initProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(dir, PROJECT_MD_PATH);
+  if (existsSync(projectPath)) {
+    return { created: false, path: projectPath };
+  }
+  await saveProjectInfo(getProjectTemplate(), dir);
+  return { created: true, path: projectPath };
+}
+async function getProjectSection(sectionName, workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return null;
+  const sectionRegex = new RegExp(
+    `## ${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n## |\\n---\\s*$|$)`,
+    "i"
+  );
+  const match = content.match(sectionRegex);
+  if (match?.[1]) {
+    return match[1].trim();
+  }
+  return null;
+}
+async function updateProjectSection(sectionName, newContent, workDir) {
+  let content = await loadProjectInfo(workDir);
+  if (!content) {
+    await initProjectInfo(workDir);
+    content = await loadProjectInfo(workDir);
+    if (!content) return false;
+  }
+  const sectionRegex = new RegExp(
+    `(## ${escapeRegex(sectionName)}\\s*\\n)([\\s\\S]*?)((?=\\n## )|(?=\\n---\\s*$)|$)`,
+    "i"
+  );
+  if (content.match(sectionRegex)) {
+    const updatedContent = content.replace(sectionRegex, `$1
+${newContent}
+
+$3`);
+    await saveProjectInfo(updatedContent, workDir);
+    return true;
+  }
+  return false;
+}
+async function appendToSection(sectionName, contentToAdd, workDir) {
+  const currentContent = await getProjectSection(sectionName, workDir);
+  if (currentContent === null) return false;
+  const newContent = currentContent + "\n" + contentToAdd;
+  return updateProjectSection(sectionName, newContent, workDir);
+}
+async function getProjectSections(workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return [];
+  const sectionRegex = /^## (.+)$/gm;
+  const sections = [];
+  let match;
+  while ((match = sectionRegex.exec(content)) !== null) {
+    if (match[1]) {
+      sections.push(match[1].trim());
+    }
+  }
+  return sections;
+}
+async function getProjectInfoStructured(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(dir, PROJECT_MD_PATH);
+  const content = await loadProjectInfo(dir);
+  if (!content) {
+    return {
+      exists: false,
+      path: projectPath,
+      sections: {},
+      raw: null
+    };
+  }
+  const sectionNames = await getProjectSections(dir);
+  const sections = {};
+  for (const name of sectionNames) {
+    const sectionContent = await getProjectSection(name, dir);
+    if (sectionContent) {
+      sections[name] = sectionContent;
+    }
+  }
+  return {
+    exists: true,
+    path: projectPath,
+    sections,
+    raw: content
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/skills/built-in/security.ts
 var ALWAYS_SKIP_FILES = [
   /vulnerability-signatures\.[jt]s$/,
   /vibe-code-signatures\.[jt]s$/,
@@ -75,7 +286,7 @@ var CRITICAL_PATTERNS = [
   { pattern: /sk_live_[A-Za-z0-9]{24,}/, severity: "critical", issue: "Stripe live API key exposed", fix: "Rotate Stripe key immediately. Use environment variables." },
   { pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/, severity: "critical", issue: "Slack token exposed", fix: "Revoke Slack token and use environment variables." }
 ];
-var SecurityAgent = class extends BaseAgent {
+var SecuritySkill = class extends BaseSkill {
   name = "security";
   description = "AI-powered security analysis: vulnerabilities, injection risks, authentication issues";
   version = "2.0.0";
@@ -298,7 +509,7 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/privacy.ts
+// src/skills/built-in/privacy.ts
 var PRIVACY_INDICATORS = {
   high: [
     { pattern: /email|phone|ssn|social.*security|passport|driver.*license/i, reason: "PII fields" },
@@ -342,7 +553,7 @@ var CRITICAL_PRIVACY_PATTERNS = [
     regulation: "PCI DSS"
   }
 ];
-var PrivacyAgent = class extends BaseAgent {
+var PrivacySkill = class extends BaseSkill {
   name = "privacy";
   description = "AI-powered privacy analysis: GDPR, CCPA, PCI-DSS compliance";
   version = "2.0.0";
@@ -593,7 +804,7 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/typecheck.ts
+// src/skills/built-in/typecheck.ts
 import { extname } from "path";
 var SKIP_FILES = [
   /node_modules\//,
@@ -604,7 +815,7 @@ var SKIP_FILES = [
   /\.test\.[jt]sx?$/,
   /\.spec\.[jt]sx?$/
 ];
-var TypeCheckAgent = class extends BaseAgent {
+var TypeCheckSkill = class extends BaseSkill {
   name = "typecheck";
   description = "Catches type errors and ensures type safety";
   version = "1.0.0";
@@ -679,8 +890,8 @@ var TypeCheckAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/comprehension.ts
-var ComprehensionAgent = class extends BaseAgent {
+// src/skills/built-in/comprehension.ts
+var ComprehensionSkill = class extends BaseSkill {
   name = "comprehension";
   description = "Explains what code does in plain language for non-technical builders";
   version = "1.0.0";
@@ -897,7 +1108,7 @@ var ComprehensionAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/accessibility.ts
+// src/skills/built-in/accessibility.ts
 var WCAG_CRITERIA = {
   // Perceivable
   "1.1.1": { name: "Non-text Content", level: "A", description: "All non-text content has text alternatives" },
@@ -924,6 +1135,7 @@ var WCAG_CRITERIA = {
   // Understandable
   "3.2.1": { name: "On Focus", level: "A", description: "Focus does not trigger unexpected context changes" },
   "3.2.2": { name: "On Input", level: "A", description: "Input does not trigger unexpected context changes" },
+  "3.2.5": { name: "Change on Request", level: "AAA", description: "Changes of context are initiated only by user request" },
   "3.3.1": { name: "Error Identification", level: "A", description: "Errors are identified and described in text" },
   "3.3.2": { name: "Labels or Instructions", level: "A", description: "Labels or instructions are provided for user input" },
   // Robust
@@ -960,7 +1172,7 @@ var REQUIRED_ARIA_ATTRIBUTES = {
   "treegrid": [],
   "treeitem": []
 };
-var AccessibilityAgent = class extends BaseAgent {
+var AccessibilitySkill = class extends BaseSkill {
   name = "accessibility";
   description = "WCAG 2.1 AA compliance: screen readers, keyboard nav, color contrast, touch targets, semantic HTML, ARIA patterns";
   version = "2.0.0";
@@ -1084,7 +1296,7 @@ var AccessibilityAgent = class extends BaseAgent {
         }
       }
       if (/<svg\s/i.test(line)) {
-        const svgContext = this.getMultiLineElement(lines, i, "svg");
+        const svgContext = this.getMultiLineElement(lines, i, "svg") ?? line;
         if (!/aria-label|aria-labelledby|<title>|role=["']img["']/i.test(svgContext) && !/aria-hidden=["']true["']/i.test(svgContext)) {
           issues.push(this.createIssue(
             this.generateIssueId(),
@@ -1112,7 +1324,7 @@ var AccessibilityAgent = class extends BaseAgent {
       const line = lines[i];
       const lineNumber = i + 1;
       if (/<button/i.test(line) || /Button\s/i.test(line)) {
-        const buttonContext = this.getMultiLineElement(lines, i, "button") || this.getMultiLineElement(lines, i, "Button");
+        const buttonContext = this.getMultiLineElement(lines, i, "button") ?? this.getMultiLineElement(lines, i, "Button") ?? line;
         const hasIconOnly = />\s*<(Icon|svg|i\s|img)[^>]*>\s*<\/(button|Button)/i.test(buttonContext) || />\s*<[A-Z][a-zA-Z]*Icon[^>]*\s*\/>\s*<\/(button|Button)/i.test(buttonContext) || /<(Icon|svg)[^>]*\/>\s*<\/(button|Button)/i.test(buttonContext);
         const hasAccessibleName = /aria-label|aria-labelledby|title=|sr-only|visually-hidden/i.test(buttonContext);
         if (hasIconOnly && !hasAccessibleName) {
@@ -1163,7 +1375,7 @@ var AccessibilityAgent = class extends BaseAgent {
         }
       }
       if (/<a\s/i.test(line) || /<Link\s/i.test(line)) {
-        const linkContext = this.getMultiLineElement(lines, i, "a") || this.getMultiLineElement(lines, i, "Link");
+        const linkContext = this.getMultiLineElement(lines, i, "a") ?? this.getMultiLineElement(lines, i, "Link") ?? line;
         if (!/href=|to=/i.test(linkContext)) {
           issues.push(this.createIssue(
             this.generateIssueId(),
@@ -1937,7 +2149,7 @@ Review code for comprehensive accessibility compliance.
   }
 };
 
-// src/agents/design-engineer.ts
+// src/skills/built-in/design-engineer.ts
 var DOMAIN_DESIGN_RULES = {
   fitness: {
     defaultMode: "dark",
@@ -2155,7 +2367,7 @@ var PROJECT_CONTEXTS = {
     effects: ["image reveals", "cursor effects", "page transitions", "scroll-linked galleries"]
   }
 };
-var DesignEngineerAgent = class extends BaseAgent {
+var DesignEngineerSkill = class extends BaseSkill {
   name = "design-engineer";
   description = "Award-winning frontend craft: design systems, motion design, creative CSS, modern color palettes, Awwwards-level polish";
   version = "2.0.0";
@@ -3662,8 +3874,8 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/legal.ts
-var LegalAgent = class extends BaseAgent {
+// src/skills/built-in/legal.ts
+var LegalSkill = class extends BaseSkill {
   name = "legal";
   description = "Comprehensive legal compliance for app development: licensing, ToS, accessibility, IP, data protection, e-commerce, and regulatory requirements";
   version = "2.0.0";
@@ -4655,10 +4867,10 @@ var LegalAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/test.ts
+// src/skills/built-in/test.ts
 import { basename, dirname } from "path";
-import { existsSync } from "fs";
-var TestAgent = class extends BaseAgent {
+import { existsSync as existsSync2 } from "fs";
+var TestSkill = class extends BaseSkill {
   name = "test";
   description = "Test coverage analysis, test quality, and testing best practices";
   version = "1.0.0";
@@ -4700,12 +4912,9 @@ var TestAgent = class extends BaseAgent {
       `${fileDir}/__tests__/${fileName}`,
       `${fileDir}/../__tests__/${fileName}`
     ];
-    const hasTestFile = testPatterns.some((pattern) => existsSync(pattern));
+    const hasTestFile = testPatterns.some((pattern) => existsSync2(pattern));
     if (!hasTestFile) {
       const severity = this.determineTestSeverity(content);
-      if (severity === "low") {
-        return issues;
-      }
       issues.push(this.createIssue(
         this.generateIssueId(),
         severity,
@@ -4751,8 +4960,8 @@ var TestAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/software-architect.ts
-var SoftwareArchitectAgent = class extends BaseAgent {
+// src/skills/built-in/software-architect.ts
+var SoftwareArchitectSkill = class extends BaseSkill {
   name = "software-architect";
   description = "Architecture patterns, code organization, SOLID principles, and scalability";
   version = "1.0.0";
@@ -4981,8 +5190,8 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/devops.ts
-var DevOpsAgent = class extends BaseAgent {
+// src/skills/built-in/devops.ts
+var DevOpsSkill = class extends BaseSkill {
   name = "devops";
   description = "Infrastructure, deployment, configuration, and operational concerns";
   version = "1.0.0";
@@ -5187,7 +5396,7 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/bug-finding.ts
+// src/skills/built-in/bug-finding.ts
 var BUG_INDICATORS = {
   high: [
     { pattern: /async|await|promise/i, reason: "async code" },
@@ -5223,7 +5432,7 @@ var CRITICAL_BUG_PATTERNS = [
     fix: "Use === for comparison instead of ="
   }
 ];
-var BugFindingAgent = class extends BaseAgent {
+var BugFindingSkill = class extends BaseSkill {
   name = "bug-finding";
   description = "AI-powered bug detection: null safety, edge cases, async issues, runtime errors";
   version = "2.0.0";
@@ -5418,8 +5627,8 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/user-testing.ts
-var UserTestingAgent = class extends BaseAgent {
+// src/skills/built-in/user-testing.ts
+var UserTestingSkill = class extends BaseSkill {
   name = "user-testing";
   description = "Simulates user personas (happy path, security tester, confused user) to find vulnerabilities";
   version = "2.0.0";
@@ -5889,8 +6098,8 @@ var UserTestingAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/trie-clean.ts
-var TrieCleanAgent = class extends BaseAgent {
+// src/skills/built-in/trie-clean.ts
+var TrieCleanSkill = class extends BaseSkill {
   name = "trie_clean";
   description = "Reviews AI-generated code for common mistakes and best practices (for non-technical users)";
   version = "1.0.0";
@@ -5974,7 +6183,7 @@ var TrieCleanAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/soc2.ts
+// src/skills/built-in/soc2.ts
 var SOC2_PATTERNS = {
   // CC6 - Logical Access Controls
   hardcodedSecrets: [
@@ -6041,7 +6250,7 @@ var REGULATION_DESCRIPTIONS = {
   "CC7.3": "Incident Detection - Proper error handling and alerting",
   "CC8.1": "Change Management - Controlled changes with proper review"
 };
-var SOC2Agent = class extends BaseAgent {
+var SOC2Skill = class extends BaseSkill {
   name = "soc2";
   description = "SOC 2 Type II compliance: access controls, encryption, logging, change management";
   version = "1.0.0";
@@ -6189,8 +6398,8 @@ Output STRICT JSON:
   }
 };
 
-// src/agents/super-reviewer.ts
-var SuperReviewerAgent = class extends BaseAgent {
+// src/skills/built-in/super-reviewer.ts
+var SuperReviewerSkill = class extends BaseSkill {
   name = "super-reviewer";
   description = "Interactive PR review: walks through changes file-by-file, explains each chunk, waits for cross-examination";
   version = "1.0.0";
@@ -6340,8 +6549,8 @@ var CRITICAL_REVIEW_CHECKLIST = {
   ]
 };
 
-// src/agents/performance.ts
-var PerformanceAgent = class extends BaseAgent {
+// src/skills/built-in/performance.ts
+var PerformanceSkill = class extends BaseSkill {
   name = "performance";
   description = "Surfaces performance patterns for human review: memory, renders, bundles, queries";
   version = "1.0.0";
@@ -6640,8 +6849,8 @@ var PerformanceAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/e2e.ts
-var E2EAgent = class extends BaseAgent {
+// src/skills/built-in/e2e.ts
+var E2ESkill = class extends BaseSkill {
   name = "e2e";
   description = "Identifies E2E test gaps and flaky test patterns for human review";
   version = "1.0.0";
@@ -6873,8 +7082,8 @@ var E2EAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/visual-qa.ts
-var VisualQAAgent = class extends BaseAgent {
+// src/skills/built-in/visual-qa.ts
+var VisualQASkill = class extends BaseSkill {
   name = "visual-qa";
   description = "Surfaces potential visual/layout issues in CSS for human review";
   version = "1.0.0";
@@ -7209,8 +7418,8 @@ var VisualQAAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/data-flow.ts
-var DataFlowAgent = class extends BaseAgent {
+// src/skills/built-in/data-flow.ts
+var DataFlowSkill = class extends BaseSkill {
   name = "data-flow";
   description = "Detects schema mismatches, placeholder data, and data integrity issues";
   version = "1.0.0";
@@ -7420,6 +7629,20 @@ var DataFlowAgent = class extends BaseAgent {
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] || "";
       const lineNumber = i + 1;
+      if (/==\s*null/.test(line) || /==\s*undefined/.test(line)) {
+        issues.push(this.createIssue(
+          this.generateIssueId(),
+          "moderate",
+          "Loose equality check against null/undefined",
+          "Use strict equality (===) to avoid accidental truthiness",
+          file,
+          lineNumber,
+          0.75,
+          void 0,
+          true,
+          { category: "equality", effort: "trivial" }
+        ));
+      }
       if (/==\s*["']['"]/.test(line) || /==\s*0[^.]/.test(line)) {
         issues.push(this.createIssue(
           this.generateIssueId(),
@@ -7439,7 +7662,7 @@ var DataFlowAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/moneybags.ts
+// src/skills/built-in/moneybags.ts
 var MONEYBAGS_ASCII = `
     \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557
     \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D
@@ -7462,51 +7685,51 @@ var MONEYBAGS_QUOTES = [
   "Floating-point for money? That's going to be an expensive lesson."
 ];
 var BASE_COST_BY_SEVERITY = {
-  critical: 500,
-  // Critical bugs found in dev - 2-4 hours of focused work
-  serious: 200,
-  // Serious issues need careful remediation - 1-2 hours
-  moderate: 75,
-  // Moderate issues are quicker fixes - 30-60 minutes
-  low: 25
-  // Low severity - mostly cleanup - 15-30 minutes
+  critical: 5e3,
+  // Critical bugs found in dev - high impact, deep fixes
+  serious: 2e3,
+  // Serious issues need careful remediation
+  moderate: 500,
+  // Moderate issues are quicker fixes
+  low: 150
+  // Low severity - mostly cleanup
 };
 var PRODUCTION_MULTIPLIER = {
-  critical: 10,
-  // Critical bugs can cause outages, breaches (capped from 30x)
-  serious: 6,
-  // Serious bugs cause significant user impact (capped from 20x)
-  moderate: 3,
-  // Moderate bugs require hotfixes, user support (capped from 10x)
+  critical: 12,
+  // Critical bugs can cause outages, breaches
+  serious: 8,
+  // Serious bugs cause significant user impact
+  moderate: 4,
+  // Moderate bugs require hotfixes, user support
   low: 2
-  // Low bugs accumulate tech debt (capped from 5x)
+  // Low bugs accumulate tech debt
 };
 var CATEGORY_MULTIPLIERS = {
   // Security categories - important but realistic
-  "security": { multiplier: 2, reason: "Security vulnerabilities require careful remediation" },
-  "authentication": { multiplier: 2.5, reason: "Auth bypass is serious but fixable" },
-  "authorization": { multiplier: 2, reason: "Authorization flaws expose sensitive data" },
-  "injection": { multiplier: 3, reason: "SQL/Command injection is severe - prioritize fix" },
-  "xss": { multiplier: 1.5, reason: "XSS needs fixing but React mitigates most cases" },
-  "secrets": { multiplier: 2.5, reason: "Exposed secrets require rotation" },
-  "cryptography": { multiplier: 1.5, reason: "Weak crypto should be updated" },
+  "security": { multiplier: 6, reason: "Security vulnerabilities require careful remediation" },
+  "authentication": { multiplier: 8, reason: "Auth bypass is serious but fixable" },
+  "authorization": { multiplier: 6, reason: "Authorization flaws expose sensitive data" },
+  "injection": { multiplier: 12, reason: "SQL/Command injection is severe - prioritize fix" },
+  "xss": { multiplier: 4, reason: "XSS needs fixing but React mitigates most cases" },
+  "secrets": { multiplier: 8, reason: "Exposed secrets require rotation" },
+  "cryptography": { multiplier: 4, reason: "Weak crypto should be updated" },
   // Data integrity categories
-  "data-loss": { multiplier: 3, reason: "Data loss is serious - ensure backups exist" },
-  "data-corruption": { multiplier: 2.5, reason: "Data corruption requires recovery work" },
-  "privacy": { multiplier: 2, reason: "Privacy violations carry compliance risk" },
+  "data-loss": { multiplier: 10, reason: "Data loss is serious - ensure backups exist" },
+  "data-corruption": { multiplier: 6, reason: "Data corruption requires recovery work" },
+  "privacy": { multiplier: 8, reason: "Privacy violations carry compliance risk" },
   // Financial categories
-  "payment": { multiplier: 3, reason: "Payment bugs need immediate attention" },
-  "billing": { multiplier: 2.5, reason: "Billing errors erode trust" },
-  "financial-calculation": { multiplier: 2, reason: "Incorrect calculations compound over time" },
+  "payment": { multiplier: 25, reason: "Payment bugs need immediate attention" },
+  "billing": { multiplier: 8, reason: "Billing errors erode trust" },
+  "financial-calculation": { multiplier: 6, reason: "Incorrect calculations compound over time" },
   // Reliability categories
-  "crash": { multiplier: 2, reason: "Crashes hurt user experience" },
-  "memory-leak": { multiplier: 1.5, reason: "Memory leaks cause gradual degradation" },
-  "deadlock": { multiplier: 2, reason: "Deadlocks require restarts" },
-  "race-condition": { multiplier: 2, reason: "Race conditions are hard to debug" },
+  "crash": { multiplier: 4, reason: "Crashes hurt user experience" },
+  "memory-leak": { multiplier: 3, reason: "Memory leaks cause gradual degradation" },
+  "deadlock": { multiplier: 4, reason: "Deadlocks require restarts" },
+  "race-condition": { multiplier: 4, reason: "Race conditions are hard to debug" },
   // User experience
-  "accessibility": { multiplier: 1.2, reason: "Accessibility issues should be addressed" },
-  "performance": { multiplier: 1.2, reason: "Performance issues hurt conversion rates" },
-  "ux": { multiplier: 1, reason: "UX bugs increase support costs" },
+  "accessibility": { multiplier: 1.5, reason: "Accessibility issues should be addressed" },
+  "performance": { multiplier: 2, reason: "Performance issues hurt conversion rates" },
+  "ux": { multiplier: 1.2, reason: "UX bugs increase support costs" },
   // Code quality
   "bug": { multiplier: 1, reason: "General bugs require developer time" },
   "type-error": { multiplier: 0.8, reason: "Type errors caught early save debugging time" },
@@ -7537,13 +7760,13 @@ var USER_COUNT_MULTIPLIERS = [
   { threshold: 50, multiplier: 0.5, label: "MVP (50 users)" },
   { threshold: 250, multiplier: 1, label: "Early stage (250 users)" },
   // Baseline (default)
-  { threshold: 1e3, multiplier: 1.5, label: "Growing (1K users)" },
-  { threshold: 5e3, multiplier: 2, label: "Traction (5K users)" },
-  { threshold: 25e3, multiplier: 2.5, label: "Scale-up (25K users)" },
-  { threshold: 1e5, multiplier: 3, label: "Growth (100K users)" },
-  { threshold: 5e5, multiplier: 3.5, label: "Large (500K users)" },
-  { threshold: 1e6, multiplier: 4, label: "Enterprise (1M+ users)" }
-  // Capped at 4x, not 40x
+  { threshold: 1e3, multiplier: 3, label: "Growing (1K users)" },
+  { threshold: 5e3, multiplier: 6, label: "Traction (5K users)" },
+  { threshold: 25e3, multiplier: 10, label: "Scale-up (25K users)" },
+  { threshold: 1e5, multiplier: 15, label: "Growth (100K users)" },
+  { threshold: 5e5, multiplier: 18, label: "Large (500K users)" },
+  { threshold: 1e6, multiplier: 20, label: "Enterprise (1M+ users)" }
+  // Capped to avoid runaway estimates
 ];
 var PER_USER_COSTS = {
   "data-loss": 5,
@@ -7559,7 +7782,7 @@ var PER_USER_COSTS = {
   "accessibility": 0.1
   // $0.10 per user (support costs)
 };
-var MoneybagAgent = class extends BaseAgent {
+var MoneybagSkill = class extends BaseSkill {
   name = "moneybags";
   description = "Estimates the dollar cost of bugs based on severity, category, and user scale. Uses industry research (IBM, NIST, Ponemon) with configurable user count scaling.";
   version = "1.1.0";
@@ -7712,8 +7935,8 @@ var MoneybagAgent = class extends BaseAgent {
     const fixHours = EFFORT_HOURS[effort] || 8;
     const developerRate = this.config.developerRate ?? DEVELOPER_HOURLY_RATE;
     const fixCost = fixHours * developerRate;
-    const BASE_NOW_CAP = 500;
-    const BASE_PROD_CAP = 2e3;
+    const BASE_NOW_CAP = 25e3;
+    const BASE_PROD_CAP = 25e4;
     const maxNowCost = BASE_NOW_CAP * userScaleMultiplier;
     const maxProdCost = BASE_PROD_CAP * userScaleMultiplier;
     const rawNowCost = baseCost * categoryMultiplier * contextMultiplier + fixCost;
@@ -8040,7 +8263,7 @@ Default: 250 users. Scale with: trie scan --users 10000
   }
 };
 
-// src/agents/production-ready.ts
+// src/skills/built-in/production-ready.ts
 var PRODUCTION_READY_ASCII = `
     \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 
     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
@@ -8202,7 +8425,7 @@ var PRODUCTION_CONFIG_FILES = [
   /vercel\.json$/,
   /netlify\.toml$/
 ];
-var ProductionReadyAgent = class extends BaseAgent {
+var ProductionReadySkill = class extends BaseSkill {
   name = "production-ready";
   description = "Production readiness checker: health endpoints, graceful shutdown, connection pooling, security headers, monitoring, and deployment gates";
   version = "1.0.0";
@@ -8466,10 +8689,1376 @@ Output STRICT JSON:
   }
 };
 
+// src/skills/installer.ts
+import { mkdir as mkdir2, rm, writeFile as writeFile2, readdir, readFile as readFile3, access, cp } from "fs/promises";
+import { join as join3 } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/skills/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function parseSkillMd(skillPath) {
+  const skillMdPath = join2(skillPath, "SKILL.md");
+  const rawContent = await readFile2(skillMdPath, "utf-8");
+  const frontmatterMatch = rawContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch || !frontmatterMatch[1]) {
+    throw new Error("Invalid SKILL.md: missing YAML frontmatter");
+  }
+  const frontmatter = parseYamlFrontmatter(frontmatterMatch[1]);
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error("Invalid SKILL.md: missing required name or description in frontmatter");
+  }
+  const content = rawContent.slice(frontmatterMatch[0].length).trim();
+  return {
+    frontmatter,
+    content,
+    rawContent
+  };
+}
+function parseYamlFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value === "") continue;
+    if (typeof value === "string") {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+        value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/skills/installer.ts
+var execAsync = promisify(exec);
+async function installSkill(source, skillName) {
+  const parts = source.split("/");
+  if (parts.length < 2) {
+    return { success: false, name: "unknown", error: "Invalid source format. Use owner/repo or owner/repo/skill-name" };
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  const specifiedSkill = skillName || parts[2];
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const tempDir = join3(skillsDir, `.temp-${Date.now()}`);
+  try {
+    await mkdir2(skillsDir, { recursive: true });
+    const repoUrl = `https://github.com/${owner}/${repo}.git`;
+    await execAsync(`git clone --depth 1 "${repoUrl}" "${tempDir}"`, { timeout: 6e4 });
+    const sourcePath = await findSkillPath(tempDir, specifiedSkill);
+    if (!sourcePath) {
+      throw new Error(`SKILL.md not found in repository. Searched in: root, skills/, ${specifiedSkill || "subdirectories"}`);
+    }
+    const parsed = await parseSkillMd(sourcePath);
+    const name = parsed.frontmatter.name;
+    const targetPath = join3(skillsDir, name);
+    await rm(targetPath, { recursive: true, force: true });
+    await cp(sourcePath, targetPath, { recursive: true });
+    await writeFile2(join3(targetPath, ".installed.json"), JSON.stringify({
+      installedFrom: source,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      repository: `${owner}/${repo}`
+    }, null, 2));
+    return { success: true, name, path: targetPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, name: skillName || "unknown", error: message };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function findSkillPath(repoPath, skillName) {
+  const searchPaths = [];
+  if (skillName) {
+    searchPaths.push(
+      join3(repoPath, "skills", skillName),
+      join3(repoPath, skillName)
+    );
+  }
+  searchPaths.push(
+    repoPath,
+    join3(repoPath, "skill")
+  );
+  if (!skillName) {
+    try {
+      const skillsSubdir = join3(repoPath, "skills");
+      await access(skillsSubdir);
+      const entries = await readdir(skillsSubdir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          searchPaths.push(join3(skillsSubdir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  for (const searchPath of searchPaths) {
+    try {
+      await parseSkillMd(searchPath);
+      return searchPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function listInstalledSkills() {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skills = [];
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const skillPath = join3(skillsDir, entry.name);
+      try {
+        const parsed = await parseSkillMd(skillPath);
+        const metaPath = join3(skillPath, ".installed.json");
+        let meta = { installedFrom: "unknown", installedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        try {
+          meta = JSON.parse(await readFile3(metaPath, "utf-8"));
+        } catch {
+        }
+        skills.push({
+          name: parsed.frontmatter.name,
+          description: parsed.frontmatter.description,
+          path: skillPath,
+          installedFrom: meta.installedFrom,
+          installedAt: meta.installedAt
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function removeSkill(skillName) {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skillPath = join3(skillsDir, skillName);
+  try {
+    await rm(skillPath, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/context-state.ts
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7, basename as basename2 } from "path";
+
+// src/memory/issue-store.ts
+import { mkdir as mkdir4, writeFile as writeFile4, readFile as readFile5, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+
+// src/memory/bm25.ts
+var BM25Index = class _BM25Index {
+  documents = /* @__PURE__ */ new Map();
+  termFrequencies = /* @__PURE__ */ new Map();
+  documentFrequencies = /* @__PURE__ */ new Map();
+  documentLengths = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  k1 = 1.5;
+  b = 0.75;
+  /**
+   * Add a document to the index
+   */
+  addDocument(doc) {
+    const tokens = this.tokenize(doc.text);
+    this.documents.set(doc.id, doc);
+    this.documentLengths.set(doc.id, tokens.length);
+    const termFreq = /* @__PURE__ */ new Map();
+    const seenTerms = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreq.set(token, (termFreq.get(token) || 0) + 1);
+      if (!seenTerms.has(token)) {
+        seenTerms.add(token);
+        this.documentFrequencies.set(token, (this.documentFrequencies.get(token) || 0) + 1);
+      }
+    }
+    this.termFrequencies.set(doc.id, termFreq);
+    this.updateAvgDocLength();
+  }
+  /**
+   * Add multiple documents
+   */
+  addDocuments(docs) {
+    for (const doc of docs) {
+      this.addDocument(doc);
+    }
+  }
+  /**
+   * Search the index
+   */
+  search(query, limit = 10) {
+    const queryTokens = this.tokenize(query);
+    const scores = /* @__PURE__ */ new Map();
+    const N = this.documents.size;
+    for (const [docId] of this.documents) {
+      let score = 0;
+      const docLength = this.documentLengths.get(docId) || 0;
+      const termFreqs = this.termFrequencies.get(docId);
+      if (!termFreqs) continue;
+      for (const term of queryTokens) {
+        const tf = termFreqs.get(term) || 0;
+        if (tf === 0) continue;
+        const df = this.documentFrequencies.get(term) || 0;
+        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+        score += idf * (numerator / denominator);
+      }
+      if (score > 0) {
+        scores.set(docId, score);
+      }
+    }
+    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => {
+      const metadata = this.documents.get(id)?.metadata;
+      const result = { id, score };
+      if (metadata !== void 0) {
+        result.metadata = metadata;
+      }
+      return result;
+    });
+  }
+  /**
+   * Get document count
+   */
+  get size() {
+    return this.documents.size;
+  }
+  /**
+   * Clear the index
+   */
+  clear() {
+    this.documents.clear();
+    this.termFrequencies.clear();
+    this.documentFrequencies.clear();
+    this.documentLengths.clear();
+    this.avgDocLength = 0;
+  }
+  /**
+   * Serialize the index to JSON
+   */
+  serialize() {
+    return JSON.stringify({
+      documents: Array.from(this.documents.entries()),
+      termFrequencies: Array.from(this.termFrequencies.entries()).map(([k, v]) => [k, Array.from(v.entries())]),
+      documentFrequencies: Array.from(this.documentFrequencies.entries()),
+      documentLengths: Array.from(this.documentLengths.entries()),
+      avgDocLength: this.avgDocLength
+    });
+  }
+  /**
+   * Load from serialized JSON
+   */
+  static deserialize(json) {
+    const data = JSON.parse(json);
+    const index = new _BM25Index();
+    index.documents = new Map(data.documents);
+    index.termFrequencies = new Map(data.termFrequencies.map(([k, v]) => [k, new Map(v)]));
+    index.documentFrequencies = new Map(data.documentFrequencies);
+    index.documentLengths = new Map(data.documentLengths);
+    index.avgDocLength = data.avgDocLength;
+    return index;
+  }
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 2 && !this.isStopWord(token));
+  }
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "be",
+      "to",
+      "of",
+      "and",
+      "a",
+      "in",
+      "that",
+      "have",
+      "i",
+      "it",
+      "for",
+      "not",
+      "on",
+      "with",
+      "he",
+      "as",
+      "you",
+      "do",
+      "at",
+      "this",
+      "but",
+      "his",
+      "by",
+      "from",
+      "they",
+      "we",
+      "say",
+      "her",
+      "she",
+      "or",
+      "an",
+      "will",
+      "my",
+      "one",
+      "all",
+      "would",
+      "there",
+      "their",
+      "what",
+      "so",
+      "up",
+      "out",
+      "if",
+      "about",
+      "who",
+      "get",
+      "which",
+      "go",
+      "me",
+      "when",
+      "make",
+      "can",
+      "like",
+      "time",
+      "no",
+      "just",
+      "him",
+      "know",
+      "take",
+      "into",
+      "year",
+      "your",
+      "some",
+      "could",
+      "them",
+      "see",
+      "other",
+      "than",
+      "then",
+      "now",
+      "look",
+      "only",
+      "come",
+      "its",
+      "over",
+      "also",
+      "back",
+      "after",
+      "use",
+      "two",
+      "how",
+      "our",
+      "first",
+      "way",
+      "even",
+      "new",
+      "want",
+      "because",
+      "any",
+      "these",
+      "give",
+      "day",
+      "most",
+      "us",
+      "should",
+      "been",
+      "has",
+      "was",
+      "are"
+    ]);
+    return stopWords.has(word);
+  }
+  updateAvgDocLength() {
+    if (this.documentLengths.size === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    const total = Array.from(this.documentLengths.values()).reduce((a, b) => a + b, 0);
+    this.avgDocLength = total / this.documentLengths.size;
+  }
+};
+
+// src/memory/compactor.ts
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+async function compactOldIssues(issues, options = {}) {
+  const keepDays = options.keepDays ?? 30;
+  const minIssues = options.minIssuesToCompact ?? 100;
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - keepDays);
+  const oldIssues = issues.filter((i) => new Date(i.timestamp) < cutoffDate);
+  const recentIssues = issues.filter((i) => new Date(i.timestamp) >= cutoffDate);
+  if (oldIssues.length < minIssues) {
+    return { summary: null, remaining: issues };
+  }
+  const summary = buildSummary(oldIssues);
+  return { summary, remaining: recentIssues };
+}
+function buildSummary(issues) {
+  const sorted = issues.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const bySeverity = {};
+  const byAgent = {};
+  const patternMap = /* @__PURE__ */ new Map();
+  const fileCount = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    bySeverity[issue.severity] = (bySeverity[issue.severity] || 0) + 1;
+    byAgent[issue.agent] = (byAgent[issue.agent] || 0) + 1;
+    const patternKey = normalizePattern(issue.issue);
+    const existing = patternMap.get(patternKey);
+    if (existing) {
+      existing.count++;
+    } else {
+      patternMap.set(patternKey, { count: 1, issue });
+    }
+    const fileName = issue.file.split("/").pop() || issue.file;
+    fileCount.set(fileName, (fileCount.get(fileName) || 0) + 1);
+  }
+  const topPatterns = Array.from(patternMap.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, 10).map(([pattern, data]) => ({
+    pattern: pattern.slice(0, 100),
+    count: data.count,
+    severity: data.issue.severity,
+    agent: data.issue.agent,
+    exampleFix: data.issue.fix.slice(0, 200)
+  }));
+  const hotFiles = Array.from(fileCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, count]) => ({ file, count }));
+  return {
+    period: `${sorted[0]?.timestamp.split("T")[0]} to ${sorted[sorted.length - 1]?.timestamp.split("T")[0]}`,
+    startDate: sorted[0]?.timestamp || "",
+    endDate: sorted[sorted.length - 1]?.timestamp || "",
+    totalIssues: issues.length,
+    resolvedCount: issues.filter((i) => i.resolved).length,
+    bySeverity,
+    byAgent,
+    topPatterns,
+    hotFiles,
+    compactedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizePattern(text) {
+  return text.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/["']/g, "").replace(/\s+/g, " ").trim().slice(0, 150);
+}
+async function saveCompactedSummary(summary, projectDir) {
+  const memoryDir = join4(projectDir, ".trie", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const summaryPath = join4(memoryDir, "compacted-summaries.json");
+  let summaries = [];
+  try {
+    if (existsSync3(summaryPath)) {
+      summaries = JSON.parse(await readFile4(summaryPath, "utf-8"));
+    }
+  } catch {
+    summaries = [];
+  }
+  summaries.push(summary);
+  if (summaries.length > 12) {
+    summaries = summaries.slice(-12);
+  }
+  await writeFile3(summaryPath, JSON.stringify(summaries, null, 2));
+}
+async function loadCompactedSummaries(projectDir) {
+  const summaryPath = join4(projectDir, ".trie", "memory", "compacted-summaries.json");
+  try {
+    if (existsSync3(summaryPath)) {
+      return JSON.parse(await readFile4(summaryPath, "utf-8"));
+    }
+  } catch {
+  }
+  return [];
+}
+async function getHistoricalInsights(projectDir) {
+  const summaries = await loadCompactedSummaries(projectDir);
+  if (summaries.length === 0) {
+    return {
+      totalHistoricalIssues: 0,
+      recurringPatterns: [],
+      improvementTrend: "unknown"
+    };
+  }
+  const totalHistoricalIssues = summaries.reduce((sum, s) => sum + s.totalIssues, 0);
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    for (const pattern of summary.topPatterns) {
+      const key = pattern.pattern;
+      const existing = patternCounts.get(key);
+      if (existing) {
+        existing.count += pattern.count;
+        existing.appearances++;
+      } else {
+        patternCounts.set(key, { ...pattern, appearances: 1 });
+      }
+    }
+  }
+  const recurringPatterns = Array.from(patternCounts.values()).filter((p) => p.appearances >= 2).sort((a, b) => b.count - a.count).slice(0, 5);
+  let improvementTrend = "unknown";
+  if (summaries.length >= 2) {
+    const recent = summaries.slice(-2);
+    const olderCount = recent[0]?.totalIssues || 0;
+    const newerCount = recent[1]?.totalIssues || 0;
+    if (newerCount < olderCount * 0.8) {
+      improvementTrend = "improving";
+    } else if (newerCount > olderCount * 1.2) {
+      improvementTrend = "declining";
+    } else {
+      improvementTrend = "stable";
+    }
+  }
+  return {
+    totalHistoricalIssues,
+    recurringPatterns,
+    improvementTrend
+  };
+}
+
+// src/memory/issue-store.ts
+async function storeIssues(issues, project, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  await mkdir4(memoryDir, { recursive: true });
+  const stored = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const hash = hashIssue(issue);
+    const storedIssue = {
+      id: issue.id,
+      hash,
+      severity: issue.severity,
+      issue: issue.issue,
+      fix: issue.fix,
+      file: issue.file,
+      agent: issue.agent,
+      timestamp: now,
+      project,
+      resolved: false
+    };
+    if (issue.line !== void 0) {
+      storedIssue.line = issue.line;
+    }
+    if (issue.category !== void 0) {
+      storedIssue.category = issue.category;
+    }
+    stored.push(storedIssue);
+  }
+  await appendToDailyLog(stored, projectDir);
+  await updateIssueIndex(stored, projectDir);
+  return stored.length;
+}
+async function searchIssues(query, options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const limit = options.limit || 10;
+  const allIssues = await loadIssueIndex(projectDir);
+  if (allIssues.length === 0) {
+    return [];
+  }
+  const filteredIssues = allIssues.filter((issue) => {
+    if (options.project && issue.project !== options.project) return false;
+    if (options.severity && !options.severity.includes(issue.severity)) return false;
+    if (options.agent && issue.agent !== options.agent) return false;
+    if (!options.includeResolved && issue.resolved) return false;
+    return true;
+  });
+  if (filteredIssues.length === 0) {
+    return [];
+  }
+  const bm25 = new BM25Index();
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const issue of filteredIssues) {
+    const searchText = `${issue.issue} ${issue.fix} ${issue.file} ${issue.agent} ${issue.category || ""} ${issue.severity}`;
+    bm25.addDocument({
+      id: issue.id,
+      text: searchText
+    });
+    issueMap.set(issue.id, issue);
+  }
+  const bm25Results = bm25.search(query, limit);
+  return bm25Results.map((result) => ({
+    issue: issueMap.get(result.id),
+    score: result.score,
+    matchType: "bm25"
+  }));
+}
+async function findSimilarIssues(issue, options = {}) {
+  const query = `${issue.issue} ${issue.fix} ${issue.agent}`;
+  const searchOptions = {
+    limit: (options.limit || 5) + 5,
+    // Get extra to account for filtering
+    includeResolved: true
+  };
+  if (options.workDir !== void 0) {
+    searchOptions.workDir = options.workDir;
+  }
+  const results = await searchIssues(query, searchOptions);
+  let filtered = results.filter((r) => r.issue.id !== issue.id);
+  if (options.excludeSameFile) {
+    filtered = filtered.filter((r) => r.issue.file !== issue.file);
+  }
+  return filtered.slice(0, options.limit || 5);
+}
+async function markIssueResolved(issueId, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const issue = index.find((i) => i.id === issueId);
+  if (!issue) return false;
+  issue.resolved = true;
+  issue.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveIssueIndex(index, projectDir);
+  return true;
+}
+async function getMemoryStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const historical = await getHistoricalInsights(projectDir);
+  const stats = {
+    totalIssues: index.length,
+    issuesByAgent: {},
+    issuesBySeverity: {},
+    resolvedCount: 0,
+    historicalIssues: historical.totalHistoricalIssues,
+    improvementTrend: historical.improvementTrend
+  };
+  for (const issue of index) {
+    stats.issuesByAgent[issue.agent] = (stats.issuesByAgent[issue.agent] || 0) + 1;
+    stats.issuesBySeverity[issue.severity] = (stats.issuesBySeverity[issue.severity] || 0) + 1;
+    if (issue.resolved) stats.resolvedCount++;
+  }
+  if (index.length > 0) {
+    const sorted = [...index].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const oldest = sorted[0]?.timestamp;
+    const newest = sorted[sorted.length - 1]?.timestamp;
+    if (oldest !== void 0) {
+      stats.oldestIssue = oldest;
+    }
+    if (newest !== void 0) {
+      stats.newestIssue = newest;
+    }
+  }
+  return stats;
+}
+async function getRecentIssues(options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const limit = options.limit || 20;
+  const daysBack = options.daysBack || 7;
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+  return index.filter((i) => new Date(i.timestamp) >= cutoff).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+}
+async function getDailyLogs(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  try {
+    if (!existsSync4(memoryDir)) return [];
+    const files = await readdir2(memoryDir);
+    return files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+async function appendToDailyLog(issues, projectDir) {
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logPath = join5(memoryDir, `${today}.md`);
+  let content = "";
+  try {
+    if (existsSync4(logPath)) {
+      content = await readFile5(logPath, "utf-8");
+    } else {
+      content = `# Issue Log: ${today}
+
+`;
+    }
+  } catch {
+    content = `# Issue Log: ${today}
+
+`;
+  }
+  const time = (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0];
+  const newEntries = issues.map(
+    (i) => `## [${time}] ${i.severity.toUpperCase()}: ${i.issue.slice(0, 80)}${i.issue.length > 80 ? "..." : ""}
+- **File:** \`${i.file}\`${i.line ? `:${i.line}` : ""}
+- **Agent:** ${i.agent}
+- **Fix:** ${i.fix.slice(0, 200)}${i.fix.length > 200 ? "..." : ""}
+`
+  ).join("\n");
+  content += newEntries + "\n";
+  await writeFile4(logPath, content);
+}
+async function loadIssueIndex(projectDir) {
+  const indexPath = join5(projectDir, ".trie", "memory", "issues.json");
+  try {
+    if (existsSync4(indexPath)) {
+      const content = await readFile5(indexPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return [];
+}
+async function updateIssueIndex(newIssues, projectDir) {
+  const memoryDir = join5(projectDir, ".trie", "memory");
+  await mkdir4(memoryDir, { recursive: true });
+  let existing = await loadIssueIndex(projectDir);
+  const hashSet = new Set(existing.map((i) => i.hash));
+  const toAdd = newIssues.filter((i) => !hashSet.has(i.hash));
+  existing = [...existing, ...toAdd];
+  if (existing.length > 500) {
+    const { summary, remaining } = await compactOldIssues(existing, {
+      keepDays: 30,
+      minIssuesToCompact: 100
+    });
+    if (summary) {
+      await saveCompactedSummary(summary, projectDir);
+      existing = remaining;
+    }
+  }
+  if (existing.length > 1e3) {
+    existing = existing.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 1e3);
+  }
+  await saveIssueIndex(existing, projectDir);
+}
+async function saveIssueIndex(issues, projectDir) {
+  const indexPath = join5(projectDir, ".trie", "memory", "issues.json");
+  await writeFile4(indexPath, JSON.stringify(issues, null, 2));
+}
+function hashIssue(issue) {
+  const content = `${issue.issue}|${issue.file}|${issue.severity}|${issue.agent}`;
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/memory/global-memory.ts
+import { mkdir as mkdir5, writeFile as writeFile5, readFile as readFile6, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import { homedir } from "os";
+var GLOBAL_TRIE_DIR = join6(homedir(), ".trie");
+var GLOBAL_MEMORY_DIR = join6(GLOBAL_TRIE_DIR, "memory");
+async function recordToGlobalMemory(issues, projectName, projectPath, healthScore = 0) {
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  await mkdir5(join6(GLOBAL_MEMORY_DIR, "projects"), { recursive: true });
+  const patterns = await loadGlobalPatterns();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const patternId = extractPatternId(issue);
+    const existing = patterns.find((p) => p.id === patternId);
+    if (existing) {
+      existing.occurrences++;
+      existing.lastSeen = now;
+      if (!existing.projects.includes(projectName)) {
+        existing.projects.push(projectName);
+      }
+    } else {
+      patterns.push({
+        id: patternId,
+        pattern: issue.issue.slice(0, 200),
+        description: issue.fix.slice(0, 200),
+        severity: issue.severity,
+        agent: issue.agent,
+        occurrences: 1,
+        projects: [projectName],
+        firstSeen: now,
+        lastSeen: now
+      });
+    }
+  }
+  await saveGlobalPatterns(patterns);
+  const summaryPath = join6(GLOBAL_MEMORY_DIR, "projects", `${sanitizeName(projectName)}.json`);
+  const summary = {
+    name: projectName,
+    path: projectPath,
+    lastScan: now,
+    healthScore,
+    totalIssues: issues.length,
+    patterns: [...new Set(issues.map((i) => extractPatternId(i)))]
+  };
+  await writeFile5(summaryPath, JSON.stringify(summary, null, 2));
+}
+async function findCrossProjectPatterns(minOccurrences = 2) {
+  const patterns = await loadGlobalPatterns();
+  return patterns.filter((p) => p.projects.length >= minOccurrences).sort((a, b) => b.occurrences - a.occurrences);
+}
+async function listTrackedProjects() {
+  const projectsDir = join6(GLOBAL_MEMORY_DIR, "projects");
+  try {
+    if (!existsSync5(projectsDir)) return [];
+    const files = await readdir3(projectsDir);
+    const summaries = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = await readFile6(join6(projectsDir, file), "utf-8");
+        summaries.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return summaries.sort(
+      (a, b) => new Date(b.lastScan).getTime() - new Date(a.lastScan).getTime()
+    );
+  } catch {
+    return [];
+  }
+}
+async function getGlobalMemoryStats() {
+  const patterns = await loadGlobalPatterns();
+  const projects = await listTrackedProjects();
+  const patternsByAgent = {};
+  for (const pattern of patterns) {
+    patternsByAgent[pattern.agent] = (patternsByAgent[pattern.agent] || 0) + 1;
+  }
+  return {
+    totalPatterns: patterns.length,
+    crossProjectPatterns: patterns.filter((p) => p.projects.length >= 2).length,
+    trackedProjects: projects.length,
+    totalOccurrences: patterns.reduce((sum, p) => sum + p.occurrences, 0),
+    fixedPatterns: patterns.filter((p) => p.fixApplied).length,
+    patternsByAgent
+  };
+}
+async function updateGlobalMemoryMd() {
+  const patterns = await loadGlobalPatterns();
+  const crossProject = patterns.filter((p) => p.projects.length >= 2);
+  const projects = await listTrackedProjects();
+  const lines = [
+    "# Global Trie Memory",
+    "",
+    "> Auto-generated file tracking patterns across all your projects.",
+    `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Summary",
+    "",
+    `- **Projects tracked:** ${projects.length}`,
+    `- **Total patterns:** ${patterns.length}`,
+    `- **Cross-project patterns:** ${crossProject.length}`,
+    "",
+    "## Cross-Project Patterns",
+    "",
+    "These issues appear in multiple projects:",
+    ""
+  ];
+  for (const p of crossProject.slice(0, 20)) {
+    lines.push(
+      `### ${p.pattern.slice(0, 60)}${p.pattern.length > 60 ? "..." : ""}`,
+      "",
+      `- **Severity:** ${p.severity}`,
+      `- **Agent:** ${p.agent}`,
+      `- **Occurrences:** ${p.occurrences} across ${p.projects.length} projects`,
+      `- **Projects:** ${p.projects.slice(0, 5).join(", ")}${p.projects.length > 5 ? "..." : ""}`
+    );
+    if (p.fixApplied) {
+      lines.push(`- **Fixed in:** ${p.fixApplied.project} on ${p.fixApplied.timestamp.split("T")[0]}`);
+    } else {
+      lines.push("- **Status:** Not fixed");
+    }
+    lines.push("");
+  }
+  lines.push(
+    "## Tracked Projects",
+    "",
+    "| Project | Last Scan | Health | Issues |",
+    "|---------|-----------|--------|--------|"
+  );
+  for (const p of projects.slice(0, 20)) {
+    lines.push(`| ${p.name} | ${p.lastScan.split("T")[0]} | ${p.healthScore}% | ${p.totalIssues} |`);
+  }
+  lines.push("", "---", "", "*This file is auto-generated by Trie. Do not edit manually.*");
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  await writeFile5(join6(GLOBAL_MEMORY_DIR, "GLOBAL_MEMORY.md"), lines.join("\n"));
+}
+async function searchGlobalPatterns(query, options = {}) {
+  const patterns = await loadGlobalPatterns();
+  const limit = options.limit || 10;
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = patterns.filter((p) => {
+    if (options.severity && !options.severity.includes(p.severity)) return false;
+    if (options.agent && p.agent !== options.agent) return false;
+    return true;
+  }).map((p) => {
+    const text = `${p.pattern} ${p.description} ${p.agent}`.toLowerCase();
+    let score = 0;
+    for (const term of queryTerms) {
+      if (text.includes(term)) score++;
+    }
+    return { pattern: p, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  return scored.map((s) => s.pattern);
+}
+async function loadGlobalPatterns() {
+  const patternsPath = join6(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  try {
+    if (existsSync5(patternsPath)) {
+      const content = await readFile6(patternsPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return [];
+}
+async function saveGlobalPatterns(patterns) {
+  await mkdir5(GLOBAL_MEMORY_DIR, { recursive: true });
+  const patternsPath = join6(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  const pruned = patterns.sort((a, b) => new Date(b.lastSeen).getTime() - new Date(a.lastSeen).getTime()).slice(0, 500);
+  await writeFile5(patternsPath, JSON.stringify(pruned, null, 2));
+}
+function extractPatternId(issue) {
+  const normalized = issue.issue.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/['"]/g, "").slice(0, 100);
+  let hash = 0;
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `${issue.agent}-${issue.severity}-${Math.abs(hash).toString(36)}`;
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+}
+
+// src/utils/context-state.ts
+var AGENTS_MD_PATH = ".trie/AGENTS.md";
+var STATE_JSON_PATH = ".trie/state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join7(workDir, STATE_JSON_PATH);
+  const defaults = getDefaultState();
+  try {
+    if (existsSync6(statePath)) {
+      const content = await readFile7(statePath, "utf-8");
+      const loaded = JSON.parse(content);
+      return {
+        ...defaults,
+        ...loaded,
+        skills: loaded.skills || defaults.skills
+      };
+    }
+  } catch {
+  }
+  return defaults;
+}
+async function saveContextState(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const trieDir = join7(workDir, ".trie");
+  const statePath = join7(workDir, STATE_JSON_PATH);
+  await mkdir6(trieDir, { recursive: true });
+  await writeFile6(statePath, JSON.stringify(state, null, 2));
+}
+async function updateContextAfterScan(results, filesScanned, contextSignals, duration) {
+  const state = await loadContextState();
+  const workDir = getWorkingDirectory(void 0, true);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const allIssues = results.flatMap((r) => r.issues);
+  const issueCounts = {
+    critical: allIssues.filter((i) => i.severity === "critical").length,
+    serious: allIssues.filter((i) => i.severity === "serious").length,
+    moderate: allIssues.filter((i) => i.severity === "moderate").length,
+    low: allIssues.filter((i) => i.severity === "low").length,
+    total: allIssues.length
+  };
+  const fileIssueMap = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    const count = fileIssueMap.get(issue.file) || 0;
+    fileIssueMap.set(issue.file, count + 1);
+  }
+  const hotFiles = Array.from(fileIssueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, issueCount]) => ({ file, issueCount }));
+  const scanSummary = {
+    timestamp: now,
+    agents: results.map((r) => r.agent),
+    filesScanned,
+    issues: issueCounts,
+    duration,
+    hotFiles
+  };
+  for (const result of results) {
+    state.agentStatus[result.agent] = {
+      lastRun: now,
+      issuesFound: result.issues.length
+    };
+  }
+  const criticalPenalty = issueCounts.critical * 25;
+  const seriousPenalty = issueCounts.serious * 10;
+  const moderatePenalty = issueCounts.moderate * 3;
+  const lowPenalty = issueCounts.low * 1;
+  const totalPenalty = Math.min(100, criticalPenalty + seriousPenalty + moderatePenalty + lowPenalty);
+  state.healthScore = Math.max(0, 100 - totalPenalty);
+  state.activePriorities = generatePriorities(issueCounts, contextSignals);
+  state.contextSignals = { ...state.contextSignals, ...contextSignals };
+  state.scanHistory = [scanSummary, ...state.scanHistory.slice(0, 19)];
+  state.lastScan = scanSummary;
+  await saveContextState(state);
+  await updateAgentsMd(state);
+  if (allIssues.length > 0) {
+    const projectName = basename2(workDir);
+    try {
+      await storeIssues(allIssues, projectName, workDir);
+      await recordToGlobalMemory(allIssues, projectName, workDir, state.healthScore);
+      await updateGlobalMemoryMd();
+    } catch {
+    }
+  }
+}
+async function updateAgentsMd(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const mdPath = join7(workDir, AGENTS_MD_PATH);
+  let content;
+  try {
+    content = await readFile7(mdPath, "utf-8");
+  } catch {
+    content = getAgentsMdTemplate();
+  }
+  content = updateSection(content, "Project State", generateProjectStateTable(state));
+  content = updateSection(content, "Active Priorities", generatePrioritiesList(state));
+  content = updateSection(content, "Agent Status", generateAgentStatusTable(state));
+  content = updateSection(content, "Recent Scan History", generateScanHistoryTable(state));
+  content = updateSection(content, "Context Signals Detected", generateContextSignals(state));
+  content = updateSection(content, "Risk Assessment", generateRiskAssessment(state));
+  content = updateSection(content, "Hot Files", generateHotFilesSection(state));
+  content = content.replace(
+    /Last updated:.*$/m,
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  );
+  await writeFile6(mdPath, content);
+}
+function updateSection(content, sectionName, newContent) {
+  const sectionRegex = new RegExp(
+    `(### ${sectionName}[\\s\\S]*?)(?=###|---|
+## |$)`,
+    "g"
+  );
+  const replacement = `### ${sectionName}
+${newContent}
+
+`;
+  if (content.match(sectionRegex)) {
+    return content.replace(sectionRegex, replacement);
+  }
+  return content;
+}
+function generateProjectStateTable(state) {
+  const lastScan = state.lastScan;
+  const lastScanDate = lastScan ? new Date(lastScan.timestamp).toLocaleString() : "Never";
+  const criticalCount = lastScan?.issues.critical ?? 0;
+  const totalTasks = lastScan?.issues.total ?? 0;
+  return `| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | ${lastScanDate} | ${lastScan ? "Auto" : "-"} |
+| Critical Issues | ${criticalCount} | ${lastScan ? "Auto" : "-"} |
+| Open Tasks | ${totalTasks} | ${lastScan ? "Auto" : "-"} |
+| Health Score | ${state.healthScore}% | ${lastScan ? "Auto" : "-"} |`;
+}
+function generatePrioritiesList(state) {
+  if (state.activePriorities.length === 0) {
+    return "_No active priorities. Run a scan to identify issues._";
+  }
+  return state.activePriorities.map((p, i) => `${i + 1}. ${p}`).join("\n");
+}
+function generatePriorities(issues, contextSignals) {
+  const priorities = [];
+  if (issues.critical > 0) {
+    priorities.push(`\u{1F6A8} Fix ${issues.critical} critical security issue${issues.critical > 1 ? "s" : ""} immediately`);
+  }
+  if (issues.serious > 0) {
+    priorities.push(`\u26A0\uFE0F Address ${issues.serious} serious issue${issues.serious > 1 ? "s" : ""} before deployment`);
+  }
+  if (contextSignals.touchesAuth && issues.critical === 0) {
+    priorities.push("\u2705 Auth code reviewed - continue monitoring");
+  }
+  if (contextSignals.touchesPayments) {
+    priorities.push("\u{1F4B3} Payment code detected - ensure PCI compliance");
+  }
+  if (contextSignals.touchesUserData) {
+    priorities.push("\u{1F510} User data handling detected - verify privacy compliance");
+  }
+  if (issues.moderate > 5) {
+    priorities.push(`\u{1F4CB} Schedule time to address ${issues.moderate} moderate issues`);
+  }
+  if (priorities.length === 0) {
+    priorities.push("\u2728 No critical issues - focus on feature development");
+  }
+  return priorities.slice(0, 5);
+}
+function generateAgentStatusTable(state) {
+  const builtInAgents = [
+    "security",
+    "privacy",
+    "legal",
+    "accessibility",
+    "bugs",
+    "design",
+    "architecture",
+    "performance",
+    "devops",
+    "soc2",
+    "e2e",
+    "typecheck",
+    "visual-qa",
+    "data-flow"
+  ];
+  let table = `| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|`;
+  for (const agent of builtInAgents) {
+    const status = state.agentStatus[agent];
+    const lastRun = status?.lastRun ? new Date(status.lastRun).toLocaleDateString() : "Never";
+    const issues = status?.issuesFound ?? "-";
+    const statusEmoji = status ? "\u2705" : "\u23F8\uFE0F";
+    table += `
+| ${agent} | ${statusEmoji} Ready | ${lastRun} | ${issues} |`;
+  }
+  return table;
+}
+function generateScanHistoryTable(state) {
+  if (state.scanHistory.length === 0) {
+    return `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |`;
+  }
+  let table = `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|`;
+  for (const scan of state.scanHistory.slice(0, 10)) {
+    const date = new Date(scan.timestamp).toLocaleDateString();
+    const agents = scan.agents.slice(0, 3).join(", ") + (scan.agents.length > 3 ? "..." : "");
+    const duration = `${(scan.duration / 1e3).toFixed(1)}s`;
+    table += `
+| ${date} | ${agents} | ${scan.filesScanned} | ${scan.issues.total} | ${duration} |`;
+  }
+  return table;
+}
+function generateContextSignals(state) {
+  const signals = [
+    "touchesAuth",
+    "touchesPayments",
+    "touchesUserData",
+    "touchesAPI",
+    "touchesDatabase",
+    "touchesCrypto"
+  ];
+  return signals.map((s) => {
+    const value = state.contextSignals[s];
+    const emoji = value === true ? "\u2705" : value === false ? "\u274C" : "\u2753";
+    return `- \`${s}\`: ${emoji} ${value === void 0 ? "Unknown" : value ? "Yes" : "No"}`;
+  }).join("\n");
+}
+function generateRiskAssessment(state) {
+  const score = state.healthScore;
+  let riskLevel;
+  let confidence;
+  if (state.lastScan === null) {
+    return `- Overall Risk: Unknown
+- Confidence: 0%`;
+  }
+  if (score >= 90) {
+    riskLevel = "\u{1F7E2} Low";
+    confidence = 95;
+  } else if (score >= 70) {
+    riskLevel = "\u{1F7E1} Medium";
+    confidence = 85;
+  } else if (score >= 50) {
+    riskLevel = "\u{1F7E0} High";
+    confidence = 80;
+  } else {
+    riskLevel = "\u{1F534} Critical";
+    confidence = 90;
+  }
+  return `- Overall Risk: ${riskLevel}
+- Health Score: ${score}%
+- Confidence: ${confidence}%`;
+}
+function generateHotFilesSection(state) {
+  if (!state.lastScan || state.lastScan.hotFiles.length === 0) {
+    return "_Run a scan to identify hot files._";
+  }
+  return state.lastScan.hotFiles.map((f) => `- \`${f.file}\` - ${f.issueCount} issue${f.issueCount > 1 ? "s" : ""}`).join("\n");
+}
+function getDefaultState() {
+  return {
+    lastScan: null,
+    healthScore: 0,
+    activePriorities: [
+      "Initial setup required - run first scan with `trie scan`",
+      "Configure agents in `.trie/config.json`",
+      "Set up CI/CD integration"
+    ],
+    contextSignals: {},
+    agentStatus: {},
+    scanHistory: [],
+    customAgents: [],
+    skills: {},
+    environment: detectEnvironment()
+  };
+}
+function detectEnvironment() {
+  if (process.env.GITHUB_ACTIONS) return "github-actions";
+  if (process.env.GITLAB_CI) return "gitlab-ci";
+  if (process.env.CI) return "ci";
+  const parent = process.env._ || "";
+  if (parent.includes("cursor")) return "cursor";
+  if (parent.includes("claude")) return "claude-code";
+  return "cli";
+}
+async function recordSkillInstalled(params) {
+  const state = await loadContextState();
+  state.skills[params.name] = {
+    source: params.source,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    timesApplied: 0,
+    appliedBy: []
+  };
+  await saveContextState(state);
+}
+async function recordSkillUsage(params) {
+  const state = await loadContextState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const skillName of params.skillNames) {
+    const skillRecord = state.skills[skillName];
+    if (skillRecord) {
+      skillRecord.timesApplied++;
+      skillRecord.lastApplied = now;
+      if (!skillRecord.appliedBy.includes(params.agentName)) {
+        skillRecord.appliedBy.push(params.agentName);
+      }
+    }
+  }
+  const agentStatus = state.agentStatus[params.agentName];
+  if (agentStatus) {
+    agentStatus.skillsApplied = params.skillNames;
+  }
+  await saveContextState(state);
+}
+function getAgentsMdTemplate() {
+  return `# Trie Agent Context
+
+> **Auto-generated file** - Updated automatically when agents run.
+> Last updated: Never (initial state)
+
+This file provides prioritized context for all AI coding assistants working with this codebase.
+Agents should read this file first and update it after completing scans.
+
+---
+
+## Quick Context (Read First)
+
+### Project State
+| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | Never | - |
+| Critical Issues | 0 | - |
+| Open Tasks | 0 | - |
+| Health Score | Unknown | - |
+
+### Active Priorities
+1. Initial setup required - run first scan with \`trie scan\`
+2. Configure agents in \`.trie/config.json\`
+3. Set up CI/CD integration
+
+### Hot Files
+_Run a scan to identify hot files._
+
+---
+
+## Agent Status
+
+### Agent Status
+| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|
+| security | Ready | Never | - |
+| privacy | Ready | Never | - |
+| bugs | Ready | Never | - |
+
+### Recent Scan History
+| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |
+
+---
+
+## Context Analysis
+
+### Context Signals Detected
+- \`touchesAuth\`: Unknown
+- \`touchesPayments\`: Unknown
+- \`touchesUserData\`: Unknown
+- \`touchesAPI\`: Unknown
+- \`touchesDatabase\`: Unknown
+- \`touchesCrypto\`: Unknown
+
+### Risk Assessment
+- Overall Risk: Unknown
+- Confidence: 0%
+
+---
+
+*This file is maintained by Trie agents. Manual edits will be preserved in non-auto sections.*
+`;
+}
+async function getContextForAI() {
+  const state = await loadContextState();
+  const workDir = getWorkingDirectory(void 0, true);
+  const lines = [];
+  if (projectInfoExists(workDir)) {
+    const projectInfo = await loadProjectInfo(workDir);
+    if (projectInfo) {
+      lines.push(projectInfo);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+  }
+  lines.push(
+    "## Trie Scan Context",
+    "",
+    `**Health Score:** ${state.healthScore}%`,
+    `**Last Scan:** ${state.lastScan ? new Date(state.lastScan.timestamp).toLocaleString() : "Never"}`,
+    "",
+    "**Active Priorities:**",
+    ...state.activePriorities.map((p) => `- ${p}`),
+    ""
+  );
+  if (state.lastScan) {
+    lines.push(
+      "**Recent Issues:**",
+      `- Critical: ${state.lastScan.issues.critical}`,
+      `- Serious: ${state.lastScan.issues.serious}`,
+      `- Moderate: ${state.lastScan.issues.moderate}`,
+      `- Low: ${state.lastScan.issues.low}`,
+      ""
+    );
+    if (state.lastScan.hotFiles.length > 0) {
+      lines.push(
+        "**Hot Files (most issues):**",
+        ...state.lastScan.hotFiles.slice(0, 5).map((f) => `- ${f.file}: ${f.issueCount} issues`),
+        ""
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/skills/gating.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join8 } from "path";
 import { execSync } from "child_process";
 async function checkSkillRequirements(frontmatter, projectDir) {
   const result = { allowed: true };
@@ -8526,7 +10115,7 @@ async function checkSkillRequirements(frontmatter, projectDir) {
     }
   }
   if (reqs.configFiles && reqs.configFiles.length > 0) {
-    const missing = reqs.configFiles.filter((file) => !existsSync2(join(projectDir, file)));
+    const missing = reqs.configFiles.filter((file) => !existsSync7(join8(projectDir, file)));
     if (missing.length > 0) {
       result.allowed = false;
       result.missingConfigs = missing;
@@ -8538,11 +10127,11 @@ async function checkSkillRequirements(frontmatter, projectDir) {
 }
 async function getProjectDependencies(projectDir) {
   try {
-    const pkgPath = join(projectDir, "package.json");
-    if (!existsSync2(pkgPath)) {
+    const pkgPath = join8(projectDir, "package.json");
+    if (!existsSync7(pkgPath)) {
       return /* @__PURE__ */ new Set();
     }
-    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    const pkg = JSON.parse(await readFile8(pkgPath, "utf-8"));
     return /* @__PURE__ */ new Set([
       ...Object.keys(pkg.dependencies || {}),
       ...Object.keys(pkg.devDependencies || {})
@@ -8578,8 +10167,8 @@ function formatGatingReason(result) {
   return `Missing: ${parts.join("; ")}`;
 }
 
-// src/agents/skill-review.ts
-var SkillReviewAgent = class extends BaseAgent {
+// src/skills/built-in/skill-review.ts
+var SkillReviewSkill = class extends BaseSkill {
   name = "skill-review";
   description = "Applies installed skills from GitHub repositories to code review";
   version = "1.0.0";
@@ -8786,13 +10375,13 @@ ${parsed.rawContent}`);
   }
 };
 
-// src/agents/custom-skill.ts
-var CustomSkill = class extends BaseAgent {
+// src/skills/built-in/custom-skill.ts
+var CustomSkill = class extends BaseSkill {
   name;
   description;
   version;
-  author;
-  authorUrl;
+  author = void 0;
+  authorUrl = void 0;
   config;
   constructor(config) {
     super();
@@ -8800,8 +10389,14 @@ var CustomSkill = class extends BaseAgent {
     this.name = config.name;
     this.description = config.description;
     this.version = config.version;
-    this.author = config.author;
-    this.authorUrl = config.authorUrl;
+    const authorAttr = config.author;
+    if (authorAttr !== void 0) {
+      this.author = authorAttr;
+    }
+    const authorUrlAttr = config.authorUrl;
+    if (authorUrlAttr !== void 0) {
+      this.authorUrl = authorUrlAttr;
+    }
   }
   get priority() {
     return {
@@ -8997,75 +10592,75 @@ var CustomSkill = class extends BaseAgent {
   }
 };
 
-// src/agents/registry.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-var AgentRegistryImpl = class {
-  agents = /* @__PURE__ */ new Map();
-  customAgentsLoaded = false;
+// src/skills/built-in/registry.ts
+import { readdir as readdir4, readFile as readFile9 } from "fs/promises";
+import { join as join9 } from "path";
+var SkillRegistryImpl = class {
+  skills = /* @__PURE__ */ new Map();
+  customSkillsLoaded = false;
   initialized = false;
   constructor() {
-    this.registerBuiltinAgents();
+    this.registerBuiltinSkills();
   }
-  registerBuiltinAgents() {
+  registerBuiltinSkills() {
     if (this.initialized) return;
     this.initialized = true;
-    const builtinAgents = [
-      // Core agents (always available)
-      new SecurityAgent(),
-      new PrivacyAgent(),
-      new TypeCheckAgent(),
-      new ComprehensionAgent(),
-      // Specialized agents
-      new AccessibilityAgent(),
-      new DesignEngineerAgent(),
-      new LegalAgent(),
-      new TestAgent(),
-      new SoftwareArchitectAgent(),
-      new DevOpsAgent(),
-      new BugFindingAgent(),
-      new UserTestingAgent(),
-      new TrieCleanAgent(),
-      new SOC2Agent(),
-      new SuperReviewerAgent(),
-      new AgentSmithAgent(),
-      // New agents (inspired by Turkey Build)
-      new PerformanceAgent(),
-      new E2EAgent(),
-      new VisualQAAgent(),
-      new DataFlowAgent(),
-      // Cost analysis agent
-      new MoneybagAgent(),
+    const builtinSkills = [
+      // Core skills (always available)
+      new SecuritySkill(),
+      new PrivacySkill(),
+      new TypeCheckSkill(),
+      new ComprehensionSkill(),
+      // Specialized skills
+      new AccessibilitySkill(),
+      new DesignEngineerSkill(),
+      new LegalSkill(),
+      new TestSkill(),
+      new SoftwareArchitectSkill(),
+      new DevOpsSkill(),
+      new BugFindingSkill(),
+      new UserTestingSkill(),
+      new TrieCleanSkill(),
+      new SOC2Skill(),
+      new SuperReviewerSkill(),
+      new AgentSmithSkill(),
+      // New skills (inspired by Turkey Build)
+      new PerformanceSkill(),
+      new E2ESkill(),
+      new VisualQASkill(),
+      new DataFlowSkill(),
+      // Cost analysis skill
+      new MoneybagSkill(),
       // Production readiness gate
-      new ProductionReadyAgent(),
-      // Skill review agent (applies external skills)
-      new SkillReviewAgent()
+      new ProductionReadySkill(),
+      // Skill review skill (applies external skills)
+      new SkillReviewSkill()
     ];
     const isWorker = typeof process !== "undefined" && (process.env.TRIE_WORKER === "true" || process.env.NODE_ENV === "test");
     if (!isWorker && !process.env.TRIE_QUIET) {
-      console.error(`Loaded config for ${builtinAgents.length} built-in agents`);
+      console.error(`Loaded config for ${builtinSkills.length} built-in skills`);
     }
-    for (const agent of builtinAgents) {
-      this.agents.set(agent.name, agent);
+    for (const skill of builtinSkills) {
+      this.skills.set(skill.name, skill);
     }
   }
   /**
    * Load custom skills from .trie/agents/ directory
    */
   async loadCustomSkills() {
-    if (this.customAgentsLoaded) return;
+    if (this.customSkillsLoaded) return;
     try {
-      const skillsDir = join2(getWorkingDirectory(void 0, true), ".trie", "agents");
-      const files = await readdir(skillsDir);
+      const skillsDir = join9(getWorkingDirectory(void 0, true), ".trie", "agents");
+      const files = await readdir4(skillsDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       let loadedCount = 0;
       for (const file of jsonFiles) {
         try {
-          const configPath = join2(skillsDir, file);
-          const content = await readFile2(configPath, "utf-8");
+          const configPath = join9(skillsDir, file);
+          const content = await readFile9(configPath, "utf-8");
           const config = JSON.parse(content);
           const skill = new CustomSkill(config);
-          this.agents.set(skill.name, skill);
+          this.skills.set(skill.name, skill);
           loadedCount++;
         } catch (error) {
           console.error(`Failed to load custom skill from ${file}:`, error);
@@ -9074,22 +10669,22 @@ var AgentRegistryImpl = class {
       if (loadedCount > 0) {
         console.error(`Loaded ${loadedCount} custom skill(s) from .trie/agents/`);
       }
-      this.customAgentsLoaded = true;
+      this.customSkillsLoaded = true;
     } catch (error) {
-      this.customAgentsLoaded = true;
+      this.customSkillsLoaded = true;
     }
-    await this.loadSkillsForAgent();
+    await this.loadSkillsForSkill();
   }
   // Backward compatibility alias
   async loadCustomAgents() {
     return this.loadCustomSkills();
   }
   /**
-   * Load installed skills for the SkillReviewAgent
+   * Load installed skills for the SkillReviewSkill
    */
-  async loadSkillsForAgent() {
-    const skillReviewAgent = this.agents.get("skill-review");
-    if (skillReviewAgent && skillReviewAgent instanceof SkillReviewAgent) {
+  async loadSkillsForSkill() {
+    const skillReviewAgent = this.skills.get("skill-review");
+    if (skillReviewAgent && skillReviewAgent instanceof SkillReviewSkill) {
       await skillReviewAgent.loadSkills();
       if (skillReviewAgent.hasSkills()) {
         console.error(`Loaded ${skillReviewAgent.getAppliedSkillNames().length} skill(s) for skill-review agent`);
@@ -9100,40 +10695,56 @@ var AgentRegistryImpl = class {
    * Reload custom skills (useful after creating new ones)
    */
   async reloadCustomSkills() {
-    for (const [name, agent] of this.agents.entries()) {
+    for (const [name, agent] of this.skills.entries()) {
       if (agent instanceof CustomSkill) {
-        this.agents.delete(name);
+        this.skills.delete(name);
       }
     }
-    this.customAgentsLoaded = false;
+    this.customSkillsLoaded = false;
     await this.loadCustomSkills();
   }
   // Backward compatibility alias
   async reloadCustomAgents() {
     return this.reloadCustomSkills();
   }
+  getSkill(name) {
+    return this.skills.get(name);
+  }
+  // Backward compatibility alias
   getAgent(name) {
-    return this.agents.get(name);
+    return this.getSkill(name);
+  }
+  getSkillsByNames(names) {
+    return names.map((name) => this.getSkill(name)).filter((skill) => skill !== void 0);
   }
+  // Backward compatibility alias
   getAgentsByNames(names) {
-    return names.map((name) => this.getAgent(name)).filter((agent) => agent !== void 0);
+    return this.getSkillsByNames(names);
   }
+  getAllSkills() {
+    return Array.from(this.skills.values());
+  }
+  // Backward compatibility alias
   getAllAgents() {
-    return Array.from(this.agents.values());
+    return this.getAllSkills();
   }
   /**
-   * Get only built-in agents
+   * Get only built-in skills
    */
-  getBuiltinAgents() {
-    return Array.from(this.agents.values()).filter(
-      (agent) => !(agent instanceof CustomSkill)
+  getBuiltinSkills() {
+    return Array.from(this.skills.values()).filter(
+      (skill) => !(skill instanceof CustomSkill)
     );
   }
+  // Backward compatibility alias
+  getBuiltinAgents() {
+    return this.getBuiltinSkills();
+  }
   /**
    * Get only custom skills
    */
   getCustomSkills() {
-    return Array.from(this.agents.values()).filter(
+    return Array.from(this.skills.values()).filter(
       (agent) => agent instanceof CustomSkill
     );
   }
@@ -9141,32 +10752,40 @@ var AgentRegistryImpl = class {
   getCustomAgents() {
     return this.getCustomSkills();
   }
-  registerAgent(agent) {
-    this.agents.set(agent.name, agent);
-    console.error(`Registered custom skill: ${agent.name}`);
+  registerSkill(skill) {
+    this.skills.set(skill.name, skill);
+    console.error(`Registered custom skill: ${skill.name}`);
+  }
+  // Backward compatibility alias
+  registerAgent(skill) {
+    this.registerSkill(skill);
   }
   /**
-   * Unregister an agent by name
+   * Unregister a skill by name
    */
+  unregisterSkill(name) {
+    return this.skills.delete(name);
+  }
+  // Backward compatibility alias
   unregisterAgent(name) {
-    return this.agents.delete(name);
+    return this.unregisterSkill(name);
   }
-  getAgentNames() {
-    return Array.from(this.agents.keys());
+  getSkillNames() {
+    return Array.from(this.skills.keys());
   }
-  getAgentDescriptions() {
-    return Array.from(this.agents.values()).map((agent) => ({
-      name: agent.name,
-      description: agent.description,
-      isCustom: agent instanceof CustomSkill
+  getSkillDescriptions() {
+    return Array.from(this.skills.values()).map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      isCustom: skill instanceof CustomSkill
     }));
   }
   /**
-   * Check if an agent is a custom skill
+   * Check if a skill is custom
    */
   isCustomSkill(name) {
-    const agent = this.agents.get(name);
-    return agent instanceof CustomSkill;
+    const skill = this.skills.get(name);
+    return skill instanceof CustomSkill;
   }
   // Backward compatibility alias
   isCustomAgent(name) {
@@ -9176,9 +10795,9 @@ var AgentRegistryImpl = class {
    * Get custom skill metadata
    */
   getCustomSkillMetadata(name) {
-    const agent = this.agents.get(name);
-    if (agent instanceof CustomSkill) {
-      return agent.getMetadata();
+    const skill = this.skills.get(name);
+    if (skill instanceof CustomSkill) {
+      return skill.getMetadata();
     }
     return null;
   }
@@ -9187,19 +10806,49 @@ var AgentRegistryImpl = class {
     return this.getCustomSkillMetadata(name);
   }
 };
-var SINGLETON_KEY = "__TRIE_AGENT_REGISTRY__";
-function getAgentRegistry() {
+var SINGLETON_KEY = "__TRIE_SKILL_REGISTRY__";
+var LEGACY_SINGLETON_KEY = "__TRIE_AGENT_REGISTRY__";
+function getSkillRegistry() {
   const global = globalThis;
   if (!global[SINGLETON_KEY]) {
-    global[SINGLETON_KEY] = new AgentRegistryImpl();
+    const existing = global[LEGACY_SINGLETON_KEY];
+    global[SINGLETON_KEY] = existing ?? new SkillRegistryImpl();
+    global[LEGACY_SINGLETON_KEY] = global[SINGLETON_KEY];
   }
   return global[SINGLETON_KEY];
 }
 
 export {
-  SuperReviewerAgent,
+  SuperReviewerSkill,
   CRITICAL_REVIEW_CHECKLIST,
+  installSkill,
+  listInstalledSkills,
+  removeSkill,
+  projectInfoExists,
+  loadProjectInfo,
+  initProjectInfo,
+  getProjectSection,
+  updateProjectSection,
+  appendToSection,
+  getProjectSections,
+  getProjectInfoStructured,
+  getHistoricalInsights,
+  searchIssues,
+  findSimilarIssues,
+  markIssueResolved,
+  getMemoryStats,
+  getRecentIssues,
+  getDailyLogs,
+  findCrossProjectPatterns,
+  listTrackedProjects,
+  getGlobalMemoryStats,
+  updateGlobalMemoryMd,
+  searchGlobalPatterns,
+  loadContextState,
+  updateContextAfterScan,
+  recordSkillInstalled,
+  getContextForAI,
   CustomSkill,
-  getAgentRegistry
+  getSkillRegistry
 };
-//# sourceMappingURL=chunk-37U65YW7.js.map
+//# sourceMappingURL=chunk-TOE75CFZ.js.map