@triedotdev/mcp 1.0.113 → 1.0.115

package/dist/{chunk-SDS3UVFY.js → chunk-AOFYU6T3.js}

@@ -1,23 +1,34 @@
 import {
-  ContextGraph,
+  getGoalManager
+} from "./chunk-2SIFK7OW.js";
+import {
+  getHypothesisEngine
+} from "./chunk-DZREHOGW.js";
+import {
+  getInsightStore
+} from "./chunk-6LXSA2OZ.js";
+import {
   GotchaPredictor,
   findCrossProjectPatterns,
+  recordToGlobalMemory
+} from "./chunk-D3EXBJE2.js";
+import {
   isAIAvailable,
-  recordToGlobalMemory,
   runAIAnalysis
-} from "./chunk-6QR6QZIX.js";
-import {
-  getGoalManager,
-  getInsightStore
-} from "./chunk-33WL3D7A.js";
+} from "./chunk-SWSK7ANT.js";
 import {
   autoResolveIssues,
-  getGuardianState,
   getHistoricalInsights,
   getIssueHash,
   searchIssues,
   storeIssues
-} from "./chunk-6JPPYG7F.js";
+} from "./chunk-55DOQNHJ.js";
+import {
+  getGuardianState
+} from "./chunk-KRH642MT.js";
+import {
+  ContextGraph
+} from "./chunk-NS2MSZMB.js";
 
 // src/guardian/guardian-agent.ts
 import { basename as basename2 } from "path";
@@ -341,554 +352,6 @@ function getRiskPredictor(projectPath) {
   return predictor;
 }
 
-// src/guardian/hypothesis.ts
-import { dirname as dirname2 } from "path";
-var HYPOTHESIS_TEMPLATES = [
-  {
-    category: "timing",
-    statement: "Issues spike after weekend deployments",
-    testCriteria: "Compare Monday issue counts to other days",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "deployment_data"]
-  },
-  {
-    category: "timing",
-    statement: "Code quality declines on Fridays",
-    testCriteria: "Compare Friday issue introduction rate to weekly average",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps"]
-  },
-  {
-    category: "pattern",
-    statement: "Auth-related code has the highest incident rate",
-    testCriteria: "Compare auth/ issue count to other directories",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files"]
-  },
-  {
-    category: "pattern",
-    statement: "Security issues cluster in specific directories",
-    testCriteria: "Check if security issues are concentrated (>50% in <3 dirs)",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files", "issue_agents"]
-  },
-  {
-    category: "code",
-    statement: "Files with multiple authors have more issues",
-    testCriteria: "Correlate file author count with issue count",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files", "git_blame"]
-  },
-  {
-    category: "code",
-    statement: "Recently modified files are more likely to have issues",
-    testCriteria: "Compare issue rate for recent vs old files",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "file_modification_times"]
-  },
-  {
-    category: "pattern",
-    statement: "Critical issues often come in clusters",
-    testCriteria: "Check temporal clustering of critical issues",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "issue_severities"]
-  }
-];
-var HypothesisEngine = class {
-  projectPath;
-  guardianState;
-  insightStore;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-    this.guardianState = getGuardianState(projectPath);
-    this.insightStore = getInsightStore(projectPath);
-  }
-  /**
-   * Create a new hypothesis
-   */
-  async createHypothesis(statement, options) {
-    const hypothesis = {
-      id: `hyp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      statement,
-      confidence: options?.initialConfidence ?? 0.5,
-      status: "proposed",
-      evidence: [],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      testCriteria: options?.testCriteria,
-      category: options?.category ?? "general"
-    };
-    await this.guardianState.addHypothesis(hypothesis);
-    return hypothesis;
-  }
-  /**
-   * Auto-generate hypotheses based on detected patterns
-   */
-  async autoGenerateHypotheses() {
-    const generated = [];
-    try {
-      await this.guardianState.load();
-      const existing = this.guardianState.getAllHypotheses();
-      const existingStatements = new Set(existing.map((h) => h.statement.toLowerCase()));
-      const issues = await searchIssues("", {
-        workDir: this.projectPath,
-        limit: 500,
-        includeResolved: true
-      });
-      if (issues.length < 10) {
-        return generated;
-      }
-      for (const template of HYPOTHESIS_TEMPLATES) {
-        if (existingStatements.has(template.statement.toLowerCase())) {
-          continue;
-        }
-        const evidence = await this.gatherInitialEvidence(template, issues);
-        if (evidence.length > 0 && evidence[0].weight >= template.minConfidence) {
-          const hypothesis = await this.createHypothesis(template.statement, {
-            category: template.category,
-            testCriteria: template.testCriteria,
-            initialConfidence: evidence[0].weight
-          });
-          for (const e of evidence) {
-            await this.guardianState.addEvidence(hypothesis.id, e);
-          }
-          generated.push(hypothesis);
-          if (generated.length >= 2) break;
-        }
-      }
-    } catch (error) {
-      console.error("Failed to auto-generate hypotheses:", error);
-    }
-    return generated;
-  }
-  /**
-   * Gather initial evidence for a hypothesis template
-   */
-  async gatherInitialEvidence(template, issues) {
-    const evidence = [];
-    switch (template.category) {
-      case "timing":
-        evidence.push(...this.analyzeTimingPatterns(template, issues));
-        break;
-      case "pattern":
-        evidence.push(...this.analyzeLocationPatterns(template, issues));
-        break;
-      case "code":
-        evidence.push(...this.analyzeCodePatterns(template, issues));
-        break;
-    }
-    return evidence;
-  }
-  /**
-   * Analyze timing patterns in issues
-   */
-  analyzeTimingPatterns(template, issues) {
-    const evidence = [];
-    const dayOfWeekCounts = {};
-    for (const { issue } of issues) {
-      const date = new Date(issue.timestamp);
-      const day = date.getDay();
-      dayOfWeekCounts[day] = (dayOfWeekCounts[day] || 0) + 1;
-    }
-    if (template.statement.includes("Friday")) {
-      const fridayCount = dayOfWeekCounts[5] || 0;
-      const avgOtherDays = (Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0) - fridayCount) / 4;
-      if (fridayCount > avgOtherDays * 1.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Friday has ${((fridayCount / avgOtherDays - 1) * 100).toFixed(0)}% more issues than average`,
-          weight: Math.min(0.8, 0.3 + (fridayCount / avgOtherDays - 1) * 0.2),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } else {
-        evidence.push({
-          type: "contradicting",
-          description: "Friday issue count is not significantly higher",
-          weight: 0.3,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (template.statement.includes("weekend") || template.statement.includes("Monday")) {
-      const mondayCount = dayOfWeekCounts[1] || 0;
-      const avgOtherDays = (Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0) - mondayCount) / 4;
-      if (mondayCount > avgOtherDays * 1.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Monday has ${((mondayCount / avgOtherDays - 1) * 100).toFixed(0)}% more issues than average`,
-          weight: Math.min(0.8, 0.3 + (mondayCount / avgOtherDays - 1) * 0.2),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Analyze location patterns in issues
-   */
-  analyzeLocationPatterns(template, issues) {
-    const evidence = [];
-    const dirCounts = {};
-    for (const { issue } of issues) {
-      const dir = dirname2(issue.file);
-      dirCounts[dir] = (dirCounts[dir] || 0) + 1;
-    }
-    const sortedDirs = Object.entries(dirCounts).sort(([, a], [, b]) => b - a);
-    if (template.statement.includes("Auth")) {
-      const authDirs = sortedDirs.filter(
-        ([dir]) => dir.toLowerCase().includes("auth") || dir.toLowerCase().includes("login") || dir.toLowerCase().includes("session")
-      );
-      const authCount = authDirs.reduce((sum, [, count]) => sum + count, 0);
-      const percentage = authCount / issues.length * 100;
-      if (percentage >= 20) {
-        evidence.push({
-          type: "supporting",
-          description: `Auth-related code has ${percentage.toFixed(0)}% of issues`,
-          weight: Math.min(0.85, 0.4 + percentage / 100),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (template.statement.includes("cluster")) {
-      const topThreeDirs = sortedDirs.slice(0, 3);
-      const topThreeCount = topThreeDirs.reduce((sum, [, count]) => sum + count, 0);
-      const percentage = topThreeCount / issues.length * 100;
-      if (percentage >= 50) {
-        evidence.push({
-          type: "supporting",
-          description: `Top 3 directories have ${percentage.toFixed(0)}% of issues`,
-          weight: Math.min(0.8, 0.3 + percentage / 100),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Analyze code patterns
-   */
-  analyzeCodePatterns(template, issues) {
-    const evidence = [];
-    if (template.statement.includes("cluster")) {
-      const criticalIssues = issues.filter((r) => r.issue.severity === "critical");
-      if (criticalIssues.length >= 3) {
-        const timestamps = criticalIssues.map((r) => new Date(r.issue.timestamp).getTime()).sort((a, b) => a - b);
-        let clusteredCount = 0;
-        for (let i = 1; i < timestamps.length; i++) {
-          if (timestamps[i] - timestamps[i - 1] < 24 * 60 * 60 * 1e3) {
-            clusteredCount++;
-          }
-        }
-        const clusterRatio = clusteredCount / (timestamps.length - 1);
-        if (clusterRatio >= 0.5) {
-          evidence.push({
-            type: "supporting",
-            description: `${(clusterRatio * 100).toFixed(0)}% of critical issues occur within 24h of another`,
-            weight: Math.min(0.75, 0.3 + clusterRatio * 0.4),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Update confidence scores based on new data
-   */
-  async updateConfidenceFromOutcomes() {
-    const analyses = [];
-    try {
-      await this.guardianState.load();
-      const activeHypotheses = this.guardianState.getActiveHypotheses();
-      for (const hypothesis of activeHypotheses) {
-        const analysis = await this.analyzeHypothesis(hypothesis);
-        analyses.push(analysis);
-        if (analysis.statusChange && this.insightStore.canCreateInsight("hypothesis-update")) {
-          const insight = this.createHypothesisInsight(analysis);
-          await this.insightStore.addInsight(insight);
-          await this.insightStore.markInsightCreated("hypothesis-update");
-        }
-      }
-      await this.guardianState.updateHypothesisAccuracy();
-    } catch (error) {
-      console.error("Failed to update hypothesis confidence:", error);
-    }
-    return analyses;
-  }
-  /**
-   * Analyze a single hypothesis
-   */
-  async analyzeHypothesis(hypothesis) {
-    const issues = await searchIssues("", {
-      workDir: this.projectPath,
-      limit: 100,
-      includeResolved: false
-    });
-    const template = HYPOTHESIS_TEMPLATES.find(
-      (t) => t.statement.toLowerCase() === hypothesis.statement.toLowerCase()
-    );
-    const recentEvidence = [];
-    if (template) {
-      recentEvidence.push(...await this.gatherInitialEvidence(template, issues));
-    } else {
-      recentEvidence.push(...this.gatherSemanticEvidence(hypothesis, issues));
-    }
-    const oldConfidence = hypothesis.confidence;
-    let newConfidence = oldConfidence;
-    for (const evidence of recentEvidence) {
-      if (evidence.type === "supporting") {
-        newConfidence = Math.min(1, newConfidence + evidence.weight * 0.1);
-      } else {
-        newConfidence = Math.max(0, newConfidence - evidence.weight * 0.1);
-      }
-    }
-    let statusChange;
-    if (newConfidence >= 0.8 && hypothesis.evidence.length >= 3) {
-      statusChange = "validated";
-      await this.guardianState.updateHypothesis(hypothesis.id, {
-        status: "validated",
-        confidence: newConfidence,
-        validatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } else if (newConfidence <= 0.2 && hypothesis.evidence.length >= 3) {
-      statusChange = "invalidated";
-      await this.guardianState.updateHypothesis(hypothesis.id, {
-        status: "invalidated",
-        confidence: newConfidence
-      });
-    } else {
-      await this.guardianState.updateHypothesis(hypothesis.id, {
-        confidence: newConfidence
-      });
-    }
-    for (const evidence of recentEvidence) {
-      await this.guardianState.addEvidence(hypothesis.id, evidence);
-    }
-    const analysis = {
-      hypothesis: { ...hypothesis, confidence: newConfidence },
-      recentEvidence,
-      confidenceChange: newConfidence - oldConfidence,
-      actionRequired: statusChange !== void 0
-    };
-    if (statusChange) {
-      analysis.statusChange = statusChange;
-    }
-    return analysis;
-  }
-  /**
-   * Gather evidence for user-created hypotheses using semantic matching
-   * 
-   * This enables agentic tracking for natural language hypotheses like:
-   * - "Mondays have more bugs than Fridays"
-   * - "Code reviews reduce bug rate"
-   * - "Security issues cluster in auth code"
-   */
-  gatherSemanticEvidence(hypothesis, issues) {
-    const evidence = [];
-    const stmt = hypothesis.statement.toLowerCase();
-    if (stmt.includes("monday") || stmt.includes("friday") || stmt.includes("weekend") || stmt.includes("morning") || stmt.includes("afternoon")) {
-      const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
-      const dayOfWeekCounts = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0 };
-      for (const { issue } of issues) {
-        const date = new Date(issue.timestamp);
-        const day = date.getDay();
-        dayOfWeekCounts[day] = (dayOfWeekCounts[day] || 0) + 1;
-      }
-      const totalIssues = Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0);
-      const avgPerDay = totalIssues / 7;
-      for (let dayIdx = 0; dayIdx < 7; dayIdx++) {
-        const dayName = dayNames[dayIdx];
-        if (stmt.includes(dayName)) {
-          const dayCount = dayOfWeekCounts[dayIdx] || 0;
-          if (stmt.includes("more") || stmt.includes("higher") || stmt.includes("spike")) {
-            if (dayCount > avgPerDay * 1.3) {
-              evidence.push({
-                type: "supporting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has ${dayCount} issues (${((dayCount / avgPerDay - 1) * 100).toFixed(0)}% above average)`,
-                weight: Math.min(0.7, 0.3 + (dayCount / avgPerDay - 1) * 0.3),
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            } else {
-              evidence.push({
-                type: "contradicting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has average or below average issue count`,
-                weight: 0.3,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            }
-          } else if (stmt.includes("fewer") || stmt.includes("less") || stmt.includes("reduce")) {
-            if (dayCount < avgPerDay * 0.7) {
-              evidence.push({
-                type: "supporting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has ${dayCount} issues (${((1 - dayCount / avgPerDay) * 100).toFixed(0)}% below average)`,
-                weight: Math.min(0.7, 0.3 + (1 - dayCount / avgPerDay) * 0.3),
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            }
-          }
-        }
-      }
-    }
-    if (stmt.includes("review") || stmt.includes("pr") || stmt.includes("pull request")) {
-      const recentIssues = issues.slice(0, 30);
-      const olderIssues = issues.slice(30);
-      if (recentIssues.length >= 10 && olderIssues.length >= 10) {
-        const recentRate = recentIssues.length;
-        const olderRate = olderIssues.length;
-        if (stmt.includes("reduce") || stmt.includes("fewer") || stmt.includes("less")) {
-          if (recentRate < olderRate) {
-            evidence.push({
-              type: "supporting",
-              description: `Recent period has ${((1 - recentRate / olderRate) * 100).toFixed(0)}% fewer issues`,
-              weight: Math.min(0.6, 0.3 + (1 - recentRate / olderRate) * 0.3),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } else {
-            evidence.push({
-              type: "contradicting",
-              description: `Issue rate has not decreased recently`,
-              weight: 0.2,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-    }
-    if (stmt.includes("cluster") || stmt.includes("concentrate") || stmt.includes("auth") || stmt.includes("specific") || stmt.includes("certain files")) {
-      const dirCounts = {};
-      for (const { issue } of issues) {
-        const dir = dirname2(issue.file);
-        dirCounts[dir] = (dirCounts[dir] || 0) + 1;
-      }
-      const sortedDirs = Object.entries(dirCounts).sort(([, a], [, b]) => b - a);
-      const topThreeCount = sortedDirs.slice(0, 3).reduce((sum, [, count]) => sum + count, 0);
-      const totalCount = issues.length;
-      const concentration = topThreeCount / totalCount;
-      if (concentration >= 0.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Top 3 directories have ${(concentration * 100).toFixed(0)}% of issues (concentrated)`,
-          weight: Math.min(0.7, 0.3 + concentration * 0.4),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } else {
-        evidence.push({
-          type: "contradicting",
-          description: `Issues are distributed across many directories`,
-          weight: 0.3,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (stmt.includes("critical") || stmt.includes("security") || stmt.includes("severity")) {
-      const criticalCount = issues.filter((r) => r.issue.severity === "critical").length;
-      const seriousCount = issues.filter((r) => r.issue.severity === "serious").length;
-      const highSeverityRatio = (criticalCount + seriousCount) / issues.length;
-      if (stmt.includes("increase") || stmt.includes("more") || stmt.includes("rise")) {
-        if (highSeverityRatio > 0.3) {
-          evidence.push({
-            type: "supporting",
-            description: `${(highSeverityRatio * 100).toFixed(0)}% of issues are high severity`,
-            weight: Math.min(0.7, 0.3 + highSeverityRatio),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      } else if (stmt.includes("decrease") || stmt.includes("fewer") || stmt.includes("reduce")) {
-        if (highSeverityRatio < 0.2) {
-          evidence.push({
-            type: "supporting",
-            description: `Only ${(highSeverityRatio * 100).toFixed(0)}% of issues are high severity`,
-            weight: 0.5,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      }
-    }
-    const agents = ["security", "performance", "accessibility", "test", "typecheck", "bug-finding"];
-    for (const agent of agents) {
-      if (stmt.includes(agent) || stmt.includes(agent.replace("-", " "))) {
-        const agentIssues = issues.filter((r) => r.issue.agent === agent);
-        const agentRatio = agentIssues.length / issues.length;
-        if (stmt.includes("most") || stmt.includes("majority") || stmt.includes("main")) {
-          if (agentRatio > 0.4) {
-            evidence.push({
-              type: "supporting",
-              description: `${agent} accounts for ${(agentRatio * 100).toFixed(0)}% of issues`,
-              weight: Math.min(0.7, 0.3 + agentRatio),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } else {
-            evidence.push({
-              type: "contradicting",
-              description: `${agent} only accounts for ${(agentRatio * 100).toFixed(0)}% of issues`,
-              weight: 0.3,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Create an insight for hypothesis status change
-   */
-  createHypothesisInsight(analysis) {
-    const isValidated = analysis.statusChange === "validated";
-    return {
-      id: `insight-hyp-${analysis.hypothesis.id}`,
-      type: isValidated ? "celebration" : "observation",
-      message: isValidated ? `Hypothesis confirmed: "${analysis.hypothesis.statement}"` : `Hypothesis disproven: "${analysis.hypothesis.statement}"`,
-      context: `Confidence: ${(analysis.hypothesis.confidence * 100).toFixed(0)}%. ${analysis.recentEvidence.length} evidence points analyzed.`,
-      relatedIssues: [],
-      priority: 5,
-      timestamp: Date.now(),
-      dismissed: false,
-      category: "pattern",
-      details: {
-        examples: analysis.recentEvidence.map((e) => `${e.type}: ${e.description}`)
-      }
-    };
-  }
-  /**
-   * Get hypothesis by ID
-   */
-  async getHypothesis(hypothesisId) {
-    await this.guardianState.load();
-    return this.guardianState.getHypothesis(hypothesisId);
-  }
-  /**
-   * Get all hypotheses
-   */
-  async getAllHypotheses() {
-    await this.guardianState.load();
-    return this.guardianState.getAllHypotheses();
-  }
-  /**
-   * Get validated hypotheses
-   */
-  async getValidatedHypotheses() {
-    await this.guardianState.load();
-    return this.guardianState.getValidatedHypotheses();
-  }
-  /**
-   * Get hypothesis accuracy stats
-   */
-  getAccuracy() {
-    const metrics = this.guardianState.getMetrics();
-    return metrics.hypothesisAccuracy;
-  }
-};
-var hypothesisEngines = /* @__PURE__ */ new Map();
-function getHypothesisEngine(projectPath) {
-  let engine = hypothesisEngines.get(projectPath);
-  if (!engine) {
-    engine = new HypothesisEngine(projectPath);
-    hypothesisEngines.set(projectPath, engine);
-  }
-  return engine;
-}
-
 // src/integrations/slack.ts
 var SlackIntegration = class {
   constructor(config) {
@@ -2164,6 +1627,97 @@ var GuardianAgent = class {
       await this.addInsight(insight);
       await this.markInsightCreated("celebration");
     }
+    if (issues.length >= 10 && this.canCreateInsight("hypothesis-generation")) {
+      try {
+        const patterns = [];
+        const observations = [];
+        if (newIssues.length > issues.length * 0.3) {
+          observations.push(`High new issue rate: ${newIssues.length} new out of ${issues.length} total`);
+        }
+        const fileFreq = {};
+        for (const issue of issues) {
+          fileFreq[issue.file] = (fileFreq[issue.file] || 0) + 1;
+        }
+        const hotFiles = Object.entries(fileFreq).filter(([, count]) => count >= 3);
+        if (hotFiles.length > 0) {
+          patterns.push(`Hotspot files: ${hotFiles.map(([f]) => basename2(f)).join(", ")}`);
+        }
+        const generated = await this.hypothesisEngine.generateHypothesesWithAI({
+          recentIssues: issues.map((i) => ({ issue: i, score: 1 })),
+          patterns,
+          observations
+        });
+        for (const hypothesis of generated) {
+          const insight = this.createInsight({
+            type: "observation",
+            message: `${this.pick(PERSONALITY.questions)} New hypothesis to test: "${hypothesis.statement}"`,
+            context: `Confidence: ${Math.round(hypothesis.confidence * 100)}%`,
+            suggestedAction: `Monitor this pattern over time`,
+            priority: 4,
+            category: "pattern",
+            details: {
+              hypothesis: hypothesis.statement,
+              testCriteria: hypothesis.testCriteria || "Collecting evidence...",
+              confidence: Math.round(hypothesis.confidence * 100)
+            }
+          });
+          newInsights.push(insight);
+          await this.addInsight(insight);
+        }
+        if (generated.length > 0) {
+          await this.markInsightCreated("hypothesis-generation");
+        }
+      } catch (error) {
+      }
+    }
+    if (issues.length >= 5 && this.canCreateInsight("pattern-discovery")) {
+      try {
+        const { IncidentIndex } = await import("./incident-index-PNIVT47T.js");
+        const { TriePatternDiscovery } = await import("./pattern-discovery-F7LU5K6E.js");
+        const { ContextGraph: ContextGraph2 } = await import("./graph-U5JWSAB5.js");
+        const graph = new ContextGraph2(this.projectPath);
+        const incidentIndex = await IncidentIndex.build(graph, this.projectPath);
+        const discovery = new TriePatternDiscovery(graph, incidentIndex);
+        const hotPatterns = discovery.discoverHotPatterns(2);
+        let patternsAdded = 0;
+        for (const hot of hotPatterns.slice(0, 5)) {
+          const existingPatterns = await graph.listNodes();
+          const alreadyExists = existingPatterns.some(
+            (n) => n.type === "pattern" && n.data.description?.includes(hot.path)
+          );
+          if (!alreadyExists) {
+            await graph.addNode("pattern", {
+              description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
+              appliesTo: [hot.path],
+              confidence: Math.min(0.95, hot.confidence),
+              occurrences: hot.incidentCount,
+              firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              isAntiPattern: hot.incidentCount >= 3,
+              source: "local"
+            });
+            patternsAdded++;
+          }
+        }
+        if (patternsAdded > 0) {
+          const insight = this.createInsight({
+            type: "observation",
+            message: `${this.pick(PERSONALITY.greetings)} Discovered ${patternsAdded} pattern${patternsAdded > 1 ? "s" : ""} in your codebase.`,
+            suggestedAction: `Check Memory \u2192 Learned Patterns to see`,
+            priority: 5,
+            category: "pattern",
+            details: {
+              patternsCount: patternsAdded,
+              topPattern: hotPatterns[0]?.path
+            }
+          });
+          newInsights.push(insight);
+          await this.addInsight(insight);
+          await this.markInsightCreated("pattern-discovery");
+        }
+      } catch (error) {
+      }
+    }
     if (this.canCreateInsight("pattern-suggestion")) {
       try {
         const globalPatterns = await findCrossProjectPatterns();
@@ -2356,7 +1910,7 @@ var GuardianAgent = class {
     await this.guardianState.recordScan();
     try {
       const riskLevel = issues.filter((i) => i.severity === "critical").length > 0 ? "critical" : issues.filter((i) => i.severity === "serious").length >= 3 ? "high" : issues.length > 10 ? "medium" : "low";
-      const { calculateAdaptiveScanFrequency } = await import("./goal-manager-AP4LTE6U.js");
+      const { calculateAdaptiveScanFrequency } = await import("./goal-manager-LMS6ZJB7.js");
       const result = await calculateAdaptiveScanFrequency(riskLevel);
       await this.guardianState.setScanFrequency(result.frequencyMs);
     } catch {
@@ -2589,4 +2143,4 @@ export {
   GuardianAgent,
   getGuardian
 };
-//# sourceMappingURL=chunk-SDS3UVFY.js.map
+//# sourceMappingURL=chunk-AOFYU6T3.js.map