claude-brain 0.4.1 → 0.5.0

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

@@ -25,12 +25,82 @@ export async function handleAnalyzeDecisionEvolution(
     const memory = getMemoryService()
 
     if (!memory.isChromaDBEnabled()) {
-      return ResponseFormatter.text(
-        `No decisions found for topic: "${topic}"\n\n` +
-        'Note: ChromaDB is not connected. Decision evolution analysis requires ChromaDB for semantic search. ' +
-        'Decisions stored via SQLite fallback are available through recall_similar. ' +
-        'To enable evolution tracking, start a ChromaDB server or configure persistent mode.'
-      )
+      // SQLite fallback: use searchRaw for semantic search + chronological analysis
+      const results = await memory.searchRaw(topic, {
+        project: project_name,
+        limit: limit || 20,
+        minSimilarity: 0.2
+      })
+
+      if (results.length === 0) {
+        return ResponseFormatter.text(`No decisions found for topic: "${topic}"`)
+      }
+
+      // Sort chronologically
+      const sorted = results
+        .map(r => ({
+          date: r.memory?.createdAt?.toISOString?.() || r.memory?.created_at || new Date().toISOString(),
+          decision: r.decision?.decision || r.memory?.content || '',
+          reasoning: r.decision?.reasoning || '',
+          similarity: r.similarity || 0
+        }))
+        .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+
+      // Simple stability assessment based on content similarity between consecutive decisions
+      let totalSimilarity = 0
+      let comparisons = 0
+      const changes: Array<{ daysBetween: number; summary: string }> = []
+
+      for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1]
+        const curr = sorted[i]
+        const daysBetween = Math.round((new Date(curr.date).getTime() - new Date(prev.date).getTime()) / (1000 * 60 * 60 * 24))
+
+        // Simple Jaccard similarity between word sets
+        const prevWords = new Set(prev.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3))
+        const currWords = new Set(curr.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3))
+        const intersection = new Set([...prevWords].filter(w => currWords.has(w)))
+        const union = new Set([...prevWords, ...currWords])
+        const jaccard = union.size > 0 ? intersection.size / union.size : 0
+        totalSimilarity += jaccard
+        comparisons++
+
+        if (jaccard < 0.5) {
+          changes.push({
+            daysBetween,
+            summary: `Changed from "${prev.decision.slice(0, 60)}..." to "${curr.decision.slice(0, 60)}..."`
+          })
+        }
+      }
+
+      const avgSimilarity = comparisons > 0 ? totalSimilarity / comparisons : 1
+      const stability = avgSimilarity > 0.7 ? 'stable' : avgSimilarity > 0.4 ? 'evolving' : 'volatile'
+      const currentState = sorted[sorted.length - 1].decision
+
+      const parts: string[] = []
+      parts.push(`## Decision Evolution: "${topic}" (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      parts.push(`**Total decisions:** ${sorted.length}`)
+      parts.push(`**Stability:** ${stability}`)
+      parts.push(`**Current state:** ${currentState.slice(0, 200)}`)
+      parts.push('')
+
+      if (changes.length > 0) {
+        parts.push('### Changes Over Time')
+        for (const change of changes) {
+          parts.push(`- **${change.daysBetween} days apart:** ${change.summary}`)
+        }
+        parts.push('')
+      }
+
+      parts.push('### Timeline')
+      for (const entry of sorted.slice(0, 10)) {
+        const date = new Date(entry.date).toLocaleDateString()
+        parts.push(`- **${date}:** ${entry.decision.slice(0, 150)}`)
+      }
+
+      const statsLine = formatMemoryStats({ recalled: sorted.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), sorted.length) + '\n\n' + statsLine)
     }
 
     const tracker = new DecisionEvolutionTracker(

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

@@ -25,12 +25,66 @@ export async function handleDetectTrends(
     const memory = getMemoryService()
 
     if (!memory.isChromaDBEnabled()) {
-      return ResponseFormatter.text(
-        'No decisions found for trend analysis.\n\n' +
-        'Note: ChromaDB is not connected. Trend detection requires ChromaDB for semantic search across decisions. ' +
-        'Decisions stored via SQLite fallback are available through recall_similar and get_patterns. ' +
-        'To enable trend detection, start a ChromaDB server or configure persistent mode.'
-      )
+      // SQLite fallback: frequency-based trend analysis
+      const decisions = await memory.fetchAllDecisions(project_name)
+
+      if (decisions.length === 0) {
+        return ResponseFormatter.text('No decisions found for trend analysis.')
+      }
+
+      // Filter by period
+      const cutoffDate = new Date()
+      cutoffDate.setDate(cutoffDate.getDate() - (period_days || 90))
+      const filtered = decisions.filter(d => new Date(d.date) >= cutoffDate)
+
+      if (filtered.length === 0) {
+        return ResponseFormatter.text(`No decisions found in the last ${period_days || 90} days.`)
+      }
+
+      // Extract term frequencies from decision content
+      const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'between', 'out', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either', 'neither', 'each', 'every', 'all', 'any', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too', 'very', 'just', 'because', 'if', 'when', 'where', 'how', 'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'him', 'his', 'she', 'her', 'it', 'its', 'they', 'them', 'their', 'use', 'using', 'used', 'decision', 'context', 'reasoning'])
+      const termCounts: Record<string, { count: number; projects: Set<string> }> = {}
+
+      for (const d of filtered) {
+        const text = `${d.decision || ''} ${d.context || ''} ${d.reasoning || ''}`.toLowerCase()
+        const words = text.match(/\b[a-z][a-z-]{2,}\b/g) || []
+        const seen = new Set<string>()
+        for (const word of words) {
+          if (stopWords.has(word) || seen.has(word)) continue
+          seen.add(word)
+          if (!termCounts[word]) termCounts[word] = { count: 0, projects: new Set() }
+          termCounts[word].count++
+          if (d.project) termCounts[word].projects.add(d.project)
+        }
+      }
+
+      const minOcc = min_occurrences || 2
+      const trends = Object.entries(termCounts)
+        .filter(([, v]) => v.count >= minOcc)
+        .map(([term, v]) => ({ term, occurrences: v.count, projects: Array.from(v.projects) }))
+        .sort((a, b) => b.occurrences - a.occurrences)
+        .slice(0, limit || 20)
+
+      const parts: string[] = []
+      parts.push(`## Trend Analysis (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      parts.push(`**Period:** Last ${period_days || 90} days`)
+      parts.push(`**Decisions analyzed:** ${filtered.length}`)
+      parts.push('')
+
+      if (trends.length > 0) {
+        parts.push('### Top Terms by Frequency')
+        for (const t of trends) {
+          parts.push(`- **${t.term}** (${t.occurrences}x, projects: ${t.projects.join(', ')})`)
+        }
+      } else {
+        parts.push('No significant trends found with current filters.')
+      }
+
+      parts.push('\n*Note: SQLite mode provides frequency-based analysis. Enable ChromaDB for momentum and rising/declining classification.*')
+
+      const statsLine = formatMemoryStats({ recalled: filtered.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), filtered.length) + '\n\n' + statsLine)
     }
 
     const detector = new TrendDetector(logger, memory.chroma.collections)

package/src/server/handlers/tools/find-cross-project-patterns.ts

@@ -25,12 +25,97 @@ export async function handleFindCrossProjectPatterns(
     const memory = getMemoryService()
 
     if (!memory.isChromaDBEnabled()) {
-      return ResponseFormatter.text(
-        'No cross-project patterns found.\n\n' +
-        'Note: ChromaDB is not connected. Cross-project pattern analysis requires ChromaDB for semantic search across decisions. ' +
-        'Decisions stored via SQLite fallback are available through recall_similar and get_patterns. ' +
-        'To enable cross-project analysis, start a ChromaDB server or configure persistent mode.'
-      )
+      // SQLite fallback: fetch all decisions, group by project, find shared terms
+      const decisions = await memory.fetchAllDecisions()
+
+      if (decisions.length === 0) {
+        return ResponseFormatter.text('No cross-project patterns found (no decisions in database).')
+      }
+
+      // Group by project
+      const byProject: Record<string, any[]> = {}
+      for (const d of decisions) {
+        const proj = d.project || 'unknown'
+        if (!byProject[proj]) byProject[proj] = []
+        byProject[proj].push(d)
+      }
+
+      const projectNames = Object.keys(byProject)
+      const minProj = min_projects || 2
+
+      if (projectNames.length < minProj) {
+        return ResponseFormatter.text(
+          `Only ${projectNames.length} project(s) found (${projectNames.join(', ')}). Need at least ${minProj} for cross-project analysis.`
+        )
+      }
+
+      // Extract significant terms per project
+      const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'and', 'but', 'or', 'not', 'so', 'if', 'when', 'where', 'how', 'what', 'which', 'who', 'this', 'that', 'use', 'using', 'used', 'decision', 'context', 'reasoning'])
+      const termProjects: Record<string, { projects: Set<string>; examples: Array<{ project: string; content: string }> }> = {}
+
+      for (const [proj, decs] of Object.entries(byProject)) {
+        const projectTerms = new Set<string>()
+        for (const d of decs) {
+          const text = `${d.decision || ''} ${d.context || ''}`.toLowerCase()
+          const words = text.match(/\b[a-z][a-z-]{2,}\b/g) || []
+          for (const word of words) {
+            if (stopWords.has(word)) continue
+            if (!projectTerms.has(word)) {
+              projectTerms.add(word)
+              if (!termProjects[word]) termProjects[word] = { projects: new Set(), examples: [] }
+              termProjects[word].projects.add(proj)
+              if (termProjects[word].examples.length < 3) {
+                termProjects[word].examples.push({ project: proj, content: d.decision?.slice(0, 100) || d.content?.slice(0, 100) || '' })
+              }
+            }
+          }
+        }
+      }
+
+      // Filter terms that appear in >= minProj projects
+      const crossPatterns = Object.entries(termProjects)
+        .filter(([, v]) => v.projects.size >= minProj)
+        .map(([term, v]) => ({
+          description: term,
+          projects: Array.from(v.projects),
+          occurrences: v.projects.size,
+          confidence: v.projects.size / projectNames.length,
+          examples: v.examples
+        }))
+        .sort((a, b) => b.occurrences - a.occurrences)
+        .slice(0, limit || 20)
+
+      if (crossPatterns.length === 0) {
+        return ResponseFormatter.text(
+          `No cross-project patterns found (analyzed ${decisions.length} decisions across ${projectNames.length} projects).`
+        )
+      }
+
+      const parts: string[] = []
+      parts.push(`## Cross-Project Patterns (SQLite)`)
+      parts.push(`**Projects analyzed:** ${projectNames.join(', ')}`)
+      parts.push(`**Decisions analyzed:** ${decisions.length}`)
+      parts.push(`**Shared terms found:** ${crossPatterns.length}`)
+      parts.push('')
+
+      for (const pattern of crossPatterns) {
+        const confidence = Math.round(pattern.confidence * 100)
+        parts.push(`### ${pattern.description} (${confidence}% confidence)`)
+        parts.push(`**Projects:** ${pattern.projects.join(', ')}`)
+        parts.push(`**Occurrences:** ${pattern.occurrences} projects`)
+        if (pattern.examples.length > 0) {
+          parts.push('**Examples:**')
+          for (const ex of pattern.examples.slice(0, 3)) {
+            parts.push(`- [${ex.project}] ${ex.content}`)
+          }
+        }
+        parts.push('')
+      }
+
+      parts.push('*Note: SQLite mode uses term-frequency analysis. Enable ChromaDB for semantic pattern generalization.*')
+
+      const statsLine = formatMemoryStats({ patterns: crossPatterns.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), crossPatterns.length) + '\n\n' + statsLine)
     }
 
     const generalizer = new PatternGeneralizer(

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

@@ -25,21 +25,6 @@ export async function handleGetDecisionTimeline(
 
     const memory = getMemoryService()
 
-    if (!memory.isChromaDBEnabled()) {
-      return ResponseFormatter.text(
-        'No decisions found for the specified criteria.\n\n' +
-        'Note: ChromaDB is not connected. Decision timeline requires ChromaDB for semantic search. ' +
-        'Decisions stored via SQLite fallback are available through recall_similar. ' +
-        'To enable timeline view, start a ChromaDB server or configure persistent mode.'
-      )
-    }
-
-    const timelineBuilder = new TimelineBuilder(
-      logger,
-      memory.chroma.collections,
-      memory.chroma.embeddings
-    )
-
     // Parse temporal expression if provided
     let startDate: string | undefined
     let endDate: string | undefined
@@ -51,6 +36,97 @@ export async function handleGetDecisionTimeline(
       endDate = parsed.endDate
     }
 
+    if (!memory.isChromaDBEnabled()) {
+      // SQLite fallback: fetch all data and build timeline
+      const [decisions, patterns, corrections] = await Promise.all([
+        memory.fetchAllDecisions(project_name),
+        memory.fetchAllPatterns(project_name),
+        memory.fetchAllCorrections(project_name)
+      ])
+
+      // Combine into timeline entries
+      let entries: Array<{ date: string; type: string; content: string; reasoning?: string }> = []
+
+      for (const d of decisions) {
+        entries.push({
+          date: d.date,
+          type: 'decision',
+          content: d.decision || d.content,
+          reasoning: d.reasoning
+        })
+      }
+      for (const p of patterns) {
+        entries.push({
+          date: p.date,
+          type: 'pattern',
+          content: p.description || p.content
+        })
+      }
+      for (const c of corrections) {
+        entries.push({
+          date: c.date,
+          type: 'correction',
+          content: c.correction || c.content,
+          reasoning: c.reasoning
+        })
+      }
+
+      // Filter by topic (substring match)
+      if (topic) {
+        const topicLower = topic.toLowerCase()
+        entries = entries.filter(e =>
+          e.content.toLowerCase().includes(topicLower) ||
+          (e.reasoning && e.reasoning.toLowerCase().includes(topicLower))
+        )
+      }
+
+      // Filter by date range
+      if (startDate) {
+        entries = entries.filter(e => e.date >= startDate!)
+      }
+      if (endDate) {
+        entries = entries.filter(e => e.date <= endDate!)
+      }
+
+      // Sort chronologically and limit
+      entries.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+      const limited = entries.slice(0, limit || 20)
+
+      if (limited.length === 0) {
+        return ResponseFormatter.text('No decisions found for the specified criteria.')
+      }
+
+      const parts: string[] = []
+      parts.push(`## Decision Timeline (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      if (topic) parts.push(`**Topic:** ${topic}`)
+      if (limited.length > 0) {
+        parts.push(`**Period:** ${new Date(limited[0].date).toLocaleDateString()} - ${new Date(limited[limited.length - 1].date).toLocaleDateString()}`)
+      }
+      parts.push(`**Total entries:** ${limited.length}`)
+      parts.push('')
+
+      for (const entry of limited) {
+        const date = new Date(entry.date).toLocaleDateString()
+        const icon = entry.type === 'decision' ? '📋' : entry.type === 'pattern' ? '🔄' : '⚠️'
+        parts.push(`### ${icon} ${date} [${entry.type}]`)
+        parts.push(entry.content.slice(0, 200))
+        if (entry.reasoning) {
+          parts.push(`*Reasoning:* ${entry.reasoning.slice(0, 100)}`)
+        }
+        parts.push('')
+      }
+
+      const statsLine = formatMemoryStats({ recalled: limited.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), limited.length) + '\n\n' + statsLine)
+    }
+
+    const timelineBuilder = new TimelineBuilder(
+      logger,
+      memory.chroma.collections,
+      memory.chroma.embeddings
+    )
+
     const timeline = await timelineBuilder.buildTimeline({
       project: project_name,
       topic,

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

@@ -32,7 +32,17 @@ export async function handleGetEpisode(
     const episodeService = getEpisodeService()
     if (!episodeService) {
       return ResponseFormatter.text(
-        'Episodic memory is not enabled. Enable it by setting knowledge.episodic.enabled=true in config.'
+        '## Episodic Memory Not Available\n\n' +
+        'Episodic memory requires ChromaDB to track conversation sessions.\n\n' +
+        '**To enable:**\n' +
+        '- Start a ChromaDB server: `chroma run --path /path/to/data`\n' +
+        '- Set `CHROMA_URL=http://localhost:8000` in your environment\n' +
+        '- Set `knowledge.episodic.enabled=true` in config\n\n' +
+        '**Alternative tools that work without ChromaDB:**\n' +
+        '- `recall_similar` — search past decisions by semantic similarity\n' +
+        '- `get_patterns` — retrieve recognized patterns\n' +
+        '- `get_corrections` — retrieve lessons learned\n' +
+        '- `smart_context` — get full project context with memory recall'
       )
     }
 

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

@@ -25,12 +25,82 @@ export async function handleGetRecommendations(
     const memory = getMemoryService()
 
     if (!memory.isChromaDBEnabled()) {
-      return ResponseFormatter.text(
-        `No recommendations found for: "${query}"\n\n` +
-        'Note: ChromaDB is not connected. Recommendations require ChromaDB for semantic search across patterns, corrections, and decisions. ' +
-        'Decisions stored via SQLite fallback are available through recall_similar, get_patterns, and get_corrections. ' +
-        'To enable recommendations, start a ChromaDB server or configure persistent mode.'
-      )
+      // SQLite fallback: combine searchRaw + searchPatterns + searchCorrections
+      const [rawResults, patternResults, correctionResults] = await Promise.all([
+        memory.searchRaw(query, { project: project_name, limit: limit || 5, minSimilarity: 0.2 }),
+        memory.searchPatterns(query, { project: project_name, limit: limit || 5, minSimilarity: 0.2 }),
+        memory.searchCorrections(query, { project: project_name, limit: limit || 5, minSimilarity: 0.2 })
+      ])
+
+      // Combine and format as recommendations
+      const recommendations: Array<{ type: string; source: string; content: string; reasoning: string; confidence: number }> = []
+
+      // Corrections get highest priority (lessons learned)
+      for (const c of correctionResults) {
+        recommendations.push({
+          type: 'correction',
+          source: 'Past Correction',
+          content: `Original: ${c.metadata?.original || ''}\nCorrection: ${c.metadata?.correction || c.content || ''}`,
+          reasoning: c.metadata?.reasoning || 'Based on previous lesson learned',
+          confidence: c.similarity || c.metadata?.confidence || 0.5
+        })
+      }
+
+      // Patterns
+      for (const p of patternResults) {
+        recommendations.push({
+          type: p.metadata?.pattern_type || 'pattern',
+          source: `Pattern (${p.metadata?.pattern_type || 'general'})`,
+          content: p.metadata?.description || p.content || '',
+          reasoning: p.metadata?.context || 'Based on recognized pattern',
+          confidence: p.similarity || p.metadata?.confidence || 0.5
+        })
+      }
+
+      // Decisions
+      for (const r of rawResults) {
+        recommendations.push({
+          type: 'decision',
+          source: 'Past Decision',
+          content: r.decision?.decision || r.memory?.content?.slice(0, 300) || '',
+          reasoning: r.decision?.reasoning || 'Based on similar past decision',
+          confidence: r.similarity || 0.5
+        })
+      }
+
+      // Sort by confidence, deduplicate, and limit
+      const seen = new Set<string>()
+      const deduped = recommendations.filter(r => {
+        const key = r.content.slice(0, 50)
+        if (seen.has(key)) return false
+        seen.add(key)
+        return true
+      })
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit || 5)
+
+      if (deduped.length === 0) {
+        return ResponseFormatter.text(`No recommendations found for: "${query}"`)
+      }
+
+      const parts: string[] = []
+      parts.push(`## Recommendations (SQLite)`)
+      parts.push(`**Query:** ${query}`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      parts.push(`**Found:** ${deduped.length}`)
+      parts.push('')
+
+      for (const rec of deduped) {
+        const confidence = Math.round(rec.confidence * 100)
+        const icon = rec.type === 'correction' ? '⚠️' : rec.type === 'best-practice' ? '✅' : rec.type === 'pattern' ? '🔄' : '📋'
+        parts.push(`### ${icon} ${rec.source} (${confidence}% confidence)`)
+        parts.push(rec.content.slice(0, 300))
+        parts.push(`*${rec.reasoning}*`)
+        parts.push('')
+      }
+
+      const statsLine = formatMemoryStats({ recalled: deduped.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), deduped.length) + '\n\n' + statsLine)
     }
 
     const recommender = new Recommender(

package/src/server/handlers/tools/list-episodes.ts

@@ -32,7 +32,17 @@ export async function handleListEpisodes(
     const episodeService = getEpisodeService()
     if (!episodeService) {
       return ResponseFormatter.text(
-        'Episodic memory is not enabled. Enable it by setting knowledge.episodic.enabled=true in config.'
+        '## Episodic Memory Not Available\n\n' +
+        'Episodic memory requires ChromaDB to track conversation sessions.\n\n' +
+        '**To enable:**\n' +
+        '- Start a ChromaDB server: `chroma run --path /path/to/data`\n' +
+        '- Set `CHROMA_URL=http://localhost:8000` in your environment\n' +
+        '- Set `knowledge.episodic.enabled=true` in config\n\n' +
+        '**Alternative tools that work without ChromaDB:**\n' +
+        '- `recall_similar` — search past decisions by semantic similarity\n' +
+        '- `get_patterns` — retrieve recognized patterns\n' +
+        '- `get_corrections` — retrieve lessons learned\n' +
+        '- `smart_context` — get full project context with memory recall'
       )
     }
 

package/src/server/handlers/tools/rate-memory.ts

@@ -39,8 +39,14 @@ export async function handleRateMemory(
     // Check if feedback is enabled
     if (!retrieval) {
       return ResponseFormatter.text(
-        'Feedback collection is not enabled. ' +
-        'Enable it by setting RETRIEVAL_FEEDBACK_ENABLED=true or retrieval.feedback.enabled=true in config.'
+        '## Memory Feedback Not Available\n\n' +
+        'Memory rating requires the retrieval feedback system, which depends on ChromaDB.\n\n' +
+        '**To enable:**\n' +
+        '- Start a ChromaDB server: `chroma run --path /path/to/data`\n' +
+        '- Set `CHROMA_URL=http://localhost:8000` in your environment\n' +
+        '- Set `RETRIEVAL_FEEDBACK_ENABLED=true` or `retrieval.feedback.enabled=true` in config\n\n' +
+        '**Note:** Your rating was not lost — the memory system will still function without feedback. ' +
+        'Feedback helps improve retrieval quality over time by learning which memories are most useful.'
       )
     }
 

package/src/server/handlers/tools/smart-context.ts

@@ -5,7 +5,7 @@
 
 import type { Logger } from 'pino'
 import type { ToolResponse } from '@/tools/types'
-import { getContextService, getPhase12Service, isServicesInitialized } from '@/server/services'
+import { getContextService, getPhase12Service, getMemoryService, isServicesInitialized } from '@/server/services'
 import { ToolValidator } from '@/server/utils/validators'
 import { ResponseFormatter } from '@/server/utils/response-formatter'
 import { withMemoryIndicator, formatMemoryStats } from '@/server/utils/memory-indicator'
@@ -52,6 +52,28 @@ export async function handleSmartContext(
     // Process with Phase 12 for proactive recall
     const phase12Result = await phase12.processMessage(current_task, project_name)
 
+    // If Phase12's gated recall found nothing, do direct search (like recall_similar)
+    if (!phase12Result.recalledMemories || phase12Result.recalledMemories.memories.length === 0) {
+      try {
+        const memory = getMemoryService()
+        const directRecall = await memory.searchRaw(current_task, {
+          project: project_name,
+          limit: 5,
+          minSimilarity: min_similarity || 0.3
+        })
+        if (directRecall.length > 0) {
+          phase12Result.recalledMemories = {
+            query: current_task,
+            memories: directRecall,
+            relevanceScore: directRecall.reduce((sum: number, m: any) => sum + (m.similarity || 0), 0) / directRecall.length,
+            triggeredBy: ['direct-search-fallback']
+          }
+        }
+      } catch (e) {
+        logger.debug({ error: e }, 'Direct recall fallback failed, continuing without')
+      }
+    }
+
     // Format base context
     const formattedContext = contextService.formatter.format(context)
 

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

@@ -43,6 +43,7 @@ export async function handleUpdateProgress(
 
     const taskId = generateTaskId(completed_task)
 
+    // Step 1: Append completed task to progress file
     await context.progress.addCompletedTask(project_name, {
       id: taskId,
       title: completed_task,
@@ -50,19 +51,8 @@ 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)
+    // Step 2: Read file bypassing cache, update next steps, write content
+    const progressFile = await vault.reader.readMarkdownFile(projectPaths.progress, false)
     const updatedContent = updateNextStepsSection(progressFile.content, next_steps)
 
     await vault.writer.writeMarkdownFile(
@@ -72,11 +62,26 @@ export async function handleUpdateProgress(
       true
     )
 
+    // Step 3: Notes appended if present
     if (notes) {
       const notesEntry = `\n## Notes (${new Date().toLocaleDateString()})\n${notes}\n`
       await vault.writer.appendContent(projectPaths.progress, notesEntry)
     }
 
+    // Step 4: Calculate and update frontmatter LAST (so nothing overwrites it)
+    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'
+    })
+
+    // Step 5: Invalidate cache so subsequent reads get fresh data
+    vault.reader.invalidateCache(projectPaths.progress)
     context.invalidateContext(project_name)
 
     logger.info({ projectName: project_name, taskId }, 'Progress updated successfully')