@triedotdev/mcp 1.0.44 → 1.0.46

package/dist/{chunk-2I6CFJTR.js → chunk-5AS3BWAZ.js}

@@ -1,11 +1,15 @@
 import {
-  CustomAgent,
+  CustomSkill,
   getAgentRegistry
-} from "./chunk-GBGONSOR.js";
+} from "./chunk-R5HWHP5N.js";
 import {
+  getGlobalMemoryStats,
+  getHistoricalInsights,
+  getMemoryStats,
+  getRecentIssues,
   loadContextState,
   updateContextAfterScan
-} from "./chunk-52SSNKXS.js";
+} from "./chunk-PZDQIFKO.js";
 import {
   ProgressReporter
 } from "./chunk-OB45V2QC.js";
@@ -658,8 +662,9 @@ var RiskAssessor = class {
 var Triager = class {
   agentRegistry = getAgentRegistry();
   config;
-  customAgentsLoaded = false;
+  customSkillsLoaded = false;
   contextState = null;
+  memoryInsights = null;
   constructor(config) {
     this.config = {
       minConfidence: 0.15,
@@ -683,17 +688,67 @@ var Triager = class {
     }
   }
   /**
-   * Ensure custom agents are loaded before triaging
+   * Load memory insights for memory-influenced triaging
    */
-  async ensureCustomAgentsLoaded() {
-    if (!this.customAgentsLoaded) {
-      await this.agentRegistry.loadCustomAgents();
-      this.customAgentsLoaded = true;
+  async loadMemoryInsights() {
+    if (this.memoryInsights !== null) return;
+    try {
+      const [stats, recent, historical, global] = await Promise.all([
+        getMemoryStats().catch(() => null),
+        getRecentIssues(20).catch(() => []),
+        getHistoricalInsights(process.cwd()).catch(() => null),
+        getGlobalMemoryStats().catch(() => null)
+      ]);
+      const recentAgents = /* @__PURE__ */ new Set();
+      for (const issue of recent) {
+        recentAgents.add(issue.agent);
+      }
+      const recurringPatternAgents = /* @__PURE__ */ new Set();
+      if (historical?.recurringPatterns) {
+        for (const pattern of historical.recurringPatterns) {
+          recurringPatternAgents.add(pattern.agent);
+        }
+      }
+      const crossProjectAgents = /* @__PURE__ */ new Set();
+      if (global?.patternsByAgent) {
+        for (const [agent, count] of Object.entries(global.patternsByAgent)) {
+          if (count >= 2) {
+            crossProjectAgents.add(agent);
+          }
+        }
+      }
+      this.memoryInsights = {
+        issuesByAgent: stats?.issuesByAgent || {},
+        recentAgents,
+        recurringPatternAgents,
+        trend: historical?.improvementTrend || "unknown",
+        crossProjectAgents
+      };
+    } catch {
+      this.memoryInsights = {
+        issuesByAgent: {},
+        recentAgents: /* @__PURE__ */ new Set(),
+        recurringPatternAgents: /* @__PURE__ */ new Set(),
+        trend: "unknown",
+        crossProjectAgents: /* @__PURE__ */ new Set()
+      };
+    }
+  }
+  /**
+   * Ensure custom skills are loaded before triaging
+   */
+  async ensureCustomSkillsLoaded() {
+    if (!this.customSkillsLoaded) {
+      await this.agentRegistry.loadCustomSkills();
+      this.customSkillsLoaded = true;
     }
   }
   async selectAgents(context, riskLevel) {
-    await this.ensureCustomAgentsLoaded();
-    await this.loadPreviousContext();
+    await this.ensureCustomSkillsLoaded();
+    await Promise.all([
+      this.loadPreviousContext(),
+      this.loadMemoryInsights()
+    ]);
     let effectiveRiskLevel = riskLevel;
     if (this.contextState?.healthScore !== void 0 && this.contextState.healthScore < 50) {
       if (riskLevel === "low" || riskLevel === "medium") {
@@ -707,6 +762,7 @@ var Triager = class {
     }
     const scores = this.scoreAgents(context, effectiveRiskLevel);
     this.boostAgentsWithHistory(scores);
+    this.boostAgentsWithMemory(scores);
     this.logAgentScoring(scores);
     const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
     qualified.sort((a, b) => {
@@ -732,6 +788,40 @@ var Triager = class {
       }
     }
   }
+  /**
+   * Boost confidence for agents based on memory patterns
+   */
+  boostAgentsWithMemory(scores) {
+    if (!this.memoryInsights) return;
+    for (const score of scores) {
+      const agentName = score.agent.name;
+      const historicalCount = this.memoryInsights.issuesByAgent[agentName] || 0;
+      if (historicalCount >= 10) {
+        const boost = Math.min(0.2, historicalCount * 0.01);
+        score.confidence = Math.min(1, score.confidence + boost);
+        score.reasons.push(`${historicalCount} historical issues`);
+      }
+      if (this.memoryInsights.recentAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.1);
+        score.reasons.push("recent activity");
+      }
+      if (this.memoryInsights.recurringPatternAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.15);
+        score.reasons.push("recurring patterns");
+      }
+      if (this.memoryInsights.crossProjectAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.1);
+        score.reasons.push("cross-project pattern");
+      }
+    }
+    if (this.memoryInsights.trend === "declining") {
+      for (const score of scores) {
+        if (score.confidence > 0) {
+          score.confidence = Math.min(1, score.confidence + 0.05);
+        }
+      }
+    }
+  }
   scoreAgents(context, riskLevel) {
     const allAgents = this.getAllAgents();
     const scores = [];
@@ -742,19 +832,19 @@ var Triager = class {
     return scores;
   }
   scoreAgent(agent, context, riskLevel) {
-    if (agent instanceof CustomAgent) {
-      return this.scoreCustomAgent(agent, context, riskLevel);
+    if (agent instanceof CustomSkill) {
+      return this.scoreCustomSkill(agent, context, riskLevel);
     }
     return this.scoreBuiltinAgent(agent, context, riskLevel);
   }
   /**
-   * Score custom agents using their activation rules
+   * Score custom skills using their activation rules
    */
-  scoreCustomAgent(agent, context, riskLevel) {
+  scoreCustomSkill(agent, context, riskLevel) {
     const reasons = [];
     let confidence = agent.getActivationConfidence(context);
     if (confidence > 0) {
-      reasons.push(`custom agent: ${agent.getMetadata().category}`);
+      reasons.push(`custom skill: ${agent.getMetadata().category}`);
       const meta = agent.getMetadata();
       if (meta.patternCount > 0) {
         reasons.push(`${meta.patternCount} detection patterns`);
@@ -1169,13 +1259,13 @@ var Triager = class {
     return `${riskLevel} risk: ${reasons.join(", ")}`;
   }
   async getSkippedAgents(context, riskLevel) {
-    await this.ensureCustomAgentsLoaded();
+    await this.ensureCustomSkillsLoaded();
     if (riskLevel === "critical") return [];
     const scores = this.scoreAgents(context, riskLevel);
     return scores.filter((s) => s.confidence < this.config.minConfidence).map((s) => s.agent.name);
   }
   async getTriagingConfidence(context, riskLevel) {
-    await this.ensureCustomAgentsLoaded();
+    await this.ensureCustomSkillsLoaded();
     const scores = this.scoreAgents(context, riskLevel);
     const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
     if (qualified.length === 0) return 0.5;
@@ -1207,16 +1297,24 @@ var Triager = class {
     return this.agentRegistry.getAllAgents();
   }
   /**
-   * Get custom agents count
+   * Get custom skills count
    */
+  getCustomSkillCount() {
+    return this.agentRegistry.getCustomSkills().length;
+  }
+  // Backward compatibility alias
   getCustomAgentCount() {
-    return this.agentRegistry.getCustomAgents().length;
+    return this.getCustomSkillCount();
   }
   /**
-   * Reload custom agents
+   * Reload custom skills
    */
+  async reloadCustomSkills() {
+    await this.agentRegistry.reloadCustomSkills();
+  }
+  // Backward compatibility alias
   async reloadCustomAgents() {
-    await this.agentRegistry.reloadCustomAgents();
+    return this.reloadCustomSkills();
   }
 };
 
@@ -5840,14 +5938,14 @@ var TrieScanTool = class {
   agentRegistry = getAgentRegistry();
   incrementalScanner = null;
   progress = new ProgressReporter();
-  customAgentsLoaded = false;
+  customSkillsLoaded = false;
   /**
-   * Ensure custom agents are loaded before using the registry
+   * Ensure custom skills are loaded before using the registry
    */
-  async ensureCustomAgentsLoaded() {
-    if (!this.customAgentsLoaded) {
-      await this.agentRegistry.loadCustomAgents();
-      this.customAgentsLoaded = true;
+  async ensureCustomSkillsLoaded() {
+    if (!this.customSkillsLoaded) {
+      await this.agentRegistry.loadCustomSkills();
+      this.customSkillsLoaded = true;
     }
   }
   async execute(args) {
@@ -5948,7 +6046,7 @@ var TrieScanTool = class {
       const riskLevel = this.riskAssessor.assessRisk(context);
       this.logRiskAssessment(context, riskLevel);
       this.progress.startPhase("ai-review", "Selecting AI agents...");
-      await this.ensureCustomAgentsLoaded();
+      await this.ensureCustomSkillsLoaded();
       let selectedAgents = forceAgents ? this.agentRegistry.getAgentsByNames(forceAgents) : await this.triager.selectAgents(context, riskLevel);
       if (excludeAgents.size > 0) {
         const before = selectedAgents.length;
@@ -6560,4 +6658,4 @@ export {
   loadConfig,
   TrieScanTool
 };
-//# sourceMappingURL=chunk-2I6CFJTR.js.map
+//# sourceMappingURL=chunk-5AS3BWAZ.js.map