@miphamai/cli 0.33.2 → 0.34.0

package/package.json

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

package/src/core/dream-engine.ts

@@ -0,0 +1,552 @@
+/**
+ * Auto-Dream: Background Memory Consolidation Engine
+ *
+ * Inspired by Claude Code's Auto-Dream mechanism: a periodic background process
+ * that reviews accumulated memory, resolves contradictions, merges related
+ * knowledge, and solidifies vague expressions into definite facts.
+ *
+ * Unlike Claude Code's LLM-driven approach, DreamEngine uses pure text analysis
+ * for the most common operations (dedup, contradiction detection via keyword
+ * overlap, stale entry cleanup). An optional summarizer callback enables
+ * LLM-powered deep consolidation when available.
+ *
+ * Designed to be called:
+ *   - Periodically (every 24h or every 5 sessions) via daemon ScheduleManager
+ *   - Manually via `/dream` CLI command
+ *   - On session end as a lightweight pass
+ *
+ * Flow:
+ *   Load all memory entries
+ *     → Phase 1: Deduplicate near-identical entries
+ *     → Phase 2: Detect contradictions (opposing claims)
+ *     → Phase 3: Merge related entries (overlapping topics)
+ *     → Phase 4: Solidify vague entries (flag "maybe"/"possibly" for review)
+ *     → Phase 5: Prune stale entries (30+ days, low relevance)
+ *     → Write consolidated memory + generate DreamReport
+ */
+
+import {
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+  mkdirSync,
+  statSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+// ── Types ──
+
+export interface DreamReport {
+  /** When the dream cycle ran */
+  timestamp: string
+  /** Total memories before consolidation */
+  beforeCount: number
+  /** Total memories after consolidation */
+  afterCount: number
+  /** Per-phase statistics */
+  phases: {
+    deduplicated: number
+    contradictionsFound: number
+    merged: number
+    solidified: number
+    pruned: number
+  }
+  /** Specific actions taken */
+  actions: DreamAction[]
+  /** Summary for display */
+  summary: string
+}
+
+export interface DreamAction {
+  type: 'dedup' | 'contradiction' | 'merge' | 'solidify' | 'prune'
+  description: string
+  filesAffected: string[]
+  autoApplied: boolean
+}
+
+interface MemoryFile {
+  path: string
+  name: string
+  frontmatter: Record<string, unknown>
+  content: string
+  /** Days since last modified */
+  age: number
+}
+
+// ── Constants ──
+
+const DEFAULT_MEMORY_DIR = join(homedir(), '.mipham', 'memory')
+const STALE_DAYS = 30
+const SIMILARITY_THRESHOLD = 0.65
+
+/** Vague qualifiers that suggest an entry needs solidification */
+const VAGUE_PATTERNS = [
+  /\bmaybe\b/i,
+  /\bperhaps\b/i,
+  /\bpossibly\b/i,
+  /\bmight\b/i,
+  /\bcould be\b/i,
+  /\bunsure\b/i,
+  /\bunclear\b/i,
+  /\bseems?\b/i,
+  /\bprobably\b/i,
+  /\btypically\b/i,
+  /\busually\b/i,
+  /\boften\b/i,
+]
+
+// ── Engine ──
+
+export class DreamEngine {
+  private memoryDir: string
+  private dreamLog: string
+
+  constructor(memoryDir: string = DEFAULT_MEMORY_DIR) {
+    this.memoryDir = memoryDir
+    this.dreamLog = join(memoryDir, 'dream-log.json')
+  }
+
+  /**
+   * Run a full dream consolidation cycle.
+   *
+   * @param options.aggressive — if true, auto-apply more actions (default: safe-only)
+   * @returns DreamReport with statistics and actions taken
+   */
+  dream(options: { aggressive?: boolean } = {}): DreamReport {
+    const { aggressive = false } = options
+    const actions: DreamAction[] = []
+    const timestamp = new Date().toISOString()
+
+    // Load all memory files
+    const memories = this.loadMemories()
+    const beforeCount = memories.length
+
+    if (memories.length === 0) {
+      return {
+        timestamp,
+        beforeCount: 0,
+        afterCount: 0,
+        phases: { deduplicated: 0, contradictionsFound: 0, merged: 0, solidified: 0, pruned: 0 },
+        actions: [],
+        summary: 'No memories to consolidate. Dream skipped.',
+      }
+    }
+
+    // ── Phase 1: Deduplicate near-identical entries ──
+    const dedupResult = this.deduplicate(memories, aggressive)
+    actions.push(...dedupResult.actions)
+    let working = dedupResult.memories
+
+    // ── Phase 2: Detect contradictions ──
+    const contradictions = this.detectContradictions(working)
+    actions.push(...contradictions)
+    // Contradictions are flagged, not auto-resolved
+
+    // ── Phase 3: Merge related entries ──
+    const mergeResult = this.mergeRelated(working, aggressive)
+    actions.push(...mergeResult.actions)
+    working = mergeResult.memories
+
+    // ── Phase 4: Solidify vague entries ──
+    const solidifyActions = this.solidifyVague(working)
+    actions.push(...solidifyActions)
+    // Solidification just flags — human or LLM should resolve
+
+    // ── Phase 5: Prune stale entries ──
+    const pruneResult = this.pruneStale(working, aggressive)
+    actions.push(...pruneResult.actions)
+    working = pruneResult.memories
+
+    // ── Persist dream log ──
+    this.saveDreamLog(timestamp, actions)
+
+    const afterCount = working.length
+    const autoApplied = actions.filter((a) => a.autoApplied).length
+    const flagged = actions.filter((a) => !a.autoApplied).length
+
+    return {
+      timestamp,
+      beforeCount,
+      afterCount,
+      phases: {
+        deduplicated: dedupResult.actions.length,
+        contradictionsFound: contradictions.length,
+        merged: mergeResult.actions.length,
+        solidified: solidifyActions.length,
+        pruned: pruneResult.actions.length,
+      },
+      actions,
+      summary: [
+        `Dream complete: ${beforeCount} → ${afterCount} memories`,
+        `${autoApplied} actions auto-applied, ${flagged} flagged for review`,
+        `Phases: ${dedupResult.actions.length} deduped, ${contradictions.length} contradictions, ${mergeResult.actions.length} merged, ${solidifyActions.length} solidified, ${pruneResult.actions.length} pruned`,
+      ].join('\n'),
+    }
+  }
+
+  // ── Phase 1: Deduplication ──
+
+  private deduplicate(
+    memories: MemoryFile[],
+    aggressive: boolean,
+  ): { memories: MemoryFile[]; actions: DreamAction[] } {
+    const actions: DreamAction[] = []
+    const kept: MemoryFile[] = []
+    const removed = new Set<string>()
+
+    for (let i = 0; i < memories.length; i++) {
+      if (removed.has(memories[i]!.path)) continue
+
+      for (let j = i + 1; j < memories.length; j++) {
+        if (removed.has(memories[j]!.path)) continue
+
+        const similarity = this.jaccardSimilarity(memories[i]!.content, memories[j]!.content)
+
+        if (similarity >= SIMILARITY_THRESHOLD) {
+          // Keep the older, more established entry
+          const keep = memories[i]!.age >= memories[j]!.age ? memories[i]! : memories[j]!
+          const remove = keep === memories[i]! ? memories[j]! : memories[i]!
+
+          if (aggressive) {
+            try {
+              unlinkSync(remove.path)
+              removed.add(remove.path)
+              actions.push({
+                type: 'dedup',
+                description: `Merged near-duplicate: "${remove.name}" → "${keep.name}" (${Math.round(similarity * 100)}% similar)`,
+                filesAffected: [remove.path],
+                autoApplied: true,
+              })
+            } catch {
+              // Best-effort
+            }
+          } else {
+            actions.push({
+              type: 'dedup',
+              description: `Near-duplicate detected: "${remove.name}" ≈ "${keep.name}" (${Math.round(similarity * 100)}% similar). Run /dream --aggressive to auto-merge.`,
+              filesAffected: [keep.path, remove.path],
+              autoApplied: false,
+            })
+          }
+        }
+      }
+
+      if (!removed.has(memories[i]!.path)) {
+        kept.push(memories[i]!)
+      }
+    }
+
+    return { memories: kept, actions }
+  }
+
+  // ── Phase 2: Contradiction Detection ──
+
+  private detectContradictions(memories: MemoryFile[]): DreamAction[] {
+    const actions: DreamAction[] = []
+
+    // Simple heuristic: two entries about the same topic (similar name/description)
+    // but with opposing sentiment markers
+    const negationWords = /\b(not?|never|no|don't|doesn't|shouldn't|can't|cannot)\b/i
+
+    for (let i = 0; i < memories.length; i++) {
+      for (let j = i + 1; j < memories.length; j++) {
+        const a = memories[i]!
+        const b = memories[j]!
+
+        // Must be about similar topics
+        const nameSim = this.jaccardSimilarity(a.name, b.name)
+        if (nameSim < 0.4) continue
+
+        // One has negation, the other doesn't → potential contradiction
+        const aNegates = negationWords.test(a.content)
+        const bNegates = negationWords.test(b.content)
+
+        if (aNegates !== bNegates) {
+          actions.push({
+            type: 'contradiction',
+            description: `Potential contradiction: "${a.name}" vs "${b.name}" — one asserts, the other negates. Review manually.`,
+            filesAffected: [a.path, b.path],
+            autoApplied: false,
+          })
+        }
+      }
+    }
+
+    return actions
+  }
+
+  // ── Phase 3: Merge Related ──
+
+  private mergeRelated(
+    memories: MemoryFile[],
+    aggressive: boolean,
+  ): { memories: MemoryFile[]; actions: DreamAction[] } {
+    const actions: DreamAction[] = []
+    const merged = new Set<string>()
+    const result: MemoryFile[] = []
+
+    for (let i = 0; i < memories.length; i++) {
+      if (merged.has(memories[i]!.path)) continue
+
+      const related: MemoryFile[] = [memories[i]!]
+
+      for (let j = i + 1; j < memories.length; j++) {
+        if (merged.has(memories[j]!.path)) continue
+
+        // Related if: same type + high name similarity + moderate content overlap
+        const metaI = memories[i]!.frontmatter['metadata'] as Record<string, unknown> | undefined
+        const metaJ = memories[j]!.frontmatter['metadata'] as Record<string, unknown> | undefined
+        const sameType = metaI?.['type'] === metaJ?.['type']
+        const nameSim = this.jaccardSimilarity(memories[i]!.name, memories[j]!.name)
+        const contentSim = this.jaccardSimilarity(
+          memories[i]!.content.slice(0, 500),
+          memories[j]!.content.slice(0, 500),
+        )
+
+        if (sameType && nameSim >= 0.5 && contentSim >= 0.3) {
+          related.push(memories[j]!)
+          merged.add(memories[j]!.path)
+        }
+      }
+
+      if (related.length >= 2 && aggressive) {
+        // Merge: keep the most recent, append "See also" links to others
+        const primary = related.sort((a, b) => b.age - a.age)[0]!
+        const secondary = related.filter((r) => r !== primary)
+
+        try {
+          const links = secondary.map((s) => `- See also: [[${s.name}]]`).join('\n')
+          const updated = primary.content + `\n\n## Related\n${links}`
+          writeFileSync(primary.path, updated, 'utf-8')
+
+          for (const s of secondary) {
+            try {
+              unlinkSync(s.path)
+            } catch {
+              /* best-effort */
+            }
+          }
+
+          actions.push({
+            type: 'merge',
+            description: `Merged ${secondary.length} related entries into "${primary.name}"`,
+            filesAffected: [primary.path, ...secondary.map((s) => s.path)],
+            autoApplied: true,
+          })
+
+          result.push(primary)
+        } catch {
+          result.push(...related)
+        }
+      } else if (related.length >= 2) {
+        actions.push({
+          type: 'merge',
+          description: `${related.length} related entries found around "${memories[i]!.name}". Run /dream --aggressive to auto-merge.`,
+          filesAffected: related.map((r) => r.path),
+          autoApplied: false,
+        })
+        result.push(...related)
+      } else {
+        result.push(memories[i]!)
+      }
+    }
+
+    return { memories: result, actions }
+  }
+
+  // ── Phase 4: Solidify Vague ──
+
+  private solidifyVague(memories: MemoryFile[]): DreamAction[] {
+    const actions: DreamAction[] = []
+
+    for (const mem of memories) {
+      const vagueMatches = VAGUE_PATTERNS.filter((p) => p.test(mem.content))
+      if (vagueMatches.length > 0) {
+        const matched = vagueMatches
+          .map((p) => {
+            const m = mem.content.match(p)
+            return m ? `"${m[0]}"` : ''
+          })
+          .filter(Boolean)
+          .join(', ')
+        actions.push({
+          type: 'solidify',
+          description: `Vague entry "${mem.name}" uses qualifiers: ${matched}. Consider replacing with definite statements.`,
+          filesAffected: [mem.path],
+          autoApplied: false,
+        })
+      }
+    }
+
+    return actions
+  }
+
+  // ── Phase 5: Prune Stale ──
+
+  private pruneStale(
+    memories: MemoryFile[],
+    aggressive: boolean,
+  ): { memories: MemoryFile[]; actions: DreamAction[] } {
+    const actions: DreamAction[] = []
+    const kept: MemoryFile[] = []
+
+    for (const mem of memories) {
+      if (mem.age > STALE_DAYS) {
+        if (aggressive) {
+          try {
+            unlinkSync(mem.path)
+            actions.push({
+              type: 'prune',
+              description: `Pruned stale entry: "${mem.name}" (${mem.age}d old)`,
+              filesAffected: [mem.path],
+              autoApplied: true,
+            })
+          } catch {
+            kept.push(mem)
+          }
+        } else {
+          actions.push({
+            type: 'prune',
+            description: `Stale entry: "${mem.name}" (${mem.age}d old). Run /dream --aggressive to prune.`,
+            filesAffected: [mem.path],
+            autoApplied: false,
+          })
+          kept.push(mem)
+        }
+      } else {
+        kept.push(mem)
+      }
+    }
+
+    return { memories: kept, actions }
+  }
+
+  // ── Helpers ──
+
+  private loadMemories(): MemoryFile[] {
+    if (!existsSync(this.memoryDir)) return []
+
+    try {
+      const files = readdirSync(this.memoryDir).filter(
+        (f) => f.endsWith('.md') && f !== 'MEMORY.md',
+      )
+
+      return files
+        .map((f) => {
+          const path = join(this.memoryDir, f)
+          try {
+            const raw = readFileSync(path, 'utf-8')
+            const { frontmatter, content } = this.parseFrontmatter(raw)
+            const stat = statSync(path)
+            const age = Math.floor((Date.now() - stat.mtimeMs) / (1000 * 60 * 60 * 24))
+            return {
+              path,
+              name: f.replace('.md', ''),
+              frontmatter: frontmatter as Record<string, unknown>,
+              content,
+              age,
+            }
+          } catch {
+            return null
+          }
+        })
+        .filter((m): m is MemoryFile => m !== null)
+    } catch {
+      return []
+    }
+  }
+
+  private parseFrontmatter(raw: string): {
+    frontmatter: Record<string, unknown>
+    content: string
+  } {
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+    if (!match) return { frontmatter: {}, content: raw }
+    try {
+      const lines = match[1]!.split('\n')
+      const fm: Record<string, unknown> = {}
+      let currentNested: Record<string, unknown> | null = null
+      let nestedKey = ''
+      for (const line of lines) {
+        // Handle nested YAML (e.g. "metadata:\n  type: feedback")
+        const nested = line.match(/^  (\w[\w\s]*?):\s*(.+)$/)
+        if (nested && currentNested !== null) {
+          currentNested[nested[1]!.trim()] = nested[2]!.trim()
+          continue
+        }
+        // Top-level key
+        const kv = line.match(/^(\w[\w\s]*?):\s*(.*)$/)
+        if (kv) {
+          const key = kv[1]!.trim()
+          const val = kv[2]!.trim()
+          if (val === '') {
+            // Empty value → start nested block
+            currentNested = {}
+            nestedKey = key
+            fm[key] = currentNested
+          } else {
+            currentNested = null
+            fm[key] = val
+          }
+        }
+      }
+      return { frontmatter: fm, content: match[2] || '' }
+    } catch {
+      return { frontmatter: {}, content: raw }
+    }
+  }
+
+  private jaccardSimilarity(a: string, b: string): number {
+    // Strip punctuation before tokenizing for robust text comparison
+    const clean = (s: string) => s.toLowerCase().replace(/[.,!?;:'"(){}[\]\\/#*&%$@]+/g, ' ')
+    const tokensA = new Set(
+      clean(a)
+        .split(/\s+/)
+        .filter((t) => t.length > 1),
+    )
+    const tokensB = new Set(
+      clean(b)
+        .split(/\s+/)
+        .filter((t) => t.length > 1),
+    )
+    if (tokensA.size === 0 || tokensB.size === 0) return 0
+
+    let intersection = 0
+    for (const t of tokensA) {
+      if (tokensB.has(t)) intersection++
+    }
+    const union = tokensA.size + tokensB.size - intersection
+    return union > 0 ? intersection / union : 0
+  }
+
+  private saveDreamLog(timestamp: string, actions: DreamAction[]): void {
+    try {
+      const dir = join(this.memoryDir, '..')
+      mkdirSync(dir, { recursive: true })
+
+      let log: Array<{ timestamp: string; actions: DreamAction[] }> = []
+      if (existsSync(this.dreamLog)) {
+        log = JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+      }
+      log.unshift({ timestamp, actions })
+      // Keep last 10 dream cycles
+      if (log.length > 10) log = log.slice(0, 10)
+      writeFileSync(this.dreamLog, JSON.stringify(log, null, 2), 'utf-8')
+    } catch {
+      // Best-effort persistence
+    }
+  }
+
+  /** Get dream history for display. */
+  getDreamHistory(): Array<{ timestamp: string; actions: DreamAction[] }> {
+    try {
+      if (!existsSync(this.dreamLog)) return []
+      return JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+    } catch {
+      return []
+    }
+  }
+}

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
@@ -428,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
@@ -534,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',
@@ -542,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({
@@ -561,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) {
@@ -1141,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/ui/app.tsx

@@ -449,6 +449,24 @@ export function App({
         }
       }
 
+      // ── Emotion detection: adjust behavior based on user's emotional state ──
+      // Uses regex heuristics (zero-latency) to detect frustration/impatience/confusion.
+      // When frustrated, prepends a terseness instruction to the user input so the
+      // AI model skips explanations and gets straight to the fix.
+      let emotionPrefix = ''
+      try {
+        const { EmotionDetector } = await import('../core/emotion-detector.js')
+        const detector = new EmotionDetector()
+        const result = detector.detect(input)
+        if (result.emotion === 'frustrated' || result.emotion === 'impatient') {
+          emotionPrefix = `[SYSTEM NOTE: The user is ${result.emotion}. Be extremely concise. Skip all explanations, preambles, and summaries. Output only the fix/result. No "here's what I did" or "let me explain". One sentence maximum before code.]\n\n`
+        } else if (result.emotion === 'confused') {
+          emotionPrefix = `[SYSTEM NOTE: The user seems confused. Explain more thoroughly, break down complex steps, and offer clarifying questions rather than assuming understanding.]\n\n`
+        }
+      } catch {
+        // Emotion detection is non-critical — fail silently
+      }
+
       // ── Normal message processing (AI chat) ──
       setMessages((prev) => [...prev, { role: 'user', content: input }])
       setIsLoading(true)
@@ -493,7 +511,10 @@ export function App({
       }
 
       try {
-        for await (const chunk of engine.process(input, controller.signal)) {
+        for await (const chunk of engine.process(
+          emotionPrefix ? emotionPrefix + input : input,
+          controller.signal,
+        )) {
           // Reasoning content (DeepSeek V4 thinking mode) — silently consumed,
           // not shown to user to avoid noise.
           if (chunk.reasoning_content) {

package/src/ui/commands.ts

@@ -929,6 +929,234 @@ const sisCleanupCmd: CommandHandler = async (ctx) => {
   return { content: lines.join('\n') }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// Auto-Dream: Background Memory Consolidation
+// ═══════════════════════════════════════════════════════════════
+
+const dreamCmd: CommandHandler = async (ctx, args) => {
+  const t = resolveT(ctx)
+  const aggressive = args.includes('--aggressive') || args.includes('-a')
+  const status = args.includes('--status') || args.includes('-s')
+
+  const engine = ctx.engine.getDreamEngine?.()
+  if (!engine) {
+    return { content: 'DreamEngine 未初始化。请确认 Mipham Code 版本 >= v0.34.0。' }
+  }
+
+  if (status) {
+    const history = engine.getDreamHistory()
+    if (history.length === 0) {
+      return { content: '🌙 尚未运行过 Auto-Dream。使用 `/dream` 手动触发首次梦境整合。' }
+    }
+    const lines: string[] = ['## 🌙 Auto-Dream 历史', '']
+    for (const entry of history.slice(0, 5)) {
+      const ts = new Date(entry.timestamp).toLocaleString('zh-CN')
+      const total = entry.actions.length
+      const applied = entry.actions.filter((a) => a.autoApplied).length
+      const flagged = entry.actions.filter((a) => !a.autoApplied).length
+      lines.push(`- **${ts}**: ${total} 行动 (${applied} 自动应用, ${flagged} 标记审查)`)
+    }
+    return { content: lines.join('\n') }
+  }
+
+  const report = engine.dream({ aggressive })
+  const lines: string[] = [
+    '## 🌙 Auto-Dream 完成',
+    '',
+    `记忆整合: ${report.beforeCount} → ${report.afterCount}`,
+    ...(report.phases.deduplicated > 0 ? [`- 去重: ${report.phases.deduplicated} 条`] : []),
+    ...(report.phases.contradictionsFound > 0
+      ? [`- 矛盾冲突: ${report.phases.contradictionsFound} 处 (需人工裁决)`]
+      : []),
+    ...(report.phases.merged > 0 ? [`- 合并: ${report.phases.merged} 组`] : []),
+    ...(report.phases.solidified > 0
+      ? [`- 模糊标记: ${report.phases.solidified} 条 (建议固化)`]
+      : []),
+    ...(report.phases.pruned > 0 ? [`- 清理过期: ${report.phases.pruned} 条`] : []),
+    '',
+  ]
+
+  const flagged = report.actions.filter((a) => !a.autoApplied)
+  if (flagged.length > 0 && !aggressive) {
+    lines.push(`⚠️  ${flagged.length} 项待审查。使用 \`/dream --aggressive\` 自动应用所有操作。`)
+    lines.push('')
+    for (const action of flagged) {
+      lines.push(`- [ ] **${action.type}**: ${action.description}`)
+    }
+  }
+
+  if (report.actions.length === 0) {
+    lines.push('✅ 记忆干净，无需整理。')
+  }
+
+  return { content: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Bug Report
+// ═══════════════════════════════════════════════════════════════
+
+const bugReportCmd: CommandHandler = async (ctx) => {
+  const t = resolveT(ctx)
+  const engine = ctx.engine
+  const lines: string[] = [
+    '## 🐛 Bug Report',
+    '',
+    '> Copy the report below and paste it into your GitHub Issue.',
+    '',
+    '---',
+    '',
+  ]
+
+  // ── Version & Runtime ──
+  lines.push('### Environment', '')
+  lines.push(`- **Mipham Code**: v${ctx.version}`)
+  lines.push(`- **Session**: ${ctx.sessionId}`)
+  lines.push(`- **Node**: ${process.version}`)
+  lines.push(`- **Platform**: ${process.platform} ${process.arch}`)
+  lines.push(
+    `- **OS**: ${process.platform === 'darwin' ? 'macOS' : process.platform === 'linux' ? 'Linux' : 'Windows'}`,
+  )
+  lines.push(`- **Provider**: ${ctx.providerId}`)
+  lines.push(`- **Model**: ${ctx.modelId}`)
+  lines.push('')
+
+  // ── SIS errors ──
+  try {
+    const db = engine.getErrorSignatureDB?.()
+    if (db) {
+      const active = db.getActive()
+      if (active.length > 0) {
+        lines.push('### Active Error Signatures', '')
+        for (const sig of active.slice(0, 10)) {
+          lines.push(
+            `- \`${sig.id}\`: ${sig.pattern} (${sig.category}, ${sig.occurrences}x, ${(sig.successRate * 100).toFixed(0)}% success)`,
+          )
+        }
+        lines.push('')
+      }
+    }
+  } catch {
+    // SIS unavailable
+  }
+
+  // ── Hook health ──
+  try {
+    const hookEngine = engine.getHookEngine?.()
+    if (hookEngine) {
+      const health = hookEngine.getHookHealth()
+      const disabled = health.filter((h) => h.health.disabled)
+      if (disabled.length > 0) {
+        lines.push('### Disabled Hooks', '')
+        for (const entry of disabled) {
+          lines.push(
+            `- \`${entry.key}\`: ${entry.health.failures} failures, disabled at ${new Date(entry.health.disabledAt).toISOString()}`,
+          )
+        }
+        lines.push('')
+      }
+    }
+  } catch {
+    // Hook health unavailable
+  }
+
+  // ── Recent dream log ──
+  try {
+    const dreamEngine = engine.getDreamEngine?.()
+    if (dreamEngine) {
+      const history = dreamEngine.getDreamHistory()
+      if (history.length > 0) {
+        const last = history[0]!
+        lines.push('### Last Auto-Dream', '')
+        lines.push(`- **Ran at**: ${last.timestamp}`)
+        lines.push(
+          `- **Actions**: ${last.actions.length} (${last.actions.filter((a: { autoApplied: boolean }) => a.autoApplied).length} applied)`,
+        )
+        lines.push('')
+      }
+    }
+  } catch {
+    // Dream engine unavailable
+  }
+
+  // ── Steps to reproduce (template) ──
+  lines.push('### Steps to Reproduce', '')
+  lines.push('1. ')
+  lines.push('2. ')
+  lines.push('3. ')
+  lines.push('')
+  lines.push('### Expected Behavior', '')
+  lines.push('')
+  lines.push('### Actual Behavior', '')
+  lines.push('')
+  lines.push('---')
+  lines.push(`🤖 Generated with Mipham Code v${ctx.version}`)
+
+  return { content: lines.join('\n'), copyContent: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Feedback
+// ═══════════════════════════════════════════════════════════════
+// Changelog
+// ═══════════════════════════════════════════════════════════════
+
+const changelogCmd: CommandHandler = async (ctx) => {
+  const t = resolveT(ctx)
+  const lines: string[] = ['## 📋 Changelog', '']
+
+  try {
+    const { execSync } = await import('node:child_process')
+    const tags = execSync('git tag --sort=-creatordate', { encoding: 'utf-8', timeout: 5000 })
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .slice(0, 15)
+
+    if (tags.length === 0) {
+      lines.push('No version tags found.')
+      return { content: lines.join('\n') }
+    }
+
+    lines.push(`Current: **v${ctx.version}**`, '')
+
+    for (let i = 0; i < tags.length; i++) {
+      const tag = tags[i]!
+      const nextTag = tags[i + 1]
+      try {
+        const range = nextTag ? `${nextTag}..${tag}` : tag
+        const log = execSync(
+          `git log --oneline --no-merges ${range} --format="%s" 2>/dev/null | head -8`,
+          { encoding: 'utf-8', timeout: 5000 },
+        )
+          .trim()
+          .split('\n')
+          .filter(Boolean)
+
+        const isCurrent = tag === `v${ctx.version}`
+        lines.push(`### ${tag}${isCurrent ? ' ← current' : ''}`, '')
+        if (log.length > 0) {
+          for (const entry of log) {
+            lines.push(`- ${entry}`)
+          }
+        } else {
+          lines.push('  _(release tag only)_')
+        }
+        lines.push('')
+      } catch {
+        lines.push(`### ${tag}`, '', '  _(details unavailable)_', '')
+      }
+    }
+  } catch {
+    lines.push('Unable to read git history. Make sure you are in the Mipham Code repository.')
+  }
+
+  lines.push('---')
+  lines.push(`Full history: \`git log --oneline\``)
+
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Workflow
 // ═══════════════════════════════════════════════════════════════
@@ -2147,25 +2375,69 @@ const statsCmd: CommandHandler = (ctx) => {
   const assistantMsgs = msgs.filter((m) => m.role === 'assistant').length
   const systemMsgs = msgs.filter((m) => m.role === 'system').length
 
-  return {
-    content: [
-      t('commands.stats.title'),
-      '',
-      t('commands.stats.messages', {
-        total: String(msgs.length),
-        user: String(userMsgs),
-        assistant: String(assistantMsgs),
-        system: String(systemMsgs),
-      }),
-      t('commands.stats.tokens', { tokens: tokens.toLocaleString() }),
-      t('commands.stats.tools', { count: String(tools.size) }),
-      t('commands.stats.provider', { provider: ctx.providerId }),
-      t('commands.stats.model', { model: ctx.modelId }),
-      t('commands.stats.permission', { permission: ctx.config.permission }),
-      '',
-      t('commands.stats.usage', { pct: ((tokens / 200_000) * 100).toFixed(1) }),
-    ].join('\n'),
+  const base = [
+    t('commands.stats.title'),
+    '',
+    t('commands.stats.messages', {
+      total: String(msgs.length),
+      user: String(userMsgs),
+      assistant: String(assistantMsgs),
+      system: String(systemMsgs),
+    }),
+    t('commands.stats.tokens', { tokens: tokens.toLocaleString() }),
+    t('commands.stats.tools', { count: String(tools.size) }),
+    t('commands.stats.provider', { provider: ctx.providerId }),
+    t('commands.stats.model', { model: ctx.modelId }),
+    t('commands.stats.permission', { permission: ctx.config.permission }),
+    '',
+    t('commands.stats.usage', { pct: ((tokens / 200_000) * 100).toFixed(1) }),
+  ]
+
+  // ── CRSI & SIS extensions ──
+  const engine = ctx.engine
+  const extras: string[] = []
+
+  try {
+    const db = engine.getErrorSignatureDB?.()
+    if (db) {
+      const s = db.getStats()
+      if (s.total > 0) {
+        extras.push(
+          '',
+          '── SIS Self-Immune ──',
+          `Signatures: ${s.total} total, ${s.active} active | Success rate: ${(s.avgSuccessRate * 100).toFixed(0)}%`,
+        )
+      }
+    }
+  } catch {
+    /* SIS not initialized */
   }
+
+  try {
+    const autoMemory = engine.getAutoMemory?.()
+    if (autoMemory) {
+      const count = autoMemory.sessionReflectionCount ?? 0
+      if (count > 0) extras.push(`CRSI Reflections: ${count} turn(s) analyzed`)
+    }
+  } catch {
+    /* CRSI not initialized */
+  }
+
+  try {
+    const meta = engine.getMetaRuleEngine?.()
+    if (meta) {
+      const analysis = meta.analyze()
+      if (analysis.systemHealth) {
+        extras.push(
+          `System Health: ${analysis.systemHealth.score}/100 — ${analysis.systemHealth.assessment}`,
+        )
+      }
+    }
+  } catch {
+    /* Meta not initialized */
+  }
+
+  return { content: [...base, ...extras].join('\n') }
 }
 
 const summaryCmd: CommandHandler = (ctx) => {
@@ -3157,31 +3429,57 @@ To switch providers without clearing keys, use /switch <provider> <model>.`,
 // Phase 4 — Feedback
 // ═══════════════════════════════════════════════════════════════
 
-const feedbackCmd: CommandHandler = (ctx, args) => {
+const feedbackCmd: CommandHandler = async (ctx, args) => {
   const message = args.join(' ').trim()
 
   const lines: string[] = ['── Feedback ──', '']
 
+  // If a message was provided, save it to ~/.mipham/feedback/
   if (message) {
-    lines.push('Your feedback:')
-    lines.push('')
-    lines.push('  """')
-    for (const line of message.split('\n')) {
-      lines.push('  ' + line)
+    try {
+      const { writeFileSync, mkdirSync, existsSync } = await import('node:fs')
+      const { join } = await import('node:path')
+      const { homedir } = await import('node:os')
+
+      const dir = join(homedir(), '.mipham', 'feedback')
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+
+      const ts = new Date().toISOString().replace(/[:.]/g, '-')
+      const file = join(dir, `feedback-${ts}.md`)
+      const content = [
+        '---',
+        `timestamp: ${new Date().toISOString()}`,
+        `version: ${ctx.version}`,
+        `session: ${ctx.sessionId}`,
+        `provider: ${ctx.providerId}`,
+        `model: ${ctx.modelId}`,
+        '---',
+        '',
+        message,
+      ].join('\n')
+      writeFileSync(file, content, 'utf-8')
+
+      lines.push('Your feedback:')
+      lines.push('')
+      lines.push('  """')
+      for (const line of message.split('\n')) {
+        lines.push('  ' + line)
+      }
+      lines.push('  """')
+      lines.push('')
+      lines.push(`✅ Saved to \`${file}\``)
+      lines.push('')
+    } catch (err) {
+      lines.push(`⚠️ Save failed: ${String(err)}`)
+      lines.push('')
     }
-    lines.push('  """')
-    lines.push('')
-    lines.push('── Preview Complete ──')
-    lines.push('')
-    lines.push('Copy the above and submit via one of the channels below.')
-    lines.push('')
   }
 
   lines.push('── Feedback Channels ──')
   lines.push('')
   lines.push('  🐛 Bug Reports')
   lines.push('     GitHub Issues: https://github.com/One-Mipham/mipham-code/issues')
-  lines.push('     Template:      Bug Report (include version + reproduction steps)')
+  lines.push('     Or run `/bug-report` to auto-generate a diagnostic report')
   lines.push('')
   lines.push('  💡 Feature Requests')
   lines.push('     GitHub Issues: https://github.com/One-Mipham/mipham-code/issues')
@@ -3562,6 +3860,9 @@ const commandsListCmd: CommandHandler = () => {
     '/recap': 'Session & Identity',
     '/export': 'Session & Identity',
     '/doctor': 'Session & Identity',
+    '/dream': 'Session & Identity',
+    '/bug-report': 'Session & Identity',
+    '/changelog': 'Session & Identity',
     '/resume': 'Session & Identity',
     '/resume last': 'Session & Identity',
     '/resume delete': 'Session & Identity',
@@ -3757,6 +4058,9 @@ registry.set('/sis errors', sisErrorsCmd)
 registry.set('/sis stats', sisStatsCmd)
 registry.set('/sis clear', sisClearCmd)
 registry.set('/sis cleanup', sisCleanupCmd)
+registry.set('/dream', dreamCmd)
+registry.set('/bug-report', bugReportCmd)
+registry.set('/changelog', changelogCmd)
 
 // Workflow
 registry.set('/plan', planCmd)
@@ -3877,6 +4181,9 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/recap': 'Summarize session so far',
   '/export': 'Export conversation to file',
   '/doctor': 'System diagnostics',
+  '/dream': 'Background memory consolidation',
+  '/bug-report': 'Generate diagnostic report for GitHub Issues',
+  '/changelog': 'Recent version history',
   '/resume': 'List saved sessions',
   '/resume last': 'Restore the most recent saved session',
   '/resume delete': 'Delete a saved session',