@triedotdev/mcp 1.0.62 → 1.0.64

package/dist/chunk-PBOVCPKE.js

@@ -0,0 +1,2566 @@
+import {
+  getGoalManager,
+  getInsightStore
+} from "./chunk-D3DMONAJ.js";
+import {
+  getGuardianState
+} from "./chunk-4YSLDGBL.js";
+import {
+  findCrossProjectPatterns,
+  recordToGlobalMemory
+} from "./chunk-7KHT2NKR.js";
+import {
+  isAIAvailable,
+  runAIAnalysis
+} from "./chunk-AQCAMIQQ.js";
+import {
+  getHistoricalInsights,
+  searchIssues,
+  storeIssues
+} from "./chunk-TSHZQKCM.js";
+
+// src/guardian/guardian-agent.ts
+import { basename as basename2 } from "path";
+
+// src/guardian/risk-predictor.ts
+import { basename, dirname } from "path";
+var DEFAULT_CONFIG = {
+  historyDays: 30,
+  incidentThreshold: 3,
+  riskWeights: {
+    incidentCount: 0.35,
+    recency: 0.25,
+    severity: 0.2,
+    complexity: 0.1,
+    churn: 0.1
+  }
+};
+var RiskPredictor = class {
+  projectPath;
+  config;
+  insightStore;
+  constructor(projectPath, config = {}) {
+    this.projectPath = projectPath;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.insightStore = getInsightStore(projectPath);
+  }
+  /**
+   * Calculate risk for a specific file or directory
+   */
+  async calculateRisk(target) {
+    const factors = [];
+    let totalRisk = 0;
+    try {
+      const issues = await searchIssues(target, {
+        workDir: this.projectPath,
+        limit: 500,
+        includeResolved: true
+      });
+      const targetIssues = issues.filter(
+        (r) => r.issue.file === target || r.issue.file.startsWith(target + "/") || dirname(r.issue.file) === target
+      );
+      const incidentCount = targetIssues.length;
+      const incidentWeight = this.config.riskWeights.incidentCount;
+      const incidentScore = Math.min(100, incidentCount * 10);
+      factors.push({
+        name: "Incident Count",
+        weight: incidentWeight,
+        value: incidentCount,
+        description: `${incidentCount} historical incidents`,
+        trend: this.calculateTrend(targetIssues.map((i) => i.issue))
+      });
+      totalRisk += incidentScore * incidentWeight;
+      let recencyScore = 0;
+      let lastIncidentDaysAgo;
+      if (targetIssues.length > 0) {
+        const latestIssue = targetIssues.sort((a, b) => new Date(b.issue.timestamp).getTime() - new Date(a.issue.timestamp).getTime())[0];
+        if (latestIssue) {
+          const daysSince = (Date.now() - new Date(latestIssue.issue.timestamp).getTime()) / (1e3 * 60 * 60 * 24);
+          lastIncidentDaysAgo = Math.floor(daysSince);
+          if (daysSince < 1) recencyScore = 100;
+          else if (daysSince < 7) recencyScore = 80;
+          else if (daysSince < 14) recencyScore = 60;
+          else if (daysSince < 30) recencyScore = 40;
+          else recencyScore = 20;
+        }
+      }
+      factors.push({
+        name: "Recency",
+        weight: this.config.riskWeights.recency,
+        value: lastIncidentDaysAgo ?? 999,
+        description: lastIncidentDaysAgo !== void 0 ? `Last incident ${lastIncidentDaysAgo} days ago` : "No recent incidents"
+      });
+      totalRisk += recencyScore * this.config.riskWeights.recency;
+      const criticalCount = targetIssues.filter((r) => r.issue.severity === "critical").length;
+      const seriousCount = targetIssues.filter((r) => r.issue.severity === "serious").length;
+      const severityScore = Math.min(100, criticalCount * 25 + seriousCount * 10);
+      factors.push({
+        name: "Severity",
+        weight: this.config.riskWeights.severity,
+        value: severityScore,
+        description: `${criticalCount} critical, ${seriousCount} serious`
+      });
+      totalRisk += severityScore * this.config.riskWeights.severity;
+      const uniqueAgents = new Set(targetIssues.map((r) => r.issue.agent)).size;
+      const complexityScore = Math.min(100, uniqueAgents * 20);
+      factors.push({
+        name: "Complexity",
+        weight: this.config.riskWeights.complexity,
+        value: uniqueAgents,
+        description: `Issues from ${uniqueAgents} different analysis types`
+      });
+      totalRisk += complexityScore * this.config.riskWeights.complexity;
+      const uniqueDates = new Set(
+        targetIssues.map((r) => r.issue.timestamp.split("T")[0])
+      ).size;
+      const churnScore = Math.min(100, uniqueDates * 10);
+      factors.push({
+        name: "Churn",
+        weight: this.config.riskWeights.churn,
+        value: uniqueDates,
+        description: `Issues found on ${uniqueDates} different days`
+      });
+      totalRisk += churnScore * this.config.riskWeights.churn;
+      const trend = this.calculateTrend(targetIssues.map((i) => i.issue));
+      let predictedRisk = totalRisk;
+      if (trend === "increasing") {
+        predictedRisk = Math.min(100, totalRisk * 1.2);
+      } else if (trend === "decreasing") {
+        predictedRisk = Math.max(0, totalRisk * 0.8);
+      }
+      const recommendations = this.generateRecommendations(factors, totalRisk);
+      const confidence = Math.min(0.95, 0.3 + incidentCount * 0.05);
+      const prediction = {
+        target,
+        currentRisk: Math.round(totalRisk),
+        predictedRisk: Math.round(predictedRisk),
+        trend,
+        factors,
+        confidence,
+        recommendations,
+        incidentCount
+      };
+      if (lastIncidentDaysAgo !== void 0) {
+        prediction.lastIncidentDaysAgo = lastIncidentDaysAgo;
+      }
+      return prediction;
+    } catch (error) {
+      console.error(`Failed to calculate risk for ${target}:`, error);
+      return {
+        target,
+        currentRisk: 50,
+        predictedRisk: 50,
+        trend: "stable",
+        factors: [],
+        confidence: 0.1,
+        recommendations: ["Unable to analyze - insufficient data"],
+        incidentCount: 0
+      };
+    }
+  }
+  /**
+   * Calculate trend from issues
+   */
+  calculateTrend(issues) {
+    if (issues.length < 3) return "stable";
+    const now = Date.now();
+    const recentCutoff = now - 7 * 24 * 60 * 60 * 1e3;
+    const olderCutoff = now - 30 * 24 * 60 * 60 * 1e3;
+    const recentIssues = issues.filter((i) => new Date(i.timestamp).getTime() > recentCutoff).length;
+    const olderIssues = issues.filter((i) => {
+      const time = new Date(i.timestamp).getTime();
+      return time > olderCutoff && time <= recentCutoff;
+    }).length;
+    const recentRate = recentIssues / 7;
+    const olderRate = olderIssues / 23;
+    if (recentRate > olderRate * 1.5) return "increasing";
+    if (recentRate < olderRate * 0.5) return "decreasing";
+    return "stable";
+  }
+  /**
+   * Generate recommendations based on risk factors
+   */
+  generateRecommendations(factors, totalRisk) {
+    const recommendations = [];
+    if (totalRisk >= 70) {
+      recommendations.push("Consider extra code review before merging changes");
+    }
+    const incidentFactor = factors.find((f) => f.name === "Incident Count");
+    if (incidentFactor && incidentFactor.value >= 5) {
+      recommendations.push("This area has recurring issues - consider refactoring");
+    }
+    const recencyFactor = factors.find((f) => f.name === "Recency");
+    if (recencyFactor && recencyFactor.value < 7) {
+      recommendations.push("Recent incident activity - monitor closely");
+    }
+    const severityFactor = factors.find((f) => f.name === "Severity");
+    if (severityFactor && severityFactor.value >= 25) {
+      recommendations.push("High severity issues present - prioritize fixes");
+    }
+    const complexityFactor = factors.find((f) => f.name === "Complexity");
+    if (complexityFactor && complexityFactor.value >= 4) {
+      recommendations.push("Multiple issue types - consider comprehensive review");
+    }
+    if (recommendations.length === 0) {
+      recommendations.push("No specific concerns - maintain normal review process");
+    }
+    return recommendations;
+  }
+  /**
+   * Predict risk trend for files that have recently changed
+   */
+  async predictRiskTrend(changedFiles) {
+    const predictions = await Promise.all(
+      changedFiles.map((f) => this.calculateRisk(f))
+    );
+    const highRiskFiles = predictions.filter((p) => p.currentRisk >= 50);
+    const totalRisk = predictions.reduce((sum, p) => sum + p.currentRisk, 0) / Math.max(1, predictions.length);
+    const trends = predictions.map((p) => p.trend);
+    const increasingCount = trends.filter((t) => t === "increasing").length;
+    const decreasingCount = trends.filter((t) => t === "decreasing").length;
+    let overallTrend = "stable";
+    if (increasingCount > decreasingCount + 1) {
+      overallTrend = "increasing";
+    } else if (decreasingCount > increasingCount + 1) {
+      overallTrend = "decreasing";
+    }
+    const factors = highRiskFiles.map((p) => ({
+      file: p.target,
+      reasons: p.incidentCount > 0 ? ["past incidents", ...p.recommendations.slice(0, 2)] : ["no historical data"]
+    }));
+    return {
+      trend: overallTrend,
+      factors,
+      overallRisk: Math.round(totalRisk)
+    };
+  }
+  /**
+   * Get project-wide risk summary
+   */
+  async getProjectRiskSummary() {
+    try {
+      const issues = await searchIssues("", {
+        workDir: this.projectPath,
+        limit: 1e3,
+        includeResolved: true
+      });
+      const dirIssueCount = /* @__PURE__ */ new Map();
+      for (const { issue } of issues) {
+        const dir = dirname(issue.file);
+        const existing = dirIssueCount.get(dir) || [];
+        existing.push(issue);
+        dirIssueCount.set(dir, existing);
+      }
+      const hotspotDirs = [...dirIssueCount.entries()].filter(([_, issues2]) => issues2.length >= this.config.incidentThreshold).sort((a, b) => b[1].length - a[1].length).slice(0, 5);
+      const hotspots = await Promise.all(
+        hotspotDirs.map(([dir]) => this.calculateRisk(dir))
+      );
+      const allDirs = [...dirIssueCount.keys()];
+      const lowRiskPredictions = await Promise.all(
+        allDirs.map((dir) => this.calculateRisk(dir))
+      );
+      const lowRiskAreas = lowRiskPredictions.filter((p) => p.currentRisk < 20 && p.incidentCount === 0).map((p) => p.target).slice(0, 5);
+      const overallRisk = hotspots.length > 0 ? hotspots.reduce((sum, p) => sum + p.currentRisk, 0) / hotspots.length : 0;
+      const trends = hotspots.map((p) => p.trend);
+      const increasingCount = trends.filter((t) => t === "increasing").length;
+      const decreasingCount = trends.filter((t) => t === "decreasing").length;
+      let trend = "stable";
+      if (increasingCount > decreasingCount) {
+        trend = "increasing";
+      } else if (decreasingCount > increasingCount) {
+        trend = "decreasing";
+      }
+      const confidence = Math.min(0.9, 0.4 + issues.length * 1e-3);
+      return {
+        overallRisk: Math.round(overallRisk),
+        trend,
+        hotspots,
+        lowRiskAreas,
+        predictions: hotspots,
+        confidence
+      };
+    } catch (error) {
+      console.error("Failed to get project risk summary:", error);
+      return {
+        overallRisk: 0,
+        trend: "stable",
+        hotspots: [],
+        lowRiskAreas: [],
+        predictions: [],
+        confidence: 0.1
+      };
+    }
+  }
+  /**
+   * Create risk prediction insight
+   */
+  async generateRiskInsight() {
+    if (!this.insightStore.canCreateInsight("risk-prediction")) {
+      return null;
+    }
+    const summary = await this.getProjectRiskSummary();
+    if (summary.hotspots.length === 0 || summary.overallRisk < 30) {
+      return null;
+    }
+    const topHotspot = summary.hotspots[0];
+    if (!topHotspot) return null;
+    const trendMap = {
+      "increasing": "worsening",
+      "stable": "stable",
+      "decreasing": "improving"
+    };
+    const insight = {
+      id: `insight-risk-${Date.now()}`,
+      type: "warning",
+      message: `\u26A0\uFE0F ${basename(topHotspot.target)}/ has elevated risk (${topHotspot.currentRisk}/100)`,
+      context: `${topHotspot.incidentCount} past incidents. ${topHotspot.recommendations[0]}`,
+      suggestedAction: "Request extra review before merging changes to this area",
+      relatedIssues: [],
+      priority: Math.min(9, 5 + Math.floor(topHotspot.currentRisk / 20)),
+      timestamp: Date.now(),
+      dismissed: false,
+      category: "security",
+      details: {
+        affectedFiles: summary.hotspots.map((h) => basename(h.target)),
+        trend: trendMap[summary.trend],
+        examples: topHotspot.recommendations
+      }
+    };
+    await this.insightStore.addInsight(insight);
+    await this.insightStore.markInsightCreated("risk-prediction");
+    return insight;
+  }
+};
+var riskPredictors = /* @__PURE__ */ new Map();
+function getRiskPredictor(projectPath) {
+  let predictor = riskPredictors.get(projectPath);
+  if (!predictor) {
+    predictor = new RiskPredictor(projectPath);
+    riskPredictors.set(projectPath, predictor);
+  }
+  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 ? `\u{1F52E} Hypothesis confirmed: "${analysis.hypothesis.statement}"` : `\u274C 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) {
+    this.config = config;
+  }
+  /**
+   * Send scan completion notification
+   */
+  async sendScanNotification(_issues, priorityReport, repositoryName, branch = "main") {
+    const { urgent, high, medium, low } = priorityReport;
+    const emoji = urgent.length > 0 ? "\u{1F6A8}" : high.length > 0 ? "\u26A0\uFE0F" : "\u2705";
+    const message = {
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `${emoji} *Trie Security Scan Complete*
+*Repository:* ${repositoryName} (${branch})`
+          }
+        },
+        {
+          type: "section",
+          fields: [
+            {
+              type: "mrkdwn",
+              text: `*\u{1F6A8} Urgent:* ${urgent.length}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u26A0\uFE0F High:* ${high.length}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u{1F538} Medium:* ${medium.length}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u{1F539} Low:* ${low.length}`
+            }
+          ]
+        }
+      ],
+      attachments: []
+    };
+    if (urgent.length > 0) {
+      const urgentDetails = urgent.slice(0, 5).map(
+        (group) => `\u2022 ${group.description} (${group.count} instances)`
+      ).join("\n");
+      message.attachments.push({
+        color: "danger",
+        title: "\u{1F6A8} Urgent Issues - Immediate Action Required",
+        text: urgentDetails,
+        footer: urgent.length > 5 ? `... and ${urgent.length - 5} more urgent issues` : void 0
+      });
+    }
+    if (high.length > 0) {
+      const highDetails = high.slice(0, 3).map(
+        (group) => `\u2022 ${group.description} (${group.count} instances)`
+      ).join("\n");
+      message.attachments.push({
+        color: "warning",
+        title: "\u26A0\uFE0F High Priority Issues",
+        text: highDetails,
+        footer: high.length > 3 ? `... and ${high.length - 3} more high priority issues` : void 0
+      });
+    }
+    if (priorityReport.recommendations.length > 0) {
+      message.attachments.push({
+        color: "good",
+        title: "\u{1F4A1} Recommendations",
+        text: priorityReport.recommendations.slice(0, 3).join("\n")
+      });
+    }
+    await this.sendMessage(message);
+  }
+  /**
+   * Send critical issue alert
+   */
+  async sendCriticalAlert(issues, repositoryName) {
+    const message = {
+      text: `\u{1F6A8} CRITICAL SECURITY ALERT: ${repositoryName}`,
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `\u{1F6A8} *CRITICAL SECURITY ALERT*
+*Repository:* ${repositoryName}
+*Critical Issues:* ${issues.length}`
+          }
+        }
+      ],
+      attachments: issues.slice(0, 5).map((issue) => ({
+        color: "danger",
+        title: `${issue.file}:${issue.line || "?"}`,
+        text: issue.issue.slice(0, 200),
+        fields: [
+          {
+            title: "Fix",
+            value: issue.fix.slice(0, 100),
+            short: false
+          }
+        ],
+        footer: `Agent: ${issue.agent}`,
+        ts: Math.floor(Date.now() / 1e3)
+      }))
+    };
+    if (issues.length > 5) {
+      message.attachments.push({
+        color: "danger",
+        text: `... and ${issues.length - 5} more critical issues. View full report for details.`
+      });
+    }
+    await this.sendMessage(message);
+  }
+  /**
+   * Send team notification
+   */
+  async sendTeamNotification(notification) {
+    const emoji = this.getNotificationEmoji(notification.type);
+    const message = {
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `${emoji} *${notification.title}*
+${notification.message}`
+          }
+        }
+      ]
+    };
+    if (notification.type === "assignment" && notification.data) {
+      const { assignment, issue } = notification.data;
+      message.attachments = [{
+        color: this.getAssignmentColor(assignment.priority),
+        fields: [
+          {
+            title: "Priority",
+            value: assignment.priority.toUpperCase(),
+            short: true
+          },
+          {
+            title: "Due Date",
+            value: assignment.dueDate ? new Date(assignment.dueDate).toLocaleDateString() : "Not set",
+            short: true
+          },
+          {
+            title: "File",
+            value: issue.file,
+            short: false
+          }
+        ]
+      }];
+    }
+    await this.sendMessage(message);
+  }
+  /**
+   * Send daily/weekly team summary
+   */
+  async sendTeamSummary(period, stats) {
+    const emoji = period === "daily" ? "\u{1F4C5}" : "\u{1F4CA}";
+    const title = `${emoji} ${period.charAt(0).toUpperCase() + period.slice(1)} Security Summary`;
+    const message = {
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `*${title}*`
+          }
+        },
+        {
+          type: "section",
+          fields: [
+            {
+              type: "mrkdwn",
+              text: `*\u{1F50D} New Issues:* ${stats.newIssues}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u2705 Resolved:* ${stats.resolvedIssues}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u23F0 Overdue:* ${stats.overdueIssues}`
+            },
+            {
+              type: "mrkdwn",
+              text: `*\u{1F4C8} Net Change:* ${stats.resolvedIssues - stats.newIssues > 0 ? "+" : ""}${stats.resolvedIssues - stats.newIssues}`
+            }
+          ]
+        }
+      ],
+      attachments: []
+    };
+    if (stats.topCategories.length > 0) {
+      const categoriesText = stats.topCategories.slice(0, 5).map((cat) => `\u2022 ${cat.category}: ${cat.count}`).join("\n");
+      message.attachments.push({
+        color: "good",
+        title: "\u{1F4CA} Top Issue Categories",
+        text: categoriesText
+      });
+    }
+    if (stats.topContributors.length > 0) {
+      const contributorsText = stats.topContributors.slice(0, 5).map((contrib) => `\u2022 ${contrib.name}: ${contrib.resolved} resolved`).join("\n");
+      message.attachments.push({
+        color: "good",
+        title: "\u{1F3C6} Top Contributors",
+        text: contributorsText
+      });
+    }
+    await this.sendMessage(message);
+  }
+  /**
+   * Send bulk fix notification
+   */
+  async sendBulkFixNotification(fixedGroups, totalFixed, repositoryName) {
+    const message = {
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `\u26A1 *Bulk Fix Applied*
+*Repository:* ${repositoryName}
+*Issues Fixed:* ${totalFixed}`
+          }
+        }
+      ],
+      attachments: [{
+        color: "good",
+        title: "\u{1F527} Fixed Issue Groups",
+        text: fixedGroups.map(
+          (group) => `\u2022 ${group.description} (${group.count} instances)`
+        ).join("\n")
+      }]
+    };
+    await this.sendMessage(message);
+  }
+  /**
+   * Send escalation notification
+   */
+  async sendEscalationNotification(overdueAssignments) {
+    const message = {
+      text: "\u{1F6A8} OVERDUE ISSUE ESCALATION",
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `\u{1F6A8} *Overdue Issue Escalation*
+${overdueAssignments.length} issues are overdue and require attention.`
+          }
+        }
+      ],
+      attachments: overdueAssignments.map((assignment) => ({
+        color: "warning",
+        title: `Issue ${assignment.issueId}`,
+        fields: [
+          {
+            title: "Assignee",
+            value: assignment.assignee,
+            short: true
+          },
+          {
+            title: "Days Overdue",
+            value: assignment.daysOverdue.toString(),
+            short: true
+          },
+          {
+            title: "Priority",
+            value: assignment.priority.toUpperCase(),
+            short: true
+          }
+        ]
+      }))
+    };
+    await this.sendMessage(message);
+  }
+  /**
+   * Send message to Slack
+   */
+  async sendMessage(message) {
+    const payload = {
+      ...message,
+      channel: this.config.channel || message.channel,
+      username: this.config.username || "Trie Security Bot",
+      icon_emoji: this.config.iconEmoji || ":shield:"
+    };
+    try {
+      const response = await fetch(this.config.webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Slack API error: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error("Failed to send Slack notification:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get emoji for notification type
+   */
+  getNotificationEmoji(type) {
+    const emojis = {
+      assignment: "\u{1F4CB}",
+      escalation: "\u{1F6A8}",
+      completion: "\u2705",
+      reminder: "\u23F0"
+    };
+    return emojis[type] ?? "\u{1F4E2}";
+  }
+  /**
+   * Get color for assignment priority
+   */
+  getAssignmentColor(priority) {
+    const colors = {
+      urgent: "danger",
+      high: "warning",
+      medium: "good",
+      low: "#36a64f"
+    };
+    return colors[priority] ?? "good";
+  }
+  /**
+   * Test Slack connection
+   */
+  async testConnection() {
+    try {
+      await this.sendMessage({
+        text: "\u{1F9EA} Trie Slack Integration Test",
+        blocks: [{
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: "*Trie Slack Integration Test*\nIf you see this message, the integration is working correctly! \u{1F389}"
+          }
+        }]
+      });
+      return true;
+    } catch (error) {
+      console.error("Slack connection test failed:", error);
+      return false;
+    }
+  }
+};
+
+// src/guardian/escalation.ts
+var DEFAULT_CONFIG2 = {
+  enabled: true,
+  targets: [],
+  cooldownMinutes: 15,
+  maxEscalationsPerHour: 5,
+  respectQuietHours: true,
+  criticalBypassQuietHours: true,
+  draftFallbackEnabled: true
+};
+var EscalationManager = class {
+  projectPath;
+  config;
+  guardianState;
+  insightStore;
+  escalationHistory = [];
+  slackClient;
+  constructor(projectPath, config = {}) {
+    this.projectPath = projectPath;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.guardianState = getGuardianState(projectPath);
+    this.insightStore = getInsightStore(projectPath);
+    const slackTarget = this.config.targets.find((t) => t.type === "slack" && t.enabled);
+    if (slackTarget?.config.webhookUrl) {
+      this.slackClient = new SlackIntegration({
+        webhookUrl: slackTarget.config.webhookUrl,
+        channel: slackTarget.config.channel,
+        username: slackTarget.config.username
+      });
+    }
+  }
+  /**
+   * Check if an issue should be auto-escalated
+   */
+  shouldAutoEscalate(issue) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (issue.severity !== "critical") {
+      return false;
+    }
+    const isSecurityIssue = issue.category === "security" || issue.agent === "security" || issue.issue.toLowerCase().includes("security") || issue.issue.toLowerCase().includes("vulnerability") || issue.issue.toLowerCase().includes("injection") || issue.issue.toLowerCase().includes("xss") || issue.issue.toLowerCase().includes("secret");
+    if (!isSecurityIssue) {
+      return false;
+    }
+    if (this.guardianState.isQuietHours()) {
+      if (!this.config.criticalBypassQuietHours) {
+        return false;
+      }
+    }
+    if (!this.insightStore.canCreateInsight("auto-escalation")) {
+      return false;
+    }
+    const recentEscalations = this.escalationHistory.filter(
+      (e) => e.timestamp > Date.now() - 60 * 60 * 1e3
+    );
+    if (recentEscalations.length >= this.config.maxEscalationsPerHour) {
+      return false;
+    }
+    const recentlyEscalated = this.escalationHistory.some(
+      (e) => e.issues.some((i) => i.file === issue.file) && e.timestamp > Date.now() - this.config.cooldownMinutes * 60 * 1e3
+    );
+    if (recentlyEscalated) {
+      return false;
+    }
+    return this.hasValidEscalationTarget("critical", "security");
+  }
+  /**
+   * Check if we have a valid escalation target
+   */
+  hasValidEscalationTarget(severity, category) {
+    return this.config.targets.some(
+      (t) => t.enabled && t.forSeverities.includes(severity) && (t.forCategories.includes(category) || t.forCategories.includes("all"))
+    );
+  }
+  /**
+   * Auto-escalate if issue is critical
+   */
+  async autoEscalateIfCritical(issue) {
+    if (!this.shouldAutoEscalate(issue)) {
+      if (issue.severity === "critical" && this.config.draftFallbackEnabled) {
+        if (this.guardianState.isQuietHours()) {
+          return this.createDraftEscalation([issue], "Blocked by quiet hours");
+        }
+      }
+      return {
+        action: "no_action",
+        reason: "Issue does not meet escalation criteria"
+      };
+    }
+    const message = this.createEscalationMessage([issue]);
+    try {
+      await this.sendEscalation(message);
+      this.escalationHistory.push(message);
+      await this.insightStore.markInsightCreated("auto-escalation");
+      await this.createEscalationInsight(message);
+      await this.guardianState.useRiskBudget(1);
+      return {
+        action: "auto_escalated",
+        reason: "Critical security issue auto-escalated",
+        message
+      };
+    } catch (error) {
+      console.error("Failed to send escalation:", error);
+      if (this.config.draftFallbackEnabled) {
+        return this.createDraftEscalation([issue], String(error));
+      }
+      return {
+        action: "failed",
+        reason: `Send failed: ${error}`,
+        message
+      };
+    }
+  }
+  /**
+   * Escalate multiple issues at once
+   */
+  async escalateIssues(issues) {
+    const criticalSecurityIssues = issues.filter(
+      (i) => i.severity === "critical" && (i.category === "security" || i.agent === "security")
+    );
+    if (criticalSecurityIssues.length === 0) {
+      return {
+        action: "no_action",
+        reason: "No critical security issues to escalate"
+      };
+    }
+    if (this.guardianState.isQuietHours() && !this.config.criticalBypassQuietHours) {
+      return this.createDraftEscalation(criticalSecurityIssues, "Blocked by quiet hours");
+    }
+    const message = this.createEscalationMessage(criticalSecurityIssues);
+    try {
+      await this.sendEscalation(message);
+      this.escalationHistory.push(message);
+      await this.insightStore.markInsightCreated("auto-escalation");
+      await this.createEscalationInsight(message);
+      return {
+        action: "auto_escalated",
+        reason: `Escalated ${criticalSecurityIssues.length} critical security issues`,
+        message
+      };
+    } catch (error) {
+      if (this.config.draftFallbackEnabled) {
+        return this.createDraftEscalation(criticalSecurityIssues, String(error));
+      }
+      return {
+        action: "failed",
+        reason: `Send failed: ${error}`,
+        message
+      };
+    }
+  }
+  /**
+   * Create an escalation message
+   */
+  createEscalationMessage(issues) {
+    const severity = issues.some((i) => i.severity === "critical") ? "critical" : "serious";
+    return {
+      id: `esc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      severity,
+      title: `\u{1F6A8} ${severity.toUpperCase()} Security Alert: ${issues.length} issue${issues.length > 1 ? "s" : ""} detected`,
+      body: this.formatEscalationBody(issues),
+      issues,
+      timestamp: Date.now(),
+      sent: false
+    };
+  }
+  /**
+   * Format escalation body text
+   */
+  formatEscalationBody(issues) {
+    const lines = [
+      `**Critical Security Issues Detected**`,
+      ``,
+      `**Project:** ${this.projectPath.split("/").pop()}`,
+      `**Issues:** ${issues.length}`,
+      `**Detected:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ``,
+      `**Summary:**`
+    ];
+    for (const issue of issues.slice(0, 5)) {
+      lines.push(`- \`${issue.file}:${issue.line || "?"}\`: ${issue.issue.slice(0, 100)}`);
+    }
+    if (issues.length > 5) {
+      lines.push(`- ... and ${issues.length - 5} more`);
+    }
+    lines.push("");
+    lines.push("**Action Required:** Review and address these issues immediately.");
+    return lines.join("\n");
+  }
+  /**
+   * Send escalation through configured channels
+   */
+  async sendEscalation(message) {
+    const enabledTargets = this.config.targets.filter((t) => t.enabled);
+    if (enabledTargets.length === 0) {
+      throw new Error("No enabled escalation targets configured");
+    }
+    const errors = [];
+    for (const target of enabledTargets) {
+      try {
+        switch (target.type) {
+          case "slack":
+            await this.sendToSlack(message, target);
+            break;
+          case "email":
+            await this.sendToEmail(message, target);
+            break;
+          case "webhook":
+            await this.sendToWebhook(message, target);
+            break;
+        }
+        message.sent = true;
+        message.sentAt = Date.now();
+        message.channel = target.type;
+      } catch (error) {
+        errors.push(`${target.type}: ${error}`);
+      }
+    }
+    if (errors.length === enabledTargets.length) {
+      throw new Error(`All escalation channels failed: ${errors.join("; ")}`);
+    }
+  }
+  /**
+   * Send to Slack
+   */
+  async sendToSlack(message, target) {
+    if (!target.config.webhookUrl) {
+      throw new Error("Slack webhook URL not configured");
+    }
+    if (this.slackClient) {
+      await this.slackClient.sendCriticalAlert(message.issues, this.projectPath.split("/").pop() || "Unknown");
+    } else {
+      const slack = new SlackIntegration({
+        webhookUrl: target.config.webhookUrl,
+        channel: target.config.channel,
+        username: target.config.username || "Trie Guardian"
+      });
+      await slack.sendCriticalAlert(message.issues, this.projectPath.split("/").pop() || "Unknown");
+    }
+  }
+  /**
+   * Send to email (placeholder - would need email provider integration)
+   */
+  async sendToEmail(message, target) {
+    if (!target.config.email) {
+      throw new Error("Email address not configured");
+    }
+    console.log(`[EMAIL ESCALATION] To: ${target.config.email}`);
+    console.log(`Subject: ${message.title}`);
+    console.log(`Body: ${message.body}`);
+  }
+  /**
+   * Send to webhook
+   */
+  async sendToWebhook(message, target) {
+    if (!target.config.webhookUrl) {
+      throw new Error("Webhook URL not configured");
+    }
+    const response = await fetch(target.config.webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: message.id,
+        severity: message.severity,
+        title: message.title,
+        body: message.body,
+        issues: message.issues.map((i) => ({
+          file: i.file,
+          line: i.line,
+          severity: i.severity,
+          issue: i.issue,
+          agent: i.agent
+        })),
+        timestamp: message.timestamp,
+        project: this.projectPath
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Webhook returned ${response.status}: ${response.statusText}`);
+    }
+  }
+  /**
+   * Create a draft escalation (when sending is blocked)
+   */
+  createDraftEscalation(issues, reason) {
+    const message = this.createEscalationMessage(issues);
+    message.error = reason;
+    this.escalationHistory.push(message);
+    return {
+      action: "draft_only",
+      reason,
+      message,
+      draftLocation: `.trie/drafts/escalation-${message.id}.json`
+    };
+  }
+  /**
+   * Create insight about escalation
+   */
+  async createEscalationInsight(message) {
+    const insight = {
+      id: `insight-esc-${message.id}`,
+      type: "warning",
+      message: `\u{1F6A8} Auto-escalated: ${message.issues.length} critical security issue${message.issues.length > 1 ? "s" : ""}`,
+      context: `Sent to ${message.channel}. Issues in: ${[...new Set(message.issues.map((i) => i.file))].slice(0, 3).join(", ")}`,
+      relatedIssues: message.issues.map((i) => i.id),
+      priority: 10,
+      timestamp: Date.now(),
+      dismissed: false,
+      category: "security",
+      details: {
+        affectedFiles: [...new Set(message.issues.map((i) => i.file))]
+      }
+    };
+    await this.insightStore.addInsight(insight);
+  }
+  /**
+   * Get escalation history
+   */
+  getEscalationHistory() {
+    return [...this.escalationHistory];
+  }
+  /**
+   * Get pending draft escalations
+   */
+  getPendingDrafts() {
+    return this.escalationHistory.filter((e) => !e.sent);
+  }
+  /**
+   * Retry a failed/draft escalation
+   */
+  async retryEscalation(messageId) {
+    const message = this.escalationHistory.find((e) => e.id === messageId);
+    if (!message) {
+      return {
+        action: "failed",
+        reason: "Escalation message not found"
+      };
+    }
+    try {
+      await this.sendEscalation(message);
+      return {
+        action: "auto_escalated",
+        reason: "Retry successful",
+        message
+      };
+    } catch (error) {
+      return {
+        action: "failed",
+        reason: `Retry failed: ${error}`,
+        message
+      };
+    }
+  }
+  /**
+   * Configure escalation targets
+   */
+  addEscalationTarget(target) {
+    this.config.targets.push(target);
+    if (target.type === "slack" && target.enabled && target.config.webhookUrl) {
+      this.slackClient = new SlackIntegration({
+        webhookUrl: target.config.webhookUrl,
+        channel: target.config.channel,
+        username: target.config.username
+      });
+    }
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+var escalationManagers = /* @__PURE__ */ new Map();
+function getEscalationManager(projectPath) {
+  let manager = escalationManagers.get(projectPath);
+  if (!manager) {
+    manager = new EscalationManager(projectPath);
+    escalationManagers.set(projectPath, manager);
+  }
+  return manager;
+}
+
+// src/guardian/meta-learning.ts
+var MetaLearner = class {
+  guardianState;
+  insightStore;
+  feedbackHistory = [];
+  weights;
+  constructor(projectPath) {
+    this.guardianState = getGuardianState(projectPath);
+    this.insightStore = getInsightStore(projectPath);
+    this.weights = {
+      security: 1,
+      quality: 1,
+      performance: 1,
+      pattern: 1,
+      progress: 1,
+      general: 1
+    };
+  }
+  /**
+   * Record user feedback on an insight
+   */
+  async recordFeedback(feedback, context) {
+    await this.insightStore.load();
+    const insight = this.insightStore.getInsight(context.insightId);
+    if (!insight) {
+      console.error(`Insight not found: ${context.insightId}`);
+      return;
+    }
+    const record = {
+      insightId: context.insightId,
+      insightType: insight.type,
+      insightCategory: insight.category,
+      feedback,
+      timestamp: Date.now()
+    };
+    if (context.latencyMs !== void 0) {
+      record.latencyMs = context.latencyMs;
+    }
+    this.feedbackHistory.push(record);
+    await this.guardianState.recordInsightFeedback(
+      feedback === "dismissed" ? "dismissed" : feedback === "acted" ? "acted" : "helpful"
+    );
+    await this.adjustWeights(record);
+  }
+  /**
+   * Adjust insight weights based on feedback
+   */
+  async adjustWeights(feedback) {
+    const category = feedback.insightCategory;
+    const currentWeight = this.weights[category];
+    if (currentWeight === void 0) return;
+    let adjustment = 0;
+    switch (feedback.feedback) {
+      case "acted":
+        adjustment = 0.05;
+        break;
+      case "helpful":
+        adjustment = 0.02;
+        break;
+      case "dismissed":
+        adjustment = -0.03;
+        break;
+      case "ignored":
+        adjustment = -0.01;
+        break;
+    }
+    this.weights[category] = Math.max(0.3, Math.min(1.5, currentWeight + adjustment));
+  }
+  /**
+   * Get current insight weights
+   */
+  getWeights() {
+    return { ...this.weights };
+  }
+  /**
+   * Get weight for a category (used to adjust insight priority)
+   */
+  getCategoryWeight(category) {
+    return this.weights[category] ?? 1;
+  }
+  /**
+   * Calculate category effectiveness
+   */
+  calculateCategoryEffectiveness() {
+    const categories = ["security", "quality", "performance", "pattern", "progress", "general"];
+    const effectiveness = [];
+    for (const category of categories) {
+      const categoryFeedback = this.feedbackHistory.filter((f) => f.insightCategory === category);
+      if (categoryFeedback.length === 0) {
+        effectiveness.push({
+          category,
+          totalInsights: 0,
+          helpfulCount: 0,
+          dismissedCount: 0,
+          actedCount: 0,
+          effectivenessScore: 0.5
+          // Neutral when no data
+        });
+        continue;
+      }
+      const helpfulCount = categoryFeedback.filter((f) => f.feedback === "helpful" || f.feedback === "acted").length;
+      const dismissedCount = categoryFeedback.filter((f) => f.feedback === "dismissed").length;
+      const actedCount = categoryFeedback.filter((f) => f.feedback === "acted").length;
+      const score = (helpfulCount + actedCount) / Math.max(1, categoryFeedback.length);
+      effectiveness.push({
+        category,
+        totalInsights: categoryFeedback.length,
+        helpfulCount,
+        dismissedCount,
+        actedCount,
+        effectivenessScore: score
+      });
+    }
+    return effectiveness;
+  }
+  /**
+   * Get agent effectiveness metrics
+   */
+  getEffectiveness() {
+    return this.guardianState.getMetrics();
+  }
+  /**
+   * Generate a comprehensive effectiveness report
+   */
+  async generateEffectivenessReport() {
+    await this.guardianState.load();
+    const metrics = this.guardianState.getMetrics();
+    const categoryBreakdown = this.calculateCategoryEffectiveness();
+    const overallScore = metrics.userSatisfaction * 0.4 + metrics.predictiveAccuracy * 0.3 + (1 - metrics.falsePositiveRate) * 0.3;
+    const recommendations = this.generateRecommendations(metrics, categoryBreakdown);
+    const trend = this.calculateTrend();
+    return {
+      overallScore,
+      predictiveAccuracy: metrics.predictiveAccuracy,
+      userSatisfaction: metrics.userSatisfaction,
+      falsePositiveRate: metrics.falsePositiveRate,
+      categoryBreakdown,
+      recommendations,
+      trends: trend
+    };
+  }
+  /**
+   * Generate improvement recommendations
+   */
+  generateRecommendations(metrics, categoryBreakdown) {
+    const recommendations = [];
+    if (metrics.falsePositiveRate > 0.3) {
+      recommendations.push("High dismissal rate detected. Consider raising insight thresholds.");
+    }
+    if (metrics.userSatisfaction < 0.5) {
+      recommendations.push("User satisfaction is low. Review insight quality and relevance.");
+    }
+    const weakCategories = categoryBreakdown.filter((c) => c.totalInsights >= 5 && c.effectivenessScore < 0.4).map((c) => c.category);
+    if (weakCategories.length > 0) {
+      recommendations.push(
+        `Low effectiveness in: ${weakCategories.join(", ")}. Consider adjusting insight generation for these categories.`
+      );
+    }
+    const strongCategories = categoryBreakdown.filter((c) => c.totalInsights >= 5 && c.effectivenessScore > 0.7).map((c) => c.category);
+    if (strongCategories.length > 0) {
+      recommendations.push(
+        `Strong performance in: ${strongCategories.join(", ")}. Consider emphasizing these insights.`
+      );
+    }
+    if (metrics.predictiveAccuracy < 0.6 && metrics.totalPredictions >= 10) {
+      recommendations.push("Prediction accuracy below target. Review risk scoring factors.");
+    }
+    if (metrics.userSatisfaction >= 0.7 && metrics.falsePositiveRate <= 0.2) {
+      recommendations.push("Agent performance is excellent. Keep up the good work!");
+    }
+    return recommendations;
+  }
+  /**
+   * Calculate trend direction
+   */
+  calculateTrend() {
+    const now = Date.now();
+    const recentCutoff = now - 7 * 24 * 60 * 60 * 1e3;
+    const olderCutoff = now - 30 * 24 * 60 * 60 * 1e3;
+    const recentFeedback = this.feedbackHistory.filter((f) => f.timestamp > recentCutoff);
+    const olderFeedback = this.feedbackHistory.filter(
+      (f) => f.timestamp > olderCutoff && f.timestamp <= recentCutoff
+    );
+    if (recentFeedback.length < 5 || olderFeedback.length < 5) {
+      return { period: "last 30 days", direction: "stable" };
+    }
+    const recentPositive = recentFeedback.filter(
+      (f) => f.feedback === "helpful" || f.feedback === "acted"
+    ).length / recentFeedback.length;
+    const olderPositive = olderFeedback.filter(
+      (f) => f.feedback === "helpful" || f.feedback === "acted"
+    ).length / olderFeedback.length;
+    const diff = recentPositive - olderPositive;
+    if (diff > 0.1) {
+      return { period: "last 30 days", direction: "improving" };
+    } else if (diff < -0.1) {
+      return { period: "last 30 days", direction: "declining" };
+    }
+    return { period: "last 30 days", direction: "stable" };
+  }
+  /**
+   * Should an insight be shown based on learning?
+   * 
+   * Uses weights and user patterns to filter low-value insights.
+   */
+  shouldShowInsight(insight) {
+    const weight = this.getCategoryWeight(insight.category);
+    if (weight < 0.5 && insight.priority < 5) {
+      return false;
+    }
+    const adjustedPriority = insight.priority * weight;
+    return adjustedPriority >= 3;
+  }
+  /**
+   * Adjust insight priority based on learning
+   */
+  adjustInsightPriority(insight) {
+    const weight = this.getCategoryWeight(insight.category);
+    return Math.round(insight.priority * weight);
+  }
+  /**
+   * Get feedback history stats
+   */
+  getFeedbackStats() {
+    const stats = {
+      total: this.feedbackHistory.length,
+      helpful: 0,
+      dismissed: 0,
+      acted: 0,
+      ignored: 0,
+      averageLatencyMs: null
+    };
+    let totalLatency = 0;
+    let latencyCount = 0;
+    for (const feedback of this.feedbackHistory) {
+      switch (feedback.feedback) {
+        case "helpful":
+          stats.helpful++;
+          break;
+        case "dismissed":
+          stats.dismissed++;
+          break;
+        case "acted":
+          stats.acted++;
+          break;
+        case "ignored":
+          stats.ignored++;
+          break;
+      }
+      if (feedback.latencyMs !== void 0) {
+        totalLatency += feedback.latencyMs;
+        latencyCount++;
+      }
+    }
+    if (latencyCount > 0) {
+      stats.averageLatencyMs = Math.round(totalLatency / latencyCount);
+    }
+    return stats;
+  }
+  /**
+   * Reset learning (for testing)
+   */
+  reset() {
+    this.feedbackHistory = [];
+    this.weights = {
+      security: 1,
+      quality: 1,
+      performance: 1,
+      pattern: 1,
+      progress: 1,
+      general: 1
+    };
+  }
+};
+var metaLearners = /* @__PURE__ */ new Map();
+function getMetaLearner(projectPath) {
+  let learner = metaLearners.get(projectPath);
+  if (!learner) {
+    learner = new MetaLearner(projectPath);
+    metaLearners.set(projectPath, learner);
+  }
+  return learner;
+}
+
+// src/guardian/guardian-agent.ts
+var PERSONALITY = {
+  greetings: [
+    "Hey, quick heads up...",
+    "Noticed something while scanning...",
+    "Worth mentioning...",
+    "Just so you know...",
+    "Spotted this..."
+  ],
+  warnings: [
+    "This needs your attention:",
+    "I'd pause on this:",
+    "Before you push...",
+    "Hold up \u2014",
+    "Important:"
+  ],
+  celebrations: [
+    "Nice work!",
+    "Good catch!",
+    "That's better.",
+    "Clean.",
+    "Progress."
+  ],
+  suggestions: [
+    "You might want to",
+    "Consider",
+    "Suggestion:",
+    "Quick win:",
+    "Idea:"
+  ],
+  questions: [
+    "Did you mean to",
+    "Should this",
+    "Is it intentional that",
+    "Quick question:"
+  ]
+};
+var GuardianAgent = class {
+  projectPath;
+  projectName;
+  lastIssueHashes = /* @__PURE__ */ new Set();
+  initialized = false;
+  // Persistent stores (Phase 1 Guardian Agency)
+  insightStore;
+  guardianState;
+  // Agency modules (Phases 2-4)
+  goalManager;
+  riskPredictor;
+  hypothesisEngine;
+  escalationManager;
+  metaLearner;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.projectName = basename2(projectPath);
+    this.insightStore = getInsightStore(projectPath);
+    this.guardianState = getGuardianState(projectPath);
+    this.goalManager = getGoalManager(projectPath);
+    this.riskPredictor = getRiskPredictor(projectPath);
+    this.hypothesisEngine = getHypothesisEngine(projectPath);
+    this.escalationManager = getEscalationManager(projectPath);
+    this.metaLearner = getMetaLearner(projectPath);
+  }
+  /**
+   * Initialize the Guardian - loads persistent state and historical data
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await this.insightStore.load();
+      await this.guardianState.load();
+      await this.guardianState.touchActive();
+      const historical = await getHistoricalInsights(this.projectPath);
+      if (historical && historical.totalHistoricalIssues > 0) {
+        const trend = historical.improvementTrend;
+        if (trend === "improving" && this.canCreateInsight("progress-trend")) {
+          await this.addInsight(this.createInsight({
+            type: "celebration",
+            message: `${this.pick(PERSONALITY.celebrations)} Your code quality has been improving over time.`,
+            priority: 2,
+            category: "progress"
+          }));
+          await this.markInsightCreated("progress-trend");
+        } else if (trend === "declining" && this.canCreateInsight("progress-trend")) {
+          await this.addInsight(this.createInsight({
+            type: "observation",
+            message: `${this.pick(PERSONALITY.greetings)} Issue count has been trending up. Might be worth a focused cleanup session.`,
+            suggestedAction: "Run `trie scan` and address top issues",
+            priority: 5,
+            category: "quality"
+          }));
+          await this.markInsightCreated("progress-trend");
+        }
+      }
+      this.initialized = true;
+    } catch {
+      this.initialized = true;
+    }
+  }
+  /**
+   * Add an insight to persistent storage
+   */
+  async addInsight(insight) {
+    return this.insightStore.addInsight(insight);
+  }
+  /**
+   * Restart the Guardian (reload state from disk)
+   */
+  async restart() {
+    this.initialized = false;
+    await this.insightStore.reload();
+    await this.guardianState.reload();
+    await this.initialize();
+  }
+  /**
+   * Load state from disk (for testing)
+   */
+  async loadState() {
+    await this.guardianState.load();
+    return {
+      goals: this.guardianState.getAllGoals(),
+      riskBudget: this.guardianState.getRiskBudget()
+    };
+  }
+  /**
+   * Process new issues from a scan and generate insights
+   * Stores issues in memory and optionally uses LLM for deeper analysis
+   */
+  async processIssues(issues, context) {
+    const newInsights = [];
+    try {
+      await storeIssues(issues, this.projectName, this.projectPath);
+      await recordToGlobalMemory(issues, this.projectName, this.projectPath);
+    } catch {
+    }
+    const currentHashes = new Set(issues.map((i) => `${i.file}:${i.line}:${i.issue.slice(0, 50)}`));
+    const newIssues = issues.filter((i) => !this.lastIssueHashes.has(`${i.file}:${i.line}:${i.issue.slice(0, 50)}`));
+    const fixedCount = [...this.lastIssueHashes].filter((h) => !currentHashes.has(h)).length;
+    const accessibilityIssues = issues.filter(
+      (i) => i.agent === "accessibility" && (i.severity === "critical" || i.severity === "serious")
+    );
+    if (accessibilityIssues.length >= 2 && this.canCreateInsight("accessibility-visual-qa")) {
+      const critical = accessibilityIssues.filter((i) => i.severity === "critical");
+      const serious = accessibilityIssues.filter((i) => i.severity === "serious");
+      const breakdown = {};
+      if (critical.length > 0) breakdown["critical"] = critical.length;
+      if (serious.length > 0) breakdown["serious"] = serious.length;
+      const affectedFiles = [...new Set(accessibilityIssues.map((i) => i.file))];
+      const examples = [...critical, ...serious].slice(0, 3).map((i) => `${basename2(i.file)}:${i.line} - ${i.issue.slice(0, 60)}`);
+      const insight = this.createInsight({
+        type: "suggestion",
+        message: `Found ${accessibilityIssues.length} accessibility issue${accessibilityIssues.length > 1 ? "s" : ""} that could block users. Screenshots would help validate real impact.`,
+        suggestedAction: "Capture screenshots for visual analysis",
+        actionCommand: 'trie_visual_qa_browser url:"http://localhost:3000"',
+        priority: 7,
+        category: "quality",
+        relatedIssues: accessibilityIssues.map((i) => i.id),
+        details: {
+          affectedFiles: affectedFiles.map((f) => basename2(f)),
+          issueBreakdown: breakdown,
+          examples
+        }
+      });
+      newInsights.push(insight);
+      await this.addInsight(insight);
+      await this.markInsightCreated("accessibility-visual-qa");
+    }
+    const securityIssues = issues.filter(
+      (i) => i.category === "security" || i.issue.toLowerCase().includes("secret") || i.issue.toLowerCase().includes("vulnerability") || i.issue.toLowerCase().includes("injection") || i.issue.toLowerCase().includes("xss")
+    );
+    if (securityIssues.length > 0 && this.canCreateInsight("security-warning")) {
+      const critical = securityIssues.filter((i) => i.severity === "critical");
+      const serious = securityIssues.filter((i) => i.severity === "serious");
+      if (critical.length > 0 || serious.length >= 2) {
+        const breakdown = {};
+        if (critical.length > 0) breakdown["critical"] = critical.length;
+        if (serious.length > 0) breakdown["serious"] = serious.length;
+        const affectedFiles = [...new Set(securityIssues.map((i) => i.file))];
+        const examples = [...critical, ...serious].slice(0, 3).map((i) => `${basename2(i.file)}:${i.line} - ${i.issue.slice(0, 60)}`);
+        const insight = this.createInsight({
+          type: "warning",
+          message: `Found ${securityIssues.length} security issue${securityIssues.length > 1 ? "s" : ""} that could expose your app.`,
+          suggestedAction: `Review ${affectedFiles.length} file${affectedFiles.length > 1 ? "s" : ""} immediately`,
+          actionCommand: "trie scan --skill security",
+          priority: 10,
+          category: "security",
+          relatedIssues: securityIssues.map((i) => i.id),
+          details: {
+            affectedFiles: affectedFiles.map((f) => basename2(f)),
+            issueBreakdown: breakdown,
+            examples
+          }
+        });
+        newInsights.push(insight);
+        await this.addInsight(insight);
+        await this.markInsightCreated("security-warning");
+      }
+    }
+    if (newIssues.length >= 3 && context.filesChanged && context.filesChanged.length > 0 && this.canCreateInsight("new-issues")) {
+      const affectedFiles = [...new Set(newIssues.map((i) => basename2(i.file)))];
+      const filesChanged = context.filesChanged.map((f) => basename2(f));
+      const breakdown = {};
+      const critical = newIssues.filter((i) => i.severity === "critical");
+      const serious = newIssues.filter((i) => i.severity === "serious");
+      const moderate = newIssues.filter((i) => i.severity === "moderate");
+      if (critical.length > 0) breakdown["critical"] = critical.length;
+      if (serious.length > 0) breakdown["serious"] = serious.length;
+      if (moderate.length > 0) breakdown["moderate"] = moderate.length;
+      const examples = newIssues.sort((a, b) => {
+        const sev = { critical: 3, serious: 2, moderate: 1, minor: 0, low: 0 };
+        return (sev[b.severity] || 0) - (sev[a.severity] || 0);
+      }).slice(0, 3).map((i) => `${basename2(i.file)}:${i.line} - ${i.issue.slice(0, 50)}`);
+      const insight = this.createInsight({
+        type: "observation",
+        message: `Recent changes introduced ${newIssues.length} new issues in ${affectedFiles.slice(0, 3).join(", ")}.`,
+        suggestedAction: `Review ${affectedFiles.length} affected file${affectedFiles.length > 1 ? "s" : ""}`,
+        priority: 6,
+        category: "quality",
+        details: {
+          affectedFiles: affectedFiles.slice(0, 8),
+          issueBreakdown: breakdown,
+          examples,
+          comparison: `Changed: ${filesChanged.slice(0, 3).join(", ")}${filesChanged.length > 3 ? ` +${filesChanged.length - 3} more` : ""}`
+        }
+      });
+      newInsights.push(insight);
+      await this.addInsight(insight);
+      await this.markInsightCreated("new-issues");
+    }
+    if (fixedCount > 0 && newIssues.length === 0 && this.canCreateInsight("celebration")) {
+      const insight = this.createInsight({
+        type: "celebration",
+        message: `${this.pick(PERSONALITY.celebrations)} ${fixedCount} issue${fixedCount > 1 ? "s" : ""} resolved.`,
+        priority: 3,
+        category: "progress"
+      });
+      newInsights.push(insight);
+      await this.addInsight(insight);
+      await this.markInsightCreated("celebration");
+    }
+    if (this.canCreateInsight("pattern-suggestion")) {
+      try {
+        const globalPatterns = await findCrossProjectPatterns();
+        const crossProjectPattern = globalPatterns.find((p) => p.projects.length > 1 && p.occurrences > 3);
+        if (crossProjectPattern) {
+          const insight = this.createInsight({
+            type: "suggestion",
+            message: `"${crossProjectPattern.description.slice(0, 40)}..." appears in ${crossProjectPattern.projects.length} projects. Consider a shared lint rule.`,
+            priority: 4,
+            category: "pattern"
+          });
+          newInsights.push(insight);
+          await this.addInsight(insight);
+          await this.markInsightCreated("pattern-suggestion");
+        }
+      } catch {
+      }
+    }
+    if (context.isWatchMode && this.shouldWarnBeforePush(issues) && this.canCreateInsight("pre-push-warning")) {
+      const criticalIssues = issues.filter((i) => i.severity === "critical");
+      const seriousIssues = issues.filter((i) => i.severity === "serious");
+      const moderateIssues = issues.filter((i) => i.severity === "moderate");
+      const breakdown = {};
+      if (criticalIssues.length > 0) breakdown["critical"] = criticalIssues.length;
+      if (seriousIssues.length > 0) breakdown["serious"] = seriousIssues.length;
+      if (moderateIssues.length > 0) breakdown["moderate"] = moderateIssues.length;
+      const criticalFiles = [...new Set(criticalIssues.map((i) => basename2(i.file)))];
+      const seriousFiles = [...new Set(seriousIssues.map((i) => basename2(i.file)))];
+      const affectedFiles = [.../* @__PURE__ */ new Set([...criticalFiles, ...seriousFiles])].slice(0, 5);
+      const examples = [...criticalIssues, ...seriousIssues].slice(0, 4).map((i) => `${basename2(i.file)}:${i.line} - ${i.issue.slice(0, 50)}`);
+      const totalBlocking = criticalIssues.length + seriousIssues.length;
+      const trend = this.lastIssueHashes.size > 0 ? totalBlocking > this.lastIssueHashes.size ? "worsening" : "improving" : void 0;
+      const insightDetails = {
+        affectedFiles,
+        issueBreakdown: breakdown,
+        examples
+      };
+      if (trend) insightDetails.trend = trend;
+      if (moderateIssues.length > 0) insightDetails.comparison = `+${moderateIssues.length} moderate (non-blocking)`;
+      const insight = this.createInsight({
+        type: "warning",
+        message: `${totalBlocking} issue${totalBlocking > 1 ? "s" : ""} need attention before pushing.`,
+        suggestedAction: "Run pre-push check",
+        actionCommand: "trie check",
+        priority: 8,
+        category: "quality",
+        details: insightDetails
+      });
+      newInsights.push(insight);
+      await this.addInsight(insight);
+      await this.markInsightCreated("pre-push-warning");
+    }
+    if (isAIAvailable() && issues.length > 0 && newIssues.length > 0) {
+      const aiInsights = await this.generateAIInsights(issues, newIssues);
+      newInsights.push(...aiInsights);
+    }
+    if (this.canCreateInsight("goal-progress")) {
+      try {
+        const patterns = await this.goalManager.analyzeIncidentPatterns();
+        const significantPatterns = patterns.filter((p) => p.confidence >= 0.6 && p.currentValue >= 3);
+        if (significantPatterns.length > 0) {
+          await this.goalManager.autoGenerateGoals();
+        }
+        await this.goalManager.updateGoalProgress();
+        const goals = this.guardianState.getAllGoals();
+        for (const goal of goals.filter((g) => g.status === "active")) {
+          const startVal = goal.startValue ?? goal.currentValue;
+          if (startVal > 0 && goal.currentValue <= startVal) {
+            const percentComplete = Math.round((1 - goal.currentValue / startVal) * 100);
+            if (percentComplete >= 50 && this.canCreateInsight(`goal-${goal.id}`)) {
+              const insight = this.createInsight({
+                type: "celebration",
+                message: `\u{1F3AF} Goal "${goal.description}" is ${percentComplete}% complete! ${goal.currentValue} issues remaining (started at ${startVal}).`,
+                priority: 4,
+                category: "progress",
+                details: {
+                  affectedFiles: goal.category ? [goal.category] : [],
+                  comparison: `${startVal} \u2192 ${goal.currentValue}`
+                }
+              });
+              newInsights.push(insight);
+              await this.addInsight(insight);
+              await this.markInsightCreated(`goal-${goal.id}`);
+            }
+          }
+        }
+        await this.markInsightCreated("goal-progress");
+      } catch {
+      }
+    }
+    if (context.filesChanged && context.filesChanged.length > 0 && this.canCreateInsight("risk-prediction")) {
+      try {
+        const riskSummary = await this.riskPredictor.predictRiskTrend(context.filesChanged);
+        if (riskSummary.overallRisk >= 50) {
+          const highRiskFactors = riskSummary.factors.filter((f) => f.reasons.length > 0);
+          if (highRiskFactors.length > 0) {
+            const topFile = highRiskFactors[0];
+            const insight = this.createInsight({
+              type: "warning",
+              message: `\u{1F52E} Risk score ${Math.round(riskSummary.overallRisk)}/100 for changed files (${riskSummary.trend}). ${topFile ? basename2(topFile.file) + " is high-risk." : ""}`,
+              suggestedAction: "Consider extra review before pushing",
+              priority: 7,
+              category: "quality",
+              details: {
+                affectedFiles: highRiskFactors.slice(0, 5).map((f) => basename2(f.file)),
+                trend: riskSummary.trend === "increasing" ? "worsening" : riskSummary.trend === "decreasing" ? "improving" : "stable"
+              }
+            });
+            newInsights.push(insight);
+            await this.addInsight(insight);
+            await this.markInsightCreated("risk-prediction");
+          }
+        }
+      } catch {
+      }
+    }
+    if (this.canCreateInsight("hypothesis-update")) {
+      try {
+        const hypotheses = this.guardianState.getAllHypotheses();
+        const testingHypotheses = hypotheses.filter((h) => h.status === "testing");
+        if (testingHypotheses.length < 3) {
+          await this.hypothesisEngine.autoGenerateHypotheses();
+        }
+        const validatedHypotheses = hypotheses.filter(
+          (h) => h.status === "validated" && h.validatedAt && Date.now() - new Date(h.validatedAt).getTime() < 24 * 60 * 60 * 1e3
+          // Within last 24h
+        );
+        for (const hypothesis of validatedHypotheses.slice(0, 2)) {
+          if (this.canCreateInsight(`hypothesis-${hypothesis.id}`)) {
+            const insight = this.createInsight({
+              type: "celebration",
+              message: `\u2705 Hypothesis validated: "${hypothesis.statement}" (${Math.round(hypothesis.confidence * 100)}% confidence)`,
+              priority: 5,
+              category: "pattern"
+            });
+            newInsights.push(insight);
+            await this.addInsight(insight);
+            await this.markInsightCreated(`hypothesis-${hypothesis.id}`);
+          }
+        }
+        await this.markInsightCreated("hypothesis-update");
+      } catch {
+      }
+    }
+    const criticalSecurityIssues = issues.filter(
+      (i) => i.severity === "critical" && (i.category === "security" || i.issue.toLowerCase().includes("secret"))
+    );
+    if (criticalSecurityIssues.length > 0) {
+      try {
+        const result = await this.escalationManager.escalateIssues(criticalSecurityIssues);
+        if (result.action === "auto_escalated" && result.message) {
+          const insight = this.createInsight({
+            type: "observation",
+            message: `\u{1F6A8} Auto-escalated ${criticalSecurityIssues.length} critical security issue(s). Check your notifications.`,
+            priority: 9,
+            category: "security",
+            details: {
+              affectedFiles: criticalSecurityIssues.slice(0, 5).map((i) => basename2(i.file)),
+              examples: criticalSecurityIssues.slice(0, 3).map((i) => i.issue.slice(0, 60))
+            }
+          });
+          newInsights.push(insight);
+          await this.addInsight(insight);
+        }
+      } catch {
+      }
+    }
+    this.lastIssueHashes = currentHashes;
+    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-KFBOAP4X.js");
+      const result = await calculateAdaptiveScanFrequency(riskLevel);
+      await this.guardianState.setScanFrequency(result.frequencyMs);
+    } catch {
+    }
+    return newInsights;
+  }
+  /**
+   * Use LLM to generate deeper insights (optional, requires ANTHROPIC_API_KEY)
+   */
+  async generateAIInsights(_allIssues, newIssues) {
+    const insights = [];
+    try {
+      if (newIssues.length < 2) return insights;
+      const issuesSummary = newIssues.slice(0, 10).map((i) => ({
+        severity: i.severity,
+        issue: i.issue.slice(0, 100),
+        file: basename2(i.file),
+        agent: i.agent
+      }));
+      const result = await runAIAnalysis({
+        systemPrompt: `You are a helpful code guardian. Analyze these issues and provide ONE brief, conversational insight.
+Be specific and actionable. Speak like a helpful colleague, not a system.
+Keep your response under 100 words. Focus on the most important pattern or concern.`,
+        userPrompt: `New issues found:
+${JSON.stringify(issuesSummary, null, 2)}
+
+What's the most important thing the developer should know? Provide a brief, conversational insight.`,
+        maxTokens: 200,
+        temperature: 0.7
+      });
+      if (result.success && result.content) {
+        const insight = this.createInsight({
+          type: "observation",
+          message: result.content.trim(),
+          priority: 5,
+          category: "general"
+        });
+        insights.push(insight);
+        await this.addInsight(insight);
+      }
+    } catch {
+    }
+    return insights;
+  }
+  /**
+   * Get active insights (not dismissed, still relevant)
+   * Now uses persistent storage (Phase 1 Guardian Agency)
+   */
+  getActiveInsights() {
+    return this.insightStore.getActiveInsights();
+  }
+  /**
+   * Dismiss an insight
+   * Now persists to disk (Phase 1 Guardian Agency)
+   */
+  async dismissInsight(insightId) {
+    const result = await this.insightStore.dismissInsight(insightId);
+    if (result) {
+      await this.guardianState.recordInsightFeedback("dismissed");
+    }
+    return result;
+  }
+  /**
+   * Record that a user found an insight helpful
+   */
+  async markInsightHelpful(_insightId) {
+    await this.guardianState.recordInsightFeedback("helpful");
+  }
+  /**
+   * Record that a user acted on an insight
+   */
+  async markInsightActedOn(_insightId) {
+    await this.guardianState.recordInsightFeedback("acted");
+  }
+  /**
+   * Get insight statistics
+   */
+  getInsightStats() {
+    return this.insightStore.getStats();
+  }
+  /**
+   * Get agent metrics (for dashboard display)
+   */
+  getAgentMetrics() {
+    return this.guardianState.getMetrics();
+  }
+  /**
+   * Check if in quiet hours
+   */
+  isQuietHours() {
+    return this.guardianState.isQuietHours();
+  }
+  /**
+   * Check if in crunch mode
+   */
+  isInCrunchMode() {
+    return this.guardianState.isInCrunchMode();
+  }
+  /**
+   * Get the insight store (for advanced operations)
+   */
+  getInsightStore() {
+    return this.insightStore;
+  }
+  /**
+   * Get the guardian state (for advanced operations)
+   */
+  getGuardianState() {
+    return this.guardianState;
+  }
+  /**
+   * Get agency modules (for watch mode integration)
+   */
+  getGoalManager() {
+    return this.goalManager;
+  }
+  getRiskPredictor() {
+    return this.riskPredictor;
+  }
+  getHypothesisEngine() {
+    return this.hypothesisEngine;
+  }
+  getEscalationManager() {
+    return this.escalationManager;
+  }
+  getMetaLearner() {
+    return this.metaLearner;
+  }
+  /**
+   * Get a rich agency status for display in watch mode
+   */
+  async getAgencyStatus() {
+    const goals = this.guardianState.getAllGoals();
+    const activeGoals = goals.filter((g) => g.status === "active");
+    const completedGoals = goals.filter((g) => g.status === "achieved");
+    const hypotheses = this.guardianState.getAllHypotheses();
+    const testingHypotheses = hypotheses.filter((h) => h.status === "testing");
+    const validatedHypotheses = hypotheses.filter((h) => h.status === "validated");
+    const metrics = this.guardianState.getMetrics();
+    const budget = this.guardianState.getRiskBudget();
+    const dailyActionsRemaining = budget.daily - budget.usedToday;
+    let riskLevel = "low";
+    if (dailyActionsRemaining <= 1) riskLevel = "critical";
+    else if (dailyActionsRemaining <= 3) riskLevel = "high";
+    else if (dailyActionsRemaining <= 5) riskLevel = "medium";
+    const totalFeedback = metrics.helpfulInsights + metrics.dismissedInsights + metrics.actedOnInsights;
+    const effectiveness = totalFeedback > 0 ? Math.round((metrics.helpfulInsights + metrics.actedOnInsights) / totalFeedback * 100) : 100;
+    const topGoal = activeGoals[0]?.description;
+    const topHypothesis = testingHypotheses[0]?.statement?.slice(0, 50);
+    const result = {
+      goals: {
+        active: activeGoals.length,
+        completed: completedGoals.length
+      },
+      hypotheses: {
+        testing: testingHypotheses.length,
+        validated: validatedHypotheses.length
+      },
+      riskLevel,
+      scanFrequency: this.guardianState.getScanFrequencyMs(),
+      effectiveness,
+      isQuietHours: this.guardianState.isQuietHours()
+    };
+    if (topGoal) result.goals.topGoal = topGoal;
+    if (topHypothesis) result.hypotheses.topHypothesis = topHypothesis;
+    return result;
+  }
+  /**
+   * Get a summary for the current state
+   */
+  getSummary(issues) {
+    const critical = issues.filter((i) => i.severity === "critical").length;
+    const serious = issues.filter((i) => i.severity === "serious").length;
+    const total = issues.length;
+    if (total === 0) {
+      return "All clear. Your code looks good.";
+    }
+    if (critical > 0) {
+      return `${critical} critical issue${critical > 1 ? "s" : ""} need${critical === 1 ? "s" : ""} immediate attention.`;
+    }
+    if (serious > 0) {
+      return `${serious} serious issue${serious > 1 ? "s" : ""} worth reviewing before shipping.`;
+    }
+    return `${total} minor thing${total > 1 ? "s" : ""} to polish when you have time.`;
+  }
+  // === Private helpers ===
+  shouldWarnBeforePush(issues) {
+    const critical = issues.filter((i) => i.severity === "critical").length;
+    const serious = issues.filter((i) => i.severity === "serious").length;
+    return critical > 0 || serious >= 3;
+  }
+  /**
+   * Check if we should create an insight of this type (cooldown not expired)
+   * Now uses persistent storage (Phase 1 Guardian Agency)
+   */
+  canCreateInsight(insightKey) {
+    return this.insightStore.canCreateInsight(insightKey);
+  }
+  /**
+   * Mark that we created an insight of this type
+   * Now persists to disk (Phase 1 Guardian Agency)
+   */
+  async markInsightCreated(insightKey) {
+    await this.insightStore.markInsightCreated(insightKey);
+  }
+  createInsight(params) {
+    return {
+      id: `insight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: Date.now(),
+      dismissed: false,
+      relatedIssues: params.relatedIssues || [],
+      ...params
+    };
+  }
+  pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+};
+var guardianInstances = /* @__PURE__ */ new Map();
+function getGuardian(projectPath) {
+  let guardian = guardianInstances.get(projectPath);
+  if (!guardian) {
+    guardian = new GuardianAgent(projectPath);
+    guardianInstances.set(projectPath, guardian);
+  }
+  return guardian;
+}
+
+export {
+  SlackIntegration,
+  GuardianAgent,
+  getGuardian
+};
+//# sourceMappingURL=chunk-PBOVCPKE.js.map