@triedotdev/mcp 1.0.169 → 1.0.171

package/dist/chunk-7IO4YUI3.js

@@ -1,1827 +0,0 @@
-import {
-  getHypothesisEngine
-} from "./chunk-I2O5OYQT.js";
-import {
-  getGoalManager
-} from "./chunk-FBNURWRY.js";
-import {
-  getInsightStore
-} from "./chunk-T63OHG4Q.js";
-import {
-  GotchaPredictor,
-  SlackIntegration,
-  findCrossProjectPatterns,
-  recordToGlobalMemory
-} from "./chunk-AHD2CBQ7.js";
-import {
-  ContextGraph
-} from "./chunk-VUL52BQL.js";
-import {
-  getStorage
-} from "./chunk-BUTOP5EB.js";
-import {
-  isAIAvailable,
-  runAIAnalysis
-} from "./chunk-FQ45QP5A.js";
-import {
-  autoResolveIssues,
-  getHistoricalInsights,
-  getIssueHash,
-  searchIssues,
-  storeIssues
-} from "./chunk-KCUOWRPX.js";
-import {
-  getProjectState
-} from "./chunk-GTKYBOXL.js";
-
-// src/agent/trie-agent.ts
-import { basename as basename2 } from "path";
-
-// src/agent/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: `[!] ${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/agent/escalation.ts
-var DEFAULT_CONFIG2 = {
-  enabled: true,
-  targets: [],
-  cooldownMinutes: 15,
-  maxEscalationsPerHour: 5,
-  respectQuietHours: true,
-  criticalBypassQuietHours: true,
-  draftFallbackEnabled: true
-};
-var EscalationManager = class {
-  projectPath;
-  config;
-  projectState;
-  insightStore;
-  escalationHistory = [];
-  slackClient;
-  constructor(projectPath, config = {}) {
-    this.projectPath = projectPath;
-    this.config = { ...DEFAULT_CONFIG2, ...config };
-    this.projectState = getProjectState(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.projectState.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.projectState.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.projectState.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.projectState.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: `${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 Agent"
-      });
-      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: `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/agent/meta-learning.ts
-var MetaLearner = class {
-  projectState;
-  insightStore;
-  feedbackHistory = [];
-  weights;
-  constructor(projectPath) {
-    this.projectState = getProjectState(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.projectState.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.projectState.getMetrics();
-  }
-  /**
-   * Generate a comprehensive effectiveness report
-   */
-  async generateEffectivenessReport() {
-    await this.projectState.load();
-    const metrics = this.projectState.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/agent/trie-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 TrieAgent = class {
-  projectPath;
-  projectName;
-  lastIssueHashes = /* @__PURE__ */ new Set();
-  initialized = false;
-  // Persistent stores
-  insightStore;
-  projectState;
-  // Agency modules
-  goalManager;
-  riskPredictor;
-  hypothesisEngine;
-  escalationManager;
-  metaLearner;
-  gotchaPredictor;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-    this.projectName = basename2(projectPath);
-    this.insightStore = getInsightStore(projectPath);
-    this.projectState = getProjectState(projectPath);
-    this.goalManager = getGoalManager(projectPath);
-    this.riskPredictor = getRiskPredictor(projectPath);
-    this.hypothesisEngine = getHypothesisEngine(projectPath);
-    this.escalationManager = getEscalationManager(projectPath);
-    this.metaLearner = getMetaLearner(projectPath);
-    this.gotchaPredictor = new GotchaPredictor(projectPath, new ContextGraph(projectPath));
-  }
-  /**
-   * Initialize the agent - loads persistent state and historical data
-   */
-  async initialize() {
-    if (this.initialized) return;
-    try {
-      await this.insightStore.load();
-      await this.projectState.load();
-      await this.projectState.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 watch` to monitor and address 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 agent (reload state from disk)
-   */
-  async restart() {
-    this.initialized = false;
-    await this.insightStore.reload();
-    await this.projectState.reload();
-    await this.initialize();
-  }
-  /**
-   * Load state from disk (for testing)
-   */
-  async loadState() {
-    await this.projectState.load();
-    return {
-      goals: this.projectState.getAllGoals(),
-      riskBudget: this.projectState.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);
-      if (context.filesChanged && context.filesChanged.length > 0) {
-        const currentHashes2 = new Set(issues.map((i) => getIssueHash(i)));
-        await autoResolveIssues(currentHashes2, context.filesChanged, 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 check",
-          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 (issues.length >= 10 && this.canCreateInsight("hypothesis-generation")) {
-      try {
-        const patterns = [];
-        const observations = [];
-        if (newIssues.length > issues.length * 0.3) {
-          observations.push(`High new issue rate: ${newIssues.length} new out of ${issues.length} total`);
-        }
-        const fileFreq = {};
-        for (const issue of issues) {
-          fileFreq[issue.file] = (fileFreq[issue.file] || 0) + 1;
-        }
-        const hotFiles = Object.entries(fileFreq).filter(([, count]) => count >= 3);
-        if (hotFiles.length > 0) {
-          patterns.push(`Hotspot files: ${hotFiles.map(([f]) => basename2(f)).join(", ")}`);
-        }
-        const generated = await this.hypothesisEngine.generateHypothesesWithAI({
-          recentIssues: issues.map((i) => ({ issue: i, score: 1 })),
-          patterns,
-          observations
-        });
-        for (const hypothesis of generated) {
-          const insight = this.createInsight({
-            type: "observation",
-            message: `${this.pick(PERSONALITY.questions)} New hypothesis to test: "${hypothesis.statement}"`,
-            context: `Confidence: ${Math.round(hypothesis.confidence * 100)}%`,
-            suggestedAction: `Monitor this pattern over time`,
-            priority: 4,
-            category: "pattern",
-            details: {
-              hypothesis: hypothesis.statement,
-              testCriteria: hypothesis.testCriteria || "Collecting evidence...",
-              confidence: Math.round(hypothesis.confidence * 100)
-            }
-          });
-          newInsights.push(insight);
-          await this.addInsight(insight);
-        }
-        if (generated.length > 0) {
-          await this.markInsightCreated("hypothesis-generation");
-        }
-      } catch (error) {
-      }
-    }
-    if (issues.length >= 5 && this.canCreateInsight("pattern-discovery")) {
-      try {
-        const { IncidentIndex } = await import("./incident-index-EFNUSGWL.js");
-        const { TriePatternDiscovery } = await import("./pattern-discovery-F7LU5K6E.js");
-        const { ContextGraph: ContextGraph2 } = await import("./graph-B3NA4S7I.js");
-        const graph = new ContextGraph2(this.projectPath);
-        const incidentIndex = await IncidentIndex.build(graph, this.projectPath);
-        const discovery = new TriePatternDiscovery(graph, incidentIndex);
-        const hotPatterns = discovery.discoverHotPatterns(2);
-        let patternsAdded = 0;
-        for (const hot of hotPatterns.slice(0, 5)) {
-          const existingPatterns = await graph.listNodes();
-          const alreadyExists = existingPatterns.some(
-            (n) => n.type === "pattern" && n.data.description?.includes(hot.path)
-          );
-          if (!alreadyExists) {
-            await graph.addNode("pattern", {
-              description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
-              appliesTo: [hot.path],
-              confidence: Math.min(0.95, hot.confidence),
-              occurrences: hot.incidentCount,
-              firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
-              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
-              isAntiPattern: hot.incidentCount >= 3,
-              source: "local"
-            });
-            patternsAdded++;
-          }
-        }
-        if (patternsAdded > 0) {
-          const insight = this.createInsight({
-            type: "observation",
-            message: `${this.pick(PERSONALITY.greetings)} Discovered ${patternsAdded} pattern${patternsAdded > 1 ? "s" : ""} in your codebase.`,
-            suggestedAction: `Check Memory \u2192 Learned Patterns to see`,
-            priority: 5,
-            category: "pattern",
-            details: {
-              patternsCount: patternsAdded,
-              topPattern: hotPatterns[0]?.path
-            }
-          });
-          newInsights.push(insight);
-          await this.addInsight(insight);
-          await this.markInsightCreated("pattern-discovery");
-        }
-      } catch (error) {
-      }
-    }
-    if (this.canCreateInsight("pattern-suggestion")) {
-      try {
-        const globalPatterns = await findCrossProjectPatterns();
-        const crossProjectPattern = globalPatterns.find((p) => p.projects.length > 1 && p.occurrences > 3);
-        if (crossProjectPattern) {
-          const insight = this.createInsight({
-            type: "suggestion",
-            message: `"${crossProjectPattern.description}" 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.projectState.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: `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: `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 (context.filesChanged && context.filesChanged.length > 0) {
-      try {
-        const gotchas = await this.gotchaPredictor.predictGotchas(context.filesChanged);
-        const storage = getStorage(this.projectPath);
-        for (const gotcha of gotchas) {
-          if (this.canCreateInsight(`gotcha-${gotcha.id}`)) {
-            const explanation = await this.gotchaPredictor.synthesizeGotchaExplanation(gotcha);
-            const insight = this.createInsight({
-              type: "warning",
-              message: `[Gotcha] ${gotcha.message}`,
-              context: explanation,
-              suggestedAction: gotcha.recommendation,
-              priority: gotcha.riskLevel === "critical" ? 9 : 7,
-              category: "quality",
-              details: {
-                affectedFiles: context.filesChanged.map((f) => basename2(f)),
-                examples: [gotcha.message, explanation]
-              }
-            });
-            newInsights.push(insight);
-            await this.addInsight(insight);
-            await this.markInsightCreated(`gotcha-${gotcha.id}`);
-          }
-          const primaryFile = context.filesChanged?.[0];
-          const ledgerGotcha = {
-            id: gotcha.id,
-            message: gotcha.message,
-            confidence: gotcha.confidence,
-            riskLevel: gotcha.riskLevel,
-            recommendation: gotcha.recommendation,
-            ...primaryFile && { file: primaryFile },
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            ...gotcha.precedentId && { precedentId: gotcha.precedentId },
-            tags: gotcha.evidence.matchingPatterns,
-            evidence: gotcha.evidence,
-            resolved: false
-          };
-          await storage.storeGotcha(ledgerGotcha);
-        }
-      } catch {
-      }
-    }
-    if (this.canCreateInsight("hypothesis-update")) {
-      try {
-        const hypotheses = this.projectState.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: `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: `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.projectState.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-QUKX2W6C.js");
-      const result = await calculateAdaptiveScanFrequency(riskLevel);
-      await this.projectState.setScanFrequency(result.frequencyMs);
-    } catch {
-    }
-    try {
-      const { getStorage: getStorage2 } = await import("./tiered-storage-DYNC5CQ6.js");
-      const storage = getStorage2(this.projectPath);
-      const resolvedIssueIds = [...this.lastIssueHashes].filter((h) => !currentHashes.has(h)).map((h) => {
-        return h.split(":").join("-");
-      });
-      if (resolvedIssueIds.length > 0) {
-        const resolvedCount = await storage.autoResolveFixedNudges(resolvedIssueIds);
-        if (resolvedCount > 0) {
-          console.debug(`[Agent] Auto-resolved ${resolvedCount} nudge${resolvedCount !== 1 ? "s" : ""} for fixed issues`);
-        }
-      }
-    } 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 reviewer. 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)
-   */
-  getActiveInsights() {
-    return this.insightStore.getActiveInsights();
-  }
-  /**
-   * Dismiss an insight
-   */
-  async dismissInsight(insightId) {
-    const result = await this.insightStore.dismissInsight(insightId);
-    if (result) {
-      await this.projectState.recordInsightFeedback("dismissed");
-    }
-    return result;
-  }
-  /**
-   * Record that a user found an insight helpful
-   */
-  async markInsightHelpful(_insightId) {
-    await this.projectState.recordInsightFeedback("helpful");
-  }
-  /**
-   * Record that a user acted on an insight
-   */
-  async markInsightActedOn(_insightId) {
-    await this.projectState.recordInsightFeedback("acted");
-  }
-  /**
-   * Get insight statistics
-   */
-  getInsightStats() {
-    return this.insightStore.getStats();
-  }
-  /**
-   * Get agent metrics (for dashboard display)
-   */
-  getAgentMetrics() {
-    return this.projectState.getMetrics();
-  }
-  /**
-   * Check if in quiet hours
-   */
-  isQuietHours() {
-    return this.projectState.isQuietHours();
-  }
-  /**
-   * Check if in crunch mode
-   */
-  isInCrunchMode() {
-    return this.projectState.isInCrunchMode();
-  }
-  /**
-   * Get the insight store (for advanced operations)
-   */
-  getInsightStore() {
-    return this.insightStore;
-  }
-  /**
-   * Get the project state (for advanced operations)
-   */
-  getProjectState() {
-    return this.projectState;
-  }
-  /**
-   * 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.projectState.getAllGoals();
-    const activeGoals = goals.filter((g) => g.status === "active");
-    const completedGoals = goals.filter((g) => g.status === "achieved");
-    const hypotheses = this.projectState.getAllHypotheses();
-    const testingHypotheses = hypotheses.filter((h) => h.status === "testing");
-    const validatedHypotheses = hypotheses.filter((h) => h.status === "validated");
-    const metrics = this.projectState.getMetrics();
-    const budget = this.projectState.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.projectState.getScanFrequencyMs(),
-      effectiveness,
-      isQuietHours: this.projectState.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)
-   */
-  canCreateInsight(insightKey) {
-    return this.insightStore.canCreateInsight(insightKey);
-  }
-  /**
-   * Mark that we created an insight of this type
-   */
-  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 agentInstances = /* @__PURE__ */ new Map();
-function getTrieAgent(projectPath) {
-  let agent = agentInstances.get(projectPath);
-  if (!agent) {
-    agent = new TrieAgent(projectPath);
-    agentInstances.set(projectPath, agent);
-  }
-  return agent;
-}
-
-export {
-  TrieAgent,
-  getTrieAgent
-};
-//# sourceMappingURL=chunk-7IO4YUI3.js.map