@miphamai/cli 0.23.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-context.ts

@@ -5,7 +5,9 @@ import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
+import type { CrsiConfig } from '../shared/index.ts'
 import { AgentExperience } from './agent-experience'
+import { ExperienceRuleExtractor } from './experience-rules.js'
 
 export interface AgentContextResult {
   context: ContextManager
@@ -15,8 +17,14 @@ export interface AgentContextResult {
 /**
  * Load agent memory files from the appropriate scope directory.
  * Returns combined content for injection into the system prompt.
+ *
+ * @param crsiRuleInjection — when false, skip experience rule extraction (CRSI feature flag).
  */
-function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local'): string {
+function loadAgentMemory(
+  agentName: string,
+  scope: 'user' | 'project' | 'local',
+  crsiRuleInjection = true,
+): string {
   let memoryDir: string
   const home = homedir()
 
@@ -56,63 +64,16 @@ function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local')
     }
   }
 
-  // Load auto-accumulated experience (always from user scope)
-  const exp = new AgentExperience(agentName)
-  const experienceContent = exp.getExperience()
-
+  // Load auto-accumulated experience rules (always from user scope)
+  // Gated by crsi.ruleInjection feature flag
   let experienceMemory = ''
-  if (experienceContent) {
-    const lines = experienceContent.split('\n')
-    const statsIdx = lines.findIndex((l) => l.startsWith('## Stats'))
-    const successIdx = lines.findIndex((l) => l.startsWith('## Success Patterns'))
-    const failureIdx = lines.findIndex((l) => l.startsWith('## Failure Patterns'))
-
-    // Header: content before the first section
-    const firstSection = Math.min(
-      successIdx !== -1 ? successIdx : Infinity,
-      failureIdx !== -1 ? failureIdx : Infinity,
-      statsIdx !== -1 ? statsIdx : Infinity,
-    )
-    const header = lines.slice(0, firstSection === Infinity ? 3 : firstSection)
-
-    // Last 5 success entries (summary line only, not detail)
-    const successLines: string[] = []
-    if (successIdx !== -1) {
-      const endIdx = Math.min(
-        failureIdx !== -1 && failureIdx > successIdx ? failureIdx : Infinity,
-        statsIdx !== -1 && statsIdx > successIdx ? statsIdx : Infinity,
-      )
-      successLines.push(
-        ...lines
-          .slice(successIdx + 1, endIdx === Infinity ? undefined : endIdx)
-          .filter((l) => l.startsWith('- ['))
-          .slice(-5),
-      )
-    }
-
-    // Last 3 failure entries (summary line only, not detail)
-    const failureLines: string[] = []
-    if (failureIdx !== -1) {
-      const endIdx = statsIdx !== -1 && statsIdx > failureIdx ? statsIdx : Infinity
-      failureLines.push(
-        ...lines
-          .slice(failureIdx + 1, endIdx === Infinity ? undefined : endIdx)
-          .filter((l) => l.startsWith('- ['))
-          .slice(-3),
-      )
-    }
-
-    // Stats section (header + stat line)
-    const stats = statsIdx !== -1 ? lines.slice(statsIdx, statsIdx + 3) : []
+  if (crsiRuleInjection) {
+    const exp = new AgentExperience(agentName)
+    const extractor = new ExperienceRuleExtractor()
+    const rules = extractor.prioritize(exp.getRules())
 
-    if (successLines.length > 0 || failureLines.length > 0) {
-      experienceMemory = [
-        '## Agent Experience',
-        ...header.filter((l) => l.trim()),
-        ...successLines,
-        ...failureLines,
-        ...stats,
-      ].join('\n')
+    if (rules.length > 0) {
+      experienceMemory = extractor.formatForInjection(rules)
     }
   }
 
@@ -139,6 +100,7 @@ export function createAgentContext(
   agentDef: AgentDefinition,
   toolRegistry: Map<string, ToolDefinition>,
   contextWindow?: number,
+  crsiConfig?: Partial<CrsiConfig>,
 ): AgentContextResult {
   // Create isolated context
   const context = new ContextManager({
@@ -149,7 +111,8 @@ export function createAgentContext(
   // Build system prompt with optional agent memory
   let systemPrompt = agentDef.systemPrompt
   if (agentDef.memory) {
-    const memory = loadAgentMemory(agentDef.name, agentDef.memory)
+    const ruleInjection = crsiConfig?.ruleInjection !== false
+    const memory = loadAgentMemory(agentDef.name, agentDef.memory, ruleInjection)
     if (memory) {
       systemPrompt = `${systemPrompt}\n\n---\n\n${memory}`
     }

package/src/agent/agent-experience.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
+import { ExperienceRuleExtractor, type ExperienceRule } from './experience-rules.js'
 
 const MAX_EXPERIENCES = 20
 
@@ -46,6 +47,13 @@ export class AgentExperience {
     }
   }
 
+  getRules(): ExperienceRule[] {
+    const content = this.getExperience()
+    if (!content) return []
+    const extractor = new ExperienceRuleExtractor()
+    return extractor.extract(content, this.agentName)
+  }
+
   private appendToSection(section: string, entry: string, type: 'success' | 'failure'): void {
     mkdirSync(this.expDir, { recursive: true })
 

package/src/agent/effectiveness-tracker.ts

@@ -0,0 +1,149 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface RuleEffectiveness {
+  ruleId: string
+  appliedCount: number
+  successAfterCount: number
+  preRuleFailureRate: number
+  postRuleFailureRate: number
+  status: 'active' | 'degrading' | 'disabled'
+  createdAt: string
+  lastEvaluatedAt: string
+  evaluationHistory: Array<{
+    date: string
+    appliedCount: number
+    failureRate: number
+  }>
+}
+
+const EVAL_THRESHOLD = 10 // evaluate after 10 applications
+const STORE_FILE = 'effectiveness.json'
+
+export class EffectivenessTracker {
+  private data: Map<string, RuleEffectiveness>
+  private storePath: string
+
+  constructor(storeDir: string = join(process.env.HOME || '~', '.mipham', 'rule-engine')) {
+    this.storePath = join(storeDir, STORE_FILE)
+    this.data = new Map()
+  }
+
+  recordApplication(ruleId: string, success: boolean): void {
+    let eff = this.data.get(ruleId)
+    if (!eff) {
+      eff = {
+        ruleId,
+        appliedCount: 0,
+        successAfterCount: 0,
+        preRuleFailureRate: 1.0,
+        postRuleFailureRate: 0,
+        status: 'active',
+        createdAt: new Date().toISOString().slice(0, 10),
+        lastEvaluatedAt: '',
+        evaluationHistory: [],
+      }
+      this.data.set(ruleId, eff)
+    }
+
+    eff.appliedCount++
+    if (success) eff.successAfterCount++
+
+    // Calculate current failure rate
+    if (eff.appliedCount >= EVAL_THRESHOLD) {
+      eff.postRuleFailureRate = 1 - eff.successAfterCount / eff.appliedCount
+    }
+  }
+
+  /**
+   * Evaluate rule effectiveness and return auto-management actions.
+   *
+   * @param autoRuleManagement — when false, skip auto-degrade/disable/enable logic
+   *   but still record evaluation history for manual review. Default true.
+   */
+  evaluate(autoRuleManagement = true): {
+    upgrades: string[]
+    degradations: string[]
+    disables: string[]
+  } {
+    const result = {
+      upgrades: [] as string[],
+      degradations: [] as string[],
+      disables: [] as string[],
+    }
+    const now = new Date().toISOString().slice(0, 10)
+
+    for (const [ruleId, eff] of this.data) {
+      if (eff.appliedCount < EVAL_THRESHOLD) continue
+
+      eff.lastEvaluatedAt = now
+      eff.evaluationHistory.push({
+        date: now,
+        appliedCount: eff.appliedCount,
+        failureRate: eff.postRuleFailureRate,
+      })
+
+      // Keep max 10 history entries
+      if (eff.evaluationHistory.length > 10) {
+        eff.evaluationHistory = eff.evaluationHistory.slice(-10)
+      }
+
+      // Auto-management is gated by crsi.autoRuleManagement feature flag
+      if (!autoRuleManagement) continue
+
+      // Degrade: active rule with high failure rate
+      if (eff.status === 'active' && eff.postRuleFailureRate > 0.6) {
+        eff.status = 'degrading'
+        result.degradations.push(ruleId)
+      }
+
+      // Disable: degrading rule with no improvement across evaluations
+      if (eff.status === 'degrading' && eff.evaluationHistory.length >= 2) {
+        const last = eff.evaluationHistory[eff.evaluationHistory.length - 1]
+        const prev = eff.evaluationHistory[eff.evaluationHistory.length - 2]
+        if (last!.failureRate >= prev!.failureRate) {
+          eff.status = 'disabled'
+          result.disables.push(ruleId)
+        }
+      }
+
+      // Upgrade: degrading rule that has improved significantly
+      if (eff.status === 'degrading' && eff.postRuleFailureRate < 0.4) {
+        eff.status = 'active'
+        result.upgrades.push(ruleId)
+      }
+    }
+
+    return result
+  }
+
+  getEffectiveness(ruleId: string): RuleEffectiveness | null {
+    return this.data.get(ruleId) || null
+  }
+
+  persist(): void {
+    const dir = dirname(this.storePath)
+    mkdirSync(dir, { recursive: true })
+
+    const obj: Record<string, RuleEffectiveness> = {}
+    for (const [k, v] of this.data) {
+      obj[k] = v
+    }
+    writeFileSync(this.storePath, JSON.stringify(obj, null, 2), 'utf-8')
+  }
+
+  load(): void {
+    if (!existsSync(this.storePath)) return
+    try {
+      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8'))
+      this.data = new Map(Object.entries(raw))
+    } catch {
+      // Corrupt file — start fresh
+      this.data = new Map()
+    }
+  }
+
+  get allRules(): RuleEffectiveness[] {
+    return Array.from(this.data.values())
+  }
+}

package/src/agent/experience-rules.ts

@@ -0,0 +1,188 @@
+export interface ExperienceRule {
+  id: string // rule-<category>-<shortHash>
+  type: 'mandatory' | 'warning'
+  condition: string
+  action: string
+  evidence: {
+    failureCount: number
+    lastFailure: string // ISO date
+    examples: string[]
+  }
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  source: 'agent-experience' | 'manual' | 'pattern-analyzer'
+  agentName: string
+  createdAt: string // ISO date
+}
+
+export interface FailureEntry {
+  date: string
+  description: string
+}
+
+export function parseFailureEntries(content: string): FailureEntry[] {
+  const entries: FailureEntry[] = []
+  const failureIdx = content.indexOf('## Failure Patterns')
+  if (failureIdx === -1) return entries
+
+  const afterFailure = content.slice(failureIdx)
+  const nextSection = afterFailure.indexOf('\n## ', '## Failure Patterns'.length)
+  const section = nextSection !== -1 ? afterFailure.slice(0, nextSection) : afterFailure
+
+  const lines = section.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^- \[(\d{4}-\d{2}-\d{2})\]\s+(.+)/)
+    if (match && match[1] && match[2]) {
+      entries.push({ date: match[1], description: match[2].trim() })
+    }
+  }
+  return entries
+}
+
+export function categorize(description: string): ExperienceRule['category'] {
+  const lower = description.toLowerCase()
+  if (lower.includes('timeout')) return 'timeout'
+  if (/module_not_found|import|\.js/.test(lower)) return 'import'
+  if (/grep|token.*overflow|search.*scope/.test(lower)) return 'search'
+  if (/bash|command.*fail|docker|npm|pnpm|cargo|brew/.test(lower)) return 'tool-params'
+  return 'semantic'
+}
+
+function createRuleId(category: string, description: string): string {
+  // Hash the first 30 chars of description for uniqueness
+  const hash = description
+    .slice(0, 30)
+    .split('')
+    .reduce((acc, c) => {
+      return ((acc << 5) - acc + c.charCodeAt(0)) | 0
+    }, 0)
+    .toString(36)
+    .slice(-6)
+  return `rule-${category}-${hash}`
+}
+
+function conditionForCategory(category: string, entries: FailureEntry[]): string {
+  const combined = entries.map((e) => e.description).join('; ')
+  switch (category) {
+    case 'timeout':
+      return 'heavy CLI commands (npm/docker/pnpm)'
+    case 'import':
+      return 'ESM module imports missing .js extension'
+    case 'search':
+      return 'full-repository Grep without directory scoping'
+    case 'tool-params':
+      return combined.slice(0, 100)
+    default:
+      return combined.slice(0, 100)
+  }
+}
+
+function actionForCategory(category: string): string {
+  switch (category) {
+    case 'timeout':
+      return 'set Bash timeout ≥ 300000ms for heavy commands'
+    case 'import':
+      return 'always append .js extension to ESM relative imports'
+    case 'search':
+      return 'use Glob to narrow directory before Grep'
+    case 'tool-params':
+      return 'review and adjust tool parameters before execution'
+    default:
+      return 'verify tool parameters match known good patterns'
+  }
+}
+
+export class ExperienceRuleExtractor {
+  extract(content: string, agentName: string): ExperienceRule[] {
+    if (!content || !content.includes('## Failure Patterns')) return []
+
+    const entries = parseFailureEntries(content)
+    if (entries.length < 2) return []
+
+    // Group by category
+    const byCategory = new Map<string, FailureEntry[]>()
+    for (const entry of entries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || []
+      existing.push(entry)
+      byCategory.set(cat, existing)
+    }
+
+    const rules: ExperienceRule[] = []
+    for (const [category, catEntries] of byCategory) {
+      if (catEntries.length < 2) continue
+
+      const type: 'mandatory' | 'warning' = catEntries.length >= 3 ? 'mandatory' : 'warning'
+      const firstEntry = catEntries[0]
+      const lastEntry = catEntries[catEntries.length - 1]
+      if (!firstEntry || !lastEntry) continue
+
+      rules.push({
+        id: createRuleId(category, firstEntry.description),
+        type,
+        condition: conditionForCategory(category, catEntries),
+        action: actionForCategory(category),
+        evidence: {
+          failureCount: catEntries.length,
+          lastFailure: lastEntry.date,
+          examples: catEntries.slice(0, 3).map((e) => e.description),
+        },
+        category: category as ExperienceRule['category'],
+        source: 'agent-experience',
+        agentName,
+        createdAt: new Date().toISOString().slice(0, 10),
+      })
+    }
+
+    return rules
+  }
+
+  prioritize(rules: ExperienceRule[]): ExperienceRule[] {
+    const order: Record<string, number> = {
+      mandatory: 0,
+      warning: 1,
+    }
+    return [...rules].sort((a, b) => {
+      const aOrder = order[a.type] ?? 0
+      const bOrder = order[b.type] ?? 0
+      const typeDiff = aOrder - bOrder
+      if (typeDiff !== 0) return typeDiff
+      // Within same type, more failures first
+      return b.evidence.failureCount - a.evidence.failureCount
+    })
+  }
+
+  formatForInjection(rules: ExperienceRule[]): string {
+    if (rules.length === 0) return ''
+
+    const mandatory = rules.filter((r) => r.type === 'mandatory')
+    const warnings = rules.filter((r) => r.type === 'warning')
+
+    let output = ''
+
+    if (mandatory.length > 0) {
+      output += '## ⚠️ Active Mandatory Rules (learned from past failures)\n\n'
+      for (const r of mandatory) {
+        const idx = mandatory.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} failures`
+        if (r.evidence.lastFailure) output += `, last: ${r.evidence.lastFailure}`
+        output += '\n'
+        if (r.evidence.examples.length > 0) {
+          output += `   Example: ${r.evidence.examples[0]}\n`
+        }
+        output += '\n'
+      }
+    }
+
+    if (warnings.length > 0) {
+      output += '## ⚡ Observed Patterns (warning level)\n\n'
+      for (const r of warnings) {
+        const idx = warnings.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} occurrences\n\n`
+      }
+    }
+
+    return output.trim()
+  }
+}

package/src/agent/pattern-analyzer.ts

@@ -0,0 +1,154 @@
+import { readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { AgentExperience } from './agent-experience.js'
+import { parseFailureEntries, categorize, type ExperienceRule } from './experience-rules.js'
+import type { ToolRule } from '../core/rule-engine.js'
+
+export interface Pattern {
+  id: string
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  agentName: string
+  frequency: number
+  confidence: 'high' | 'medium' | 'low'
+  examples: string[]
+  firstSeen: string
+  lastSeen: string
+}
+
+export class PatternAnalyzer {
+  analyzeAgent(agentName: string, baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    const exp = new AgentExperience(agentName, dir)
+    const content = exp.getExperience()
+    if (!content) return []
+
+    const allEntries = parseFailureEntries(content)
+
+    // Group by category
+    const byCategory = new Map<string, { descriptions: string[]; dates: string[] }>()
+    for (const entry of allEntries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || { descriptions: [], dates: [] }
+      existing.descriptions.push(entry.description)
+      existing.dates.push(entry.date)
+      byCategory.set(cat, existing)
+    }
+
+    const patterns: Pattern[] = []
+    for (const [category, data] of byCategory) {
+      if (data.descriptions.length < 3) continue
+
+      patterns.push({
+        id: `pattern-${category}-${agentName}`,
+        category: category as Pattern['category'],
+        agentName,
+        frequency: data.descriptions.length,
+        confidence: data.descriptions.length >= 5 ? 'high' : 'medium',
+        examples: data.descriptions.slice(0, 5),
+        firstSeen: data.dates[0] ?? '',
+        lastSeen: data.dates[data.dates.length - 1] ?? '',
+      })
+    }
+
+    return patterns
+  }
+
+  analyzeAllAgents(baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    if (!existsSync(dir)) return []
+
+    let agents: string[]
+    try {
+      agents = readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+    } catch {
+      return []
+    }
+
+    const allPatterns: Pattern[] = []
+    for (const agent of agents) {
+      allPatterns.push(...this.analyzeAgent(agent, baseDir))
+    }
+    return allPatterns
+  }
+
+  toRule(pattern: Pattern): ExperienceRule {
+    return {
+      id: `${pattern.id}-${Date.now().toString(36)}`,
+      type: pattern.frequency >= 3 ? 'mandatory' : 'warning',
+      condition: this._conditionForCategory(pattern),
+      action: this._actionForCategory(pattern.category),
+      evidence: {
+        failureCount: pattern.frequency,
+        lastFailure: pattern.lastSeen,
+        examples: pattern.examples.slice(0, 3),
+      },
+      category: pattern.category,
+      source: 'pattern-analyzer',
+      agentName: pattern.agentName,
+      createdAt: new Date().toISOString().slice(0, 10),
+    }
+  }
+
+  toToolRule(pattern: Pattern): ToolRule {
+    const toolNameMap: Record<string, string> = {
+      timeout: 'Bash',
+      'tool-params': 'Bash',
+      import: 'Write',
+      search: 'Grep',
+      semantic: 'Bash',
+    }
+
+    return {
+      id: pattern.id,
+      toolName: toolNameMap[pattern.category] || 'Bash',
+      category: pattern.category,
+      match: (p: Record<string, unknown>): boolean => {
+        if (pattern.category === 'timeout') {
+          const cmd = String(p.command ?? '')
+          const heavy = /npm|docker|pnpm|cargo|brew|install|build/.test(cmd)
+          if (!heavy) return false
+          const timeout = (p as Record<string, unknown>).timeout as number | undefined
+          return !timeout || timeout < 300_000
+        }
+        return true
+      },
+      fix: (p: Record<string, unknown>) => ({
+        modified: pattern.category === 'timeout' ? { ...p, timeout: 300_000 } : p,
+        warning: `🤖 [auto-rule] ${pattern.category}: ${pattern.frequency} 次同类失败 — ${this._actionForCategory(pattern.category)}`,
+      }),
+      source: 'pattern-analyzer',
+      enabled: true,
+    }
+  }
+
+  // ── Private helpers ──
+
+  private _conditionForCategory(pattern: Pattern): string {
+    switch (pattern.category) {
+      case 'timeout':
+        return 'heavy CLI commands (npm/docker/pnpm/cargo)'
+      case 'import':
+        return 'ESM module imports missing .js extension'
+      case 'search':
+        return 'full-repository search without directory scoping'
+      default:
+        return pattern.examples[0]?.slice(0, 100) || 'unknown condition'
+    }
+  }
+
+  private _actionForCategory(category: string): string {
+    switch (category) {
+      case 'timeout':
+        return 'set Bash timeout ≥ 300000ms for heavy commands'
+      case 'import':
+        return 'append .js extension to ESM relative imports'
+      case 'search':
+        return 'use Glob to narrow directory before Grep'
+      default:
+        return 'review and adjust tool parameters before execution'
+    }
+  }
+}

package/src/agent/sub-agent.ts

@@ -7,6 +7,16 @@ import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
 import { AgentExperience } from './agent-experience'
+import { PatternAnalyzer } from './pattern-analyzer.js'
+import type { ExperienceRuleEngine } from '../core/rule-engine.js'
+
+// Singleton instances (created lazily)
+let _patternAnalyzer: PatternAnalyzer | undefined
+
+function getPatternAnalyzer(): PatternAnalyzer {
+  if (!_patternAnalyzer) _patternAnalyzer = new PatternAnalyzer()
+  return _patternAnalyzer
+}
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -32,6 +42,7 @@ export class SubAgent {
     private toolRegistry: Map<string, ToolDefinition>,
     private permission?: PermissionSystem,
     private hookEngine?: HookEngine,
+    private ruleEngine?: ExperienceRuleEngine,
   ) {}
 
   /**
@@ -85,6 +96,24 @@ export class SubAgent {
             options.agentDef,
           )
         }
+
+        // CRSI: trigger pattern analysis after each agent execution
+        // Gated by crsi.autoPatternAnalysis feature flag
+        if (options.autoPatternAnalysis !== false) {
+          try {
+            const analyzer = getPatternAnalyzer()
+            const agentName = options.agentDef?.name || agentType
+            const patterns = analyzer.analyzeAgent(agentName)
+            if (patterns.length > 0 && this.ruleEngine) {
+              for (const pattern of patterns) {
+                const toolRule = analyzer.toToolRule(pattern)
+                this.ruleEngine.register(toolRule)
+              }
+            }
+          } catch {
+            // Pattern analysis failure never blocks agent execution
+          }
+        }
       })
 
       return `[background-task:${taskId}]`
@@ -97,6 +126,25 @@ export class SubAgent {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
       this.logSuccessExperience(agentType, description, result, options.agentDef)
+
+      // CRSI: trigger pattern analysis after successful sync execution
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       return result
     } catch (err) {
       if (this.hookEngine) {
@@ -109,6 +157,25 @@ export class SubAgent {
         )
       }
       this.logFailureExperience(agentType, description, String(err), options.agentDef)
+
+      // CRSI: trigger pattern analysis after failed sync execution (failures produce patterns too)
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       throw err
     }
   }

package/src/agent/types.ts

@@ -46,4 +46,6 @@ export interface SubAgentOptions {
   onProgress?: (chunk: string) => void
   /** When set, tool executions use this path as cwd (git worktree isolation). */
   worktreePath?: string
+  /** CRSI: when false, skip pattern analysis after agent execution. Default true. */
+  autoPatternAnalysis?: boolean
 }

package/src/config/defaults.ts

@@ -22,6 +22,12 @@ export const DEFAULT_CONFIG: MiphamConfig = {
     mcp: { oauthEnabled: true },
     context: { useRealTokenizer: true, adaptiveThresholds: true },
   },
+  crsi: {
+    ruleInjection: true,
+    preToolHook: true,
+    autoPatternAnalysis: true,
+    autoRuleManagement: true,
+  },
 }
 
 export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {

package/src/core/engine.ts

@@ -3,6 +3,7 @@ import type {
   ToolDefinition,
   ToolResult,
   InferenceHookConfig,
+  CrsiConfig,
 } from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
@@ -16,6 +17,9 @@ import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import type { SkillsLoader } from '../skills/loader'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
 import { RulesLoader } from './rules-loader'
+import { ExperienceRuleEngine } from './rule-engine.js'
+import { PatternAnalyzer } from '../agent/pattern-analyzer.js'
+import { EffectivenessTracker } from '../agent/effectiveness-tracker.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
@@ -37,6 +41,9 @@ export class QueryEngine {
   private agentRegistry?: AgentRegistry
   private agentViewManager?: AgentViewManager
   private skillsLoader?: SkillsLoader
+  private ruleEngine?: ExperienceRuleEngine
+  private _patternAnalyzer?: PatternAnalyzer
+  private _effectivenessTracker?: EffectivenessTracker
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
@@ -54,7 +61,10 @@ export class QueryEngine {
     private context: ContextManager,
     private tools: Map<string, ToolDefinition>,
     private permission: PermissionSystem = new PermissionSystem('default'),
-  ) {}
+    ruleEngine?: ExperienceRuleEngine,
+  ) {
+    this.ruleEngine = ruleEngine
+  }
 
   /** Session identifier for cross-session messaging. Set by the app startup via setSessionId(). */
   private sessionId: string = 'session-1'
@@ -128,6 +138,8 @@ export class QueryEngine {
   private usageTracker = new UsageTracker()
   /** Inference hook (DLP) configuration. */
   private inferenceHookConfig?: InferenceHookConfig
+  /** CRSI feature flags. */
+  private crsiConfig?: Partial<CrsiConfig>
 
   /** Register the rules loader. */
   setRulesLoader(loader: RulesLoader): void {
@@ -140,6 +152,11 @@ export class QueryEngine {
     this.inferenceHookConfig = config
   }
 
+  /** Register CRSI feature flags. */
+  setCrsiConfig(config: Partial<CrsiConfig> | undefined): void {
+    this.crsiConfig = config
+  }
+
   /** Pending task notifications from background agents (cleared after draining). */
   private pendingTaskNotifications: Array<StreamChunk> = []
 
@@ -796,6 +813,7 @@ export class QueryEngine {
 
     // Run PreToolUse hooks
     let effectiveParams = params
+    let hookWarnings: string[] = []
     if (this.hookEngine) {
       const preResult = await this.hookEngine.executePreToolUse(name, params, this.sessionId)
       if (!preResult.allowed) {
@@ -810,6 +828,17 @@ export class QueryEngine {
       }
     }
 
+    // CRSI RuleEngine intercept — gated by crsi.preToolHook feature flag
+    if (this.crsiConfig?.preToolHook !== false && this.ruleEngine) {
+      const ruleResult = this.ruleEngine.intercept(name, effectiveParams)
+      if (Object.keys(ruleResult.modified).length > 0) {
+        effectiveParams = ruleResult.modified
+      }
+      if (ruleResult.warnings.length > 0) {
+        hookWarnings = ruleResult.warnings
+      }
+    }
+
     try {
       const result = await tool.execute(effectiveParams, {
         cwd: process.cwd(),
@@ -823,16 +852,35 @@ export class QueryEngine {
         agentRegistry: this.agentRegistry,
         backgroundAgentRegistry: getBackgroundAgentRegistry(),
         permissionSystem: this.permission,
+        ruleEngine: this.ruleEngine,
       })
 
       // Track touched files for rules matching
       this.trackTouchedFile(name, effectiveParams)
 
+      // Prepend CRSI warnings to result content
+      if (hookWarnings.length > 0 && result.success) {
+        result.content = hookWarnings.join('\n') + '\n' + (result.content || '')
+      }
+
       // Run PostToolUse hooks
       if (this.hookEngine) {
         await this.hookEngine.executePostToolUse(name, effectiveParams, result, this.sessionId)
       }
 
+      // CRSI: Track rule effectiveness after tool execution
+      if (hookWarnings.length > 0) {
+        const tracker = this.getEffectivenessTracker()
+        for (const warning of hookWarnings) {
+          const match = warning.match(/^\[rule:([^\]]+)\]/)
+          const ruleId = match?.[1]
+          if (ruleId) {
+            tracker.recordApplication(ruleId, result.success)
+          }
+        }
+        tracker.persist()
+      }
+
       return result
     } catch (err) {
       // Sanitize error: strip stack traces and internal paths to prevent
@@ -864,6 +912,27 @@ export class QueryEngine {
     return this.tools
   }
 
+  getRuleEngine(): ExperienceRuleEngine | undefined {
+    return this.ruleEngine
+  }
+
+  /** Lazily-initialized PatternAnalyzer singleton. */
+  getPatternAnalyzer(): PatternAnalyzer {
+    if (!this._patternAnalyzer) {
+      this._patternAnalyzer = new PatternAnalyzer()
+    }
+    return this._patternAnalyzer
+  }
+
+  /** Lazily-initialized EffectivenessTracker singleton. */
+  getEffectivenessTracker(): EffectivenessTracker {
+    if (!this._effectivenessTracker) {
+      this._effectivenessTracker = new EffectivenessTracker()
+      this._effectivenessTracker.load()
+    }
+    return this._effectivenessTracker
+  }
+
   /** Register a tool dynamically (used by MCP auto-registration). */
   registerTool(tool: ToolDefinition): void {
     if (this.tools.has(tool.name)) {

package/src/core/rule-engine.ts

@@ -0,0 +1,179 @@
+import type { ExperienceRule } from '../agent/experience-rules.js'
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface ToolRule {
+  id: string
+  toolName: string
+  category: string
+  match: (params: Record<string, unknown>) => boolean
+  fix: (params: Record<string, unknown>) => {
+    modified: Record<string, unknown>
+    warning: string
+  }
+  source: 'builtin' | 'pattern-analyzer' | 'manual'
+  enabled: boolean
+}
+
+const BUILTIN_RULES: ToolRule[] = [
+  {
+    id: 'rule-timeout-bash-heavy',
+    toolName: 'Bash',
+    category: 'timeout',
+    match: (p: Record<string, unknown>) => {
+      const cmd = String(p.command ?? '')
+      const heavy = /npm (install|ci|test)|docker build|pnpm install|cargo build|brew install/.test(
+        cmd,
+      )
+      if (!heavy) return false
+      const timeout = (p as Record<string, unknown>).timeout as number | undefined
+      return !timeout || timeout < 300_000
+    },
+    fix: (p: Record<string, unknown>) => {
+      const prevTimeout = (p as Record<string, unknown>).timeout as number | undefined
+      return {
+        modified: { ...p, timeout: 300_000 },
+        warning: `⏱️ timeout 已从 ${prevTimeout || 'default'}ms 自动提升至 300000ms（该命令类型历史超时率 > 50%）`,
+      }
+    },
+    source: 'builtin',
+    enabled: true,
+  },
+  {
+    id: 'rule-git-force-protection',
+    toolName: 'Bash',
+    category: 'tool-params',
+    match: (p: Record<string, unknown>) => {
+      const cmd = String(p.command ?? '')
+      return /git (push|reset) .*--force/.test(cmd) && !p.dangerouslyDisableSandbox
+    },
+    fix: (p: Record<string, unknown>) => ({
+      modified: p,
+      warning: '⚠️ 检测到 git --force 操作。如需执行请设置 dangerouslyDisableSandbox: true',
+    }),
+    source: 'builtin',
+    enabled: true,
+  },
+]
+
+export class ExperienceRuleEngine {
+  private rules: ToolRule[]
+  private storePath: string
+
+  constructor(storeDir: string = join(process.env.HOME || '~', '.mipham', 'rule-engine')) {
+    this.rules = [...BUILTIN_RULES.map((r) => ({ ...r }))]
+    this.storePath = join(storeDir, 'rules.json')
+    this.load()
+  }
+
+  register(rule: ToolRule): void {
+    // Replace if same ID exists, otherwise append
+    const idx = this.rules.findIndex((r) => r.id === rule.id)
+    if (idx !== -1) {
+      this.rules[idx] = rule
+    } else {
+      this.rules.push(rule)
+    }
+    this.persist()
+  }
+
+  intercept(
+    toolName: string,
+    params: Record<string, unknown>,
+  ): { modified: Record<string, unknown>; warnings: string[] } {
+    let modified = params
+    const warnings: string[] = []
+
+    for (const rule of this.rules) {
+      if (!rule.enabled) continue
+      if (rule.toolName !== toolName) continue
+
+      try {
+        if (rule.match(modified)) {
+          const result = rule.fix(modified)
+          modified = result.modified
+          if (result.warning) {
+            warnings.push(`[rule:${rule.id}] ${result.warning}`)
+          }
+        }
+      } catch {
+        // Rule match/fix failures never block execution
+      }
+    }
+
+    return { modified, warnings }
+  }
+
+  convertFromExperienceRules(experienceRules: ExperienceRule[]): ToolRule[] {
+    return experienceRules.map((er): ToolRule => {
+      // Map experience rule category to tool name
+      const toolNameMap: Record<string, string> = {
+        timeout: 'Bash',
+        'tool-params': 'Bash',
+        import: 'Write',
+        search: 'Grep',
+        semantic: 'Bash',
+      }
+      const toolName = toolNameMap[er.category] || 'Bash'
+
+      return {
+        id: er.id,
+        toolName,
+        category: er.category,
+        match: (p: Record<string, unknown>): boolean => {
+          if (er.category === 'timeout') {
+            const cmd = String(p.command ?? '')
+            const heavy = /npm|docker|pnpm|cargo|brew|install|build/.test(cmd)
+            if (!heavy) return false
+            const timeout = (p as Record<string, unknown>).timeout as number | undefined
+            return !timeout || timeout < 300_000
+          }
+          // Default: always match for the given tool
+          return true
+        },
+        fix: (p: Record<string, unknown>) => ({
+          modified: { ...p, timeout: 300_000 },
+          warning: `⏱️ [auto-rule] ${er.action} (${er.evidence.failureCount} 次历史失败)`,
+        }),
+        source: 'pattern-analyzer',
+        enabled: true,
+      }
+    })
+  }
+
+  getActiveRules(): ToolRule[] {
+    return this.rules.filter((r) => r.enabled)
+  }
+
+  setRuleEnabled(id: string, enabled: boolean): void {
+    const rule = this.rules.find((r) => r.id === id)
+    if (rule) {
+      rule.enabled = enabled
+      this.persist()
+    }
+  }
+
+  /** Persist non-builtin rules to disk. */
+  persist(): void {
+    const nonBuiltin = this.rules.filter((r) => r.source !== 'builtin')
+    const dir = dirname(this.storePath)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(this.storePath, JSON.stringify(nonBuiltin, null, 2), 'utf-8')
+  }
+
+  /** Load persisted non-builtin rules from disk. Rejects rules whose IDs conflict with builtins. */
+  load(): void {
+    if (!existsSync(this.storePath)) return
+    try {
+      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8')) as ToolRule[]
+      const builtinIds = new Set(BUILTIN_RULES.map((r) => r.id))
+      for (const rule of raw) {
+        // Reject if a builtin with the same ID exists (builtins always win)
+        if (builtinIds.has(rule.id)) continue
+        this.rules.push(rule)
+      }
+    } catch {
+      // Corrupt file — start fresh with only builtins
+    }
+  }
+}

package/src/index.tsx

@@ -20,6 +20,7 @@ import { InstructionsLoader } from './core/instructions'
 import { loadSessionMemories, getMemoryManager } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
 import { QueryEngine } from './core/engine'
+import { ExperienceRuleEngine } from './core/rule-engine.js'
 import { SessionStore } from './core/session-store'
 import type { PermissionLevel } from './shared/types'
 import { SkillsLoader } from './skills/loader'
@@ -247,7 +248,8 @@ export async function runApp(options: RunOptions): Promise<void> {
   const artifactServer = new ArtifactServer(artifactsDir, ARTIFACT_PORT)
 
   // Create query engine
-  const engine = new QueryEngine(registry, context, tools)
+  const ruleEngine = new ExperienceRuleEngine()
+  const engine = new QueryEngine(registry, context, tools, undefined, ruleEngine)
   engine.setHookEngine(hookEngine)
   engine.setArtifactServer(artifactServer)
   engine.setAgentViewManager(agentViewManager)

package/src/shared/types.ts

@@ -72,6 +72,7 @@ export interface ToolContext {
   agentRegistry?: import('../agent/agent-registry').AgentRegistry
   backgroundAgentRegistry?: import('../agent/background-registry').BackgroundAgentRegistry
   permissionSystem?: import('../core/permission').PermissionSystem
+  ruleEngine?: import('../core/rule-engine').ExperienceRuleEngine
 }
 
 // ── Artifact Types ──
@@ -162,6 +163,8 @@ export interface MiphamConfig {
   }
   /** Phase 9 feature flags. All default to true. */
   features?: Partial<FeatureFlags>
+  /** Phase 10 CRSI feature flags. All default to true. */
+  crsi?: Partial<CrsiConfig>
 }
 
 export interface FeatureFlags {
@@ -169,6 +172,17 @@ export interface FeatureFlags {
   context: { useRealTokenizer: boolean; adaptiveThresholds: boolean }
 }
 
+export interface CrsiConfig {
+  /** Extract and inject experience rules into agent system prompts. */
+  ruleInjection: boolean
+  /** Intercept tool calls and auto-fix known failure patterns before execution. */
+  preToolHook: boolean
+  /** Analyze agent outcomes for recurring failure patterns. */
+  autoPatternAnalysis: boolean
+  /** Auto-degrade/disable low-effectiveness rules based on success-rate tracking. */
+  autoRuleManagement: boolean
+}
+
 export interface McpServerConfig {
   name: string
   command: string

package/src/tools/agent/agent.ts

@@ -60,7 +60,13 @@ export const agentTool: ToolDefinition = {
     const agentDef = ctx.agentRegistry?.resolve(agentType)
 
     try {
-      const sub = new SubAgent(registry, toolRegistry, ctx.permissionSystem)
+      const sub = new SubAgent(
+        registry,
+        toolRegistry,
+        ctx.permissionSystem,
+        undefined,
+        ctx.ruleEngine,
+      )
       const result = await sub.execute(prompt, description, {
         type: agentType,
         agentDef,

package/src/ui/commands.ts

@@ -446,6 +446,124 @@ const skillsCmd: CommandHandler = (ctx) => {
   return { content: lines.join('\n') }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// CRSI (Conversational Rule Self-Improvement)
+// ═══════════════════════════════════════════════════════════════
+
+const crsiRulesCmd: CommandHandler = (ctx) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const rules = engine.getActiveRules()
+  if (rules.length === 0) {
+    return { content: 'No active CRSI rules.' }
+  }
+  const lines: string[] = ['## Active CRSI Rules', '']
+  for (const r of rules) {
+    const status = r.enabled ? '✅' : '⛔'
+    lines.push(`- \`${r.id}\` [${r.category}] ${r.toolName} — ${r.source} ${status}`)
+  }
+  lines.push('', `Total: ${rules.length} active rules`)
+  lines.push('', 'Use `/crsi disable <rule-id>` to disable a rule.')
+  return { content: lines.join('\n') }
+}
+
+const crsiDisableCmd: CommandHandler = (ctx, args) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const ruleId = args[0]?.trim()
+  if (!ruleId) {
+    return { content: 'Usage: /crsi disable <rule-id>' }
+  }
+  engine.setRuleEnabled(ruleId, false)
+  return {
+    content: `Rule \`${ruleId}\` has been disabled. Use \`/crsi restore ${ruleId}\` to re-enable.`,
+  }
+}
+
+const crsiAnalyzeCmd: CommandHandler = async (ctx) => {
+  const analyzer = ctx.engine.getPatternAnalyzer()
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI system is not available.' }
+  }
+
+  const patterns = analyzer.analyzeAllAgents()
+  if (patterns.length === 0) {
+    return { content: 'No failure patterns found across agents.' }
+  }
+
+  let registered = 0
+  for (const pattern of patterns) {
+    const toolRule = analyzer.toToolRule(pattern)
+    engine.register(toolRule)
+    registered++
+  }
+
+  const lines: string[] = [
+    '## CRSI Analysis Complete',
+    '',
+    `Found ${patterns.length} patterns, ${registered} rules registered.`,
+    '',
+  ]
+  for (const p of patterns) {
+    lines.push(
+      `- [${p.category}] \`${p.agentName}\` — ${p.frequency} failures (${p.confidence} confidence)`,
+    )
+  }
+  return { content: lines.join('\n') }
+}
+
+const crsiRestoreCmd: CommandHandler = (ctx, args) => {
+  const engine = ctx.engine.getRuleEngine()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+  const ruleId = args.join(' ').trim()
+  if (!ruleId) {
+    return { content: 'Usage: /crsi restore <rule-id>' }
+  }
+  engine.setRuleEnabled(ruleId, true)
+  return { content: `Rule \`${ruleId}\` has been re-enabled.` }
+}
+
+const crsiStatsCmd: CommandHandler = async (ctx) => {
+  const engine = ctx.engine.getRuleEngine()
+  const tracker = ctx.engine.getEffectivenessTracker()
+  if (!engine) {
+    return { content: 'CRSI rule engine is not available.' }
+  }
+
+  const rules = engine.getActiveRules()
+  const lines: string[] = ['## CRSI Statistics', '']
+  lines.push(`Total active rules: ${rules.length}`)
+  lines.push(`Builtin: ${rules.filter((r) => r.source === 'builtin').length}`)
+  lines.push(`Auto-generated: ${rules.filter((r) => r.source === 'pattern-analyzer').length}`)
+  lines.push(`Manual: ${rules.filter((r) => r.source === 'manual').length}`)
+
+  if (tracker) {
+    let totalInterceptions = 0
+    let totalSuccesses = 0
+    for (const r of rules) {
+      const eff = tracker.getEffectiveness(r.id)
+      if (eff) {
+        totalInterceptions += eff.appliedCount
+        totalSuccesses += eff.successAfterCount
+      }
+    }
+    lines.push('')
+    lines.push(`Total interceptions: ${totalInterceptions}`)
+    lines.push(
+      `Success rate after rules: ${totalInterceptions > 0 ? Math.round((totalSuccesses / totalInterceptions) * 100) : 0}%`,
+    )
+  }
+
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Workflow
 // ═══════════════════════════════════════════════════════════════
@@ -3072,6 +3190,11 @@ const commandsListCmd: CommandHandler = () => {
     '/plugin-enable': 'Plugins',
     '/plugin-disable': 'Plugins',
     '/commands': 'Tools & Skills',
+    '/crsi rules': 'Tools & Skills',
+    '/crsi disable': 'Tools & Skills',
+    '/crsi analyze': 'Tools & Skills',
+    '/crsi restore': 'Tools & Skills',
+    '/crsi stats': 'Tools & Skills',
     '/plan': 'Workflow',
     '/no-plan': 'Workflow',
     '/tdd': 'Workflow',
@@ -3209,6 +3332,11 @@ registry.set('/remove-plugin', removePluginCmd)
 registry.set('/plugin-enable', pluginEnableCmd)
 registry.set('/plugin-disable', pluginDisableCmd)
 registry.set('/commands', commandsListCmd)
+registry.set('/crsi rules', crsiRulesCmd)
+registry.set('/crsi disable', crsiDisableCmd)
+registry.set('/crsi analyze', crsiAnalyzeCmd)
+registry.set('/crsi restore', crsiRestoreCmd)
+registry.set('/crsi stats', crsiStatsCmd)
 
 // Workflow
 registry.set('/plan', planCmd)
@@ -3359,6 +3487,11 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/remove-plugin': 'Remove an installed plugin',
   '/plugin-enable': 'Enable a disabled plugin',
   '/plugin-disable': 'Disable an enabled plugin',
+  '/crsi rules': 'List all active CRSI rules with their status',
+  '/crsi disable': 'Disable a CRSI rule by ID',
+  '/crsi analyze': 'Manually trigger CRSI pattern analysis across all agents',
+  '/crsi restore': 'Restore a disabled or degraded CRSI rule',
+  '/crsi stats': 'Show CRSI overall effectiveness statistics',
   '/plan': 'Enter plan mode',
   '/no-plan': 'Exit plan mode',
   '/tdd': 'Test-Driven Development workflow (RED → GREEN → REFACTOR)',