claude-brain 0.17.11 → 0.17.12

package/VERSION

@@ -1 +1 @@
-0.17.11
+0.17.12

package/package.json

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

package/src/routing/intent-classifier.ts

@@ -41,7 +41,9 @@ const DECISION_PHRASES = [
   'the solution is', 'implement using', 'going with',
   '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'
+  'settled on', 'committing to', 'opting for', 'sticking with',
+  // BUG-006: "Chose X because Y" — bare "chose" at start
+  'chose ',
 ]
 
 // Explicit "store this" phrases — the user wants to persist something
@@ -81,7 +83,9 @@ const MISTAKE_PHRASES = [
   'the fix is', 'the fix was', 'fixed by', 'solved by',
   'was wrong', 'was broken', 'was incorrect',
   'gotcha:', 'pitfall:', 'watch out for', 'be careful with',
-  'turns out that'
+  'turns out that',
+  // BUG-006: "Mistake:" prefix (colon form, e.g. "Mistake: I was using...")
+  'mistake:',
 ]
 
 // Progress indicators
@@ -177,7 +181,9 @@ const DELETE_PHRASES = [
   'forget that', 'forget about', 'delete that', 'delete the memory', 'delete the decision',
   'remove that memory', 'remove that decision', 'that was wrong',
   'discard that', 'erase that', 'undo that decision',
-  'remove the memory', 'clear that', 'drop that'
+  'remove the memory', 'clear that', 'drop that',
+  // BUG-006: Bulk delete support
+  'delete all',
 ]
 
 // Phase 19 B3: Temporal signal phrases
@@ -307,7 +313,10 @@ export class IntentClassifier {
     if (QUESTION_WORDS.includes(firstWord)) return false
     // Phase 19 B4: Additional question guards
     if (this.startsWithQuestionPattern(lower)) return false
-    return STORE_PHRASES.some(p => lower.includes(p))
+    if (STORE_PHRASES.some(p => lower.includes(p))) return true
+    // BUG-006: "Using X for Y" at start of message is a declarative preference
+    if (lower.startsWith('using ') && lower.includes(' for ')) return true
+    return false
   }
 
   private isDecisionMade(lower: string, original?: string): boolean {

package/src/routing/router.ts

@@ -44,6 +44,8 @@ interface RecentDecision {
   content: string
   project: string
   storedAt: number
+  /** Keyword overlap ratio with query (0-1), computed by findRecentDecisions */
+  overlapScore?: number
 }
 
 /** How long recent decisions stay eligible for fast-path recall (ms) */
@@ -962,14 +964,17 @@ export class BrainRouter {
       })
     }
 
-    // C11: Add graph results as "Related Concepts" (Bug 3: filter low-score, cap to 0.4)
+    // C11: Add graph results as "Related Concepts"
+    // When a project filter is active, cap graph results lower (0.25) so they don't
+    // outrank project-scoped ChromaDB results. Without a project filter, cap at 0.4.
+    const graphScoreCap = searchProject ? 0.25 : 0.4
     const relevantGraphResults = graphResults.filter(g => g.score >= 0.6)
     if (relevantGraphResults.length > 0) {
       tiers.push({
         label: 'Related Concepts',
         results: relevantGraphResults.map(g => ({
           content: g.content,
-          score: Math.min(g.score, 0.4),
+          score: Math.min(g.score, graphScoreCap),
           source: 'Knowledge Graph',
           metadata: g.metadata as Record<string, unknown>
         }))
@@ -1022,14 +1027,16 @@ export class BrainRouter {
       }
     }
 
-    // Bug 4: Inject recently stored decisions as high-score tier
+    // Bug 4: Inject recently stored decisions using keyword overlap as score
     const recentMatches = this.findRecentDecisions(query, searchProject)
-    if (recentMatches.length > 0) {
+    // Only include results whose overlap score meets the hard floor (0.35)
+    const qualifiedRecent = recentMatches.filter(d => (d.overlapScore || 0) >= 0.35)
+    if (qualifiedRecent.length > 0) {
       tiers.unshift({
         label: 'Recent Decisions',
-        results: recentMatches.map(d => ({
+        results: qualifiedRecent.map(d => ({
           content: d.content,
-          score: 0.95,
+          score: d.overlapScore || 0,
           source: 'Recent Decision',
           metadata: { storedAt: d.storedAt, project: d.project }
         }))
@@ -1124,14 +1131,15 @@ export class BrainRouter {
       }
     }
 
-    // Always include graph exploration
+    // Always include graph exploration — cap scores when project filter is active
+    const explorationGraphCap = searchProject ? 0.25 : 0.5
     const graphResults = await this.searchEngine.searchGraph(query, 10)
     if (graphResults.length > 0) {
       tiers.push({
         label: 'Knowledge Graph',
         results: graphResults.map(g => ({
           content: g.content,
-          score: g.score,
+          score: Math.min(g.score, explorationGraphCap),
           source: 'Knowledge Graph',
           metadata: g.metadata as Record<string, unknown>
         }))
@@ -1392,7 +1400,8 @@ export class BrainRouter {
   }
 
   /**
-   * Bug 4: Find recent decisions matching a query by keyword overlap
+   * Bug 4: Find recent decisions matching a query by keyword overlap.
+   * Returns matches with their overlapScore (ratio of query keywords found in content).
    */
   private findRecentDecisions(query: string, project?: string): RecentDecision[] {
     const now = Date.now()
@@ -1406,13 +1415,18 @@ export class BrainRouter {
     )
     if (queryWords.size === 0) return []
 
-    return this.recentDecisions.filter(d => {
+    const matches: RecentDecision[] = []
+    for (const d of this.recentDecisions) {
       // Project filter: skip if searching a specific project and it doesn't match
-      if (project && d.project !== project) return false
-      const contentWords = d.content.toLowerCase().split(/\s+/).filter(w => w.length > 2)
-      const overlap = contentWords.filter(w => queryWords.has(w)).length
-      return overlap >= 1
-    })
+      if (project && d.project !== project) continue
+      const contentWords = new Set(d.content.toLowerCase().split(/\s+/).filter(w => w.length > 2))
+      const overlap = [...queryWords].filter(w => contentWords.has(w)).length
+      if (overlap >= 1) {
+        const overlapScore = overlap / queryWords.size
+        matches.push({ ...d, overlapScore })
+      }
+    }
+    return matches
   }
 
   private generateTaskId(title: string): string {