claude-brain 0.9.1 → 0.9.2

package/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "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.1',
+  serverVersion: '0.9.2',
   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.9.1'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.9.2'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/memory/chroma/store.ts

@@ -489,8 +489,19 @@ export class ChromaMemoryStore {
 
   async deleteDecision(id: string): Promise<void> {
     try {
+      // Delete from decisions collection
       const collection = await this.collections.getDecisions()
       await collection.delete({ ids: [id] })
+
+      // ALSO delete from memories collection (dual storage uses same ID)
+      try {
+        const memoriesCollection = await this.collections.getMemories()
+        await memoriesCollection.delete({ ids: [id] })
+        this.logger.debug({ id }, 'Decision also deleted from memories collection')
+      } catch {
+        // Memories collection entry may not exist, that's ok
+      }
+
       this.logger.info({ id }, 'Decision deleted')
 
     } catch (error) {

package/src/routing/intent-classifier.ts

@@ -173,14 +173,14 @@ export class IntentClassifier {
       return { primary: 'update_memory', confidence: 0.85, secondary }
     }
 
-    // 4. store_this: explicit "remember:", "save this:", "I prefer"
-    if (this.isStoreThis(lower)) {
+    // 4. store_this: explicit "remember:", "save this:", "I prefer" (never for questions)
+    if (this.isStoreThis(lower, message)) {
       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)) {
+    // 5. decision_made: decision phrases + reasoning (never for questions)
+    if (this.isDecisionMade(lower, message)) {
       if (this.hasComparisonSignal(lower)) secondary.push('comparison')
       return { primary: 'decision_made', confidence: 0.85, secondary }
     }
@@ -242,11 +242,20 @@ export class IntentClassifier {
     return NO_ACTION_PHRASES.some(p => lower === p || lower === p + '.' || lower === p + '!')
   }
 
-  private isStoreThis(lower: string): boolean {
+  private isStoreThis(lower: string, original?: string): boolean {
+    // Questions are never storage requests — "Do I prefer X?" is a query, not "I prefer X"
+    if (original?.trim().endsWith('?')) return false
+    const firstWord = lower.split(/\s+/)[0] || ''
+    if (QUESTION_WORDS.includes(firstWord)) return false
     return STORE_PHRASES.some(p => lower.includes(p))
   }
 
-  private isDecisionMade(lower: string): boolean {
+  private isDecisionMade(lower: string, original?: string): boolean {
+    // Questions are never decisions — "Did I decide to use X?" is a query
+    if (original?.trim().endsWith('?')) return false
+    const firstWord = lower.split(/\s+/)[0] || ''
+    if (QUESTION_WORDS.includes(firstWord)) return false
+
     const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
     if (!hasDecision) return false
     // Higher confidence if reasoning is also present

package/src/routing/router.ts

@@ -565,7 +565,8 @@ export class BrainRouter {
   }
 
   /**
-   * Update a previous decision — finds the most recent matching memory and replaces it
+   * Update a previous decision — searches by content to find the right one, then replaces it.
+   * Uses lastStoredId only for generic "actually, X" with no descriptive subject.
    */
   private async handleUpdateMemory(
     message: string,
@@ -579,14 +580,51 @@ export class BrainRouter {
     }
 
     const memory = getMemoryService()
+    const topic = entities.topic || message
+    const hasSpecificContent = this.hasDescriptiveContent(message)
 
-    // Strategy: find the most recent similar decision, delete it, store the new one
-    // First try the lastStoredId shortcut
+    // If the message has specific content, search for the matching decision first
+    if (hasSpecificContent) {
+      try {
+        const results = await memory.searchRaw(topic, {
+          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: ${topic.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, fall through
+      }
+    }
+
+    // Generic update ("actually, use X instead") — use lastStoredId
     if (this.lastStoredId) {
       const newId = await memory.updateDecision(
         this.lastStoredId,
         effectiveProject,
-        `Updated: ${entities.topic || message.slice(0, 200)}`,
+        `Updated: ${topic.slice(0, 200)}`,
         message,
         entities.reasoning || 'Updated via brain tool',
         { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
@@ -603,44 +641,10 @@ export class BrainRouter {
       }
     }
 
-    // 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),
+      topic.slice(0, 200),
       message,
       entities.reasoning || '',
       { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
@@ -658,7 +662,8 @@ export class BrainRouter {
   }
 
   /**
-   * Delete a memory — finds the most recent matching memory and removes it
+   * Delete a memory — searches by content to find the right one.
+   * Only uses lastStoredId for very generic requests like "forget that" with no descriptive words.
    */
   private async handleDeleteMemory(
     message: string,
@@ -672,8 +677,41 @@ export class BrainRouter {
     }
 
     const memory = getMemoryService()
+    const topic = entities.topic || message
+
+    // Check if the message has meaningful content to search by
+    // (strip common delete phrases to see if there's a real subject)
+    const hasSpecificContent = this.hasDescriptiveContent(message)
+
+    // If the user described what to delete, ALWAYS search by content first
+    if (hasSpecificContent) {
+      try {
+        const results = await memory.searchRaw(topic, {
+          project: effectiveProject,
+          limit: 3,
+          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) || ''
 
-    // First try the lastStoredId shortcut
+          await memory.deleteDecision(targetId)
+          if (this.lastStoredId === targetId) this.lastStoredId = null
+
+          return {
+            action: 'stored',
+            summary: `Deleted memory`,
+            content: `Deleted: "${content.slice(0, 100)}" (ID: ${targetId})`,
+            relevantItems: 0
+          }
+        }
+      } catch {
+        // Search failed, fall through
+      }
+    }
+
+    // Generic request ("forget that", "delete that") — use lastStoredId
     if (this.lastStoredId) {
       try {
         await memory.deleteDecision(this.lastStoredId)
@@ -686,36 +724,10 @@ export class BrainRouter {
           relevantItems: 0
         }
       } catch {
-        // Deletion failed, try search approach
+        // Deletion failed
       }
     }
 
-    // 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',
@@ -959,6 +971,22 @@ export class BrainRouter {
     }
   }
 
+  /**
+   * Check if a delete/update message has descriptive content beyond just the command words.
+   * "forget that" → false (generic), "forget the migrations note" → true (specific)
+   */
+  private hasDescriptiveContent(message: string): boolean {
+    const COMMAND_WORDS = [
+      'forget', 'delete', 'remove', 'discard', 'erase', 'undo', 'clear', 'drop',
+      'actually', 'correction', 'update', 'change', 'replace', 'modify', 'revise',
+      'amend', 'override', 'scratch', 'no', 'wait', 'instead',
+      'that', 'this', 'the', 'it', 'about', 'memory', 'decision', 'to', 'a', 'an'
+    ]
+    const words = message.toLowerCase().split(/[\s,;:.!?]+/).filter(w => w.length > 1)
+    const meaningfulWords = words.filter(w => !COMMAND_WORDS.includes(w))
+    return meaningfulWords.length >= 2
+  }
+
   private generateTaskId(title: string): string {
     return title
       .toLowerCase()