nexus-agents 2.26.1 → 2.28.0

package/dist/chunk-PGNRXCYY.js

@@ -1,776 +0,0 @@
-import {
-  HEARTBEAT_TIMEOUTS
-} from "./chunk-LCDOP543.js";
-import {
-  CLI_NAMES,
-  RateLimitError,
-  TASK_CATEGORIES,
-  computeAdaptiveThresholds,
-  getErrorMessage,
-  getOutcomeStore,
-  getSpecialization,
-  getTimeProvider
-} from "./chunk-BOWNZMPH.js";
-
-// src/mcp/tools/weather-report-types.ts
-import { z } from "zod";
-var WeatherReportInputSchema = z.object({
-  /** Filter by CLI name. */
-  cli: z.enum(CLI_NAMES).optional().describe("Filter by CLI"),
-  /** Filter by task category. */
-  category: z.enum([
-    "architecture",
-    "code_generation",
-    "code_review",
-    "research",
-    "security_review",
-    "planning",
-    "documentation",
-    "testing",
-    "devops",
-    "exploration"
-  ]).optional().describe("Filter by task category"),
-  /** Include adaptive routing bonus data. */
-  includeAdaptive: z.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
-});
-var WeatherReportConfigSchema = z.object({
-  /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z.number().int().min(1).max(1e3).default(3),
-  /** Exploration rate: fraction of random routing (0.0-1.0). */
-  explorationRate: z.number().min(0).max(1).default(0.1),
-  /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z.number().min(0).max(10).default(5)
-});
-function createDefaultWeatherConfig() {
-  return WeatherReportConfigSchema.parse({});
-}
-
-// src/mcp/gateway/gateway-keywords.ts
-var SECURITY_KEYWORDS = [
-  "security",
-  "vulnerabilit",
-  "cve-",
-  "exploit",
-  "injection",
-  "xss",
-  "csrf",
-  "auth",
-  "penetration",
-  "threat",
-  "malware",
-  "credentials",
-  "secrets",
-  "encryption",
-  "certificate"
-];
-var ARCHITECTURE_KEYWORDS = [
-  "architecture",
-  "breaking change",
-  "breaking api",
-  "api change",
-  "migration",
-  "refactor.*system",
-  "redesign",
-  "microservice",
-  "monolith",
-  "deprecation",
-  "schema change",
-  "database",
-  "infrastructure"
-];
-var PROMOTED_ROLES = /* @__PURE__ */ new Set(["security_expert", "architecture_expert"]);
-
-// src/mcp/gateway/tier-classifier.ts
-var TOOL_TIER_MAP = {
-  // Tier 1 — Read-only
-  list_experts: 1 /* DIRECT */,
-  list_workflows: 1 /* DIRECT */,
-  memory_query: 1 /* DIRECT */,
-  memory_stats: 1 /* DIRECT */,
-  weather_report: 1 /* DIRECT */,
-  research_query: 1 /* DIRECT */,
-  research_analyze: 1 /* DIRECT */,
-  research_catalog_review: 1 /* DIRECT */,
-  // Tier 2 — Model selection
-  delegate_to_model: 2 /* ANALYZED */,
-  create_expert: 2 /* ANALYZED */,
-  execute_expert: 2 /* ANALYZED */,
-  research_add: 2 /* ANALYZED */,
-  research_discover: 2 /* ANALYZED */,
-  registry_import: 2 /* ANALYZED */,
-  // Tier 3 — Full orchestration
-  orchestrate: 3 /* ORCHESTRATED */,
-  consensus_vote: 3 /* ORCHESTRATED */,
-  execute_spec: 3 /* ORCHESTRATED */,
-  run_workflow: 3 /* ORCHESTRATED */,
-  run_graph_workflow: 3 /* ORCHESTRATED */,
-  issue_triage: 3 /* ORCHESTRATED */
-};
-function classifyRequestTier(toolName, params, overrides) {
-  const defaultTier = TOOL_TIER_MAP[toolName] ?? 2 /* ANALYZED */;
-  const effectiveTier = overrides?.[toolName] ?? defaultTier;
-  if (defaultTier === 1 /* DIRECT */ && effectiveTier === 1 /* DIRECT */) {
-    return 1 /* DIRECT */;
-  }
-  if (effectiveTier < 3 /* ORCHESTRATED */ && shouldPromote(params)) {
-    return 3 /* ORCHESTRATED */;
-  }
-  return effectiveTier;
-}
-function shouldPromote(params) {
-  const role = params["role"];
-  if (typeof role === "string" && PROMOTED_ROLES.has(role)) {
-    return true;
-  }
-  const textFields = ["task", "proposal", "prompt"];
-  for (const field of textFields) {
-    const value = params[field];
-    if (typeof value === "string" && containsPromotionKeyword(value)) {
-      return true;
-    }
-  }
-  return false;
-}
-var TIER_NAME_TO_ENUM = {
-  DIRECT: 1 /* DIRECT */,
-  ANALYZED: 2 /* ANALYZED */,
-  ORCHESTRATED: 3 /* ORCHESTRATED */
-};
-function parseTierOverrides(overrides) {
-  if (overrides === void 0) return void 0;
-  const result = {};
-  for (const [tool, tierName] of Object.entries(overrides)) {
-    const tier = TIER_NAME_TO_ENUM[tierName];
-    if (tier !== void 0) {
-      result[tool] = tier;
-    }
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
-}
-function containsPromotionKeyword(text) {
-  const lower = text.toLowerCase();
-  for (const kw of SECURITY_KEYWORDS) {
-    if (lower.includes(kw)) return true;
-  }
-  for (const kw of ARCHITECTURE_KEYWORDS) {
-    if (new RegExp(kw, "i").test(text)) return true;
-  }
-  return false;
-}
-
-// src/mcp/gateway/tier-recommender.ts
-var DEFAULT_CONFIG = {
-  minSamples: 20,
-  promoteFailureRate: 0.3,
-  demoteSuccessRate: 0.95,
-  demoteMinSamples: 50
-};
-function getCategoryTier(category) {
-  const categoryToolMap = {
-    research: "research_query",
-    exploration: "research_discover",
-    code_generation: "delegate_to_model",
-    code_review: "run_workflow",
-    architecture: "orchestrate",
-    security_review: "orchestrate",
-    planning: "orchestrate",
-    documentation: "run_workflow",
-    testing: "run_workflow",
-    devops: "delegate_to_model"
-  };
-  const tool = categoryToolMap[category];
-  if (tool !== void 0) {
-    return TOOL_TIER_MAP[tool] ?? 2 /* ANALYZED */;
-  }
-  return 2 /* ANALYZED */;
-}
-function generateTierRecommendations(summary, config) {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-  const recommendations = [];
-  for (const [category, stats] of summary.byCategory) {
-    const rec = evaluateCategory(category, stats, cfg);
-    if (rec !== null) recommendations.push(rec);
-  }
-  return recommendations;
-}
-function evaluateCategory(category, stats, cfg) {
-  if (stats.count < cfg.minSamples) return null;
-  const currentTier = getCategoryTier(category);
-  const failureRate = 1 - stats.successRate;
-  if (failureRate > cfg.promoteFailureRate && currentTier < 3 /* ORCHESTRATED */) {
-    const recommendedTier = currentTier + 1;
-    return {
-      category,
-      currentTier,
-      recommendedTier,
-      direction: "promote",
-      successRate: stats.successRate,
-      sampleCount: stats.count,
-      reason: `${category}: ${(failureRate * 100).toFixed(0)}% failure rate over ${String(stats.count)} tasks \u2014 recommend promoting to Tier ${String(recommendedTier)}`
-    };
-  }
-  if (stats.successRate > cfg.demoteSuccessRate && stats.count >= cfg.demoteMinSamples && currentTier > 1 /* DIRECT */) {
-    const recommendedTier = currentTier - 1;
-    return {
-      category,
-      currentTier,
-      recommendedTier,
-      direction: "demote",
-      successRate: stats.successRate,
-      sampleCount: stats.count,
-      reason: `${category}: ${(stats.successRate * 100).toFixed(0)}% success rate over ${String(stats.count)} tasks \u2014 eligible for demotion to Tier ${String(recommendedTier)}`
-    };
-  }
-  return null;
-}
-
-// src/adapters/rate-limit-detector.ts
-var RATE_LIMIT_PATTERNS = [
-  "rate limit",
-  "rate_limit",
-  "too many requests",
-  "429",
-  "quota exceeded",
-  "throttl",
-  "requests per minute",
-  "tokens per minute"
-];
-function isRateLimitLikeError(error) {
-  const message = getErrorMessage(error).toLowerCase();
-  return RATE_LIMIT_PATTERNS.some((p) => message.includes(p));
-}
-function parseRetryAfterMs(errorMessage) {
-  const lower = errorMessage.toLowerCase();
-  const secondsMatch = /retry[- ]?after[:\s]+(\d+(?:\.\d+)?)\s*(?:s|sec)/i.exec(lower);
-  if (secondsMatch !== null) {
-    const parsed = parseFloat(secondsMatch[1] ?? "0");
-    return Math.ceil(parsed * 1e3);
-  }
-  const msMatch = /(?:retry[- ]?after|wait)[:\s]+(\d+)\s*(?:ms|millisecond)/i.exec(lower);
-  if (msMatch !== null) {
-    return parseInt(msMatch[1] ?? "0", 10);
-  }
-  const againMatch = /try again in (\d+(?:\.\d+)?)\s*(?:s|sec)/i.exec(lower);
-  if (againMatch !== null) {
-    const parsed = parseFloat(againMatch[1] ?? "0");
-    return Math.ceil(parsed * 1e3);
-  }
-  return void 0;
-}
-function toRateLimitError(error, provider) {
-  const message = getErrorMessage(error);
-  const retryAfterMs = parseRetryAfterMs(message);
-  return new RateLimitError(message, {
-    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
-    ...provider !== void 0 ? { provider } : {},
-    ...error instanceof Error ? { cause: error } : {}
-  });
-}
-var MAX_EVENTS = 200;
-var events = [];
-function recordRateLimitEvent(event) {
-  events.push(event);
-  if (events.length > MAX_EVENTS) {
-    events.splice(0, events.length - MAX_EVENTS);
-  }
-}
-function getRateLimitStats() {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const existing = grouped.get(event.provider);
-    if (existing !== void 0) {
-      existing.push(event);
-    } else {
-      grouped.set(event.provider, [event]);
-    }
-  }
-  const stats = [];
-  for (const [provider, providerEvents] of grouped) {
-    const retryValues = providerEvents.map((e) => e.retryAfterMs).filter((v) => v !== void 0);
-    const avgRetry = retryValues.length > 0 ? retryValues.reduce((a, b) => a + b, 0) / retryValues.length : void 0;
-    const lastEvent = providerEvents[providerEvents.length - 1];
-    stats.push({
-      provider,
-      totalHits: providerEvents.length,
-      lastHitAt: lastEvent?.timestamp ?? 0,
-      ...avgRetry !== void 0 ? { avgRetryAfterMs: Math.round(avgRetry) } : { avgRetryAfterMs: void 0 }
-    });
-  }
-  return stats;
-}
-
-// src/mcp/middleware/tool-metrics.ts
-var MAX_ENTRIES = 5e3;
-var metrics = [];
-function recordToolMetric(metric) {
-  metrics.push(metric);
-  if (metrics.length > MAX_ENTRIES) {
-    metrics.splice(0, metrics.length - MAX_ENTRIES);
-  }
-}
-function getToolStats() {
-  const groups = /* @__PURE__ */ new Map();
-  for (const m of metrics) {
-    const list = groups.get(m.toolName);
-    if (list !== void 0) {
-      list.push(m);
-    } else {
-      groups.set(m.toolName, [m]);
-    }
-  }
-  const stats = [];
-  for (const [toolName, list] of groups) {
-    const sc = list.filter((m) => m.success).length;
-    const td = list.reduce((s, m) => s + m.durationMs, 0);
-    stats.push({
-      toolName,
-      totalCalls: list.length,
-      successRate: sc / list.length,
-      avgDurationMs: td / list.length,
-      errorCount: list.length - sc
-    });
-  }
-  return stats.sort((a, b) => b.totalCalls - a.totalCalls);
-}
-function createMetricsMiddleware() {
-  return async (args, ctx, next) => {
-    const startTime = getTimeProvider().now();
-    try {
-      const result = await next(args, ctx);
-      const durationMs = getTimeProvider().now() - startTime;
-      recordToolMetric({
-        toolName: ctx.requestContext.toolName,
-        durationMs,
-        success: result.isError !== true,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return result;
-    } catch (error) {
-      const durationMs = getTimeProvider().now() - startTime;
-      recordToolMetric({
-        toolName: ctx.requestContext.toolName,
-        durationMs,
-        success: false,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  };
-}
-
-// src/agents/heartbeat-monitor.ts
-var DEFAULT_SLOW_THRESHOLD_MS = HEARTBEAT_TIMEOUTS.slowThresholdMs;
-var DEFAULT_STALLED_THRESHOLD_MS = HEARTBEAT_TIMEOUTS.stalledThresholdMs;
-var DEFAULT_ABSOLUTE_MAX_MS = HEARTBEAT_TIMEOUTS.absoluteMaxMs;
-var HeartbeatMonitor = class {
-  config;
-  sessions = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = {
-      slowThresholdMs: config?.slowThresholdMs ?? DEFAULT_SLOW_THRESHOLD_MS,
-      stalledThresholdMs: config?.stalledThresholdMs ?? DEFAULT_STALLED_THRESHOLD_MS,
-      absoluteMaxMs: config?.absoluteMaxMs ?? DEFAULT_ABSOLUTE_MAX_MS
-    };
-  }
-  /** Start tracking a new expert session. Returns session ID. */
-  startSession(expertId) {
-    const sessionId = `hb-${expertId}-${String(Date.now())}`;
-    const now = Date.now();
-    this.sessions.set(sessionId, {
-      expertId,
-      startedAt: now,
-      lastHeartbeat: now,
-      heartbeatCount: 0,
-      previousHealth: "alive"
-    });
-    return sessionId;
-  }
-  /** Record a heartbeat for an active session. */
-  heartbeat(sessionId) {
-    const entry = this.sessions.get(sessionId);
-    if (entry === void 0) return;
-    entry.lastHeartbeat = Date.now();
-    entry.heartbeatCount++;
-  }
-  /** Stop tracking a session. */
-  endSession(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  /** Check if a session has exceeded the stalled threshold. */
-  isStalled(sessionId) {
-    const entry = this.sessions.get(sessionId);
-    if (entry === void 0) return false;
-    const elapsed = Date.now() - entry.lastHeartbeat;
-    return elapsed >= this.config.stalledThresholdMs;
-  }
-  /** Check if a session has exceeded the absolute max lifetime. */
-  isExpired(sessionId) {
-    const entry = this.sessions.get(sessionId);
-    if (entry === void 0) return false;
-    return Date.now() - entry.startedAt >= this.config.absoluteMaxMs;
-  }
-  /** Get aggregate health report for all active sessions. */
-  getHealth() {
-    const now = Date.now();
-    const sessions = [];
-    let stalledCount = 0;
-    for (const [sessionId, entry] of this.sessions) {
-      const timeSince = now - entry.lastHeartbeat;
-      const health = this.classifyHealth(timeSince);
-      if (health === "stalled") stalledCount++;
-      sessions.push({
-        sessionId,
-        expertId: entry.expertId,
-        startedAt: entry.startedAt,
-        lastHeartbeat: entry.lastHeartbeat,
-        heartbeatCount: entry.heartbeatCount,
-        health,
-        elapsedMs: now - entry.startedAt,
-        timeSinceHeartbeatMs: timeSince
-      });
-    }
-    return {
-      activeSessions: this.sessions.size,
-      stalledSessions: stalledCount,
-      sessions
-    };
-  }
-  /**
-   * Get health state with transition detection for a session.
-   * Updates previousHealth on each call to track transitions.
-   * (Issue #1088 Phase 4 — observability)
-   */
-  getSessionHealth(sessionId) {
-    const entry = this.sessions.get(sessionId);
-    if (entry === void 0) return void 0;
-    const now = Date.now();
-    const timeSince = now - entry.lastHeartbeat;
-    const health = this.classifyHealth(timeSince);
-    const changed = health !== entry.previousHealth;
-    const result = {
-      sessionId,
-      agentId: entry.expertId,
-      health,
-      previousHealth: entry.previousHealth,
-      changed,
-      elapsedMs: now - entry.startedAt,
-      heartbeatCount: entry.heartbeatCount
-    };
-    entry.previousHealth = health;
-    return result;
-  }
-  /** Number of currently tracked sessions. */
-  get activeCount() {
-    return this.sessions.size;
-  }
-  classifyHealth(timeSinceMs) {
-    if (timeSinceMs >= this.config.stalledThresholdMs) return "stalled";
-    if (timeSinceMs >= this.config.slowThresholdMs) return "slow";
-    return "alive";
-  }
-};
-var globalMonitor;
-function getHeartbeatMonitor() {
-  globalMonitor ??= new HeartbeatMonitor();
-  return globalMonitor;
-}
-
-// src/mcp/tools/weather-report.ts
-var CLI_NAMES2 = ["claude", "gemini", "codex", "opencode"];
-function generateWeatherReport(input, config) {
-  const cfg = { ...createDefaultWeatherConfig(), ...config };
-  const store = getOutcomeStore();
-  const includeAdaptive = input.includeAdaptive ?? true;
-  const summary = store.summarize(buildQuery(input.cli, input.category));
-  const cliWeather = buildCliWeather(summary, input);
-  const adaptiveBonuses = includeAdaptive ? computeAdaptiveBonuses(cfg) : [];
-  const tierRecommendations = buildTierRecommendations(summary);
-  const rateLimits = buildRateLimitReport();
-  const toolPerformance = buildToolPerformance();
-  const failureBreakdown = buildFailureBreakdown(input);
-  const agentHealth = buildAgentHealth();
-  const expertPerformance = buildExpertPerformance();
-  const base = {
-    overall: {
-      totalTasks: summary.totalTasks,
-      successRate: summary.successRate,
-      avgDurationMs: summary.avgDurationMs
-    },
-    cliWeather,
-    adaptiveBonuses,
-    tierRecommendations,
-    ...rateLimits.length > 0 ? { rateLimits } : {},
-    ...toolPerformance.length > 0 ? { toolPerformance } : {},
-    ...failureBreakdown.length > 0 ? { failureBreakdown } : {},
-    ...agentHealth !== void 0 ? { agentHealth } : {},
-    ...expertPerformance.length > 0 ? { expertPerformance } : {},
-    explorationRate: cfg.explorationRate,
-    coldStartThreshold: cfg.coldStartThreshold,
-    collectedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (includeAdaptive) {
-    return {
-      ...base,
-      learningInsights: buildLearningInsights(),
-      recommendedMappings: buildRecommendedMappings()
-    };
-  }
-  return base;
-}
-function buildAgentHealth() {
-  const monitor = getHeartbeatMonitor();
-  if (monitor.activeCount === 0) return void 0;
-  const health = monitor.getHealth();
-  return {
-    activeSessions: health.activeSessions,
-    stalledSessions: health.stalledSessions,
-    sessions: health.sessions.map((s) => ({
-      sessionId: s.sessionId,
-      expertId: s.expertId,
-      health: s.health,
-      elapsedMs: s.elapsedMs,
-      timeSinceHeartbeatMs: s.timeSinceHeartbeatMs,
-      heartbeatCount: s.heartbeatCount
-    }))
-  };
-}
-function buildRateLimitReport() {
-  return getRateLimitStats().map((s) => ({
-    provider: s.provider,
-    totalHits: s.totalHits,
-    lastHitAt: s.lastHitAt,
-    avgRetryAfterMs: s.avgRetryAfterMs
-  }));
-}
-function getAdaptiveBonus(cli, category, config) {
-  const cfg = { ...createDefaultWeatherConfig(), ...config };
-  const store = getOutcomeStore();
-  const cliName = cli;
-  const outcomes = store.query({ cli: cliName, category });
-  if (outcomes.length < cfg.coldStartThreshold) return 0;
-  const thresholds = computeAdaptiveThresholds(store, cliName, category);
-  const successRate = outcomes.filter((o) => o.success).length / outcomes.length;
-  const delta = successRate - thresholds.baseline;
-  const maxBonus = thresholds.maxBonus > 0 ? thresholds.maxBonus : cfg.maxBonusAdjustment;
-  const scaled = delta / 0.3 * maxBonus;
-  return clamp(scaled, -maxBonus, maxBonus);
-}
-function buildQuery(cli, category) {
-  const query = {};
-  if (cli !== void 0) query.cli = cli;
-  if (category !== void 0) query.category = category;
-  return query;
-}
-function buildCliWeather(summary, input) {
-  const clis = input.cli !== void 0 ? [input.cli] : [...CLI_NAMES2];
-  return clis.map((cli) => {
-    const stats = summary.byCli.get(cli);
-    const store = getOutcomeStore();
-    const cliOutcomes = store.query({ cli });
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const cat of TASK_CATEGORIES) {
-      const catOutcomes = cliOutcomes.filter((o) => o.category === cat);
-      if (catOutcomes.length > 0) {
-        const sc = catOutcomes.filter((o) => o.success).length;
-        const td = catOutcomes.reduce((s, o) => s + o.durationMs, 0);
-        byCategory.set(cat, {
-          count: catOutcomes.length,
-          successRate: sc / catOutcomes.length,
-          avgDurationMs: td / catOutcomes.length
-        });
-      }
-    }
-    return {
-      cli,
-      totalTasks: stats?.count ?? 0,
-      successRate: stats?.successRate ?? 0,
-      avgDurationMs: stats?.avgDurationMs ?? 0,
-      byCategory
-    };
-  });
-}
-function computeAdaptiveBonuses(cfg) {
-  const bonuses = [];
-  for (const cli of CLI_NAMES2) {
-    for (const category of TASK_CATEGORIES) {
-      const spec = getSpecialization(category);
-      const staticBonus = getStaticBonusForCli(cli, spec);
-      const store = getOutcomeStore();
-      const outcomes = store.query({ cli, category });
-      const sampleCount = outcomes.length;
-      const sufficient = sampleCount >= cfg.coldStartThreshold;
-      const adaptiveAdj = sufficient ? getAdaptiveBonus(cli, category, cfg) : 0;
-      if (sampleCount > 0 || staticBonus > 0 || adaptiveAdj !== 0) {
-        bonuses.push({
-          cli,
-          category,
-          staticBonus,
-          adaptiveBonus: Math.round(adaptiveAdj * 10) / 10,
-          sampleCount,
-          sufficient
-        });
-      }
-    }
-  }
-  return bonuses;
-}
-function getStaticBonusForCli(cli, spec) {
-  if (cli === spec.primaryCli) return spec.bonus;
-  if (cli === spec.secondaryCli) return Math.floor(spec.bonus / 2);
-  return 0;
-}
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
-function buildLearningInsights() {
-  const store = getOutcomeStore();
-  const insights = [];
-  for (const cli of CLI_NAMES2) {
-    for (const category of TASK_CATEGORIES) {
-      const thresholds = computeAdaptiveThresholds(store, cli, category);
-      if (thresholds.sampleCount > 0) {
-        insights.push({
-          cli,
-          category,
-          trend: thresholds.trend,
-          confidence: thresholds.confidence,
-          adjustedBaseline: thresholds.baseline,
-          sampleCount: thresholds.sampleCount
-        });
-      }
-    }
-  }
-  return insights;
-}
-function buildRecommendedMappings() {
-  const store = getOutcomeStore();
-  const mappings = [];
-  for (const category of TASK_CATEGORIES) {
-    let bestCli = "";
-    let bestRate = -1;
-    let bestCount = 0;
-    for (const cli of CLI_NAMES2) {
-      const outcomes = store.query({ cli, category });
-      if (outcomes.length === 0) continue;
-      const rate = outcomes.filter((o) => o.success).length / outcomes.length;
-      if (rate > bestRate || rate === bestRate && outcomes.length > bestCount) {
-        bestCli = cli;
-        bestRate = rate;
-        bestCount = outcomes.length;
-      }
-    }
-    if (bestCli !== "") {
-      const confidence = bestCount >= 20 ? "high" : bestCount >= 10 ? "medium" : "low";
-      mappings.push({
-        category,
-        recommendedCli: bestCli,
-        successRate: bestRate,
-        sampleCount: bestCount,
-        confidence
-      });
-    }
-  }
-  return mappings;
-}
-var WORKER_MODEL_PREFIX = "worker-";
-function findDominantError(failed) {
-  if (failed.length === 0) return void 0;
-  const counts = /* @__PURE__ */ new Map();
-  for (const f of failed) {
-    const cat = f.failureCategory ?? "unknown";
-    counts.set(cat, (counts.get(cat) ?? 0) + 1);
-  }
-  let maxCount = 0;
-  let dominant;
-  for (const [cat, count] of counts) {
-    if (count > maxCount) {
-      maxCount = count;
-      dominant = cat;
-    }
-  }
-  return dominant;
-}
-function buildExpertPerformance() {
-  const store = getOutcomeStore();
-  const allOutcomes = store.query();
-  const workerOutcomes = allOutcomes.filter((o) => o.model.startsWith(WORKER_MODEL_PREFIX));
-  if (workerOutcomes.length === 0) return [];
-  const byRole = /* @__PURE__ */ new Map();
-  for (const o of workerOutcomes) {
-    const role = o.model.slice(WORKER_MODEL_PREFIX.length);
-    const existing = byRole.get(role) ?? [];
-    existing.push(o);
-    byRole.set(role, existing);
-  }
-  const entries = [];
-  for (const [role, outcomes] of byRole) {
-    const successes = outcomes.filter((o) => o.success).length;
-    const totalDuration = outcomes.reduce((s, o) => s + o.durationMs, 0);
-    const dominantErrorPattern = findDominantError(outcomes.filter((o) => !o.success));
-    entries.push({
-      role,
-      totalTasks: outcomes.length,
-      successRate: successes / outcomes.length,
-      avgDurationMs: Math.round(totalDuration / outcomes.length),
-      ...dominantErrorPattern !== void 0 ? { dominantErrorPattern } : {}
-    });
-  }
-  return entries.sort((a, b) => b.totalTasks - a.totalTasks);
-}
-function buildFailureBreakdown(input) {
-  const store = getOutcomeStore();
-  const outcomes = store.query(buildQuery(input.cli, input.category));
-  const failed = outcomes.filter((o) => !o.success);
-  if (failed.length === 0) return [];
-  const counts = /* @__PURE__ */ new Map();
-  for (const o of failed) {
-    const cat = o.failureCategory ?? "unknown";
-    counts.set(cat, (counts.get(cat) ?? 0) + 1);
-  }
-  const entries = [];
-  for (const [category, count] of counts) {
-    entries.push({
-      category,
-      count,
-      percentage: Math.round(count / failed.length * 1e3) / 10
-    });
-  }
-  return entries.sort((a, b) => b.count - a.count);
-}
-function buildToolPerformance() {
-  return getToolStats().map((s) => ({
-    toolName: s.toolName,
-    totalCalls: s.totalCalls,
-    successRate: Math.round(s.successRate * 1e3) / 1e3,
-    avgDurationMs: Math.round(s.avgDurationMs),
-    errorCount: s.errorCount
-  }));
-}
-function buildTierRecommendations(summary) {
-  return generateTierRecommendations(summary).map((r) => ({
-    category: r.category,
-    direction: r.direction,
-    currentTier: r.currentTier,
-    recommendedTier: r.recommendedTier,
-    successRate: r.successRate,
-    sampleCount: r.sampleCount,
-    reason: r.reason
-  }));
-}
-
-export {
-  isRateLimitLikeError,
-  toRateLimitError,
-  recordRateLimitEvent,
-  getHeartbeatMonitor,
-  createMetricsMiddleware,
-  WeatherReportInputSchema,
-  SECURITY_KEYWORDS,
-  ARCHITECTURE_KEYWORDS,
-  PROMOTED_ROLES,
-  classifyRequestTier,
-  parseTierOverrides,
-  generateWeatherReport,
-  getAdaptiveBonus
-};
-//# sourceMappingURL=chunk-PGNRXCYY.js.map