claude-brain 0.3.6 → 0.4.0

package/README.md

@@ -28,7 +28,7 @@ A locally-running development assistant that bridges Obsidian knowledge vaults w
 # Install globally (requires Bun)
 bun install -g claude-brain
 
-# Interactive setup (vault path, log level, installs ~/CLAUDE.md)
+# Interactive setup (vault path, log level, installs ~/.claude/CLAUDE.md)
 claude-brain setup
 
 # Register with Claude Code

package/VERSION

@@ -1 +1 @@
-0.3.6
+0.4.0

package/package.json

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

package/src/cli/commands/update.ts

@@ -69,17 +69,19 @@ export async function runUpdate() {
   }
   console.log()
 
-  // Step 2: Update CLAUDE.md
+  // Step 2: Update CLAUDE.md to ~/.claude/CLAUDE.md (where Claude Code reads it)
   const sourcePath = path.join(PACKAGE_ROOT, 'assets', 'CLAUDE.md')
-  const destPath = path.join(os.homedir(), 'CLAUDE.md')
+  const claudeDir = path.join(os.homedir(), '.claude')
+  const destPath = path.join(claudeDir, 'CLAUDE.md')
 
   if (!existsSync(sourcePath)) {
     console.log(warningText('  CLAUDE.md asset not found in package, skipping'))
   } else if (!existsSync(destPath)) {
     await withSpinner('Installing CLAUDE.md', async () => {
+      await fs.mkdir(claudeDir, { recursive: true })
       await fs.copyFile(sourcePath, destPath)
     })
-    console.log(successText('  CLAUDE.md installed to ~/CLAUDE.md'))
+    console.log(successText('  CLAUDE.md installed to ~/.claude/CLAUDE.md'))
   } else {
     const sourceContent = readFileSync(sourcePath, 'utf-8')
     const destContent = readFileSync(destPath, 'utf-8')
@@ -90,7 +92,21 @@ export async function runUpdate() {
       await withSpinner('Updating CLAUDE.md', async () => {
         await fs.copyFile(sourcePath, destPath)
       })
-      console.log(successText('  CLAUDE.md updated to latest version'))
+      console.log(successText('  CLAUDE.md updated to ~/.claude/CLAUDE.md'))
+    }
+  }
+
+  // Clean up old ~/CLAUDE.md if it exists (from previous versions)
+  const oldDestPath = path.join(os.homedir(), 'CLAUDE.md')
+  if (existsSync(oldDestPath)) {
+    try {
+      const oldContent = readFileSync(oldDestPath, 'utf-8')
+      if (oldContent.includes('Claude Brain')) {
+        await fs.unlink(oldDestPath)
+        console.log(dimText('  Removed old ~/CLAUDE.md (migrated to ~/.claude/)'))
+      }
+    } catch {
+      // ignore cleanup errors
     }
   }
 

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.3.6',
+  serverVersion: '0.4.0',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -196,7 +196,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.3.6'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.4.0'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/context/standards-manager.ts

@@ -248,6 +248,26 @@ export class StandardsManager {
             'Ignoring error handling',
             'Deep nesting'
           ]
+        },
+        {
+          language: 'JavaScript',
+          version: 'ES2022+',
+          style: 'standard',
+          linting: {},
+          conventions: [
+            'Use strict mode',
+            'Prefer const over let',
+            'Use async/await over promises',
+            'Use optional chaining and nullish coalescing',
+            'Add JSDoc comments for public APIs'
+          ],
+          antiPatterns: [
+            'Using var',
+            'Callback hell',
+            'Ignoring error handling',
+            'Deep nesting',
+            'Mutating function arguments'
+          ]
         }
       ],
       frameworks: [],

package/src/memory/chroma/client.ts

@@ -82,8 +82,9 @@ export class ChromaClientManager {
         this.isConnected = true
         this.logger.info('ChromaDB client initialized successfully')
       } catch (heartbeatError) {
-        this.logger.warn({ error: heartbeatError }, 'ChromaDB heartbeat failed, connection may not be fully established')
-        this.isConnected = true
+        this.isConnected = false
+        this.logger.warn({ error: heartbeatError }, 'ChromaDB heartbeat failed')
+        throw new Error(`ChromaDB server unreachable: ${heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError)}`)
       }
 
     } catch (error) {

package/src/memory/chroma/config.ts

@@ -35,7 +35,14 @@ export function getChromaConfigFromEnv(): Partial<ChromaConfig> {
 
   if (process.env.CHROMA_HOST) {
     config.host = process.env.CHROMA_HOST
-    config.mode = 'cloud'
+    // Only default to cloud if CHROMA_MODE isn't explicitly set
+    if (!process.env.CHROMA_MODE) {
+      config.mode = 'cloud'
+    }
+  }
+
+  if (process.env.CHROMA_MODE) {
+    config.mode = process.env.CHROMA_MODE as any
   }
 
   if (process.env.CHROMA_EMBEDDING_PROVIDER) {

package/src/memory/index.ts

@@ -55,6 +55,7 @@ export class MemoryManager {
   private logger: Logger
   private initialized: boolean = false
   private useChromaDB: boolean = true
+  private onDecisionStoredCallbacks: ((input: any) => void)[] = []
 
   constructor(
     dbPath: string,
@@ -176,6 +177,24 @@ export class MemoryManager {
     return this.database.healthCheck()
   }
 
+  /**
+   * Check if ChromaDB backend is enabled and connected
+   */
+  isChromaDBEnabled(): boolean {
+    return this.useChromaDB
+  }
+
+  /**
+   * Add a listener that fires when a decision is stored (from any backend)
+   */
+  addDecisionStoredListener(callback: (input: any) => void): void {
+    this.onDecisionStoredCallbacks.push(callback)
+    // Also wire to ChromaDB listener if available
+    if (this.useChromaDB) {
+      this.chroma.store.addDecisionStoredListener(callback)
+    }
+  }
+
   async rememberDecision(
     project: string,
     context: string,
@@ -193,7 +212,7 @@ export class MemoryManager {
         tags: options?.tags
       })
     }
-    return this.store.storeDecision({
+    const id = await this.store.storeDecision({
       project,
       context,
       decision,
@@ -201,6 +220,13 @@ export class MemoryManager {
       alternatives: options?.alternatives,
       tags: options?.tags
     })
+    // Notify listeners (e.g., knowledge graph builder) for SQLite path
+    for (const cb of this.onDecisionStoredCallbacks) {
+      try {
+        cb({ project, context, decision, reasoning, alternatives: options?.alternatives, tags: options?.tags, id })
+      } catch {}
+    }
+    return id
   }
 
   /**
@@ -281,7 +307,7 @@ export class MemoryManager {
   }
 
   /**
-   * Store a pattern in memory
+   * Store a pattern in memory — routes to ChromaDB or SQLite
    */
   async storePattern(input: {
     project: string
@@ -291,14 +317,14 @@ export class MemoryManager {
     confidence: number
     context?: string
   }): Promise<string> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern storage requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.storePattern(input)
     }
-    return this.chroma.store.storePattern(input)
+    return this.store.storePattern(input)
   }
 
   /**
-   * Store a correction/lesson learned in memory
+   * Store a correction/lesson learned — routes to ChromaDB or SQLite
    */
   async storeCorrection(input: {
     project: string
@@ -308,14 +334,14 @@ export class MemoryManager {
     context?: string
     confidence: number
   }): Promise<string> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction storage requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.storeCorrection(input)
     }
-    return this.chroma.store.storeCorrection(input)
+    return this.store.storeCorrection(input)
   }
 
   /**
-   * Get patterns for a project
+   * Get patterns for a project — routes to ChromaDB or SQLite
    */
   async getPatterns(
     project?: string,
@@ -324,35 +350,39 @@ export class MemoryManager {
       limit?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern retrieval requires ChromaDB backend')
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getPatternsByProject(project, options)
+      }
+      return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
     }
     if (project) {
-      return this.chroma.store.getPatternsByProject(project, options)
+      return this.store.getPatternsByProject(project, options)
     }
-    // If no project specified, search all patterns
-    return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
+    return this.store.searchPatterns('', { limit: options?.limit || 10 })
   }
 
   /**
-   * Get corrections for a project
+   * Get corrections for a project — routes to ChromaDB or SQLite
    */
   async getCorrections(
     project?: string,
     options?: { limit?: number }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction retrieval requires ChromaDB backend')
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
+      }
+      return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
     }
     if (project) {
-      return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
+      return this.store.getCorrectionsByProject(project, options?.limit || 10)
     }
-    // If no project specified, search all corrections
-    return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
+    return this.store.searchCorrections('', { limit: options?.limit || 10 })
   }
 
   /**
-   * Search patterns by query
+   * Search patterns by query — routes to ChromaDB or SQLite
    */
   async searchPatterns(
     query: string,
@@ -363,14 +393,14 @@ export class MemoryManager {
       minSimilarity?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern search requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.searchPatterns(query, options)
     }
-    return this.chroma.store.searchPatterns(query, options)
+    return this.store.searchPatterns(query, options)
   }
 
   /**
-   * Search corrections by query
+   * Search corrections by query — routes to ChromaDB or SQLite
    */
   async searchCorrections(
     query: string,
@@ -380,10 +410,10 @@ export class MemoryManager {
       minSimilarity?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction search requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.searchCorrections(query, options)
     }
-    return this.chroma.store.searchCorrections(query, options)
+    return this.store.searchCorrections(query, options)
   }
 }
 

package/src/memory/schema.ts

@@ -41,12 +41,44 @@ CREATE TABLE IF NOT EXISTS decisions (
 -- Index for decision lookups
 CREATE INDEX IF NOT EXISTS idx_decisions_memory
   ON decisions(memory_id);
+
+-- Patterns table (Phase 12)
+-- Stores reusable patterns with SQLite fallback
+CREATE TABLE IF NOT EXISTS patterns (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  project TEXT NOT NULL,
+  pattern_type TEXT NOT NULL CHECK(pattern_type IN ('solution','anti-pattern','best-practice','common-issue')),
+  description TEXT NOT NULL,
+  example TEXT,
+  confidence REAL DEFAULT 0.8,
+  context TEXT,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_patterns_project ON patterns(project);
+
+-- Corrections table (Phase 12)
+-- Stores lessons learned with SQLite fallback
+CREATE TABLE IF NOT EXISTS corrections (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  project TEXT NOT NULL,
+  original TEXT NOT NULL,
+  correction TEXT NOT NULL,
+  reasoning TEXT NOT NULL,
+  context TEXT,
+  confidence REAL DEFAULT 0.9,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_corrections_project ON corrections(project);
 `
 
 /**
  * Schema version for migrations
  */
-export const SCHEMA_VERSION = 1
+export const SCHEMA_VERSION = 2
 
 /**
  * Check if schema needs migration

package/src/memory/store.ts

@@ -17,7 +17,7 @@ import type {
   DecisionRow
 } from './types'
 import { EmbeddingService } from './embeddings'
-import { embeddingToBuffer, bufferToEmbedding } from './embedding-utils'
+import { embeddingToBuffer, bufferToEmbedding, cosineSimilarity } from './embedding-utils'
 
 export class MemoryStore {
   private db: Database
@@ -326,6 +326,316 @@ export class MemoryStore {
     }
   }
 
+  /**
+   * Store a pattern (creates memory + pattern record)
+   */
+  async storePattern(input: {
+    project: string
+    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    description: string
+    example?: string
+    confidence: number
+    context?: string
+  }): Promise<string> {
+    try {
+      const content = `Pattern (${input.pattern_type}): ${input.description}${input.context ? `\nContext: ${input.context}` : ''}${input.example ? `\nExample: ${input.example}` : ''}`
+
+      const memoryId = await this.storeMemory({
+        project: input.project,
+        content,
+        metadata: {
+          type: 'pattern',
+          pattern_type: input.pattern_type,
+          confidence: input.confidence
+        }
+      })
+
+      const patternId = randomUUID()
+      const now = new Date().toISOString()
+      const stmt = this.db.prepare(`
+        INSERT INTO patterns (id, memory_id, project, pattern_type, description, example, confidence, context, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        patternId,
+        memoryId,
+        input.project,
+        input.pattern_type,
+        input.description,
+        input.example || null,
+        input.confidence,
+        input.context || null,
+        now
+      )
+
+      this.logger.info({ patternId, memoryId, project: input.project }, 'Pattern stored')
+      return patternId
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store pattern')
+      throw error
+    }
+  }
+
+  /**
+   * Store a correction (creates memory + correction record)
+   */
+  async storeCorrection(input: {
+    project: string
+    original: string
+    correction: string
+    reasoning: string
+    context?: string
+    confidence: number
+  }): Promise<string> {
+    try {
+      const content = `Correction: ${input.correction}\nOriginal: ${input.original}\nReasoning: ${input.reasoning}${input.context ? `\nContext: ${input.context}` : ''}`
+
+      const memoryId = await this.storeMemory({
+        project: input.project,
+        content,
+        metadata: {
+          type: 'correction',
+          confidence: input.confidence
+        }
+      })
+
+      const correctionId = randomUUID()
+      const now = new Date().toISOString()
+      const stmt = this.db.prepare(`
+        INSERT INTO corrections (id, memory_id, project, original, correction, reasoning, context, confidence, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        correctionId,
+        memoryId,
+        input.project,
+        input.original,
+        input.correction,
+        input.reasoning,
+        input.context || null,
+        input.confidence,
+        now
+      )
+
+      this.logger.info({ correctionId, memoryId, project: input.project }, 'Correction stored')
+      return correctionId
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store correction')
+      throw error
+    }
+  }
+
+  /**
+   * Get patterns by project with optional type filter
+   */
+  getPatternsByProject(project: string, options?: {
+    pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    limit?: number
+  }): any[] {
+    try {
+      let sql = 'SELECT * FROM patterns WHERE project = ?'
+      const params: any[] = [project]
+
+      if (options?.pattern_type) {
+        sql += ' AND pattern_type = ?'
+        params.push(options.pattern_type)
+      }
+
+      sql += ' ORDER BY created_at DESC'
+
+      if (options?.limit) {
+        sql += ' LIMIT ?'
+        params.push(options.limit)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      return rows.map(row => ({
+        id: row.id,
+        description: row.description,
+        metadata: {
+          project: row.project,
+          pattern_type: row.pattern_type,
+          example: row.example || '',
+          confidence: row.confidence,
+          context: row.context || '',
+          created_at: row.created_at
+        }
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get patterns by project')
+      return []
+    }
+  }
+
+  /**
+   * Get corrections by project
+   */
+  getCorrectionsByProject(project: string, limit: number = 10): any[] {
+    try {
+      const stmt = this.db.prepare(
+        'SELECT * FROM corrections WHERE project = ? ORDER BY created_at DESC LIMIT ?'
+      )
+      const rows = stmt.all(project, limit) as any[]
+
+      return rows.map(row => ({
+        id: row.id,
+        correction: row.correction,
+        metadata: {
+          project: row.project,
+          original: row.original,
+          correction: row.correction,
+          reasoning: row.reasoning,
+          context: row.context || '',
+          confidence: row.confidence,
+          created_at: row.created_at
+        }
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get corrections by project')
+      return []
+    }
+  }
+
+  /**
+   * Search patterns using semantic search on underlying memories
+   */
+  async searchPatterns(
+    query: string,
+    options?: {
+      project?: string
+      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<any[]> {
+    try {
+      // If no query, return all patterns for the project
+      if (!query && options?.project) {
+        return this.getPatternsByProject(options.project, {
+          pattern_type: options?.pattern_type,
+          limit: options?.limit
+        })
+      }
+
+      // Generate embedding for semantic search
+      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'pattern')
+
+      let sql = `
+        SELECT p.*, m.embedding, m.content as memory_content
+        FROM patterns p
+        JOIN memories m ON p.memory_id = m.id
+        WHERE 1=1
+      `
+      const params: any[] = []
+
+      if (options?.project) {
+        sql += ' AND p.project = ?'
+        params.push(options.project)
+      }
+      if (options?.pattern_type) {
+        sql += ' AND p.pattern_type = ?'
+        params.push(options.pattern_type)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      const results = rows.map(row => {
+        const embedding = bufferToEmbedding(row.embedding)
+        const similarity = cosineSimilarity(queryEmbedding, embedding)
+        return {
+          id: row.id,
+          content: row.description,
+          metadata: {
+            project: row.project,
+            pattern_type: row.pattern_type,
+            example: row.example || '',
+            confidence: row.confidence,
+            context: row.context || '',
+            created_at: row.created_at
+          },
+          similarity
+        }
+      })
+      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, options?.limit || 10)
+
+      return results
+    } catch (error) {
+      this.logger.error({ error, query }, 'Pattern search failed')
+      return []
+    }
+  }
+
+  /**
+   * Search corrections using semantic search on underlying memories
+   */
+  async searchCorrections(
+    query: string,
+    options?: {
+      project?: string
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<any[]> {
+    try {
+      // If no query, return all corrections for the project
+      if (!query && options?.project) {
+        return this.getCorrectionsByProject(options.project, options?.limit || 10)
+      }
+
+      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'correction')
+
+      let sql = `
+        SELECT c.*, m.embedding, m.content as memory_content
+        FROM corrections c
+        JOIN memories m ON c.memory_id = m.id
+        WHERE 1=1
+      `
+      const params: any[] = []
+
+      if (options?.project) {
+        sql += ' AND c.project = ?'
+        params.push(options.project)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      const results = rows.map(row => {
+        const embedding = bufferToEmbedding(row.embedding)
+        const similarity = cosineSimilarity(queryEmbedding, embedding)
+        return {
+          id: row.id,
+          content: row.correction,
+          metadata: {
+            project: row.project,
+            original: row.original,
+            correction: row.correction,
+            reasoning: row.reasoning,
+            context: row.context || '',
+            confidence: row.confidence,
+            created_at: row.created_at
+          },
+          similarity
+        }
+      })
+      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, options?.limit || 10)
+
+      return results
+    } catch (error) {
+      this.logger.error({ error, query }, 'Correction search failed')
+      return []
+    }
+  }
+
   /**
    * Convert database row to Decision object
    */

package/src/server/handlers/tools/analyze-decision-evolution.ts

@@ -35,7 +35,10 @@ export async function handleAnalyzeDecisionEvolution(
     })
 
     if (analysis.totalDecisions === 0) {
-      return ResponseFormatter.text(`No decisions found for topic: "${topic}"`)
+      const chromaNote = !memory.isChromaDBEnabled()
+        ? '\n\nNote: ChromaDB is not connected. Decision evolution analysis requires ChromaDB for semantic search. Start a ChromaDB server or switch to persistent mode.'
+        : ''
+      return ResponseFormatter.text(`No decisions found for topic: "${topic}"` + chromaNote)
     }
 
     const parts: string[] = []

package/src/server/handlers/tools/detect-trends.ts

@@ -33,7 +33,10 @@ export async function handleDetectTrends(
     })
 
     if (analysis.totalDecisionsAnalyzed === 0) {
-      return ResponseFormatter.text('No decisions found for trend analysis.')
+      const chromaNote = !memory.isChromaDBEnabled()
+        ? '\n\nNote: ChromaDB is not connected. Trend detection requires ChromaDB for semantic search across decisions. Start a ChromaDB server or switch to persistent mode.'
+        : ''
+      return ResponseFormatter.text('No decisions found for trend analysis.' + chromaNote)
     }
 
     const parts: string[] = []

package/src/server/handlers/tools/get-decision-timeline.ts

@@ -50,7 +50,10 @@ export async function handleGetDecisionTimeline(
     })
 
     if (timeline.entries.length === 0) {
-      return ResponseFormatter.text('No decisions found for the specified criteria.')
+      const chromaNote = !memory.isChromaDBEnabled()
+        ? '\n\nNote: ChromaDB is not connected. Decision timeline requires ChromaDB for semantic search. Start a ChromaDB server or switch to persistent mode.'
+        : ''
+      return ResponseFormatter.text('No decisions found for the specified criteria.' + chromaNote)
     }
 
     // Format timeline

package/src/server/handlers/tools/get-recommendations.ts

@@ -35,7 +35,10 @@ export async function handleGetRecommendations(
     })
 
     if (result.recommendations.length === 0) {
-      return ResponseFormatter.text(`No recommendations found for: "${query}"`)
+      const chromaNote = !memory.isChromaDBEnabled()
+        ? '\n\nNote: ChromaDB is not connected. Recommendations require ChromaDB for semantic search across patterns, corrections, and decisions. Start a ChromaDB server or switch to persistent mode.'
+        : ''
+      return ResponseFormatter.text(`No recommendations found for: "${query}"` + chromaNote)
     }
 
     const parts: string[] = []

package/src/server/handlers/tools/schemas.ts

@@ -204,7 +204,7 @@ export const GetRecommendationsSchema = z.object({
 })
 
 export const FindCrossProjectPatternsSchema = z.object({
-  min_projects: z.number().int().min(2).max(50).optional().default(2),
+  min_projects: z.number().int().min(1).max(50).optional().default(2),
   limit: z.number().int().min(1).max(100).optional().default(20),
   query: z.string().optional()
 })

package/src/server/handlers/tools/update-progress.ts

@@ -50,6 +50,18 @@ export async function handleUpdateProgress(
       completedAt: new Date()
     })
 
+    // Calculate and update completion percentage
+    const progressState = await context.progress.getProgress(project_name)
+    const totalTasks = progressState.completedTasks.length + progressState.currentTasks.length
+    const completionPercentage = totalTasks > 0
+      ? Math.round((progressState.completedTasks.length / totalTasks) * 100)
+      : 0
+
+    await context.progress.updateProgress(project_name, {
+      completionPercentage,
+      currentPhase: completionPercentage >= 100 ? 'complete' : 'active'
+    })
+
     const progressFile = await vault.reader.readMarkdownFile(projectPaths.progress)
     const updatedContent = updateNextStepsSection(progressFile.content, next_steps)
 

package/src/server/handlers/tools/what-if-analysis.ts

@@ -63,7 +63,10 @@ export async function handleWhatIfAnalysis(
       return ResponseFormatter.text(withMemoryIndicator(content, totalAffected))
     }
 
-    return ResponseFormatter.text(content)
+    const chromaNote = !memory.isChromaDBEnabled()
+      ? '\n\nNote: ChromaDB is not connected. What-if analysis requires ChromaDB for semantic search across decisions. Start a ChromaDB server or switch to persistent mode.'
+      : ''
+    return ResponseFormatter.text(content + chromaNote)
 
   } catch (error) {
     ErrorHandler.logError(logger, error, { tool: 'what_if_analysis' })

package/src/server/services.ts

@@ -157,7 +157,8 @@ export async function initializeServices(config: Config, logger: Logger): Promis
         }
 
         // Hook builder into decision storage for real-time graph population
-        memory.chroma.store.addDecisionStoredListener((input) => {
+        // Uses MemoryManager listener so it works for both ChromaDB and SQLite paths
+        memory.addDecisionStoredListener((input) => {
           builder.processDecision(input)
         })
 

package/src/setup/wizard.ts

@@ -122,7 +122,7 @@ export class SetupWizard {
       {
         type: 'confirm',
         name: 'installClaudeMd',
-        message: 'Install CLAUDE.md protocol file to ~/CLAUDE.md?',
+        message: 'Install CLAUDE.md protocol file to ~/.claude/CLAUDE.md?',
         initial: true
       }
     ])
@@ -244,7 +244,7 @@ SERVER_NAME=claude-brain
 
   private async confirmClaudeMdInstall(): Promise<boolean> {
     const sourcePath = path.join(PACKAGE_ROOT, 'assets', 'CLAUDE.md')
-    const destPath = path.join(os.homedir(), 'CLAUDE.md')
+    const destPath = path.join(os.homedir(), '.claude', 'CLAUDE.md')
 
     if (!existsSync(sourcePath)) {
       console.log(warningText('CLAUDE.md asset not found, skipping'))
@@ -255,7 +255,7 @@ SERVER_NAME=claude-brain
       const { overwrite } = await prompts({
         type: 'confirm',
         name: 'overwrite',
-        message: '~/CLAUDE.md already exists. Overwrite?',
+        message: '~/.claude/CLAUDE.md already exists. Overwrite?',
         initial: false,
       })
       if (!overwrite) {
@@ -269,7 +269,9 @@ SERVER_NAME=claude-brain
 
   private async copyClaudeMd(): Promise<void> {
     const sourcePath = path.join(PACKAGE_ROOT, 'assets', 'CLAUDE.md')
-    const destPath = path.join(os.homedir(), 'CLAUDE.md')
+    const claudeDir = path.join(os.homedir(), '.claude')
+    const destPath = path.join(claudeDir, 'CLAUDE.md')
+    await fs.mkdir(claudeDir, { recursive: true })
     await fs.copyFile(sourcePath, destPath)
   }