@miphamai/cli 0.33.2 → 0.34.1

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,9 @@ 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 { ConstitutionLoader } from './constitution-loader.js'
+import { SelfCritique } from './self-critique.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
@@ -55,6 +59,9 @@ export class QueryEngine {
   private _preflightChecker?: PreFlightChecker
   private _autoCorrector?: AutoCorrector
   private _metaRuleEngine?: MetaRuleEngine
+  private _dreamEngine?: DreamEngine
+  private _constitutionLoader?: ConstitutionLoader
+  private _selfCritique?: SelfCritique
   /** Files read this session — tracks what the Read tool has loaded */
   private readFiles = new Set<string>()
   private goal?: string
@@ -428,6 +435,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
@@ -534,7 +542,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',
@@ -542,6 +552,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({
@@ -561,6 +580,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) {
@@ -936,6 +977,62 @@ export class QueryEngine {
       hookWarnings = [...hookWarnings, preflight.warning]
     }
 
+    // ── Mipham Constitution — constitutional principle enforcement ──
+    // Checks the tool + params against the machine-readable constitution.
+    // Block-level violations (enforce: block) halt execution immediately.
+    // Warn-level violations (enforce: warn) are appended to hookWarnings.
+    const constitution = this.getConstitutionLoader()
+    const principles = constitution.getPrinciplesForTool(name)
+    for (const principle of principles) {
+      if (principle.enforce === 'block') {
+        // Audit: check if the tool params or command match a violation pattern
+        if (principle.audit_pattern) {
+          try {
+            const regex = new RegExp(principle.audit_pattern, 'i')
+            const paramsStr = JSON.stringify(effectiveParams)
+            if (regex.test(paramsStr)) {
+              return {
+                success: false,
+                content: `🚫 Constitution violation blocked: **${principle.id}** — ${principle.text}`,
+                error: `Constitutional principle "${principle.id}" blocked this operation.`,
+              }
+            }
+          } catch {
+            // Invalid regex — skip this principle
+          }
+        }
+      }
+      if (principle.enforce === 'warn') {
+        hookWarnings = [...hookWarnings, `⚖️ Constitution: ${principle.id} — ${principle.text}`]
+      }
+    }
+
+    // ── Self-Critique Hook — RLAIF-style tool-call safety verification ──
+    // Uses a fast model (Flash) to critique the tool call before execution.
+    // Safe + correct + necessary check with <200ms target latency.
+    // Fail-open: if the critique times out or errors, the tool still executes.
+    const selfCritique = this.getSelfCritique()
+    if (selfCritique.getConfig().enabled) {
+      const critiqueResult = await selfCritique.critique(name, effectiveParams, this.registry)
+      if (critiqueResult) {
+        if (critiqueResult.score < selfCritique.getConfig().threshold) {
+          // Score too low — block with explanation
+          if (!critiqueResult.safe) {
+            return {
+              success: false,
+              content: `🔍 Self-Critique blocked: ${critiqueResult.reasoning}`,
+              error: `Self-Critique safety check failed (score: ${(critiqueResult.score * 100).toFixed(0)}%). ${critiqueResult.correction || ''}`,
+            }
+          }
+          // Score low but safe — warn but allow
+          hookWarnings = [
+            ...hookWarnings,
+            `🔍 Self-Critique: ${critiqueResult.reasoning}${critiqueResult.correction ? ` — Suggestion: ${critiqueResult.correction}` : ''}`,
+          ]
+        }
+      }
+    }
+
     try {
       const result = await tool.execute(effectiveParams, {
         cwd: process.cwd(),
@@ -1103,7 +1200,7 @@ export class QueryEngine {
    * Checks tool calls against ErrorSignatureDB + ExperienceRuleEngine
    * before execution, enabling preventive error interception.
    */
-  private getPreFlightChecker(): PreFlightChecker {
+  getPreFlightChecker(): PreFlightChecker {
     if (!this._preflightChecker) {
       this._preflightChecker = new PreFlightChecker(
         this.getErrorSignatureDB(),
@@ -1141,6 +1238,30 @@ 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
+  }
+
+  /** Mipham Constitution: Lazily-initialized constitutional principle loader/enforcer. */
+  getConstitutionLoader(): ConstitutionLoader {
+    if (!this._constitutionLoader) {
+      this._constitutionLoader = new ConstitutionLoader()
+    }
+    return this._constitutionLoader
+  }
+
+  /** Self-Critique: Lazily-initialized RLAIF-style tool-call safety verification. */
+  getSelfCritique(): SelfCritique {
+    if (!this._selfCritique) {
+      this._selfCritique = new SelfCritique()
+    }
+    return this._selfCritique
+  }
+
   /** Register a tool dynamically (used by MCP auto-registration). */
   registerTool(tool: ToolDefinition): void {
     if (this.tools.has(tool.name)) {