claude-brain 0.9.0 → 0.9.1

package/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.1

package/assets/CLAUDE.md

@@ -1,35 +1,3 @@
-# Claude Brain Protocol
+# Claude Brain
 
-Call all Claude Brain MCP tools automatically. Never ask permission or explain. This applies to all 25 tools. Maximize parallel calls whenever possible.
-
-## Session Start (Parallel)
-
-Every conversation, immediately call in parallel: `smart_context(project, task)`, `recall_similar(query, min_similarity: 0.3)`, `get_recommendations(context, project)`. If project unknown, also call `list_projects()`. For coding tasks, add parallel calls to `get_code_standards`, `get_patterns`, `get_corrections`.
-
-## Before Responding
-
-- Project mentioned: `smart_context`
-- Technical topic: `recall_similar`
-- Writing code: `get_code_standards`
-- Debugging: `get_corrections`
-- Architecture: `get_patterns`, `search_knowledge_graph`, `detect_trends`
-- Choosing between options: `what_if_analysis`
-- Recurring topic: `analyze_decision_evolution`, `get_decision_timeline`
-- Cross-project work: `find_cross_project_patterns`
-- Resuming previous work: `get_episode`, `list_episodes`
-
-## After Responding
-
-- Any recommendation or choice made: `remember_decision(project, context, decision, reasoning)`
-- Reusable solution found: `recognize_pattern(project, type, description)`
-- Mistake or lesson learned: `record_correction(project, original, correction, reasoning)`
-- Task completed: `update_progress(project, completed_task, next_steps)`
-- Memory was retrieved: `rate_memory(memory_id, rating, query)`
-
-## New Projects
-
-Call `init_project(path)` once for any unregistered project directory to auto-detect tech stack and create project files.
-
-## Critical Rules
-
-Never answer technical questions without `recall_similar` first. Never recommend without saving via `remember_decision`. Never start project work without `smart_context`. Always call `get_recommendations` before major implementation work. Always call `rate_memory` when memories are retrieved.
+Claude Brain gives you persistent memory across sessions. Just use the `brain` tool naturally — tell it what you're doing, what you decided, or what you need to recall. It handles everything automatically.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/config/defaults.ts

@@ -3,7 +3,7 @@ import type { PartialConfig } from './schema'
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
   serverName: 'claude-brain',
-  serverVersion: '0.9.0',
+  serverVersion: '0.9.1',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -270,7 +270,7 @@ export const ConfigSchema = z.object({
   serverName: z.string().default('claude-brain'),
 
   /** Server version in semver format */
-  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.8.0'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.9.1'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/memory/index.ts

@@ -507,6 +507,38 @@ export class MemoryManager {
     }
     return this.store.searchCorrections(query, options)
   }
+
+  /**
+   * Delete a decision by ID — routes to ChromaDB or SQLite
+   */
+  async deleteDecision(id: string): Promise<void> {
+    if (this.useChromaDB) {
+      await this.chroma.store.deleteDecision(id)
+    } else {
+      this.store.deleteMemory(id)
+    }
+  }
+
+  /**
+   * Update a decision by storing a new version and deleting the old one
+   */
+  async updateDecision(
+    oldId: string,
+    project: string,
+    context: string,
+    decision: string,
+    reasoning: string,
+    options?: { alternatives?: string; tags?: string[] }
+  ): Promise<string> {
+    // Delete old version
+    try {
+      await this.deleteDecision(oldId)
+    } catch {
+      // Old ID might not exist, continue with storing new version
+    }
+    // Store new version
+    return this.rememberDecision(project, context, decision, reasoning, options)
+  }
 }
 
 /**

package/src/routing/entity-extractor.ts

@@ -84,6 +84,19 @@ const TECH_ALIASES: Record<string, string> = {
   'gql': 'graphql', 'golang': 'go',
 }
 
+// Common English words that should never be treated as project names
+const GENERIC_WORDS: Set<string> = new Set([
+  'small', 'large', 'big', 'new', 'old', 'good', 'bad', 'best', 'worst',
+  'simple', 'complex', 'easy', 'hard', 'fast', 'slow', 'quick', 'all',
+  'this', 'that', 'these', 'those', 'some', 'any', 'every', 'each',
+  'other', 'another', 'next', 'last', 'first', 'final', 'main', 'side',
+  'personal', 'general', 'specific', 'local', 'global', 'internal', 'external',
+  'current', 'future', 'past', 'recent', 'data', 'test', 'code', 'file',
+  'the', 'for', 'with', 'from', 'into', 'about', 'like', 'just', 'more',
+  'production', 'development', 'staging', 'projects', 'apps', 'tools',
+  'frontend', 'backend', 'fullstack', 'mobile', 'web', 'desktop', 'cli'
+])
+
 export interface BrainExtractedEntities {
   project?: string
   technologies: string[]
@@ -159,8 +172,13 @@ export class BrainEntityExtractor {
       const match = message.match(pattern)
       if (match && match[1]) {
         const candidate = match[1].toLowerCase()
-        // Filter out common false positives
-        if (!COMMON_TECH.has(candidate) && candidate.length > 1 && candidate.length < 50) {
+        // Filter out common false positives: tech names, generic words, adjectives
+        if (
+          !COMMON_TECH.has(candidate) &&
+          !GENERIC_WORDS.has(candidate) &&
+          candidate.length > 2 &&
+          candidate.length < 50
+        ) {
           return candidate
         }
       }

package/src/routing/intent-classifier.ts

@@ -10,12 +10,16 @@ export type Intent =
   | 'session_start'
   | 'context_needed'
   | 'decision_made'
+  | 'store_this'
   | 'pattern_found'
   | 'mistake_learned'
   | 'progress_update'
   | 'question'
   | 'comparison'
   | 'exploration'
+  | 'list_all'
+  | 'update_memory'
+  | 'delete_memory'
   | 'no_action'
 
 export interface ClassificationResult {
@@ -24,13 +28,30 @@ export interface ClassificationResult {
   secondary: Intent[]
 }
 
-// Decision-indicating phrases (from automation/decision-detector.ts)
+// Decision-indicating phrases
 const DECISION_PHRASES = [
   'i recommend', 'you should use', 'the best approach',
   'i suggest', 'better to use', 'prefer using',
   'go with', 'decided to', "let's use", 'we will use',
   'the solution is', 'implement using', 'going with',
-  'switching to', 'adopting', 'we chose', 'the plan is to'
+  'switching to', 'adopting', 'we chose', 'the plan is to',
+  'i decided that', 'decided that', 'choosing', 'we picked',
+  'settled on', 'committing to', 'opting for', 'sticking with'
+]
+
+// Explicit "store this" phrases — the user wants to persist something
+const STORE_PHRASES = [
+  'remember:', 'remember this:', 'remember that',
+  'note to self:', 'note to self', 'note:', 'save this:',
+  'save this', 'store this', 'keep this', 'record this',
+  'i prefer', 'my preference is', 'my convention is',
+  'i like to', 'i always', 'always use', 'never use this',
+  'from now on', 'going forward', 'the rule is',
+  'my approach is', 'my standard is', 'the standard is',
+  'we should always', 'we should never',
+  'i want to remember', 'don\'t forget',
+  'for future reference', 'for the record',
+  'important:', 'key decision:', 'takeaway:'
 ]
 
 const REASONING_PHRASES = [
@@ -43,16 +64,20 @@ const REASONING_PHRASES = [
 const MISTAKE_PHRASES = [
   'bug was', 'the issue was', 'the problem was', 'mistake was',
   'should have', "shouldn't have", 'should not have',
-  'lesson learned', "don't use", 'avoid using', 'never use',
+  'lesson learned', "don't use", 'avoid using',
   'the fix is', 'the fix was', 'fixed by', 'solved by',
-  'was wrong', 'was broken', 'was incorrect'
+  'was wrong', 'was broken', 'was incorrect',
+  'gotcha:', 'pitfall:', 'watch out for', 'be careful with',
+  'i learned that', 'turns out that'
 ]
 
 // Progress indicators
 const PROGRESS_PHRASES = [
   'finished', 'completed', 'done with', 'implemented',
   'built', 'created', 'added', 'fixed', 'resolved',
-  'shipped', 'deployed', 'merged', 'released'
+  'shipped', 'deployed', 'merged', 'released',
+  "i'm working on", 'currently working', 'making progress',
+  'just did', 'just finished'
 ]
 
 // Comparison indicators
@@ -97,6 +122,32 @@ const NO_ACTION_PHRASES = [
   'understood', 'noted', 'alright', 'right'
 ]
 
+// List/browse indicators
+const LIST_PHRASES = [
+  'list all', 'show all', 'what decisions',
+  'what have i decided', 'all my decisions', 'all decisions',
+  'everything about', 'what do i know', 'what do we know',
+  'show me everything', 'list decisions', 'list memories',
+  'browse', 'dump all', 'show my'
+]
+
+// Update/correct existing memory
+const UPDATE_PHRASES = [
+  'actually,', 'actually ', 'correction:', 'update that',
+  'i changed my mind', 'change that to', 'instead of what i said',
+  'supersedes', 'override', 'revise that', 'amend that',
+  'that should be', 'update the decision', 'modify that',
+  'replace that with', 'no wait', 'scratch that, use'
+]
+
+// Delete/forget memory
+const DELETE_PHRASES = [
+  'forget that', 'forget about', 'delete that', 'delete the',
+  'remove that memory', 'remove that decision', 'that was wrong',
+  'discard that', 'erase that', 'undo that decision',
+  'remove the memory', 'clear that', 'drop that'
+]
+
 export class IntentClassifier {
   /**
    * Classify the intent of a message
@@ -112,54 +163,75 @@ export class IntentClassifier {
       return { primary: 'no_action', confidence: 0.95, secondary: [] }
     }
 
-    // 2. decision_made: decision phrases + reasoning
+    // 2. delete_memory: "forget that", "delete", "remove"
+    if (this.isDeleteMemory(lower)) {
+      return { primary: 'delete_memory', confidence: 0.90, secondary }
+    }
+
+    // 3. update_memory: "actually", "correction:", "change that to"
+    if (this.isUpdateMemory(lower)) {
+      return { primary: 'update_memory', confidence: 0.85, secondary }
+    }
+
+    // 4. store_this: explicit "remember:", "save this:", "I prefer"
+    if (this.isStoreThis(lower)) {
+      if (this.hasDecisionSignal(lower)) secondary.push('decision_made')
+      return { primary: 'store_this', confidence: 0.90, secondary }
+    }
+
+    // 5. decision_made: decision phrases + reasoning
     if (this.isDecisionMade(lower)) {
       if (this.hasComparisonSignal(lower)) secondary.push('comparison')
       return { primary: 'decision_made', confidence: 0.85, secondary }
     }
 
-    // 3. mistake_learned: correction/bug/lesson indicators
+    // 6. mistake_learned: correction/bug/lesson indicators
     if (this.isMistakeLearned(lower)) {
       return { primary: 'mistake_learned', confidence: 0.85, secondary }
     }
 
-    // 4. progress_update: completed task indicators (NOT questions)
+    // 7. list_all: "list all", "what decisions", "show all"
+    if (this.isListAll(lower, message)) {
+      return { primary: 'list_all', confidence: 0.85, secondary }
+    }
+
+    // 8. progress_update: completed task indicators (NOT questions)
     if (this.isProgressUpdate(lower, message)) {
       if (this.hasSessionSignal(lower)) secondary.push('session_start')
       return { primary: 'progress_update', confidence: 0.85, secondary }
     }
 
-    // 5. comparison: vs, which is better, etc.
+    // 9. comparison: vs, which is better, etc.
     if (this.isComparison(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
       return { primary: 'comparison', confidence: 0.85, secondary }
     }
 
-    // 6. pattern_found: explicit pattern documentation
+    // 10. pattern_found: explicit pattern documentation
     if (this.isPatternFound(lower)) {
       return { primary: 'pattern_found', confidence: 0.80, secondary }
     }
 
-    // 7. session_start: starting/resuming work
+    // 11. session_start: starting/resuming work
     if (this.isSessionStart(lower)) {
       secondary.push('context_needed')
       return { primary: 'session_start', confidence: 0.90, secondary }
     }
 
-    // 8. exploration: timeline, trends, graph, history
+    // 12. exploration: timeline, trends, graph, history
     if (this.isExploration(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
       return { primary: 'exploration', confidence: 0.75, secondary }
     }
 
-    // 9. question: starts with question word or ends with ?
+    // 13. question: starts with question word or ends with ?
     if (this.isQuestion(lower, message)) {
       if (this.hasComparisonSignal(lower)) secondary.push('comparison')
       if (this.hasExplorationSignal(lower)) secondary.push('exploration')
       return { primary: 'question', confidence: 0.80, secondary }
     }
 
-    // 10. Default: context_needed
+    // 14. Default: context_needed
     return { primary: 'context_needed', confidence: 0.60, secondary }
   }
 
@@ -170,6 +242,10 @@ export class IntentClassifier {
     return NO_ACTION_PHRASES.some(p => lower === p || lower === p + '.' || lower === p + '!')
   }
 
+  private isStoreThis(lower: string): boolean {
+    return STORE_PHRASES.some(p => lower.includes(p))
+  }
+
   private isDecisionMade(lower: string): boolean {
     const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
     if (!hasDecision) return false
@@ -182,6 +258,10 @@ export class IntentClassifier {
     return MISTAKE_PHRASES.some(p => lower.includes(p))
   }
 
+  private isListAll(lower: string, _original: string): boolean {
+    return LIST_PHRASES.some(p => lower.includes(p))
+  }
+
   private isProgressUpdate(lower: string, original: string): boolean {
     // Must not be a question
     if (original.trim().endsWith('?')) return false
@@ -214,7 +294,19 @@ export class IntentClassifier {
     return QUESTION_WORDS.includes(firstWord)
   }
 
+  private isUpdateMemory(lower: string): boolean {
+    return UPDATE_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isDeleteMemory(lower: string): boolean {
+    return DELETE_PHRASES.some(p => lower.includes(p))
+  }
+
   // Secondary signal checks
+  private hasDecisionSignal(lower: string): boolean {
+    return DECISION_PHRASES.some(p => lower.includes(p))
+  }
+
   private hasComparisonSignal(lower: string): boolean {
     return COMPARISON_PHRASES.some(p => lower.includes(p))
   }

package/src/routing/router.ts

@@ -19,6 +19,9 @@ import {
   isServicesInitialized
 } from '@/server/services'
 
+/** Default project when none can be detected */
+const DEFAULT_PROJECT = 'general'
+
 export interface BrainInput {
   message: string
   project?: string
@@ -30,6 +33,10 @@ export class BrainRouter {
   private responseFilter: ResponseFilter
   private logger: Logger
 
+  /** Track the most recently stored decision ID for update/delete operations */
+  private lastStoredId: string | null = null
+  private lastStoredProject: string | null = null
+
   constructor(logger: Logger) {
     this.classifier = new IntentClassifier()
     this.entityExtractor = new BrainEntityExtractor()
@@ -64,6 +71,9 @@ export class BrainRouter {
         case 'decision_made':
           return this.handleDecisionMade(message, project, entities)
 
+        case 'store_this':
+          return this.handleStoreThis(message, project, entities)
+
         case 'pattern_found':
           return this.handlePatternFound(message, project, entities)
 
@@ -82,6 +92,15 @@ export class BrainRouter {
         case 'exploration':
           return this.handleExploration(message, project, entities)
 
+        case 'list_all':
+          return this.handleListAll(message, project, entities)
+
+        case 'update_memory':
+          return this.handleUpdateMemory(message, project, entities)
+
+        case 'delete_memory':
+          return this.handleDeleteMemory(message, project, entities)
+
         default:
           return this.handleContextNeeded(message, project, entities)
       }
@@ -252,35 +271,78 @@ export class BrainRouter {
     return this.responseFilter.synthesize(tiers, message, project)
   }
 
-  private async handleDecisionMade(
+  /**
+   * Handle explicit "store this" requests — always uses the FULL message as the decision text.
+   * This prevents content mangling from entity extraction.
+   */
+  private async handleStoreThis(
     message: string,
     project: string | undefined,
     entities: BrainExtractedEntities
   ): Promise<BrainResponse> {
-    if (!project) {
-      return {
-        action: 'none',
-        summary: 'Cannot store decision without a project',
-        content: 'Please specify which project this decision relates to.',
-        relevantItems: 0
+    // Use "general" as fallback when no project is detected
+    const effectiveProject = project || DEFAULT_PROJECT
+
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    const memory = getMemoryService()
+
+    // ALWAYS use the full message as the decision — never the extracted fragment
+    const decision = message
+    const reasoning = entities.reasoning || ''
+    const context = entities.topic || message.slice(0, 200)
+
+    const decisionId = await memory.rememberDecision(
+      effectiveProject,
+      context,
+      decision,
+      reasoning,
+      {
+        alternatives: entities.alternatives,
+        tags: entities.technologies.length > 0 ? entities.technologies : ['user-stored']
       }
+    )
+
+    // Track for potential update/delete
+    this.lastStoredId = decisionId
+    this.lastStoredProject = effectiveProject
+
+    // Also write to vault
+    this.writeToVault(effectiveProject, decision, reasoning, context, entities.alternatives)
+
+    return {
+      action: 'stored',
+      summary: `Stored: ${message.slice(0, 60)}`,
+      content: `Memory stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Content:** ${decision}${reasoning ? `\n**Reasoning:** ${reasoning}` : ''}`,
+      relevantItems: 1
     }
+  }
+
+  private async handleDecisionMade(
+    message: string,
+    project: string | undefined,
+    entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    // Use "general" as fallback when no project is detected
+    const effectiveProject = project || DEFAULT_PROJECT
 
     if (!isServicesInitialized()) {
       return this.servicesNotReady()
     }
 
     const memory = getMemoryService()
-    const vault = getVaultService()
 
-    // Extract decision components (use entities or fall back to raw message)
-    const decision = entities.decision || message
+    // ALWAYS use the full message as the decision text to prevent content mangling.
+    // The extracted entities are used only for structured metadata.
+    const decision = message
     const reasoning = entities.reasoning || ''
     const context = entities.topic || message.slice(0, 200)
     const alternatives = entities.alternatives
 
     const decisionId = await memory.rememberDecision(
-      project,
+      effectiveProject,
       context,
       decision,
       reasoning,
@@ -290,20 +352,17 @@ export class BrainRouter {
       }
     )
 
+    // Track for potential update/delete
+    this.lastStoredId = decisionId
+    this.lastStoredProject = effectiveProject
+
     // Also write to vault
-    try {
-      const projectPaths = vault.getProjectPaths(project)
-      const date = new Date().toISOString().split('T')[0]
-      const entry = `### Decision: ${decision.slice(0, 100)}\n\n**Date:** ${date}\n**Context:** ${context}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}\n${alternatives ? `**Alternatives:** ${alternatives}\n` : ''}\n---\n\n`
-      await vault.writer.appendContent(projectPaths.decisions, entry, '\n')
-    } catch {
-      // Vault write failed — memory storage still succeeded
-    }
+    this.writeToVault(effectiveProject, decision, reasoning, context, alternatives)
 
     return {
       action: 'stored',
-      summary: `Stored decision: ${decision.slice(0, 60)}`,
-      content: `Decision stored (ID: ${decisionId})\n\n**Project:** ${project}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}`,
+      summary: `Stored decision: ${message.slice(0, 60)}`,
+      content: `Decision stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}`,
       relevantItems: 1
     }
   }
@@ -313,14 +372,7 @@ export class BrainRouter {
     project: string | undefined,
     entities: BrainExtractedEntities
   ): Promise<BrainResponse> {
-    if (!project) {
-      return {
-        action: 'none',
-        summary: 'Cannot store pattern without a project',
-        content: 'Please specify which project this pattern relates to.',
-        relevantItems: 0
-      }
-    }
+    const effectiveProject = project || DEFAULT_PROJECT
 
     if (!isServicesInitialized()) {
       return this.servicesNotReady()
@@ -328,10 +380,10 @@ export class BrainRouter {
 
     const memory = getMemoryService()
     const patternType = entities.patternType || 'solution'
-    const description = entities.topic || message
+    const description = message // Use full message
 
     const patternId = await memory.storePattern({
-      project,
+      project: effectiveProject,
       pattern_type: patternType,
       description,
       confidence: 0.8,
@@ -341,7 +393,7 @@ export class BrainRouter {
     return {
       action: 'stored',
       summary: `Stored ${patternType}: ${description.slice(0, 60)}`,
-      content: `Pattern stored (ID: ${patternId})\n\n**Type:** ${patternType}\n**Project:** ${project}\n**Description:** ${description}`,
+      content: `Pattern stored (ID: ${patternId})\n\n**Type:** ${patternType}\n**Project:** ${effectiveProject}\n**Description:** ${description}`,
       relevantItems: 1
     }
   }
@@ -351,14 +403,7 @@ export class BrainRouter {
     project: string | undefined,
     entities: BrainExtractedEntities
   ): Promise<BrainResponse> {
-    if (!project) {
-      return {
-        action: 'none',
-        summary: 'Cannot store correction without a project',
-        content: 'Please specify which project this lesson relates to.',
-        relevantItems: 0
-      }
-    }
+    const effectiveProject = project || DEFAULT_PROJECT
 
     if (!isServicesInitialized()) {
       return this.servicesNotReady()
@@ -366,12 +411,13 @@ export class BrainRouter {
 
     const memory = getMemoryService()
 
+    // Use full message as the original content to prevent mangling
     const original = entities.original || message
     const correction = entities.correction || ''
     const reasoning = entities.reasoning || 'Lesson learned from experience'
 
     const correctionId = await memory.storeCorrection({
-      project,
+      project: effectiveProject,
       original,
       correction: correction || message,
       reasoning,
@@ -382,7 +428,7 @@ export class BrainRouter {
     return {
       action: 'stored',
       summary: `Stored correction: ${original.slice(0, 60)}`,
-      content: `Correction stored (ID: ${correctionId})\n\n**Project:** ${project}\n**Original:** ${original}\n**Correction:** ${correction || '(see original message)'}`,
+      content: `Correction stored (ID: ${correctionId})\n\n**Project:** ${effectiveProject}\n**Original:** ${original}\n**Correction:** ${correction || '(see original message)'}`,
       relevantItems: 1
     }
   }
@@ -392,26 +438,21 @@ export class BrainRouter {
     project: string | undefined,
     entities: BrainExtractedEntities
   ): Promise<BrainResponse> {
-    if (!project) {
-      return {
-        action: 'none',
-        summary: 'Cannot update progress without a project',
-        content: 'Please specify which project to update progress for.',
-        relevantItems: 0
-      }
-    }
+    const effectiveProject = project || DEFAULT_PROJECT
 
     if (!isServicesInitialized()) {
       return this.servicesNotReady()
     }
 
     const contextService = getContextService()
+    const memory = getMemoryService()
 
     const completedTask = entities.completedTask || message
     const nextSteps = entities.nextSteps || 'Continue development'
 
+    // Store in session context
     try {
-      await contextService.progress.addCompletedTask(project, {
+      await contextService.progress.addCompletedTask(effectiveProject, {
         id: this.generateTaskId(completedTask),
         title: completedTask,
         status: 'done',
@@ -421,14 +462,268 @@ export class BrainRouter {
       // Progress update failed — still report what we found
     }
 
+    // Also store as a searchable memory in ChromaDB so it appears in search results
+    try {
+      await memory.rememberDecision(
+        effectiveProject,
+        `Progress update`,
+        `Progress: ${completedTask}${nextSteps !== 'Continue development' ? `. Next: ${nextSteps}` : ''}`,
+        'Progress tracking',
+        { tags: ['progress', ...entities.technologies] }
+      )
+    } catch {
+      // Memory storage failed, context-only storage still succeeded
+    }
+
     return {
       action: 'stored',
       summary: `Progress: ${completedTask.slice(0, 60)}`,
-      content: `Progress updated for ${project}\n\n**Completed:** ${completedTask}\n**Next:** ${nextSteps}`,
+      content: `Progress updated for ${effectiveProject}\n\n**Completed:** ${completedTask}\n**Next:** ${nextSteps}`,
+      relevantItems: 1
+    }
+  }
+
+  /**
+   * List all decisions for a project
+   */
+  private async handleListAll(
+    message: string,
+    project: string | undefined,
+    entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    const memory = getMemoryService()
+    const effectiveProject = project // No fallback — list all if no project
+
+    try {
+      const decisions = await memory.fetchAllDecisions(effectiveProject)
+      const patterns = await memory.fetchAllPatterns(effectiveProject)
+      const corrections = await memory.fetchAllCorrections(effectiveProject)
+
+      const parts: string[] = []
+      const projectLabel = effectiveProject || 'all projects'
+
+      if (decisions.length > 0) {
+        parts.push(`## Decisions (${decisions.length})`)
+        for (const d of decisions.slice(0, 20)) {
+          const decision = d.decision || d.document || d.content || ''
+          const date = d.created_at ? ` (${String(d.created_at).split('T')[0]})` : ''
+          parts.push(`- ${decision.slice(0, 150)}${date}`)
+        }
+        if (decisions.length > 20) {
+          parts.push(`_...and ${decisions.length - 20} more_`)
+        }
+        parts.push('')
+      }
+
+      if (patterns.length > 0) {
+        parts.push(`## Patterns (${patterns.length})`)
+        for (const p of patterns.slice(0, 10)) {
+          const desc = p.description || p.document || p.content || ''
+          parts.push(`- **${p.pattern_type || 'solution'}**: ${desc.slice(0, 120)}`)
+        }
+        parts.push('')
+      }
+
+      if (corrections.length > 0) {
+        parts.push(`## Corrections (${corrections.length})`)
+        for (const c of corrections.slice(0, 10)) {
+          const orig = c.original || c.document || c.content || ''
+          parts.push(`- ${orig.slice(0, 120)}`)
+        }
+        parts.push('')
+      }
+
+      const total = decisions.length + patterns.length + corrections.length
+
+      if (total === 0) {
+        return {
+          action: 'none',
+          summary: `No memories found for ${projectLabel}`,
+          content: `No decisions, patterns, or corrections stored yet for ${projectLabel}.`,
+          relevantItems: 0
+        }
+      }
+
+      return {
+        action: 'retrieved',
+        summary: `${total} memories for ${projectLabel}`,
+        content: parts.join('\n'),
+        relevantItems: total
+      }
+    } catch (error) {
+      return {
+        action: 'none',
+        summary: 'Error listing memories',
+        content: `Failed to list memories: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        relevantItems: 0
+      }
+    }
+  }
+
+  /**
+   * Update a previous decision — finds the most recent matching memory and replaces it
+   */
+  private async handleUpdateMemory(
+    message: string,
+    project: string | undefined,
+    entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    const effectiveProject = project || this.lastStoredProject || DEFAULT_PROJECT
+
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    const memory = getMemoryService()
+
+    // Strategy: find the most recent similar decision, delete it, store the new one
+    // First try the lastStoredId shortcut
+    if (this.lastStoredId) {
+      const newId = await memory.updateDecision(
+        this.lastStoredId,
+        effectiveProject,
+        `Updated: ${entities.topic || message.slice(0, 200)}`,
+        message,
+        entities.reasoning || 'Updated via brain tool',
+        { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
+      )
+
+      this.lastStoredId = newId
+      this.lastStoredProject = effectiveProject
+
+      return {
+        action: 'stored',
+        summary: `Updated decision`,
+        content: `Previous decision replaced with:\n\n**Project:** ${effectiveProject}\n**New content:** ${message}`,
+        relevantItems: 1
+      }
+    }
+
+    // No recent ID — search for the most similar decision to update
+    try {
+      const results = await memory.searchRaw(entities.topic || message, {
+        project: effectiveProject,
+        limit: 1,
+        minSimilarity: 0.3
+      })
+
+      if (results.length > 0 && results[0].id) {
+        const oldId = results[0].id
+        const newId = await memory.updateDecision(
+          oldId,
+          effectiveProject,
+          `Updated: ${entities.topic || message.slice(0, 200)}`,
+          message,
+          entities.reasoning || 'Updated via brain tool',
+          { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
+        )
+
+        this.lastStoredId = newId
+        this.lastStoredProject = effectiveProject
+
+        const oldContent = results[0].decision?.decision || results[0].content?.slice(0, 100) || ''
+        return {
+          action: 'stored',
+          summary: `Updated decision`,
+          content: `Replaced: "${oldContent.slice(0, 80)}"\n\nWith:\n**New content:** ${message}`,
+          relevantItems: 1
+        }
+      }
+    } catch {
+      // Search failed
+    }
+
+    // Fallback: just store as a new decision
+    const decisionId = await memory.rememberDecision(
+      effectiveProject,
+      entities.topic || message.slice(0, 200),
+      message,
+      entities.reasoning || '',
+      { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
+    )
+
+    this.lastStoredId = decisionId
+    this.lastStoredProject = effectiveProject
+
+    return {
+      action: 'stored',
+      summary: `Stored as new (no matching decision found to update)`,
+      content: `Stored as new decision (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Content:** ${message}`,
       relevantItems: 1
     }
   }
 
+  /**
+   * Delete a memory — finds the most recent matching memory and removes it
+   */
+  private async handleDeleteMemory(
+    message: string,
+    project: string | undefined,
+    entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    const effectiveProject = project || this.lastStoredProject || DEFAULT_PROJECT
+
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    const memory = getMemoryService()
+
+    // First try the lastStoredId shortcut
+    if (this.lastStoredId) {
+      try {
+        await memory.deleteDecision(this.lastStoredId)
+        const deletedId = this.lastStoredId
+        this.lastStoredId = null
+        return {
+          action: 'stored',
+          summary: `Deleted most recent memory`,
+          content: `Deleted memory (ID: ${deletedId})`,
+          relevantItems: 0
+        }
+      } catch {
+        // Deletion failed, try search approach
+      }
+    }
+
+    // Search for the most similar decision to delete
+    try {
+      const results = await memory.searchRaw(entities.topic || message, {
+        project: effectiveProject,
+        limit: 1,
+        minSimilarity: 0.3
+      })
+
+      if (results.length > 0 && results[0].id) {
+        const targetId = results[0].id
+        const content = results[0].decision?.decision || results[0].content?.slice(0, 100) || ''
+
+        await memory.deleteDecision(targetId)
+        this.lastStoredId = null
+
+        return {
+          action: 'stored',
+          summary: `Deleted memory`,
+          content: `Deleted: "${content.slice(0, 100)}" (ID: ${targetId})`,
+          relevantItems: 0
+        }
+      }
+    } catch {
+      // Search failed
+    }
+
+    return {
+      action: 'none',
+      summary: 'No matching memory found to delete',
+      content: 'Could not find a memory matching your request. Try being more specific about what to delete.',
+      relevantItems: 0
+    }
+  }
+
   private async handleQuestion(
     message: string,
     project: string | undefined,
@@ -612,6 +907,24 @@ export class BrainRouter {
 
   // ===== Helpers =====
 
+  private async writeToVault(
+    project: string,
+    decision: string,
+    reasoning: string,
+    context: string,
+    alternatives?: string
+  ): Promise<void> {
+    try {
+      const vault = getVaultService()
+      const projectPaths = vault.getProjectPaths(project)
+      const date = new Date().toISOString().split('T')[0]
+      const entry = `### Decision: ${decision.slice(0, 100)}\n\n**Date:** ${date}\n**Context:** ${context}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}\n${alternatives ? `**Alternatives:** ${alternatives}\n` : ''}\n---\n\n`
+      await vault.writer.appendContent(projectPaths.decisions, entry, '\n')
+    } catch {
+      // Vault write failed — memory storage still succeeded
+    }
+  }
+
   private async addExplorationResults(
     query: string,
     _project: string | undefined,