@miphamai/cli 0.32.6 → 0.33.0

package/src/core/meta-rule-engine.ts

@@ -0,0 +1,602 @@
+/**
+ * SIS Phase 3 (RSI Level 3): Meta-Rule Engine — Rules About Rules
+ *
+ * The recursive core of CRSI: analyzes accumulated SIS data to
+ * improve the rule-generation system itself.
+ *
+ * Meta-rule types:
+ *   1. Threshold Tuning — adjust confidence thresholds based on outcomes
+ *   2. Strategy Optimization — which fixStrategy works best per category?
+ *   3. Cross-Rule Patterns — discover relationships across unrelated rules
+ *   4. Category Emergence — detect new error categories not in the predefined set
+ *
+ * Flow:
+ *   ErrorSignatureDB + EffectivenessTracker data
+ *     → MetaRuleEngine.analyze()
+ *       → MetaRule[] (actionable suggestions for rule system improvement)
+ *         → /crsi meta displays + optionally auto-applies safe meta-rules
+ */
+
+import type { ErrorSignatureDB, ErrorSignature } from './error-signature-db.js'
+import type { EffectivenessTracker } from '../agent/effectiveness-tracker.js'
+
+// ── Types ──
+
+export type MetaRuleCategory =
+  'threshold-tuning' | 'strategy-optimization' | 'cross-rule-pattern' | 'category-emergence'
+
+export type MetaRuleConfidence = 'high' | 'medium' | 'low'
+
+export interface MetaRule {
+  /** Unique identifier */
+  id: string
+  /** Type of meta-rule */
+  category: MetaRuleCategory
+  /** Human-readable title */
+  title: string
+  /** Detailed explanation */
+  description: string
+  /** Suggested action */
+  recommendation: string
+  /** Whether this can be auto-applied safely */
+  autoApplicable: boolean
+  /** Statistical evidence supporting this meta-rule */
+  evidence: MetaEvidence
+  /** Confidence level */
+  confidence: MetaRuleConfidence
+  /** When this meta-rule was generated */
+  generatedAt: string
+}
+
+export interface MetaEvidence {
+  /** Number of data points supporting this conclusion */
+  sampleSize: number
+  /** Key metrics */
+  metrics: Record<string, number>
+  /** Supporting rule/signature IDs */
+  relatedIds: string[]
+  /** Raw summary for display */
+  summary: string
+}
+
+export interface MetaAnalysis {
+  /** Discovered meta-rules */
+  metaRules: MetaRule[]
+  /** Overall system health assessment */
+  systemHealth: SystemHealth
+  /** When the analysis was performed */
+  analyzedAt: string
+}
+
+export interface SystemHealth {
+  /** Overall CRSI health score (0-100) */
+  score: number
+  /** Component-level scores */
+  components: {
+    errorSignatures: number // 0-100
+    preflightPrevention: number
+    autoCorrection: number
+    immuneMemory: number
+    ruleEffectiveness: number
+  }
+  /** Top-level assessment */
+  assessment: string
+  /** Recommended actions */
+  recommendations: string[]
+}
+
+// ── Constants ──
+
+/** Minimum data points needed to generate a meta-rule */
+const MIN_SAMPLE_SIZE = 5
+
+// ── Engine ──
+
+export class MetaRuleEngine {
+  private errorDB?: ErrorSignatureDB
+  private tracker?: EffectivenessTracker
+
+  constructor(errorDB?: ErrorSignatureDB, tracker?: EffectivenessTracker) {
+    this.errorDB = errorDB
+    this.tracker = tracker
+  }
+
+  /** Set or update the data sources after construction. */
+  setErrorDB(db: ErrorSignatureDB): void {
+    this.errorDB = db
+  }
+
+  setTracker(tracker: EffectivenessTracker): void {
+    this.tracker = tracker
+  }
+
+  /**
+   * Run a full meta-analysis across all available data sources.
+   *
+   * @returns MetaAnalysis with discovered meta-rules and system health
+   */
+  analyze(): MetaAnalysis {
+    const metaRules: MetaRule[] = []
+
+    // Phase 1: Threshold tuning recommendations
+    metaRules.push(...this.analyzeThresholds())
+
+    // Phase 2: Strategy effectiveness per category
+    metaRules.push(...this.analyzeStrategies())
+
+    // Phase 3: Cross-rule pattern discovery
+    metaRules.push(...this.discoverCrossRulePatterns())
+
+    // Phase 4: Emergent category detection
+    metaRules.push(...this.detectEmergentCategories())
+
+    // Sort by confidence (high → medium → low), then by category severity
+    metaRules.sort((a, b) => {
+      const confOrder = { high: 0, medium: 1, low: 2 }
+      const confDiff = confOrder[a.confidence] - confOrder[b.confidence]
+      if (confDiff !== 0) return confDiff
+      return b.evidence.sampleSize - a.evidence.sampleSize
+    })
+
+    const systemHealth = this.computeSystemHealth(metaRules)
+
+    return {
+      metaRules,
+      systemHealth,
+      analyzedAt: new Date().toISOString(),
+    }
+  }
+
+  // ── Phase 1: Threshold Tuning ──
+
+  /**
+   * Analyze whether current thresholds (AUTO_RETRY_THRESHOLD, ZERO_SUCCESS_THRESHOLD,
+   * SIMILARITY_THRESHOLD) are optimal based on observed outcomes.
+   */
+  private analyzeThresholds(): MetaRule[] {
+    const rules: MetaRule[] = []
+    const sigs = this.errorDB?.getActive() || []
+    if (sigs.length < MIN_SAMPLE_SIZE) return rules
+
+    // Check if many signatures plateau just below AUTO_RETRY_THRESHOLD (0.7)
+    const nearThreshold = sigs.filter(
+      (s) => s.successRate >= 0.5 && s.successRate < 0.7 && s.occurrences >= 5,
+    )
+
+    if (nearThreshold.length >= 3) {
+      const avgRate =
+        nearThreshold.reduce((sum, s) => sum + s.successRate, 0) / nearThreshold.length
+      rules.push({
+        id: `meta-threshold-retry-${Date.now().toString(36)}`,
+        category: 'threshold-tuning',
+        title: '降低自动重试阈值建议',
+        description: `${nearThreshold.length} 个错误签名成功率在 50%-70% 之间（平均 ${Math.round(avgRate * 100)}%），但不足以触发自动重试。如果阈值从 70% 降到 60%，可自动修复其中 ${Math.round(nearThreshold.filter((s) => s.successRate >= 0.6).length)} 个签名。`,
+        recommendation: `考虑将 AUTO_RETRY_THRESHOLD 从 0.7 降至 0.6，或对特定类别（如 timeout）使用差异化阈值`,
+        autoApplicable: false, // threshold changes need human review
+        evidence: {
+          sampleSize: nearThreshold.length,
+          metrics: {
+            avgSuccessRate: Math.round(avgRate * 100) / 100,
+            belowThreshold: nearThreshold.length,
+            totalSignatures: sigs.length,
+          },
+          relatedIds: nearThreshold.map((s) => s.id),
+          summary: `${nearThreshold.length}/${sigs.length} 签名接近但未达到自动重试阈值`,
+        },
+        confidence: nearThreshold.length >= 5 ? 'high' : 'medium',
+        generatedAt: new Date().toISOString(),
+      })
+    }
+
+    // Check if ZERO_SUCCESS_THRESHOLD (10) is appropriate
+    const zeroSuccess = sigs.filter((s) => s.successCount === 0 && s.occurrences >= 3)
+    if (zeroSuccess.length >= 5) {
+      rules.push({
+        id: `meta-threshold-zero-${Date.now().toString(36)}`,
+        category: 'threshold-tuning',
+        title: '加速零成功率签名淘汰',
+        description: `${zeroSuccess.length} 个签名成功率始终为 0，其中 ${zeroSuccess.filter((s) => s.occurrences >= 5).length} 个已发生 ≥5 次。当前零成功淘汰阈值是 10 次，可考虑降至 5-7 次以加速清理无效签名。`,
+        recommendation: '将 ZERO_SUCCESS_THRESHOLD 从 10 降至 7，加速淘汰无效签名',
+        autoApplicable: false,
+        evidence: {
+          sampleSize: zeroSuccess.length,
+          metrics: {
+            zeroSuccessCount: zeroSuccess.length,
+            avgOccurrences:
+              Math.round(
+                (zeroSuccess.reduce((sum, s) => sum + s.occurrences, 0) / zeroSuccess.length) * 10,
+              ) / 10,
+            wouldRetireAt7: zeroSuccess.filter((s) => s.occurrences >= 7).length,
+          },
+          relatedIds: zeroSuccess.map((s) => s.id),
+          summary: `${zeroSuccess.length} 签名零成功率，可加速淘汰`,
+        },
+        confidence: zeroSuccess.length >= 8 ? 'high' : 'medium',
+        generatedAt: new Date().toISOString(),
+      })
+    }
+
+    return rules
+  }
+
+  // ── Phase 2: Strategy Optimization ──
+
+  /**
+   * Analyze which fixStrategy works best for each error category.
+   * e.g., "replace outperforms warn for timeout errors"
+   */
+  private analyzeStrategies(): MetaRule[] {
+    const rules: MetaRule[] = []
+    const sigs = this.errorDB?.getActive() || []
+    if (sigs.length < MIN_SAMPLE_SIZE) return rules
+
+    // Group by category + fixStrategy
+    const byCatStrategy = new Map<
+      string,
+      { successRates: number[]; occurrences: number[]; ids: string[] }
+    >()
+
+    for (const sig of sigs) {
+      if (sig.occurrences < 3) continue // too new to evaluate
+      const key = `${sig.category}:${sig.fixStrategy}`
+      const entry = byCatStrategy.get(key) || { successRates: [], occurrences: [], ids: [] }
+      entry.successRates.push(sig.successRate)
+      entry.occurrences.push(sig.occurrences)
+      entry.ids.push(sig.id)
+      byCatStrategy.set(key, entry)
+    }
+
+    // For each category, compare strategies
+    const categories = new Set(sigs.map((s) => s.category))
+    for (const cat of categories) {
+      const strategies = new Map<
+        string,
+        { avgRate: number; count: number; totalOcc: number; ids: string[] }
+      >()
+
+      for (const [key, data] of byCatStrategy) {
+        if (!key.startsWith(cat + ':')) continue
+        const strategy = key.split(':')[1]!
+        if (!strategy) continue
+        const avgRate = data.successRates.reduce((a, b) => a + b, 0) / data.successRates.length
+        const totalOcc = data.occurrences.reduce((a, b) => a + b, 0)
+        strategies.set(strategy, {
+          avgRate,
+          count: data.successRates.length,
+          totalOcc,
+          ids: data.ids,
+        })
+      }
+
+      if (strategies.size < 2) continue
+
+      // Find best and worst strategy for this category
+      const sorted = [...strategies.entries()].sort((a, b) => b[1].avgRate - a[1].avgRate)
+      const best = sorted[0]!
+      const worst = sorted[sorted.length - 1]!
+      if (!best || !worst) continue
+
+      if (best[1].avgRate - worst[1].avgRate > 0.2 && best[1].count >= 2) {
+        rules.push({
+          id: `meta-strategy-${cat}-${Date.now().toString(36)}`,
+          category: 'strategy-optimization',
+          title: `${cat} 类别最优策略: ${best[0]}`,
+          description: `在 ${cat} 类别中，\`${best[0]}\` 策略平均成功率 ${Math.round(best[1].avgRate * 100)}%（${best[1].count} 个签名），\`${worst[0]}\` 仅 ${Math.round(worst[1].avgRate * 100)}%（${worst[1].count} 个签名），差距 ${Math.round((best[1].avgRate - worst[1].avgRate) * 100)} 个百分点。`,
+          recommendation: `将 ${cat} 类别的新签名默认策略设为 \`${best[0]}\`，并考虑将现有 \`${worst[0]}\` 策略签名迁移为 \`${best[0]}\``,
+          autoApplicable: best[1].avgRate > 0.85 && best[1].count >= 5,
+          evidence: {
+            sampleSize: best[1].count + worst[1].count,
+            metrics: {
+              bestStrategyAvg: Math.round(best[1].avgRate * 100) / 100,
+              worstStrategyAvg: Math.round(worst[1].avgRate * 100) / 100,
+              gap: Math.round((best[1].avgRate - worst[1].avgRate) * 100) / 100,
+              bestCount: best[1].count,
+              worstCount: worst[1].count,
+            },
+            relatedIds: [...best[1].ids, ...worst[1].ids],
+            summary: `${best[0]} 比 ${worst[0]} 高 ${Math.round((best[1].avgRate - worst[1].avgRate) * 100)}%`,
+          },
+          confidence: best[1].count >= 5 ? 'high' : 'medium',
+          generatedAt: new Date().toISOString(),
+        })
+      }
+    }
+
+    return rules
+  }
+
+  // ── Phase 3: Cross-Rule Pattern Discovery ──
+
+  /**
+   * Discover patterns that span multiple unrelated rules.
+   * e.g., "all rules targeting Bash with high success share the pattern
+   *        of increasing timeout or adding --no-* flags"
+   */
+  private discoverCrossRulePatterns(): MetaRule[] {
+    const rules: MetaRule[] = []
+    const sigs = this.errorDB?.getActive() || []
+    if (sigs.length < 8) return rules
+
+    // Pattern 1: Check if high-success signatures cluster by tool
+    const highSuccess = sigs.filter((s) => s.successRate >= 0.8 && s.occurrences >= 5)
+    const byTool = new Map<string, ErrorSignature[]>()
+    for (const s of highSuccess) {
+      const list = byTool.get(s.toolName) || []
+      list.push(s)
+      byTool.set(s.toolName, list)
+    }
+
+    // If one tool dominates high-success signatures
+    const toolEntries = [...byTool.entries()].sort((a, b) => b[1].length - a[1].length)
+    const dominant = toolEntries[0]
+    const runnerUp = toolEntries[1]
+    if (
+      dominant &&
+      runnerUp &&
+      toolEntries.length >= 2 &&
+      dominant[1].length > runnerUp[1].length * 2
+    ) {
+      rules.push({
+        id: `meta-cross-tool-${Date.now().toString(36)}`,
+        category: 'cross-rule-pattern',
+        title: `${dominant[0]} 工具规则最成熟`,
+        description: `${dominant[0]} 工具有 ${dominant[1].length} 个高成功率签名（≥80%），远超第二名 ${runnerUp[0]}（${runnerUp[1].length} 个）。SIS 对 ${dominant[0]} 类错误的免疫力最强。`,
+        recommendation: `优先在其他工具（${toolEntries
+          .slice(1)
+          .map((e) => e[0])
+          .join(', ')}）上扩展签名覆盖，追赶 ${dominant[0]} 的成熟度`,
+        autoApplicable: false,
+        evidence: {
+          sampleSize: highSuccess.length,
+          metrics: {
+            dominantCount: dominant[1].length,
+            runnerUpCount: runnerUp[1].length,
+            totalHighSuccess: highSuccess.length,
+          },
+          relatedIds: dominant[1].map((s) => s.id),
+          summary: `${dominant[0]} 领先 ${runnerUp[1].length}→${dominant[1].length}`,
+        },
+        confidence: dominant[1].length >= 10 ? 'high' : 'medium',
+        generatedAt: new Date().toISOString(),
+      })
+    }
+
+    // Pattern 2: Detect fix action patterns (common substrings in fix actions)
+    const fixActions = sigs.filter((s) => s.fixAction && s.fixAction.length > 0)
+    if (fixActions.length >= 5) {
+      const commonPrefixes = new Map<string, number>()
+      for (const s of fixActions) {
+        const words = s.fixAction.split(/\s+/)
+        if (words.length >= 2) {
+          const bigram = words.slice(0, 2).join(' ')
+          commonPrefixes.set(bigram, (commonPrefixes.get(bigram) || 0) + 1)
+        }
+      }
+
+      const topBigrams = [...commonPrefixes.entries()]
+        .filter(([, count]) => count >= 3)
+        .sort((a, b) => b[1] - a[1])
+
+      for (const [bigram, count] of topBigrams.slice(0, 3)) {
+        rules.push({
+          id: `meta-cross-bigram-${Date.now().toString(36)}`,
+          category: 'cross-rule-pattern',
+          title: `修复模式复用: "${bigram}..."`,
+          description: `${count} 个签名使用以 "${bigram}" 开头的修复动作。这是高频修复模式，可能值得提升为内置规则模板。`,
+          recommendation: `为 "${bigram}" 模式创建快速修复模板，加速新签名创建`,
+          autoApplicable: false,
+          evidence: {
+            sampleSize: count,
+            metrics: { count, totalFixActions: fixActions.length },
+            relatedIds: fixActions.filter((s) => s.fixAction.startsWith(bigram)).map((s) => s.id),
+            summary: `${count}/${fixActions.length} 修复动作以 "${bigram}" 开头`,
+          },
+          confidence: count >= 5 ? 'high' : 'low',
+          generatedAt: new Date().toISOString(),
+        })
+      }
+    }
+
+    return rules
+  }
+
+  // ── Phase 4: Emergent Category Detection ──
+
+  /**
+   * Detect error categories that don't fit the predefined set.
+   * e.g., if many errors contain "rate limit" or "quota exceeded",
+   * we may need a new 'rate-limit' category.
+   */
+  private detectEmergentCategories(): MetaRule[] {
+    const rules: MetaRule[] = []
+    const sigs = this.errorDB?.getActive() || []
+    if (sigs.length < 10) return rules
+
+    // Look for signature clusters that don't clearly fit known categories
+    // by analyzing pattern keywords
+    const keywords = new Map<string, { count: number; sigs: ErrorSignature[] }>()
+
+    const candidateKeywords = [
+      'rate limit',
+      'quota',
+      'network',
+      'connection',
+      'auth',
+      'token',
+      'memory',
+      'disk',
+      'parse',
+      'syntax',
+      'version',
+      'conflict',
+    ]
+
+    for (const sig of sigs) {
+      const pattern = sig.pattern.toLowerCase()
+      for (const kw of candidateKeywords) {
+        if (pattern.includes(kw)) {
+          const entry = keywords.get(kw) || { count: 0, sigs: [] }
+          entry.count++
+          entry.sigs.push(sig)
+          keywords.set(kw, entry)
+        }
+      }
+    }
+
+    for (const [kw, data] of keywords) {
+      if (data.count >= 3) {
+        // Check if these signatures' current categories are mostly 'semantic'
+        // (meaning the system couldn't classify them well)
+        const semanticRatio = data.sigs.filter((s) => s.category === 'semantic').length / data.count
+
+        rules.push({
+          id: `meta-emergent-${kw.replace(/\s+/g, '-')}-${Date.now().toString(36)}`,
+          category: 'category-emergence',
+          title: `新错误类别候选: "${kw}"`,
+          description: `${data.count} 个签名包含关键词 "${kw}"，其中 ${Math.round(semanticRatio * 100)}% 被归类为 'semantic'（无法精细分类）。这可能是一个值得独立追踪的新错误类别。`,
+          recommendation:
+            semanticRatio > 0.5
+              ? `创建新类别 \`${kw.replace(/\s+/g, '-')}\`，将 ${data.count} 个签名重新分类`
+              : `监控 "${kw}" 相关签名增长趋势，若持续增长则创建独立类别`,
+          autoApplicable: false,
+          evidence: {
+            sampleSize: data.count,
+            metrics: {
+              count: data.count,
+              semanticRatio: Math.round(semanticRatio * 100) / 100,
+              avgSuccessRate:
+                Math.round(
+                  (data.sigs.reduce((sum, s) => sum + s.successRate, 0) / data.count) * 100,
+                ) / 100,
+            },
+            relatedIds: data.sigs.map((s) => s.id),
+            summary: `${data.count} 签名匹配 "${kw}"，${Math.round(semanticRatio * 100)}% 为 semantic`,
+          },
+          confidence: data.count >= 5 ? 'high' : data.count >= 4 ? 'medium' : 'low',
+          generatedAt: new Date().toISOString(),
+        })
+      }
+    }
+
+    return rules
+  }
+
+  // ── System Health Computation ──
+
+  /**
+   * Compute overall CRSI system health from meta-analysis results.
+   */
+  private computeSystemHealth(metaRules: MetaRule[]): SystemHealth {
+    const sigs = this.errorDB?.getActive() || []
+    const stats = this.errorDB?.getStats() || { total: 0, active: 0, avgSuccessRate: 0 }
+
+    // ── Error Signatures health ──
+    let errorSignaturesScore = 50 // baseline
+    if (sigs.length > 0) {
+      const coverageBonus = Math.min(sigs.length * 2, 30) // up to 30 for volume
+      const successBonus = Math.round(stats.avgSuccessRate * 20) // up to 20 for quality
+      errorSignaturesScore = Math.min(50 + coverageBonus + successBonus, 100)
+    }
+
+    // ── Preflight Prevention health ──
+    const fixSigs = sigs.filter(
+      (s) =>
+        s.fixStrategy === 'replace' || s.fixStrategy === 'prepend' || s.fixStrategy === 'append',
+    ).length
+    let preflightScore = 50
+    if (sigs.length > 0) {
+      const fixRatio = fixSigs / sigs.length
+      preflightScore = Math.min(50 + Math.round(fixRatio * 50), 100)
+    }
+
+    // ── Auto Correction health ──
+    const highConfSigs = sigs.filter((s) => s.successRate >= 0.7).length
+    let autoCorrectionScore = 50
+    if (sigs.length > 0) {
+      autoCorrectionScore = Math.min(50 + Math.round((highConfSigs / sigs.length) * 50), 100)
+    }
+
+    // ── Immune Memory health ──
+    let immuneScore = 50
+    if (stats.total > 0) {
+      const activeRatio = stats.active / stats.total
+      immuneScore = Math.min(50 + Math.round(activeRatio * 50), 100)
+    }
+
+    // ── Rule Effectiveness health (from tracker) ──
+    let ruleEffectivenessScore = 50 // default if no tracker
+    if (this.tracker) {
+      const allEff = this.tracker.allRules
+      if (allEff.length > 0) {
+        const avgSuccess =
+          allEff.reduce((sum, e) => {
+            const rate = e.appliedCount > 0 ? e.successAfterCount / e.appliedCount : 0
+            return sum + rate
+          }, 0) / allEff.length
+        ruleEffectivenessScore = Math.min(50 + Math.round(avgSuccess * 50), 100)
+      }
+    }
+
+    // ── Composite Score ──
+    const score = Math.round(
+      errorSignaturesScore * 0.25 +
+        preflightScore * 0.2 +
+        autoCorrectionScore * 0.25 +
+        immuneScore * 0.15 +
+        ruleEffectivenessScore * 0.15,
+    )
+
+    // ── Assessment ──
+    let assessment: string
+    if (score >= 80) assessment = '🟢 SIS 免疫系统运行良好。错误覆盖率、自动修复率均处于健康水平。'
+    else if (score >= 60)
+      assessment = '🟡 SIS 免疫系统基本正常。部分组件需要关注，建议按下方推荐优化。'
+    else if (score >= 40) assessment = '🟠 SIS 免疫系统有待加强。错误签名覆盖不足或自动修复率偏低。'
+    else assessment = '🔴 SIS 免疫系统薄弱。需要大量积累错误签名并提升修复成功率。'
+
+    // ── Recommendations ──
+    const recommendations: string[] = []
+    if (errorSignaturesScore < 60) recommendations.push('增加错误签名积累：让系统经历更多错误场景')
+    if (preflightScore < 60) recommendations.push('提升预防能力：将更多 warn 策略升级为 fix 策略')
+    if (autoCorrectionScore < 60)
+      recommendations.push('提升自动修复率：验证并提升现有签名的成功率至 70%+')
+    if (immuneScore < 60) recommendations.push('清理免疫记忆：运行 /sis cleanup 移除过期和无效签名')
+    if (ruleEffectivenessScore < 60)
+      recommendations.push('提升规则有效性：检查 EffectivenessTracker 中低效规则')
+
+    // Add meta-rule driven recommendations
+    const highConfMeta = metaRules.filter((m) => m.confidence === 'high')
+    if (highConfMeta.length > 0) {
+      recommendations.push(`发现 ${highConfMeta.length} 个高置信度元规则，建议审查后应用`)
+    }
+
+    const autoApplicable = metaRules.filter((m) => m.autoApplicable)
+    if (autoApplicable.length > 0) {
+      recommendations.push(`${autoApplicable.length} 个元规则可自动应用，执行 /crsi meta --apply`)
+    }
+
+    if (recommendations.length === 0) {
+      recommendations.push('系统运行良好，无需立即行动。持续监控即可。')
+    }
+
+    return {
+      score,
+      components: {
+        errorSignatures: errorSignaturesScore,
+        preflightPrevention: preflightScore,
+        autoCorrection: autoCorrectionScore,
+        immuneMemory: immuneScore,
+        ruleEffectiveness: ruleEffectivenessScore,
+      },
+      assessment,
+      recommendations,
+    }
+  }
+
+  /**
+   * Get a summary of auto-applicable meta-rules for safe auto-application.
+   */
+  getAutoApplicable(metaRules: MetaRule[]): MetaRule[] {
+    return metaRules.filter((m) => m.autoApplicable && m.confidence === 'high')
+  }
+}