claude-brain 0.9.3 → 0.10.0

package/VERSION

@@ -1 +1 @@
-0.9.3
+0.10.0

package/package.json

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

package/src/memory/chroma/store.ts

@@ -179,7 +179,12 @@ export class ChromaMemoryStore {
           confidence: 1.0,
           created_at: now,
           updated_at: now,
-          decision_id: id
+          decision_id: id,
+          // Phase 19: Include decision fields so memories collection results
+          // can surface decision content without cross-collection lookup
+          decision: input.decision,
+          reasoning: input.reasoning,
+          context: input.context
         }
 
         await memoriesCollection.add({

package/src/memory/index.ts

@@ -244,27 +244,38 @@ export class MemoryManager {
         minSimilarity: options?.minSimilarity || 0.5
       })
       // Transform ChromaDB results to match MemorySearchResult structure
-      return chromaResults.map(r => ({
-        memory: {
-          id: r.id,
-          project: r.metadata.project || options?.project || 'unknown',
-          content: typeof r.content === 'string' ? r.content : JSON.stringify(r.content),
-          createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
-          metadata: r.metadata
-        },
-        similarity: r.similarity,
-        decision: r.metadata.decision ? {
+      // Includes flat `content` field for direct access (Phase 19)
+      return chromaResults.map(r => {
+        const memoryContent = typeof r.content === 'string' ? r.content : JSON.stringify(r.content)
+        const decisionObj = r.metadata.decision ? {
           id: r.id,
           project: r.metadata.project || options?.project || 'unknown',
           context: r.metadata.context || '',
-          decision: r.metadata.decision || (typeof r.content === 'string' ? r.content : ''),
+          decision: r.metadata.decision || memoryContent,
           reasoning: r.metadata.reasoning || '',
           alternatives: r.metadata.alternatives_considered || '',
           tags: r.metadata.tags || [],
           outcome: r.metadata.outcome,
           createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date()
         } : undefined
-      }))
+
+        return {
+          // Flat fields for direct access (Phase 19)
+          id: r.id,
+          content: decisionObj ? decisionObj.decision : memoryContent,
+          // Nested fields for backward compatibility
+          memory: {
+            id: r.id,
+            project: r.metadata.project || options?.project || 'unknown',
+            content: memoryContent,
+            createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
+            metadata: r.metadata
+          },
+          similarity: r.similarity,
+          decision: decisionObj,
+          metadata: r.metadata
+        }
+      })
     } else {
       return await this.search.search(query, {
         project: options?.project,

package/src/routing/intent-classifier.ts

@@ -1,9 +1,14 @@
 /**
  * Brain Intent Classifier
- * Phase 16: Rule-based intent classification for the unified brain() tool
+ * Phase 16 + Phase 19: Rule-based intent classification for the unified brain() tool
  *
  * Priority-ordered — first confident match wins.
  * No LLM calls, pure pattern matching.
+ *
+ * Phase 19 changes:
+ * - B1: Question confidence raised (? → 0.95, question word → 0.90)
+ * - B2: session_start narrowed (must be at start + no progress indicators)
+ * - B3: Temporal signal detection added to secondary intents
  */
 
 export type Intent =
@@ -102,13 +107,20 @@ const EXPLORATION_PHRASES = [
   'decisions about', 'when did we', 'list episodes'
 ]
 
-// Session start indicators
+// Session start indicators — Phase 19: narrowed to require start-of-message
 const SESSION_START_PHRASES = [
   'starting work', 'beginning work', 'resuming',
   'picking up', 'getting started', 'opening',
   'starting on', 'working on', 'beginning on'
 ]
 
+// Progress indicators that disqualify session_start
+const PROGRESS_INDICATORS = [
+  'finished', 'completed', 'done', 'fixed', 'resolved',
+  'shipped', 'deployed', 'merged', 'released', 'just did',
+  'making progress', 'currently working'
+]
+
 // Question indicators
 const QUESTION_WORDS = [
   'what', 'how', 'when', 'why', 'where', 'which',
@@ -148,6 +160,21 @@ const DELETE_PHRASES = [
   'remove the memory', 'clear that', 'drop that'
 ]
 
+// Phase 19 B3: Temporal signal phrases
+const TEMPORAL_PHRASES = [
+  'last week', 'last month', 'last year', 'yesterday', 'today',
+  'this week', 'this month', 'this year',
+  'since january', 'since february', 'since march', 'since april',
+  'since may', 'since june', 'since july', 'since august',
+  'since september', 'since october', 'since november', 'since december',
+  'in january', 'in february', 'in march', 'in april',
+  'in may', 'in june', 'in july', 'in august',
+  'in september', 'in october', 'in november', 'in december',
+  'ago', 'recently', 'before', 'after', 'during',
+  'last few days', 'past week', 'past month',
+  'earlier this', 'earlier today', 'over the past'
+]
+
 export class IntentClassifier {
   /**
    * Classify the intent of a message
@@ -156,6 +183,9 @@ export class IntentClassifier {
     const lower = message.toLowerCase().trim()
     const secondary: Intent[] = []
 
+    // Phase 19 B3: Detect temporal signals for secondary intent
+    const hasTemporal = this.hasTemporalSignal(lower)
+
     // Check in priority order — first confident match wins
 
     // 1. no_action: very short messages, greetings, acknowledgments
@@ -204,6 +234,7 @@ export class IntentClassifier {
     // 9. comparison: vs, which is better, etc.
     if (this.isComparison(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
+      if (hasTemporal) secondary.push('exploration')
       return { primary: 'comparison', confidence: 0.85, secondary }
     }
 
@@ -212,7 +243,7 @@ export class IntentClassifier {
       return { primary: 'pattern_found', confidence: 0.80, secondary }
     }
 
-    // 11. session_start: starting/resuming work
+    // 11. session_start: starting/resuming work (Phase 19: narrowed check)
     if (this.isSessionStart(lower)) {
       secondary.push('context_needed')
       return { primary: 'session_start', confidence: 0.90, secondary }
@@ -221,17 +252,24 @@ export class IntentClassifier {
     // 12. exploration: timeline, trends, graph, history
     if (this.isExploration(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
+      if (hasTemporal) secondary.push('exploration')
       return { primary: 'exploration', confidence: 0.75, secondary }
     }
 
     // 13. question: starts with question word or ends with ?
+    // Phase 19 B1: Higher confidence for questions
     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 }
+      if (hasTemporal) secondary.push('exploration')
+
+      // Phase 19 B1: ? → 0.95, question word → 0.90
+      const confidence = message.trim().endsWith('?') ? 0.95 : 0.90
+      return { primary: 'question', confidence, secondary }
     }
 
     // 14. Default: context_needed
+    if (hasTemporal) secondary.push('exploration')
     return { primary: 'context_needed', confidence: 0.60, secondary }
   }
 
@@ -247,6 +285,8 @@ export class IntentClassifier {
     if (original?.trim().endsWith('?')) return false
     const firstWord = lower.split(/\s+/)[0] || ''
     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))
   }
 
@@ -255,6 +295,8 @@ export class IntentClassifier {
     if (original?.trim().endsWith('?')) return false
     const firstWord = lower.split(/\s+/)[0] || ''
     if (QUESTION_WORDS.includes(firstWord)) return false
+    // Phase 19 B4: Additional question guards
+    if (this.startsWithQuestionPattern(lower)) return false
 
     const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
     if (!hasDecision) return false
@@ -289,8 +331,23 @@ export class IntentClassifier {
     return hasPattern && lower.length > 50
   }
 
+  /**
+   * Phase 19 B2: Narrowed session_start detection.
+   * Must start at beginning of message AND have no progress indicators.
+   * "working on X" in the middle of a sentence is not a session start.
+   */
   private isSessionStart(lower: string): boolean {
-    return SESSION_START_PHRASES.some(p => lower.includes(p))
+    // Must NOT have progress indicators (e.g. "finished working on X" is progress, not session start)
+    if (PROGRESS_INDICATORS.some(p => lower.includes(p))) return false
+
+    // Phase 19 B2: Session phrases must match near the start of the message
+    for (const phrase of SESSION_START_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1 && idx <= 5) {
+        return true
+      }
+    }
+    return false
   }
 
   private isExploration(lower: string): boolean {
@@ -300,7 +357,10 @@ export class IntentClassifier {
   private isQuestion(lower: string, original: string): boolean {
     if (original.trim().endsWith('?')) return true
     const firstWord = lower.split(/\s+/)[0] || ''
-    return QUESTION_WORDS.includes(firstWord)
+    if (QUESTION_WORDS.includes(firstWord)) return true
+    // Phase 19 B4: "do I", "did we", "have we", "can we" patterns
+    if (this.startsWithQuestionPattern(lower)) return true
+    return false
   }
 
   private isUpdateMemory(lower: string): boolean {
@@ -327,4 +387,32 @@ export class IntentClassifier {
   private hasSessionSignal(lower: string): boolean {
     return SESSION_START_PHRASES.some(p => lower.includes(p))
   }
+
+  /**
+   * Phase 19 B3: Detect temporal signals in the message.
+   * Used to add 'temporal' context to secondary intents.
+   */
+  hasTemporalSignal(lower: string): boolean {
+    return TEMPORAL_PHRASES.some(p => lower.includes(p))
+  }
+
+  /**
+   * Phase 19 B4: Extended question guards.
+   * Catches "do I", "did we", "have we", "can we" etc. patterns
+   * that start with auxiliary verbs not in the QUESTION_WORDS list.
+   */
+  private startsWithQuestionPattern(lower: string): boolean {
+    const questionStarters = [
+      'do i ', 'do we ', 'do you ',
+      'did i ', 'did we ', 'did you ',
+      'have i ', 'have we ', 'have you ',
+      'has it ', 'has the ',
+      'can i ', 'can we ', 'can you ',
+      'will i ', 'will we ', 'will you ',
+      'am i ', 'was i ', 'were we ',
+      'shall we ', 'shall i ',
+      'tell me '
+    ]
+    return questionStarters.some(p => lower.startsWith(p))
+  }
 }

package/src/routing/response-filter.ts

@@ -1,7 +1,10 @@
 /**
  * Brain Response Filter
- * Phase 16: Filters noise, deduplicates, ranks, and synthesizes results
- * from the unified brain() tool
+ * Phase 16 + Phase 19: Filters noise, deduplicates, ranks, and synthesizes results
+ *
+ * Phase 19 changes:
+ * - D2: Lower word overlap threshold 0.85 → 0.75, add ID-based and prefix-based dedup
+ * - D3: Split INFRA_NOISE into strong (1 hit = filter) and weak (2+ hits = filter)
  */
 
 export interface FilterableResult {
@@ -32,13 +35,19 @@ export interface TierResults {
 }
 
 export class ResponseFilter {
-  // Infrastructure noise terms — strip from non-claude-brain projects
-  private readonly INFRA_NOISE = [
+  // D3: Strong noise — 1 hit is enough to filter (very specific internal terms)
+  private readonly STRONG_NOISE = [
+    'mcp-server', 'model-context-protocol', 'embedding-service', 'vector-database',
+    'mcp tool', 'tool handler', 'precompute engine', 'knowledge graph builder',
+    'semantic cache', 'bun:test'
+  ]
+
+  // D3: Weak noise — need 2+ hits to filter (terms that could appear in legitimate decisions)
+  private readonly WEAK_NOISE = [
     'chromadb', 'chroma', 'minisearch', 'compromise', 'better-sqlite3',
-    'pino', 'hono', 'bun:test', 'zod', 'mcp-server', 'claude-brain',
-    'model-context-protocol', 'embedding-service', 'vector-database',
-    'mcp tool', 'tool handler', 'phase 12', 'phase 13', 'phase 14', 'phase 15',
-    'semantic cache', 'precompute engine', 'knowledge graph builder'
+    'pino', 'hono', 'zod', 'claude-brain',
+    'phase 12', 'phase 13', 'phase 14', 'phase 15', 'phase 16',
+    'phase 17', 'phase 18', 'phase 19'
   ]
 
   /**
@@ -52,7 +61,7 @@ export class ResponseFilter {
       filtered = filtered.filter(r => !this.isInfrastructureNoise(r.content))
     }
 
-    // 2. Remove near-duplicates (>85% word overlap, keep higher score)
+    // 2. Remove near-duplicates (Phase 19 D2: improved dedup)
     filtered = this.deduplicateResults(filtered)
 
     // 3. Apply dynamic threshold (at least 70% of median similarity)
@@ -134,32 +143,56 @@ export class ResponseFilter {
   }
 
   /**
-   * Check if content is infrastructure/internal noise
+   * D3: Check if content is infrastructure/internal noise
+   * Strong noise: 1 hit filters
+   * Weak noise: 2+ hits filters
    */
   private isInfrastructureNoise(content: string): boolean {
     const lower = content.toLowerCase()
-    let noiseHits = 0
 
-    for (const term of this.INFRA_NOISE) {
+    // Strong noise: a single hit is enough
+    for (const term of this.STRONG_NOISE) {
       if (lower.includes(term)) {
-        noiseHits++
+        return true
       }
     }
 
-    // If more than 2 infrastructure terms appear, it's likely noise
-    return noiseHits >= 2
+    // Weak noise: need 2+ hits
+    let weakHits = 0
+    for (const term of this.WEAK_NOISE) {
+      if (lower.includes(term)) {
+        weakHits++
+      }
+    }
+    return weakHits >= 2
   }
 
   /**
-   * Remove near-duplicate results (>85% word overlap)
+   * D2: Improved deduplication
+   * - ID-based dedup (if metadata has an ID)
+   * - Prefix-based dedup (first 100 chars match)
+   * - Word overlap dedup (lowered from 0.85 to 0.75)
    */
   private deduplicateResults(results: FilterableResult[]): FilterableResult[] {
     const kept: FilterableResult[] = []
+    const seenIds = new Set<string>()
+    const seenPrefixes = new Set<string>()
 
     for (const result of results) {
+      // ID-based dedup
+      const id = (result.metadata as any)?.id || (result.metadata as any)?.decision_id
+      if (id && seenIds.has(id)) continue
+      if (id) seenIds.add(id)
+
+      // Prefix-based dedup (first 100 chars, normalized)
+      const prefix = result.content.slice(0, 100).toLowerCase().replace(/\s+/g, ' ').trim()
+      if (prefix.length > 20 && seenPrefixes.has(prefix)) continue
+      if (prefix.length > 20) seenPrefixes.add(prefix)
+
+      // Word overlap dedup (D2: lowered to 0.75)
       const isDuplicate = kept.some(existing => {
         const overlap = this.calculateWordOverlap(existing.content, result.content)
-        return overlap > 0.85
+        return overlap > 0.75
       })
 
       if (!isDuplicate) {