@miphamai/cli 0.33.1 → 0.34.0

package/src/core/emotion-detector.ts

@@ -0,0 +1,257 @@
+/**
+ * Emotion Detector — User Frustration Detection
+ *
+ * Inspired by Claude Code's emotion detection: parses user input for signals
+ * of frustration, confusion, or satisfaction. Adjusts agent behavior accordingly:
+ *   - Frustration → be more concise, skip explanations, get to the fix faster
+ *   - Confusion → explain more, offer context, slow down
+ *   - Satisfaction → maintain current mode
+ *
+ * Uses regex heuristics (no LLM call) for zero-latency detection.
+ * Designed as a lightweight pre-processor in the input pipeline.
+ */
+
+// ── Types ──
+
+export type Emotion =
+  | 'frustrated' // User is angry/annoyed — move fast, skip explanations
+  | 'confused' // User doesn't understand — explain more
+  | 'impatient' // User wants speed — be terse
+  | 'satisfied' // User is happy — continue normally
+  | 'neutral' // No strong signal
+
+export interface EmotionResult {
+  emotion: Emotion
+  /** 0.0-1.0 confidence in the detected emotion */
+  confidence: number
+  /** Specific phrases that triggered the detection */
+  triggers: string[]
+  /** Suggested behavior adjustment for the agent */
+  suggestion: string
+}
+
+// ── Constants ──
+
+/** Patterns that indicate frustration/anger. Ordered by severity. */
+const FRUSTRATION_PATTERNS: Array<{ pattern: RegExp; weight: number; label: string }> = [
+  { pattern: /\b(wtf|wtaf)\b/i, weight: 0.9, label: 'profanity' },
+  {
+    pattern: /\b(useless|worthless|garbage|rubbish|broken)\b/i,
+    weight: 0.8,
+    label: 'strong-negative',
+  },
+  { pattern: /\b(damn|shit|crap)\b/i, weight: 0.7, label: 'mild-profanity' },
+  {
+    pattern: /\b(stop|don't|do not)\s+(explain|talk|lecture|ramble)\b/i,
+    weight: 0.85,
+    label: 'stop-explaining',
+  },
+  {
+    pattern: /\b(just\s+fix\s+it|just\s+do\s+it|get\s+on\s+with\s+it)\b/i,
+    weight: 0.8,
+    label: 'just-fix-it',
+  },
+  {
+    pattern: /\b(no|wrong|incorrect|bad|terrible|awful)\s*[!！]{1,3}/i,
+    weight: 0.75,
+    label: 'emphatic-no',
+  },
+  { pattern: /\b(again\?|still|not\s+again)\b/i, weight: 0.7, label: 'repeated-failure' },
+  { pattern: /\b(i\s+said|i\s+told\s+you|i\s+already)\b/i, weight: 0.75, label: 'i-already-said' },
+  { pattern: /\b(no\s+no\s+no|nope\s+nope)\b/i, weight: 0.7, label: 'repeated-no' },
+  { pattern: /[！!]{2,}/, weight: 0.6, label: 'multiple-exclamation' },
+  {
+    pattern: /\b(why|why\s+would\s+you|what\s+are\s+you\s+doing)\b/i,
+    weight: 0.65,
+    label: 'why-question',
+  },
+  { pattern: /[？?]{2,}/, weight: 0.4, label: 'multiple-question-marks' },
+]
+
+/** Patterns that indicate confusion / need for more explanation */
+const CONFUSION_PATTERNS: Array<{ pattern: RegExp; weight: number; label: string }> = [
+  {
+    pattern: /\b(i\s+don'?t\s+understand|i\s+am\s+confused|i'?m\s+confused)\b/i,
+    weight: 0.9,
+    label: 'explicit-confusion',
+  },
+  {
+    pattern: /\b(what\s+does|what\s+is|what\s+are|how\s+does)\b/i,
+    weight: 0.6,
+    label: 'what-is-question',
+  },
+  {
+    pattern: /\b(can\s+you\s+explain|explain\s+this|elaborate)\b/i,
+    weight: 0.7,
+    label: 'ask-for-explanation',
+  },
+  { pattern: /\b(wait|huh|eh\?+|hmm+)\b/i, weight: 0.5, label: 'hesitation' },
+  {
+    pattern: /\b(i\s+thought|i\s+expected|shouldn'?t\s+it)\b/i,
+    weight: 0.6,
+    label: 'mismatch-expectation',
+  },
+]
+
+/** Patterns that indicate impatience */
+const IMPATIENCE_PATTERNS: Array<{ pattern: RegExp; weight: number; label: string }> = [
+  { pattern: /\b(hurry|quick|fast|faster|asap|urgent)\b/i, weight: 0.8, label: 'speed-words' },
+  {
+    pattern: /\b(just\s+the\s+(code|answer|result|fix|summary))\b/i,
+    weight: 0.75,
+    label: 'just-the-result',
+  },
+  {
+    pattern: /\b(skip\s+(the\s+)?(explanation|details|context|background))\b/i,
+    weight: 0.8,
+    label: 'skip-explanation',
+  },
+  { pattern: /\b(tldr|tl;dr|summary|summarize)\b/i, weight: 0.7, label: 'tldr' },
+  {
+    pattern: /\b(get\s+to\s+the\s+point|cut\s+to\s+the\s+chase)\b/i,
+    weight: 0.75,
+    label: 'get-to-point',
+  },
+]
+
+/** Patterns that indicate satisfaction */
+const SATISFACTION_PATTERNS: Array<{ pattern: RegExp; weight: number; label: string }> = [
+  { pattern: /\b(thanks|thank\s+you|thx|ty|tyvm)\b/i, weight: 0.5, label: 'thanks' },
+  {
+    pattern: /\b(great|awesome|perfect|excellent|amazing|brilliant|beautiful)\b/i,
+    weight: 0.6,
+    label: 'positive-words',
+  },
+  { pattern: /\b(nice|good\s+job|well\s+done|love\s+it)\b/i, weight: 0.7, label: 'praise' },
+  {
+    pattern: /\b(exactly|finally|yes!|that'?s\s+it)\b/i,
+    weight: 0.6,
+    label: 'confirmation-positive',
+  },
+  { pattern: /[👍🙌🎉✨💯🔥✅]/u, weight: 0.5, label: 'positive-emoji' },
+]
+
+// ── Detector ──
+
+export class EmotionDetector {
+  /**
+   * Analyze user input for emotional signals.
+   *
+   * @param input — raw user message text
+   * @param recentContext — optional recent conversation turns for pattern detection
+   * @returns EmotionResult with detected emotion and behavioral suggestion
+   */
+  detect(input: string, recentContext?: string[]): EmotionResult {
+    // Check frustration first (most actionable)
+    const frustration = this.scorePatterns(input, FRUSTRATION_PATTERNS, recentContext)
+    if (frustration.score >= 0.5) {
+      return {
+        emotion: 'frustrated',
+        confidence: frustration.score,
+        triggers: frustration.triggers,
+        suggestion:
+          frustration.score >= 0.8
+            ? 'User is very frustrated. Be extremely concise. Skip ALL explanations. Output only the fix/result. No preamble, no summary, no "here\'s what I did". One sentence max before code.'
+            : 'User is frustrated. Be concise. Skip explanations. Get to the fix immediately.',
+      }
+    }
+
+    // Check impatience
+    const impatience = this.scorePatterns(input, IMPATIENCE_PATTERNS)
+    if (impatience.score >= 0.5) {
+      return {
+        emotion: 'impatient',
+        confidence: impatience.score,
+        triggers: impatience.triggers,
+        suggestion:
+          'User wants speed. Skip explanations. Output the result immediately. No "let me explain why" — just the answer.',
+      }
+    }
+
+    // Check confusion
+    const confusion = this.scorePatterns(input, CONFUSION_PATTERNS)
+    if (confusion.score >= 0.5) {
+      return {
+        emotion: 'confused',
+        confidence: confusion.score,
+        triggers: confusion.triggers,
+        suggestion:
+          'User is confused. Explain more. Offer context. Break down complex steps. Ask clarifying questions rather than assuming.',
+      }
+    }
+
+    // Check satisfaction
+    const satisfaction = this.scorePatterns(input, SATISFACTION_PATTERNS)
+    if (satisfaction.score >= 0.5) {
+      return {
+        emotion: 'satisfied',
+        confidence: satisfaction.score,
+        triggers: satisfaction.triggers,
+        suggestion:
+          'User is satisfied. Maintain current tone and pace. Good time for optional suggestions.',
+      }
+    }
+
+    return {
+      emotion: 'neutral',
+      confidence: 0,
+      triggers: [],
+      suggestion: 'No strong emotional signal. Proceed normally.',
+    }
+  }
+
+  /**
+   * Quick check — does this input contain ANY frustration signal?
+   * Use as a pre-filter before the full detect() call.
+   */
+  isFrustrated(input: string): boolean {
+    return FRUSTRATION_PATTERNS.some((p) => p.pattern.test(input))
+  }
+
+  /**
+   * Detect repeated frustration across multiple turns (escalation detection).
+   */
+  detectEscalation(recentInputs: string[]): boolean {
+    if (recentInputs.length < 2) return false
+    const recent = recentInputs.slice(-3)
+    const frustrationCount = recent.filter((i) => this.isFrustrated(i)).length
+    return frustrationCount >= 2
+  }
+
+  // ── Internal ──
+
+  private scorePatterns(
+    input: string,
+    patterns: Array<{ pattern: RegExp; weight: number; label: string }>,
+    recentContext?: string[],
+  ): { score: number; triggers: string[] } {
+    const triggers: string[] = []
+    let totalWeight = 0
+    let matchCount = 0
+
+    for (const p of patterns) {
+      if (p.pattern.test(input)) {
+        triggers.push(p.label)
+        totalWeight += p.weight
+        matchCount++
+      }
+    }
+
+    // Check recent context for frustration escalation
+    if (recentContext && patterns === FRUSTRATION_PATTERNS) {
+      const recentFrustration = recentContext
+        .slice(-2)
+        .filter((ctx) => patterns.some((p) => p.pattern.test(ctx))).length
+      if (recentFrustration >= 1) {
+        totalWeight += 0.15 // escalation bonus
+      }
+    }
+
+    // Normalize: first match passes at weight ≥ 0.5; additional matches increase confidence
+    // with diminishing returns (matchCount-1 so single match = no dampening)
+    const score =
+      matchCount === 0 ? 0 : Math.min(1.0, totalWeight / (1 + Math.max(0, matchCount - 1) * 0.5))
+
+    return { score, triggers }
+  }
+}

package/src/core/engine.ts

@@ -15,6 +15,7 @@ import type { AgentRegistry } from '../agent/agent-registry'
 import { analyzeForMemory } from './memory/memory-writer'
 import { getMemoryManager } from './memory/memory-loader'
 import { AutoMemoryEngine } from './auto-memory.js'
+import type { ToolCallRecord } from './auto-memory.js'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import type { SkillsLoader } from '../skills/loader'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
@@ -26,6 +27,7 @@ import { ErrorSignatureDB } from './error-signature-db.js'
 import { PreFlightChecker } from './preflight-checker.js'
 import { AutoCorrector } from './auto-corrector.js'
 import { MetaRuleEngine } from './meta-rule-engine.js'
+import { DreamEngine } from './dream-engine.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
@@ -55,6 +57,7 @@ export class QueryEngine {
   private _preflightChecker?: PreFlightChecker
   private _autoCorrector?: AutoCorrector
   private _metaRuleEngine?: MetaRuleEngine
+  private _dreamEngine?: DreamEngine
   /** Files read this session — tracks what the Read tool has loaded */
   private readFiles = new Set<string>()
   private goal?: string
@@ -160,6 +163,11 @@ export class QueryEngine {
     this.hookEngine = hooks
   }
 
+  /** Get the registered hook engine (for health inspection). */
+  getHookEngine(): HookEngine | undefined {
+    return this.hookEngine
+  }
+
   /** Register the artifact server for tool context. */
   setArtifactServer(server: ArtifactServer): void {
     this.artifactServer = server
@@ -423,6 +431,7 @@ export class QueryEngine {
     let thinkingContent = ''
     let turnApiInputTokens = 0
     let turnApiOutputTokens = 0
+    const turnStart = Date.now()
     const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
     // Stream model response
@@ -529,7 +538,9 @@ export class QueryEngine {
     }
 
     // Execute any tools that were requested
+    const toolCallRecords: ToolCallRecord[] = []
     for (const toolUse of toolUses) {
+      const toolStart = Date.now()
       const result = await this.executeTool(toolUse.name, toolUse.input)
       yield {
         type: 'tool_result',
@@ -537,6 +548,15 @@ export class QueryEngine {
         content: result.success ? result.content : result.error || result.content,
       }
 
+      // Collect tool call record for CRSI auto-reflection
+      toolCallRecords.push({
+        name: toolUse.name,
+        input: toolUse.input,
+        success: result.success,
+        error: result.success ? undefined : result.error || 'Unknown error',
+        durationMs: Date.now() - toolStart,
+      })
+
       // Add tool use + result to context
       // DeepSeek V4 thinking mode requires reasoning_content on every assistant message
       this.context.addMessage({
@@ -556,6 +576,28 @@ export class QueryEngine {
       })
     }
 
+    // ── CRSI Reflection: Wire AutoMemoryEngine.analyzeTurn() into main loop ──
+    // This is the primary CRSI learning mechanism — every turn's tool calls,
+    // successes, and failures are analyzed for patterns and fed into the
+    // CRSI pipeline (PatternAnalyzer → ExperienceRuleEngine → ErrorSignatureDB).
+    if (toolCallRecords.length > 0) {
+      try {
+        const autoMemory = this.getAutoMemory()
+        const reflection = autoMemory.analyzeTurn({
+          sessionId: this.sessionId,
+          userMessage: userInput,
+          assistantContent,
+          toolCalls: toolCallRecords,
+          modelProvider: this.registry.getActive().config.id,
+          modelId: this.registry.getActiveModel(),
+          turnDurationMs: turnStart ? Date.now() - turnStart : 0,
+        })
+        autoMemory.persist(reflection)
+      } catch {
+        // Reflection is non-critical — failures must not break the main loop
+      }
+    }
+
     // Record API token usage for this turn, attributed to executed tools
     if (turnApiInputTokens > 0 || turnApiOutputTokens > 0) {
       if (toolUses.length > 0) {
@@ -1136,6 +1178,14 @@ export class QueryEngine {
     return this._metaRuleEngine
   }
 
+  /** Auto-Dream: Lazily-initialized background memory consolidation engine. */
+  getDreamEngine(): DreamEngine {
+    if (!this._dreamEngine) {
+      this._dreamEngine = new DreamEngine()
+    }
+    return this._dreamEngine
+  }
+
   /** Register a tool dynamically (used by MCP auto-registration). */
   registerTool(tool: ToolDefinition): void {
     if (this.tools.has(tool.name)) {

package/src/core/hooks.ts

@@ -6,6 +6,29 @@ import type {
   ToolResult,
 } from '../shared/index.ts'
 
+// ── Hook resilience types ──
+
+interface HookHealth {
+  /** Consecutive failure count */
+  failures: number
+  /** Timestamp of last failure (ms since epoch) */
+  lastFailureTime: number
+  /** Whether the hook is currently disabled due to repeated failures */
+  disabled: boolean
+  /** Timestamp when disabled (ms since epoch) */
+  disabledAt: number
+  /** Total failure count (lifetime) */
+  totalFailures: number
+}
+
+/** Max consecutive failures before auto-disabling a hook */
+const MAX_CONSECUTIVE_FAILURES = 5
+
+/** Cooldown period in ms before a disabled hook is re-tried (5 minutes) */
+const COOLDOWN_MS = 5 * 60 * 1000
+
+// ── Helpers ──
+
 /**
  * Merge two permission decisions, keeping the more restrictive one.
  * Priority: deny > defer > ask > allow
@@ -22,6 +45,8 @@ export function mergePermissionDecision(
 
 export class HookEngine {
   private hooks: HookDefinition[] = []
+  /** Health tracking per hook key (event[:toolName]) */
+  private health = new Map<string, HookHealth>()
 
   register(hook: HookDefinition): void {
     this.hooks.push(hook)
@@ -71,31 +96,26 @@ export class HookEngine {
 
   // ── NEW event executors ──
 
-  /** Stop hook: fires when AI completes a turn. Can block to force continuation. */
   async executeStop(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'Stop', sessionId }
     return this.runHooks('Stop', undefined, ctx)
   }
 
-  /** UserPromptSubmit: fires when user submits input. Can block malicious input. */
   async executeUserPromptSubmit(prompt: string, sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'UserPromptSubmit', sessionId, userPrompt: prompt }
     return this.runHooks('UserPromptSubmit', undefined, ctx)
   }
 
-  /** PreCompact: fires before context compaction. */
   async executePreCompact(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'PreCompact', sessionId }
     return this.runHooks('PreCompact', undefined, ctx)
   }
 
-  /** PostCompact: fires after context compaction. Can inject additional context. */
   async executePostCompact(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'PostCompact', sessionId }
     return this.runHooks('PostCompact', undefined, ctx)
   }
 
-  /** ConfigChange: fires when configuration changes. */
   async executeConfigChange(key: string, value: unknown, sessionId: string): Promise<HookResult> {
     const ctx: HookContext = {
       event: 'ConfigChange',
@@ -106,7 +126,6 @@ export class HookEngine {
     return this.runHooks('ConfigChange', undefined, ctx)
   }
 
-  /** SubagentStart: fires when a sub-agent begins execution. */
   async executeSubagentStart(
     agentType: string,
     description: string,
@@ -120,7 +139,6 @@ export class HookEngine {
     return this.runHooks('SubagentStart', undefined, ctx)
   }
 
-  /** SubagentStop: fires when a sub-agent completes (success or failure). */
   async executeSubagentStop(
     agentType: string,
     description: string,
@@ -137,7 +155,6 @@ export class HookEngine {
     return this.runHooks('SubagentStop', undefined, ctx)
   }
 
-  /** PostToolUseFailure: fires when a tool call fails. */
   async executePostToolUseFailure(
     toolName: string,
     toolInput: Record<string, unknown>,
@@ -154,7 +171,6 @@ export class HookEngine {
     return this.runHooks('PostToolUseFailure', toolName, ctx)
   }
 
-  /** PreInference: fires before every model API call for DLP inspection. */
   async executePreInference(
     messages: Array<{ role: string; content: string }>,
     toolCalls: Array<{
@@ -177,6 +193,79 @@ export class HookEngine {
     return this.runHooks('PreInference', undefined, ctx)
   }
 
+  // ── Health & Resilience ──
+
+  /** Get a hook health key for tracking. */
+  private healthKey(hook: HookDefinition): string {
+    return hook.toolName ? `${hook.event}:${hook.toolName}` : hook.event
+  }
+
+  /** Check if a hook should be skipped due to repeated failures. */
+  private shouldSkip(key: string): boolean {
+    const h = this.health.get(key)
+    if (!h) return false
+
+    // If disabled, check cooldown
+    if (h.disabled) {
+      const elapsed = Date.now() - h.disabledAt
+      if (elapsed < COOLDOWN_MS) {
+        return true // still in cooldown
+      }
+      // Cooldown expired — re-enable for a trial
+      h.disabled = false
+      h.failures = 0
+      process.stderr.write(`🔄 Hook "${key}" cooldown expired — re-enabled for trial.\n`)
+      return false
+    }
+
+    return false
+  }
+
+  /** Record a hook success — resets failure counter. */
+  private recordSuccess(key: string): void {
+    const h = this.health.get(key)
+    if (h) {
+      h.failures = 0
+      h.disabled = false
+    }
+  }
+
+  /** Record a hook failure — may trigger auto-disable. */
+  private recordFailure(key: string): void {
+    let h = this.health.get(key)
+    if (!h) {
+      h = { failures: 0, lastFailureTime: 0, disabled: false, disabledAt: 0, totalFailures: 0 }
+      this.health.set(key, h)
+    }
+
+    h.failures++
+    h.totalFailures++
+    h.lastFailureTime = Date.now()
+
+    if (h.failures >= MAX_CONSECUTIVE_FAILURES && !h.disabled) {
+      h.disabled = true
+      h.disabledAt = Date.now()
+      process.stderr.write(
+        `⚠️  Hook "${key}" failed ${MAX_CONSECUTIVE_FAILURES} consecutive times — auto-disabled for ${COOLDOWN_MS / 60_000} minutes.\n` +
+          `   Use /hooks enable "${key}" to re-enable manually.\n`,
+      )
+    }
+  }
+
+  /** Get the health status of all hooks. */
+  getHookHealth(): Array<{ key: string; health: HookHealth }> {
+    return Array.from(this.health.entries()).map(([key, health]) => ({ key, health }))
+  }
+
+  /** Manually re-enable a disabled hook. */
+  reEnableHook(key: string): boolean {
+    const h = this.health.get(key)
+    if (!h || !h.disabled) return false
+    h.disabled = false
+    h.failures = 0
+    return true
+  }
+
   // ── Core execution ──
 
   private async runHooks(
@@ -191,9 +280,23 @@ export class HookEngine {
     const result: HookResult = { allowed: true }
 
     for (const hook of matching) {
+      const key = this.healthKey(hook)
+
+      // ── Resilience: skip disabled hooks ──
+      if (this.shouldSkip(key)) {
+        result.additionalContext = result.additionalContext
+          ? result.additionalContext +
+            `\n[Hook "${key}" skipped — temporarily disabled after repeated failures]`
+          : `[Hook "${key}" skipped — temporarily disabled after repeated failures]`
+        continue
+      }
+
       try {
         const hookResult = await hook.handler(ctx)
 
+        // Record success
+        this.recordSuccess(key)
+
         // Block on first deny — stops further hook execution
         if (!hookResult.allowed) {
           return { ...hookResult }
@@ -233,6 +336,8 @@ export class HookEngine {
           result.updatedOutput = hookResult.updatedOutput
         }
       } catch {
+        // Record failure — may trigger auto-disable
+        this.recordFailure(key)
         // Hook failures do not block execution
       }
     }