@triedotdev/mcp 1.0.61 → 1.0.63

package/dist/{chunk-S4VGGLXF.js → chunk-X2PABPBH.js}

@@ -1,3 +1,7 @@
+import {
+  recordToGlobalMemory,
+  updateGlobalMemoryMd
+} from "./chunk-7KHT2NKR.js";
 import {
   checkFileLevelIssues,
   getVibeCodeTrie,
@@ -6,13 +10,20 @@ import {
 import {
   AgentSmithSkill,
   BaseSkill,
+  output
+} from "./chunk-K6BQBKIR.js";
+import {
   isAIAvailable,
-  output,
   runAIAnalysis
-} from "./chunk-32WLOG6E.js";
+} from "./chunk-AQCAMIQQ.js";
+import {
+  atomicWriteFile,
+  atomicWriteJSON,
+  storeIssues
+} from "./chunk-TSHZQKCM.js";
 import {
   getWorkingDirectory
-} from "./chunk-ASGSTVVF.js";
+} from "./chunk-KOFQ47YW.js";
 import {
   isInteractiveMode
 } from "./chunk-RAZUNSBI.js";
@@ -284,10 +295,13 @@ var SECURITY_INDICATORS = {
 };
 var CRITICAL_PATTERNS = [
   // Real secrets (not placeholders)
-  { pattern: /AKIA[A-Z0-9]{16}/, severity: "critical", issue: "AWS Access Key exposed", fix: "Remove AWS key and rotate immediately. Use environment variables." },
+  { pattern: /\b(AKI|ASI|AGP|AID|ANP|ARO|AIP)A[A-Z0-9]{16}\b/, severity: "critical", issue: "AWS Access Key exposed", fix: "Remove AWS key and rotate immediately. Use environment variables." },
+  { pattern: /aws_secret_access_key\s*[:=]\s*['"][A-Za-z0-9/+=]{40}['"]/i, severity: "critical", issue: "AWS Secret Access Key exposed", fix: "Remove AWS secret and rotate immediately. Use environment variables or a secret manager." },
   { pattern: /-----BEGIN (RSA |EC |DSA )?PRIVATE KEY-----/, severity: "critical", issue: "Private key exposed in code", fix: "Remove private key immediately. Store in secure vault." },
   { pattern: /ghp_[A-Za-z0-9]{36}/, severity: "critical", issue: "GitHub personal access token exposed", fix: "Revoke token and use environment variables." },
+  { pattern: /github_pat_[A-Za-z0-9_]{70,}/, severity: "critical", issue: "GitHub fine-grained token exposed", fix: "Revoke token and use environment variables." },
   { 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: /rk_live_[A-Za-z0-9]{24,}/, severity: "critical", issue: "Stripe live restricted 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 SecuritySkill = class extends BaseSkill {
@@ -484,6 +498,7 @@ Output STRICT JSON:
     const issues = [];
     for (const file of files) {
       if (this.shouldAlwaysSkip(file)) continue;
+      if (this.isTestFile(file)) continue;
       try {
         const content = await this.readFile(file);
         const lines = content.split("\n");
@@ -1213,17 +1228,25 @@ var AccessibilitySkill = class extends BaseSkill {
     const seriousCount = issues.filter((i) => i.severity === "serious").length;
     if (criticalCount > 0 || seriousCount > 2) {
       const score = this.calculateAccessibilityScore(issues);
+      const shouldTriggerVisualQA = criticalCount > 0 || seriousCount >= 2;
+      let recommendation = `Review and fix accessibility issues starting with critical problems. Use axe-core or Lighthouse for additional validation.`;
+      if (shouldTriggerVisualQA) {
+        recommendation = `${recommendation}
+
+\u2139\uFE0F Consider running 'trie_visual_qa_browser' to capture screenshots for Guardian visual analysis of these accessibility issues.`;
+      }
       issues.push(this.createIssue(
         this.generateIssueId(),
         "low",
         // Summary is informational, not a blocker
-        `Accessibility Score: ${score}/100 \u2014 ${criticalCount} critical, ${seriousCount} serious issues`,
-        `Review and fix accessibility issues starting with critical problems. Use axe-core or Lighthouse for additional validation.`,
+        `Accessibility Score: ${score}/100 \u2014 ${criticalCount} critical, ${seriousCount} serious issues${shouldTriggerVisualQA ? " (Visual QA recommended)" : ""}`,
+        recommendation,
         files[0] || "project",
         void 0,
         0.6,
         void 0,
-        false
+        false,
+        { category: "accessibility-summary" }
       ));
     }
     return issues;
@@ -7699,55 +7722,55 @@ var MONEYBAGS_QUOTES = [
   "Floating-point for money? That's going to be an expensive lesson."
 ];
 var BASE_COST_BY_SEVERITY = {
-  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
+  critical: 300,
+  // Critical bugs found in dev (~2 hrs @ $150)
+  serious: 150,
+  // Serious issues (~1 hr @ $150)
+  moderate: 75,
+  // Moderate issues (~30 min @ $150)
+  low: 25
+  // Low severity - quick fixes (~10 min @ $150)
 };
 var PRODUCTION_MULTIPLIER = {
-  critical: 12,
-  // Critical bugs can cause outages, breaches
-  serious: 8,
-  // Serious bugs cause significant user impact
-  moderate: 4,
+  critical: 5,
+  // Critical bugs can cause outages, but smaller scale
+  serious: 3,
+  // Serious bugs cause user impact
+  moderate: 2,
   // Moderate bugs require hotfixes, user support
-  low: 2
+  low: 1.5
   // Low bugs accumulate tech debt
 };
 var CATEGORY_MULTIPLIERS = {
-  // Security categories - important but realistic
-  "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" },
+  // Security categories - reduced but still prioritized
+  "security": { multiplier: 3, reason: "Security vulnerabilities require careful remediation" },
+  "authentication": { multiplier: 4, reason: "Auth bypass is serious but fixable" },
+  "authorization": { multiplier: 3, reason: "Authorization flaws expose sensitive data" },
+  "injection": { multiplier: 6, reason: "SQL/Command injection is severe - prioritize fix" },
+  "xss": { multiplier: 2.5, reason: "XSS needs fixing but React mitigates most cases" },
+  "secrets": { multiplier: 4, reason: "Exposed secrets require rotation" },
+  "cryptography": { multiplier: 2.5, reason: "Weak crypto should be updated" },
   // Data integrity categories
-  "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: 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" },
+  "data-loss": { multiplier: 5, reason: "Data loss is serious - ensure backups exist" },
+  "data-corruption": { multiplier: 3.5, reason: "Data corruption requires recovery work" },
+  "privacy": { multiplier: 3.5, reason: "Privacy violations carry compliance risk" },
+  // Financial categories - still high priority but more reasonable
+  "payment": { multiplier: 8, reason: "Payment bugs need immediate attention" },
+  "billing": { multiplier: 4, reason: "Billing errors erode trust" },
+  "financial-calculation": { multiplier: 3.5, reason: "Incorrect calculations compound over time" },
   // Reliability categories
-  "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" },
+  "crash": { multiplier: 2.5, reason: "Crashes hurt user experience" },
+  "memory-leak": { multiplier: 2, reason: "Memory leaks cause gradual degradation" },
+  "deadlock": { multiplier: 2.5, reason: "Deadlocks require restarts" },
+  "race-condition": { multiplier: 2.5, reason: "Race conditions are hard to debug" },
   // User experience
-  "accessibility": { multiplier: 1.5, reason: "Accessibility issues should be addressed" },
-  "performance": { multiplier: 2, reason: "Performance issues hurt conversion rates" },
+  "accessibility": { multiplier: 1.3, reason: "Accessibility issues should be addressed" },
+  "performance": { multiplier: 1.5, 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" },
-  "logic-error": { multiplier: 1.5, reason: "Logic errors produce incorrect outcomes" },
+  "logic-error": { multiplier: 1.3, reason: "Logic errors produce incorrect outcomes" },
   // Default
   "default": { multiplier: 1, reason: "General code issues" }
 };
@@ -7762,24 +7785,37 @@ var CONTEXT_MULTIPLIERS = {
   touchesFileSystem: { multiplier: 1.05, description: "File system operations" }
 };
 var EFFORT_HOURS = {
-  trivial: 0.5,
-  easy: 2,
-  medium: 8,
-  hard: 24
+  trivial: 0.25,
+  // 15 minutes - typo fix, obvious one-liner
+  easy: 1,
+  // 1 hour - simple fix, clear solution
+  medium: 4,
+  // 4 hours - half day, requires some investigation
+  hard: 16
+  // 2 days - complex fix, testing needed
 };
 var DEVELOPER_HOURLY_RATE = 150;
+var INDUSTRY_MULTIPLIERS = {
+  "solopreneur": { multiplier: 0.2, label: "Solopreneur (1-person team, minimal overhead)" },
+  "startup": { multiplier: 0.6, label: "Startup (small team, fast iteration)" },
+  "saas": { multiplier: 0.8, label: "SaaS (recurring revenue, moderate compliance)" },
+  "ecommerce": { multiplier: 1, label: "E-commerce (transactions, customer data)" },
+  "enterprise": { multiplier: 1.5, label: "Enterprise (large contracts, SLAs)" },
+  "fintech": { multiplier: 2, label: "Fintech (financial regulations, audits)" },
+  "healthcare": { multiplier: 2.5, label: "Healthcare (HIPAA, patient data)" }
+};
 var DEFAULT_USER_COUNT = 250;
 var USER_COUNT_MULTIPLIERS = [
   { threshold: 0, multiplier: 0.2, label: "Pre-launch (0 users)" },
-  { threshold: 50, multiplier: 0.5, label: "MVP (50 users)" },
-  { threshold: 250, multiplier: 1, label: "Early stage (250 users)" },
-  // Baseline (default)
-  { 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)" }
+  { threshold: 50, multiplier: 0.35, label: "MVP (50 users)" },
+  { threshold: 250, multiplier: 0.6, label: "Early stage (250 users)" },
+  { threshold: 1e3, multiplier: 1, label: "Growing (1K users)" },
+  // Baseline
+  { threshold: 5e3, multiplier: 2, label: "Traction (5K users)" },
+  { threshold: 25e3, multiplier: 4, label: "Scale-up (25K users)" },
+  { threshold: 1e5, multiplier: 7, label: "Growth (100K users)" },
+  { threshold: 5e5, multiplier: 10, label: "Large (500K users)" },
+  { threshold: 1e6, multiplier: 12, label: "Enterprise (1M+ users)" }
   // Capped to avoid runaway estimates
 ];
 var PER_USER_COSTS = {
@@ -7832,6 +7868,70 @@ var MoneybagSkill = class extends BaseSkill {
     }
     return { multiplier: scale.multiplier, label: scale.label };
   }
+  /**
+   * Get the industry multiplier for current industry setting
+   */
+  getIndustryMultiplier() {
+    const industry = this.config.industry;
+    if (!industry || !INDUSTRY_MULTIPLIERS[industry]) {
+      return { multiplier: 1, label: "General (no industry specified)" };
+    }
+    return INDUSTRY_MULTIPLIERS[industry];
+  }
+  /**
+   * Get paying user count (defaults to userCount if not set)
+   */
+  get payingUsers() {
+    return this.config.payingUsers && this.config.payingUsers > 0 ? this.config.payingUsers : this.userCount;
+  }
+  /**
+   * Get monthly recurring revenue (MRR)
+   */
+  get monthlyRevenue() {
+    const rpu = this.config.revenuePerUser ?? 0;
+    return this.payingUsers * rpu;
+  }
+  /**
+   * Get revenue context for cost scaling
+   * If revenue is set, we can make smarter decisions about cost impact
+   */
+  getRevenueContext() {
+    const rpu = this.config.revenuePerUser ?? 0;
+    const payingUsers = this.payingUsers;
+    const mrr = payingUsers * rpu;
+    if (rpu <= 0 || mrr <= 0) {
+      return {
+        hasRevenue: false,
+        mrr: 0,
+        payingUsers,
+        revenuePerUser: 0,
+        revenueMultiplier: 1,
+        label: "No revenue data"
+      };
+    }
+    let revenueMultiplier;
+    let label;
+    if (mrr < 500) {
+      revenueMultiplier = 0.2;
+      label = `Hobby ($${mrr}/mo MRR)`;
+    } else if (mrr < 2e3) {
+      revenueMultiplier = 0.4;
+      label = `Side project ($${mrr.toLocaleString()}/mo MRR)`;
+    } else if (mrr < 1e4) {
+      revenueMultiplier = 0.7;
+      label = `Small business ($${mrr.toLocaleString()}/mo MRR)`;
+    } else if (mrr < 5e4) {
+      revenueMultiplier = 1;
+      label = `Growing business ($${(mrr / 1e3).toFixed(0)}k/mo MRR)`;
+    } else if (mrr < 2e5) {
+      revenueMultiplier = 1.5;
+      label = `Established ($${(mrr / 1e3).toFixed(0)}k/mo MRR)`;
+    } else {
+      revenueMultiplier = 2;
+      label = `Scale-up ($${(mrr / 1e3).toFixed(0)}k/mo MRR)`;
+    }
+    return { hasRevenue: true, mrr, payingUsers, revenuePerUser: rpu, revenueMultiplier, label };
+  }
   /**
    * Display the Moneybags entrance banner
    * Uses OutputManager to route to TUI or console
@@ -7931,6 +8031,10 @@ var MoneybagSkill = class extends BaseSkill {
     const userScaleMultiplier = userScale.multiplier;
     const userScaleLabel = userScale.label;
     const userCount = this.userCount;
+    const industryScale = this.getIndustryMultiplier();
+    const industryMultiplier = industryScale.multiplier;
+    const revenueContext = this.getRevenueContext();
+    const revenueMultiplier = revenueContext.hasRevenue ? revenueContext.revenueMultiplier : 1;
     const perUserRate = PER_USER_COSTS[category] || 0;
     const affectedUserPercent = {
       critical: 0.75,
@@ -7944,20 +8048,33 @@ var MoneybagSkill = class extends BaseSkill {
     };
     const affectedUsers = Math.round(userCount * affectedUserPercent[issue.severity]);
     const perUserCost = Math.round(perUserRate * affectedUsers);
-    const effort = issue.effort || "medium";
-    const fixHours = EFFORT_HOURS[effort] || 8;
+    const defaultEffort = issue.severity === "critical" ? "hard" : issue.severity === "serious" ? "medium" : "easy";
+    const effort = issue.effort || defaultEffort;
+    const fixHours = EFFORT_HOURS[effort] || 4;
     const developerRate = this.config.developerRate ?? DEVELOPER_HOURLY_RATE;
     const fixCost = fixHours * developerRate;
-    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;
-    const totalNowCost = Math.round(Math.min(rawNowCost, maxNowCost));
-    const rawProductionCost = baseCost * productionMultiplier * categoryMultiplier * contextMultiplier + perUserCost + // Add per-user costs for production impact
-    fixCost * 2;
-    const totalProductionCost = Math.round(Math.min(rawProductionCost, maxProdCost));
-    const savings = totalProductionCost - totalNowCost;
+    let totalNowCost;
+    let totalProductionCost;
+    let savings;
+    const isPreRevenue = !revenueContext.hasRevenue || revenueContext.mrr === 0;
+    if (isPreRevenue) {
+      totalNowCost = Math.round(fixCost);
+      const severityMultiplier = { critical: 2, serious: 1.5, moderate: 1.2, low: 1 }[issue.severity];
+      totalProductionCost = Math.round(fixCost * severityMultiplier);
+      savings = totalProductionCost - totalNowCost;
+    } else {
+      const BASE_NOW_CAP = 3e3;
+      const BASE_PROD_CAP = 15e3;
+      const effectiveMultiplier = Math.min(userScaleMultiplier, revenueMultiplier) * 0.7 + revenueMultiplier * 0.3;
+      const maxNowCost = BASE_NOW_CAP * effectiveMultiplier;
+      const maxProdCost = BASE_PROD_CAP * effectiveMultiplier;
+      const rawNowCost = baseCost * categoryMultiplier * contextMultiplier * industryMultiplier * revenueMultiplier + fixCost;
+      totalNowCost = Math.round(Math.min(rawNowCost, maxNowCost));
+      const rawProductionCost = baseCost * productionMultiplier * categoryMultiplier * contextMultiplier * industryMultiplier * revenueMultiplier + perUserCost + // Add per-user costs for production impact
+      fixCost * 2;
+      totalProductionCost = Math.round(Math.min(rawProductionCost, maxProdCost));
+      savings = totalProductionCost - totalNowCost;
+    }
     const summary = this.generateCostSummary(
       issue,
       totalNowCost,
@@ -8016,16 +8133,28 @@ var MoneybagSkill = class extends BaseSkill {
   /**
    * Generate a human-readable cost summary
    */
-  generateCostSummary(_issue, nowCost, productionCost, savings, contextFactors, userCount) {
+  generateCostSummary(_issue, nowCost, productionCost, savings, contextFactors, _userCount) {
     const formatCurrency = (n) => n >= 1e3 ? `$${(n / 1e3).toFixed(1)}k` : `$${n}`;
-    const formatUsers = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(0)}K` : `${n}`;
+    const revenueContext = this.getRevenueContext();
+    const isPreRevenue = !revenueContext.hasRevenue || revenueContext.mrr === 0;
+    if (isPreRevenue) {
+      const hours = nowCost / (this.config.developerRate ?? DEVELOPER_HOURLY_RATE);
+      const hoursStr = hours < 1 ? `${Math.round(hours * 60)}min` : `${hours.toFixed(1)}hr`;
+      let summary2 = `Dev time: ${hoursStr} (${formatCurrency(nowCost)})`;
+      if (contextFactors.length > 0) {
+        summary2 += ` | ${contextFactors.join(", ")}`;
+      }
+      return summary2;
+    }
     let summary = `Fix now: ${formatCurrency(nowCost)} | If production: ${formatCurrency(productionCost)} | Save: ${formatCurrency(savings)}`;
-    summary += ` (${formatUsers(userCount)} users)`;
+    const mrrStr = revenueContext.mrr >= 1e3 ? `$${(revenueContext.mrr / 1e3).toFixed(0)}k MRR` : `$${revenueContext.mrr} MRR`;
+    summary += ` (${mrrStr})`;
     if (contextFactors.length > 0) {
       summary += ` | Risk factors: ${contextFactors.join(", ")}`;
     }
-    const scaledHighThreshold = 5e4 * (userCount / 1e3);
-    const scaledMediumThreshold = 1e4 * (userCount / 1e3);
+    const mrrScale = Math.max(1, Math.sqrt(revenueContext.mrr / 1e4));
+    const scaledHighThreshold = 75e3 * mrrScale;
+    const scaledMediumThreshold = 2e4 * mrrScale;
     if (productionCost > scaledHighThreshold) {
       summary = `[HIGH COST RISK] ${summary}`;
     } else if (productionCost > scaledMediumThreshold) {
@@ -8187,11 +8316,11 @@ FOCUS ON HIGH-COST ISSUES:
 4. **Privacy Violations** (10x multiplier): PII exposure, GDPR violations
 5. **System Crashes** (8x multiplier): Production downtime ($5,600/minute average)
 
-COST ESTIMATION FACTORS:
-- Critical bugs: $5k now, $150k in production
-- Serious bugs: $2k now, $40k in production  
-- Moderate bugs: $500 now, $5k in production
-- Low bugs: $100 now, $500 in production
+COST ESTIMATION FACTORS (baseline for 1K users, scale by industry/user count):
+- Critical bugs: $2k now, $16k in production
+- Serious bugs: $800 now, $4k in production  
+- Moderate bugs: $200 now, $600 in production
+- Low bugs: $50 now, $100 in production
 
 For each issue, estimate:
 - Cost to fix NOW (during development)
@@ -8248,11 +8377,11 @@ Output STRICT JSON:
     const totalSavings = totalProductionCost - totalNowCost;
     const userScale = this.getUserScaleMultiplier();
     const userCount = this.userCount;
-    const scaleMultiplier = userScale.multiplier;
+    const scaleMultiplier = Math.max(1, userScale.multiplier);
     let riskLevel = "low";
-    if (totalProductionCost > 1e5 * scaleMultiplier) riskLevel = "critical";
-    else if (totalProductionCost > 25e3 * scaleMultiplier) riskLevel = "high";
-    else if (totalProductionCost > 5e3 * scaleMultiplier) riskLevel = "medium";
+    if (totalProductionCost > 2e5 * scaleMultiplier) riskLevel = "critical";
+    else if (totalProductionCost > 75e3 * scaleMultiplier) riskLevel = "high";
+    else if (totalProductionCost > 2e4 * scaleMultiplier) riskLevel = "medium";
     const formatCurrency = (n) => n >= 1e6 ? `$${(n / 1e6).toFixed(2)}M` : n >= 1e3 ? `$${(n / 1e3).toFixed(1)}k` : `$${n}`;
     const formatUsers = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}K` : `${n}`;
     const summary = `
@@ -8649,7 +8778,14 @@ var ProductionReadySkill = class extends BaseSkill {
       metRequirements / totalRequirements * 50 + (50 - criticalIssues * 20 - seriousIssues * 10)
     ));
     const status = criticalIssues > 0 || seriousIssues > 2 ? "not-ready" : seriousIssues > 0 ? "caution" : "ready";
-    output().readiness(readinessScore, metRequirements, totalRequirements, status);
+    const requirements = [];
+    for (const [key, config] of Object.entries(PRODUCTION_PATTERNS)) {
+      requirements.push({
+        name: config.requirement,
+        met: this.foundRequirements.has(key)
+      });
+    }
+    output().readiness(readinessScore, metRequirements, totalRequirements, status, requirements);
   }
   getAIEnhancementSystemPrompt() {
     return `You are a production readiness engineer reviewing code for deployment.
@@ -8713,10 +8849,12 @@ 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 { mkdir as mkdir2, rm, writeFile as writeFile2, readdir, readFile as readFile3, access, cp, stat } from "fs/promises";
+import { join as join3, basename as basename2, extname as extname2 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
+import { homedir } from "os";
+import { existsSync as existsSync3 } from "fs";
 
 // src/skills/parser.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -8765,14 +8903,44 @@ function parseYamlFrontmatter(yaml) {
 
 // src/skills/installer.ts
 var execAsync = promisify(exec);
-async function installSkill(source, skillName) {
+var GLOBAL_SKILLS_DIRS = {
+  trie: join3(homedir(), ".trie", "skills"),
+  cursor: join3(homedir(), ".cursor", "skills"),
+  claude: join3(homedir(), ".claude", "skills"),
+  opencode: join3(homedir(), ".config", "opencode", "skills")
+};
+var GLOBAL_SKILLS_DIR = GLOBAL_SKILLS_DIRS.trie;
+function getAllGlobalSkillDirs() {
+  return Object.values(GLOBAL_SKILLS_DIRS);
+}
+function parseGitHubSource(source) {
+  const urlMatch = source.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/(?:tree|blob)\/[^/]+\/(.+))?$/);
+  if (urlMatch) {
+    const skill = urlMatch[3]?.replace(/\/$/, "");
+    return {
+      owner: urlMatch[1],
+      repo: urlMatch[2],
+      ...skill ? { skill } : {}
+    };
+  }
   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" };
+  if (parts.length >= 2) {
+    const skill = parts[2];
+    return {
+      owner: parts[0],
+      repo: parts[1],
+      ...skill ? { skill } : {}
+    };
+  }
+  return null;
+}
+async function installSkill(source, skillName) {
+  const parsed = parseGitHubSource(source);
+  if (!parsed) {
+    return { success: false, name: "unknown", error: "Invalid source format. Use owner/repo, owner/repo/skill-name, or full GitHub URL" };
   }
-  const owner = parts[0];
-  const repo = parts[1];
-  const specifiedSkill = skillName || parts[2];
+  const { owner, repo, skill: parsedSkill } = parsed;
+  const specifiedSkill = skillName || parsedSkill;
   const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
   const tempDir = join3(skillsDir, `.temp-${Date.now()}`);
   try {
@@ -8783,8 +8951,8 @@ async function installSkill(source, skillName) {
     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 parsed2 = await parseSkillMd(sourcePath);
+    const name = parsed2.frontmatter.name;
     const targetPath = join3(skillsDir, name);
     await rm(targetPath, { recursive: true, force: true });
     await cp(sourcePath, targetPath, { recursive: true });
@@ -8834,8 +9002,77 @@ async function findSkillPath(repoPath, skillName) {
     } catch {
     }
   }
+  if (skillName) {
+    const subagentPath = await findClaudeCodeSubagent(repoPath, skillName);
+    if (subagentPath) {
+      return subagentPath;
+    }
+  }
   return null;
 }
+async function findClaudeCodeSubagent(repoPath, skillName) {
+  const searchNames = [
+    `${skillName}.md`,
+    `${skillName.replace(/-/g, "_")}.md`,
+    // Also try without common suffixes
+    skillName.replace(/-pro$/, "-pro.md"),
+    skillName.replace(/-expert$/, "-expert.md")
+  ];
+  for (const fileName of searchNames) {
+    const filePath = join3(repoPath, fileName);
+    try {
+      await access(filePath);
+      const content = await readFile3(filePath, "utf-8");
+      if (content.startsWith("---")) {
+        return await convertClaudeCodeToSkillMd(repoPath, filePath, skillName);
+      }
+    } catch {
+    }
+  }
+  try {
+    const entries = await readdir(repoPath);
+    const mdFiles = entries.filter((e) => e.endsWith(".md") && !e.toLowerCase().includes("readme") && !e.toLowerCase().includes("license"));
+    if (mdFiles.length > 0) {
+      const availableSkills = mdFiles.map((f) => f.replace(".md", "")).join(", ");
+      throw new Error(`Skill "${skillName}" not found. Available: ${availableSkills}`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Available:")) {
+      throw e;
+    }
+  }
+  return null;
+}
+async function convertClaudeCodeToSkillMd(repoPath, filePath, skillName) {
+  const content = await readFile3(filePath, "utf-8");
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    throw new Error("Invalid frontmatter format");
+  }
+  const frontmatter = fmMatch[1];
+  const body = fmMatch[2];
+  const nameMatch = frontmatter.match(/name:\s*(.+)/);
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  const modelMatch = frontmatter.match(/model:\s*(.+)/);
+  const name = nameMatch ? nameMatch[1].trim() : skillName;
+  const description = descMatch ? descMatch[1].trim() : `Skill from Claude Code subagent: ${name}`;
+  const model = modelMatch ? modelMatch[1].trim() : void 0;
+  const tempSkillDir = join3(repoPath, ".converted-skill", name);
+  await mkdir2(tempSkillDir, { recursive: true });
+  let newContent = `---
+name: ${name}
+description: ${description}
+author: claude-code-subagent
+tags: [claude-code, subagent${model ? `, ${model}` : ""}]
+---
+
+# ${name}
+
+${body}
+`;
+  await writeFile2(join3(tempSkillDir, "SKILL.md"), newContent, "utf-8");
+  return tempSkillDir;
+}
 async function listInstalledSkills() {
   const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
   const skills = [];
@@ -8876,800 +9113,141 @@ async function removeSkill(skillName) {
     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");
+async function listGlobalSkills() {
+  const skills = [];
   try {
-    if (existsSync3(summaryPath)) {
-      return JSON.parse(await readFile4(summaryPath, "utf-8"));
+    const entries = await readdir(GLOBAL_SKILLS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const skillPath = join3(GLOBAL_SKILLS_DIR, entry.name);
+      try {
+        const parsed = await parseSkillMd(skillPath);
+        const metaPath = join3(skillPath, ".installed.json");
+        let meta = { installedFrom: "custom", 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 [];
-}
-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
-  };
+  return skills;
 }
-
-// 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;
+async function writeSkillToAllDirs(name, skillMdContent, metadata) {
+  const writtenTo = [];
+  let primaryPath = "";
+  for (const [tool, baseDir] of Object.entries(GLOBAL_SKILLS_DIRS)) {
+    try {
+      await mkdir2(baseDir, { recursive: true });
+      const skillPath = join3(baseDir, name);
+      if (existsSync3(skillPath)) {
+        continue;
+      }
+      await mkdir2(skillPath, { recursive: true });
+      await writeFile2(join3(skillPath, "SKILL.md"), skillMdContent, "utf-8");
+      await writeFile2(join3(skillPath, ".installed.json"), JSON.stringify(metadata, null, 2));
+      writtenTo.push(tool);
+      if (tool === "trie") {
+        primaryPath = skillPath;
+      }
+    } catch {
     }
-    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 (!primaryPath && writtenTo.length > 0) {
+    const firstTool = writtenTo[0];
+    if (firstTool) {
+      primaryPath = join3(GLOBAL_SKILLS_DIRS[firstTool], name);
     }
-    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 [];
   }
+  return { primaryPath, writtenTo };
 }
-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 = "";
+async function createSkillFromFile(filePath, skillName, description) {
   try {
-    if (existsSync4(logPath)) {
-      content = await readFile5(logPath, "utf-8");
-    } else {
-      content = `# Issue Log: ${today}
+    const stats = await stat(filePath);
+    if (!stats.isFile()) {
+      return { success: false, name: "unknown", error: "Path is not a file" };
+    }
+    const content = await readFile3(filePath, "utf-8");
+    if (!content.trim()) {
+      return { success: false, name: "unknown", error: "File is empty" };
+    }
+    const ext = extname2(filePath);
+    const baseFileName = basename2(filePath, ext);
+    const name = skillName || baseFileName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+    const primarySkillPath = join3(GLOBAL_SKILLS_DIR, name);
+    if (existsSync3(primarySkillPath)) {
+      return { success: false, name, error: `Skill "${name}" already exists. Use a different name or remove the existing skill.` };
+    }
+    const skillDescription = description || `Custom skill created from ${basename2(filePath)}`;
+    const skillMdContent = `---
+name: ${name}
+description: ${skillDescription}
+author: custom
+tags: [custom, local]
+---
 
-`;
-    }
-  } catch {
-    content = `# Issue Log: ${today}
+# ${name}
 
+${content}
 `;
-  }
-  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
-      });
+    const metadata = {
+      installedFrom: `file://${filePath}`,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "custom",
+      originalFile: basename2(filePath)
+    };
+    const { primaryPath, writtenTo } = await writeSkillToAllDirs(name, skillMdContent, metadata);
+    if (writtenTo.length === 0) {
+      return { success: false, name, error: "Failed to write skill to any directory" };
     }
+    return {
+      success: true,
+      name,
+      path: primaryPath,
+      writtenTo
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, name: skillName || "unknown", error: message };
   }
-  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 {
+async function removeGlobalSkill(skillName) {
+  let removed = false;
+  for (const baseDir of getAllGlobalSkillDirs()) {
+    const skillPath = join3(baseDir, skillName);
+    try {
+      if (existsSync3(skillPath)) {
+        await rm(skillPath, { recursive: true });
+        removed = true;
       }
+    } 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();
+  return removed;
 }
 
 // src/utils/context-state.ts
+import { readFile as readFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, basename as basename3 } from "path";
 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 statePath = join4(workDir, STATE_JSON_PATH);
   const defaults = getDefaultState();
   try {
-    if (existsSync6(statePath)) {
-      const content = await readFile7(statePath, "utf-8");
+    if (existsSync4(statePath)) {
+      const content = await readFile4(statePath, "utf-8");
       const loaded = JSON.parse(content);
       return {
         ...defaults,
@@ -9683,10 +9261,10 @@ async function loadContextState() {
 }
 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));
+  const trieDir = join4(workDir, ".trie");
+  const statePath = join4(workDir, STATE_JSON_PATH);
+  await mkdir3(trieDir, { recursive: true });
+  await atomicWriteJSON(statePath, state);
 }
 async function updateContextAfterScan(results, filesScanned, contextSignals, duration) {
   const state = await loadContextState();
@@ -9733,7 +9311,7 @@ async function updateContextAfterScan(results, filesScanned, contextSignals, dur
   await saveContextState(state);
   await updateAgentsMd(state);
   if (allIssues.length > 0) {
-    const projectName = basename2(workDir);
+    const projectName = basename3(workDir);
     try {
       await storeIssues(allIssues, projectName, workDir);
       await recordToGlobalMemory(allIssues, projectName, workDir, state.healthScore);
@@ -9744,10 +9322,10 @@ async function updateContextAfterScan(results, filesScanned, contextSignals, dur
 }
 async function updateAgentsMd(state) {
   const workDir = getWorkingDirectory(void 0, true);
-  const mdPath = join7(workDir, AGENTS_MD_PATH);
+  const mdPath = join4(workDir, AGENTS_MD_PATH);
   let content;
   try {
-    content = await readFile7(mdPath, "utf-8");
+    content = await readFile4(mdPath, "utf-8");
   } catch {
     content = getAgentsMdTemplate();
   }
@@ -9762,7 +9340,7 @@ async function updateAgentsMd(state) {
     /Last updated:.*$/m,
     `Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
   );
-  await writeFile6(mdPath, content);
+  await atomicWriteFile(mdPath, content);
 }
 function updateSection(content, sectionName, newContent) {
   const sectionRegex = new RegExp(
@@ -10079,9 +9657,9 @@ async function getContextForAI() {
 }
 
 // src/skills/gating.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join8 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
 import { execSync } from "child_process";
 async function checkSkillRequirements(frontmatter, projectDir) {
   const result = { allowed: true };
@@ -10138,7 +9716,7 @@ async function checkSkillRequirements(frontmatter, projectDir) {
     }
   }
   if (reqs.configFiles && reqs.configFiles.length > 0) {
-    const missing = reqs.configFiles.filter((file) => !existsSync7(join8(projectDir, file)));
+    const missing = reqs.configFiles.filter((file) => !existsSync5(join5(projectDir, file)));
     if (missing.length > 0) {
       result.allowed = false;
       result.missingConfigs = missing;
@@ -10150,11 +9728,11 @@ async function checkSkillRequirements(frontmatter, projectDir) {
 }
 async function getProjectDependencies(projectDir) {
   try {
-    const pkgPath = join8(projectDir, "package.json");
-    if (!existsSync7(pkgPath)) {
+    const pkgPath = join5(projectDir, "package.json");
+    if (!existsSync5(pkgPath)) {
       return /* @__PURE__ */ new Set();
     }
-    const pkg = JSON.parse(await readFile8(pkgPath, "utf-8"));
+    const pkg = JSON.parse(await readFile5(pkgPath, "utf-8"));
     return /* @__PURE__ */ new Set([
       ...Object.keys(pkg.dependencies || {}),
       ...Object.keys(pkg.devDependencies || {})
@@ -10620,8 +10198,8 @@ var CustomSkill = class extends BaseSkill {
 };
 
 // src/skills/built-in/registry.ts
-import { readdir as readdir4, readFile as readFile9 } from "fs/promises";
-import { join as join9 } from "path";
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import { join as join6 } from "path";
 var SkillRegistryImpl = class {
   skills = /* @__PURE__ */ new Map();
   customSkillsLoaded = false;
@@ -10677,14 +10255,14 @@ var SkillRegistryImpl = class {
   async loadCustomSkills() {
     if (this.customSkillsLoaded) return;
     try {
-      const skillsDir = join9(getWorkingDirectory(void 0, true), ".trie", "agents");
-      const files = await readdir4(skillsDir);
+      const skillsDir = join6(getWorkingDirectory(void 0, true), ".trie", "agents");
+      const files = await readdir2(skillsDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       let loadedCount = 0;
       for (const file of jsonFiles) {
         try {
-          const configPath = join9(skillsDir, file);
-          const content = await readFile9(configPath, "utf-8");
+          const configPath = join6(skillsDir, file);
+          const content = await readFile6(configPath, "utf-8");
           const config = JSON.parse(content);
           const skill = new CustomSkill(config);
           this.skills.set(skill.name, skill);
@@ -10855,6 +10433,9 @@ export {
   installSkill,
   listInstalledSkills,
   removeSkill,
+  listGlobalSkills,
+  createSkillFromFile,
+  removeGlobalSkill,
   projectInfoExists,
   loadProjectInfo,
   initProjectInfo,
@@ -10863,18 +10444,6 @@ export {
   appendToSection,
   getProjectSections,
   getProjectInfoStructured,
-  getHistoricalInsights,
-  searchIssues,
-  findSimilarIssues,
-  markIssueResolved,
-  getMemoryStats,
-  getRecentIssues,
-  getDailyLogs,
-  findCrossProjectPatterns,
-  listTrackedProjects,
-  getGlobalMemoryStats,
-  updateGlobalMemoryMd,
-  searchGlobalPatterns,
   loadContextState,
   updateContextAfterScan,
   recordSkillInstalled,
@@ -10882,4 +10451,4 @@ export {
   CustomSkill,
   getSkillRegistry
 };
-//# sourceMappingURL=chunk-S4VGGLXF.js.map
+//# sourceMappingURL=chunk-X2PABPBH.js.map