claude-brain 0.17.13 → 0.22.0

package/src/routing/router.ts

@@ -13,7 +13,7 @@
 import type { Logger } from 'pino'
 import { IntentClassifier, type ClassificationResult } from './intent-classifier'
 import { BrainEntityExtractor, type BrainExtractedEntities } from './entity-extractor'
-import { ResponseFilter, type BrainResponse, type TierResults } from './response-filter'
+import { ResponseFilter, type BrainResponse, type TierResults, formatCompactResponse, formatDetailResponse, formatTimeline, groupByDay } from './response-filter'
 import { SearchEngine } from './search-engine'
 import type { NormalizedResult } from './types'
 import {
@@ -23,9 +23,11 @@ import {
   getPhase12Service,
   getEpisodeService,
   getSessionTracker,
+  getCodeLinker,
   isServicesInitialized
 } from '@/server/services'
 import { timed } from '@/utils/timing'
+import type { ObservationCompressor } from '@/memory/compression'
 
 /** Default project when none can be detected */
 const DEFAULT_PROJECT = 'general'
@@ -58,6 +60,9 @@ export class BrainRouter {
   private searchEngine: SearchEngine
   private logger: Logger
 
+  /** Phase 30: Optional LLM compressor for long observations */
+  private compressor: ObservationCompressor | null = null
+
   /** Track the most recently stored decision ID for update/delete operations */
   private lastStoredId: string | null = null
   private lastStoredProject: string | null = null
@@ -73,6 +78,11 @@ export class BrainRouter {
     this.logger = logger.child({ component: 'brain-router' })
   }
 
+  /** Phase 30: Set the optional LLM compressor */
+  setCompressor(compressor: ObservationCompressor): void {
+    this.compressor = compressor
+  }
+
   async route(input: BrainInput): Promise<BrainResponse> {
     const { message, project: inputProject } = input
 
@@ -130,6 +140,12 @@ export class BrainRouter {
         case 'delete_memory':
           return this.handleDeleteMemory(message, project, entities)
 
+        case 'detail_request':
+          return this.handleDetailRequest(message, project, entities)
+
+        case 'timeline':
+          return this.handleTimeline(message, project, entities)
+
         default:
           return this.handleContextNeeded(message, project, entities, classification)
       }
@@ -385,10 +401,12 @@ export class BrainRouter {
     }
 
     const memory = getMemoryService()
-    const decision = message
     const reasoning = entities.reasoning || ''
     const context = entities.topic || message.slice(0, 200)
 
+    // Phase 30: Optional LLM compression
+    const { content: decision, rawContent } = await this.maybeCompress(message, 'store')
+
     const decisionId = await timed('brain:store', () => memory.rememberDecision(
       effectiveProject,
       context,
@@ -410,16 +428,18 @@ export class BrainRouter {
     // Invalidate cache for this project
     this.searchEngine.invalidateCache(effectiveProject)
 
-    // Background: vault write + episode linking (non-critical)
+    // Background: vault write + episode linking + code linkage (non-critical)
     setImmediate(() => {
       this.writeToVault(effectiveProject, decision, reasoning, context, entities.alternatives)
       this.linkToActiveEpisode(effectiveProject, decisionId, 'decision')
+      this.linkToCodeFiles(decisionId, decision, effectiveProject)
     })
 
+    const compressedNote = rawContent ? '\n*(compressed)*' : ''
     return {
       action: 'stored',
       summary: `Stored: ${message.slice(0, 60)}`,
-      content: `Memory stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Content:** ${decision}${reasoning ? `\n**Reasoning:** ${reasoning}` : ''}`,
+      content: `Memory stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Content:** ${decision}${reasoning ? `\n**Reasoning:** ${reasoning}` : ''}${compressedNote}`,
       relevantItems: 1
     }
   }
@@ -436,11 +456,13 @@ export class BrainRouter {
     }
 
     const memory = getMemoryService()
-    const decision = message
     const reasoning = entities.reasoning || ''
     const context = entities.topic || message.slice(0, 200)
     const alternatives = entities.alternatives
 
+    // Phase 30: Optional LLM compression
+    const { content: decision, rawContent } = await this.maybeCompress(message, 'decision')
+
     const decisionId = await timed('brain:store', () => memory.rememberDecision(
       effectiveProject,
       context,
@@ -461,16 +483,18 @@ export class BrainRouter {
     // Invalidate cache
     this.searchEngine.invalidateCache(effectiveProject)
 
-    // Background: vault write + episode linking (non-critical)
+    // Background: vault write + episode linking + code linkage (non-critical)
     setImmediate(() => {
       this.writeToVault(effectiveProject, decision, reasoning, context, alternatives)
       this.linkToActiveEpisode(effectiveProject, decisionId, 'decision')
+      this.linkToCodeFiles(decisionId, decision, effectiveProject)
     })
 
+    const compressedNote = rawContent ? '\n*(compressed)*' : ''
     return {
       action: 'stored',
       summary: `Stored decision: ${message.slice(0, 60)}`,
-      content: `Decision stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}`,
+      content: `Decision stored (ID: ${decisionId})\n\n**Project:** ${effectiveProject}\n**Decision:** ${decision}\n**Reasoning:** ${reasoning}${compressedNote}`,
       relevantItems: 1
     }
   }
@@ -501,8 +525,9 @@ export class BrainRouter {
     // Invalidate cache
     this.searchEngine.invalidateCache(effectiveProject)
 
-    // Link to active episode
+    // Link to active episode + code files
     this.linkToActiveEpisode(effectiveProject, patternId, 'pattern')
+    this.linkToCodeFiles(patternId, description, effectiveProject)
 
     return {
       action: 'stored',
@@ -540,8 +565,9 @@ export class BrainRouter {
     // Invalidate cache
     this.searchEngine.invalidateCache(effectiveProject)
 
-    // Link to active episode
+    // Link to active episode + code files
     this.linkToActiveEpisode(effectiveProject, correctionId, 'correction')
+    this.linkToCodeFiles(correctionId, original, effectiveProject)
 
     return {
       action: 'stored',
@@ -627,44 +653,7 @@ export class BrainRouter {
       const patterns = await memory.fetchAllPatterns(effectiveProject)
       const corrections = await memory.fetchAllCorrections(effectiveProject)
 
-      const parts: string[] = []
       const projectLabel = effectiveProject || 'all projects'
-
-      if (decisions.length > 0) {
-        parts.push(`## Decisions (${decisions.length})`)
-        for (const d of decisions.slice(0, 20)) {
-          const rawDecision = d.decision || d.document || d.content || ''
-          const decision = typeof rawDecision === 'string' ? rawDecision : JSON.stringify(rawDecision)
-          const rawDate = d.created_at || d.date || ''
-          const date = rawDate ? ` (${String(rawDate).split('T')[0]})` : ''
-          parts.push(`- ${decision.slice(0, 150)}${date}`)
-        }
-        if (decisions.length > 20) {
-          parts.push(`_...and ${decisions.length - 20} more_`)
-        }
-        parts.push('')
-      }
-
-      if (patterns.length > 0) {
-        parts.push(`## Patterns (${patterns.length})`)
-        for (const p of patterns.slice(0, 10)) {
-          const rawDesc = p.description || p.document || p.content || ''
-          const desc = typeof rawDesc === 'string' ? rawDesc : JSON.stringify(rawDesc)
-          parts.push(`- **${p.pattern_type || 'solution'}**: ${desc.slice(0, 120)}`)
-        }
-        parts.push('')
-      }
-
-      if (corrections.length > 0) {
-        parts.push(`## Corrections (${corrections.length})`)
-        for (const c of corrections.slice(0, 10)) {
-          const rawOrig = c.original || c.document || c.content || ''
-          const orig = typeof rawOrig === 'string' ? rawOrig : JSON.stringify(rawOrig)
-          parts.push(`- ${orig.slice(0, 120)}`)
-        }
-        parts.push('')
-      }
-
       const total = decisions.length + patterns.length + corrections.length
 
       if (total === 0) {
@@ -676,10 +665,42 @@ export class BrainRouter {
         }
       }
 
+      // Phase 27: Use compact format for list_all
+      const allItems: any[] = [
+        ...decisions.map(d => ({
+          id: d.id || (d as any).decision_id,
+          content: typeof (d.decision || d.document || d.content) === 'string'
+            ? (d.decision || d.document || d.content)
+            : JSON.stringify(d.decision || d.document || d.content || ''),
+          category: 'decision',
+          project: d.project || effectiveProject || 'general',
+          created_at: d.created_at || d.date || '',
+        })),
+        ...patterns.map(p => ({
+          id: p.id,
+          content: typeof (p.description || p.document || p.content) === 'string'
+            ? (p.description || p.document || p.content)
+            : JSON.stringify(p.description || p.document || p.content || ''),
+          category: p.pattern_type || 'pattern',
+          project: p.project || effectiveProject || 'general',
+          created_at: p.created_at || '',
+        })),
+        ...corrections.map(c => ({
+          id: c.id,
+          content: typeof (c.original || c.document || c.content) === 'string'
+            ? (c.original || c.document || c.content)
+            : JSON.stringify(c.original || c.document || c.content || ''),
+          category: 'correction',
+          project: c.project || effectiveProject || 'general',
+          created_at: c.created_at || '',
+        })),
+      ]
+
+      const compactContent = formatCompactResponse(allItems, `all memories for ${projectLabel}`)
       return {
         action: 'retrieved',
         summary: `${total} memories for ${projectLabel}`,
-        content: parts.join('\n'),
+        content: compactContent,
         relevantItems: total
       }
     } catch (error) {
@@ -798,6 +819,37 @@ export class BrainRouter {
     const memory = getMemoryService()
     const topic = entities.topic || message
     const hasSpecificContent = this.hasDescriptiveContent(message)
+    const lower = message.toLowerCase()
+
+    // BUG-006 T6: Bulk delete — "delete all memories for project X"
+    if (lower.includes('delete all') || lower.includes('remove all') || lower.includes('clear all')) {
+      const bulkProject = entities.project || project || this.lastStoredProject
+      if (bulkProject) {
+        try {
+          const decisions = await memory.chroma.store.getDecisionsByProject(bulkProject)
+          if (decisions.length === 0) {
+            return {
+              action: 'none',
+              summary: 'No memories found',
+              content: `No memories found for project "${bulkProject}".`,
+              relevantItems: 0
+            }
+          }
+          for (const d of decisions) {
+            await memory.deleteDecision(d.id)
+          }
+          this.searchEngine.invalidateCache(bulkProject)
+          return {
+            action: 'stored',
+            summary: `Bulk deleted ${decisions.length} memories`,
+            content: `Deleted all ${decisions.length} memories for project "${bulkProject}".`,
+            relevantItems: 0
+          }
+        } catch {
+          // Bulk delete failed, fall through to single-item delete
+        }
+      }
+    }
 
     if (hasSpecificContent) {
       try {
@@ -927,7 +979,12 @@ export class BrainRouter {
           content: r.content,
           score: r.score,
           source: r.source === 'decision' ? 'Past Decision' : r.source,
-          metadata: r.metadata as Record<string, unknown>
+          metadata: {
+            ...(r.metadata as Record<string, unknown>),
+            id: r.id,
+            project: r.project,
+            created_at: r.date
+          }
         }))
       })
     }
@@ -947,7 +1004,13 @@ export class BrainRouter {
           content: p.content,
           score: p.score,
           source: `Pattern`,
-          metadata: p.metadata as Record<string, unknown>
+          metadata: {
+            ...(p.metadata as Record<string, unknown>),
+            id: p.id,
+            project: p.project,
+            created_at: p.date,
+            category: 'pattern'
+          }
         }))
       })
     }
@@ -959,7 +1022,13 @@ export class BrainRouter {
           content: c.content,
           score: c.score,
           source: 'Lesson Learned',
-          metadata: c.metadata as Record<string, unknown>
+          metadata: {
+            ...(c.metadata as Record<string, unknown>),
+            id: c.id,
+            project: c.project,
+            created_at: c.date,
+            category: 'correction'
+          }
         }))
       })
     }
@@ -967,8 +1036,19 @@ export class BrainRouter {
     // 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.
+    // BUG-006 T4: Also require keyword overlap with query to prevent noise
     const graphScoreCap = searchProject ? 0.25 : 0.4
-    const relevantGraphResults = graphResults.filter(g => g.score >= 0.6)
+    const queryWordsForGraph = new Set(query.toLowerCase().split(/\s+/).filter(w => w.length > 2))
+    const relevantGraphResults = graphResults.filter(g => {
+      if (g.score < 0.6) return false
+      // Require at least one query keyword to appear in graph content
+      if (queryWordsForGraph.size > 0) {
+        const contentLower = g.content.toLowerCase()
+        const hasOverlap = [...queryWordsForGraph].some(w => contentLower.includes(w))
+        if (!hasOverlap) return false
+      }
+      return true
+    })
     if (relevantGraphResults.length > 0) {
       tiers.push({
         label: 'Related Concepts',
@@ -1046,7 +1126,44 @@ export class BrainRouter {
     // Register with episode
     this.registerEpisodeMessage(message, displayProject, 'question')
 
-    return this.responseFilter.synthesize(tiers, message, displayProject)
+    // Phase 27: Use compact format for progressive disclosure
+    // Combine all tier results, filter, then format compactly
+    const allResults: import('./response-filter').FilterableResult[] = []
+    for (const tier of tiers) {
+      allResults.push(...tier.results)
+    }
+
+    if (allResults.length === 0) {
+      return {
+        action: 'none',
+        summary: 'No relevant information found',
+        content: `No results found for: "${message.slice(0, 100)}"`,
+        relevantItems: 0
+      }
+    }
+
+    const filtered = this.responseFilter.filter(allResults, message, displayProject)
+    if (filtered.length === 0) {
+      return {
+        action: 'none',
+        summary: 'Results filtered out as noise or irrelevant',
+        content: `No relevant results after filtering for: "${message.slice(0, 100)}"`,
+        relevantItems: 0
+      }
+    }
+
+    // Collect result IDs for detail lookups
+    const resultIds = filtered
+      .map(r => (r.metadata as any)?.id || (r.metadata as any)?.decision_id)
+      .filter(Boolean)
+
+    const compactContent = formatCompactResponse(filtered, message)
+    return {
+      action: 'retrieved',
+      summary: `Found ${filtered.length} result${filtered.length === 1 ? '' : 's'}`,
+      content: compactContent,
+      relevantItems: filtered.length
+    }
   }
 
   /**
@@ -1132,12 +1249,21 @@ export class BrainRouter {
     }
 
     // Always include graph exploration — cap scores when project filter is active
+    // BUG-006 T4: Also require keyword overlap with query to prevent noise
     const explorationGraphCap = searchProject ? 0.25 : 0.5
+    const explorationQueryWords = new Set(query.toLowerCase().split(/\s+/).filter(w => w.length > 2))
     const graphResults = await this.searchEngine.searchGraph(query, 10)
-    if (graphResults.length > 0) {
+    const filteredGraphResults = graphResults.filter(g => {
+      if (explorationQueryWords.size > 0) {
+        const contentLower = g.content.toLowerCase()
+        return [...explorationQueryWords].some(w => contentLower.includes(w))
+      }
+      return true
+    })
+    if (filteredGraphResults.length > 0) {
       tiers.push({
         label: 'Knowledge Graph',
-        results: graphResults.map(g => ({
+        results: filteredGraphResults.map(g => ({
           content: g.content,
           score: Math.min(g.score, explorationGraphCap),
           source: 'Knowledge Graph',
@@ -1240,8 +1366,268 @@ export class BrainRouter {
     return this.responseFilter.synthesize(tiers, message, displayProject, 'analyzed')
   }
 
+  /**
+   * Phase 27: Handle detail requests — "details obs_abc123", "expand <id>"
+   * Looks up a single observation by ID and returns full detail view.
+   */
+  private async handleDetailRequest(
+    message: string,
+    project: string | undefined,
+    _entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    // Extract ID from message using regex
+    const idMatch = message.match(/\b(obs_\w+|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}|[a-f0-9]{8,})\b/i)
+    if (!idMatch) {
+      return {
+        action: 'none',
+        summary: 'No observation ID provided',
+        content: 'Please provide an observation ID. Use brain("details {ID}") with an ID from search results.',
+        relevantItems: 0
+      }
+    }
+
+    const id = idMatch[1]
+    const observation = await this.lookupById(id)
+
+    if (!observation) {
+      return {
+        action: 'none',
+        summary: `No observation found: ${id}`,
+        content: `No observation found with ID: ${id}`,
+        relevantItems: 0
+      }
+    }
+
+    // Increment access count
+    this.incrementAccess(id)
+
+    return {
+      action: 'retrieved',
+      summary: `Details for ${id.slice(0, 12)}...`,
+      content: formatDetailResponse(observation),
+      relevantItems: 1
+    }
+  }
+
+  /**
+   * Phase 27: Handle timeline requests — "timeline for project", "recent activity"
+   * Fetches observations in a time range and groups by day.
+   */
+  private async handleTimeline(
+    message: string,
+    project: string | undefined,
+    entities: BrainExtractedEntities
+  ): Promise<BrainResponse> {
+    if (!isServicesInitialized()) {
+      return this.servicesNotReady()
+    }
+
+    const effectiveProject = entities.project || project
+    const displayProject = effectiveProject || DEFAULT_PROJECT
+
+    // Parse time range from message (default: last 7 days)
+    const now = new Date()
+    let start: Date
+    let daysBack = 7
+    const lower = message.toLowerCase()
+    if (lower.includes('yesterday')) {
+      daysBack = 1
+      start = new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000)
+    } else if (lower.includes('today')) {
+      daysBack = 0
+      // Start of today, not "now"
+      start = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+    } else if (lower.includes('last month') || lower.includes('past month')) {
+      daysBack = 30
+      start = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
+    } else if (lower.includes('last week') || lower.includes('past week')) {
+      daysBack = 7
+      start = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+    } else if (lower.includes('last 3 days') || lower.includes('past 3 days')) {
+      daysBack = 3
+      start = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000)
+    } else {
+      start = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+    }
+
+    const observations = await this.fetchRecentObservations(effectiveProject, start, now)
+    if (observations.length === 0) {
+      return {
+        action: 'none',
+        summary: `No activity found for ${displayProject}`,
+        content: `No observations found in the last ${daysBack === 0 ? 'day' : `${daysBack} day(s)`} for ${displayProject}.`,
+        relevantItems: 0
+      }
+    }
+
+    const grouped = groupByDay(observations)
+    const timelineContent = formatTimeline(grouped, displayProject)
+
+    return {
+      action: 'retrieved',
+      summary: `Timeline for ${displayProject} (${observations.length} items)`,
+      content: timelineContent,
+      relevantItems: observations.length
+    }
+  }
+
+  /**
+   * Phase 27: Look up a single observation by ID.
+   * Tries FTS5 first, then falls back to ChromaDB search.
+   */
+  private async lookupById(id: string): Promise<any | null> {
+    const memory = getMemoryService()
+
+    // Try FTS5 first (fast, direct lookup)
+    if (memory.fts5) {
+      const result = memory.fts5.getById(id)
+      if (result) return result
+    }
+
+    // Fallback: search ChromaDB by ID if available
+    if (memory.isChromaDBEnabled()) {
+      try {
+        const collections = memory.chroma.collections
+        // Try decisions collection
+        const decisions = await collections.getDecisions()
+        if (decisions) {
+          try {
+            const result = await decisions.get({ ids: [id] })
+            if (result?.documents?.[0]) {
+              return {
+                id,
+                content: result.documents[0],
+                metadata: result.metadatas?.[0] || {},
+                category: 'decision',
+                project: (result.metadatas?.[0] as any)?.project || '',
+                created_at: (result.metadatas?.[0] as any)?.created_at || '',
+                reasoning: (result.metadatas?.[0] as any)?.reasoning || null,
+                tags: [],
+                confidence: 0.8
+              }
+            }
+          } catch { /* ID not in this collection */ }
+        }
+      } catch {
+        // ChromaDB lookup failed
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Phase 27: Fetch recent observations in a date range.
+   * Tries FTS5 first, then falls back to ChromaDB temporal search.
+   */
+  private async fetchRecentObservations(
+    project: string | undefined,
+    start: Date,
+    end: Date
+  ): Promise<any[]> {
+    const memory = getMemoryService()
+
+    // Try FTS5 first (efficient SQL-level date filtering)
+    if (memory.fts5 && project) {
+      return memory.fts5.fetchByTimeRange(project, start, end)
+    }
+
+    // Also try FTS5 without project filter
+    if (memory.fts5 && !project) {
+      // FTS5 fetchByTimeRange requires project, use fetchAll with date filtering
+      try {
+        const all = memory.fts5.search('*', undefined, 100)
+        return all.filter(r => {
+          const date = new Date(r.created_at)
+          if (isNaN(date.getTime())) return false
+          return date >= start && date <= end
+        }).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())
+      } catch {
+        // FTS5 search failed, fall through
+      }
+    }
+
+    // Fallback: use memory fetchAll with date filtering
+    try {
+      const allDecisions = await memory.fetchAllDecisions(project)
+      const allPatterns = await memory.fetchAllPatterns(project)
+      const allCorrections = await memory.fetchAllCorrections(project)
+
+      const allItems = [
+        ...allDecisions.map((d: any) => ({
+          id: d.id || d.decision_id,
+          content: d.decision || d.document || d.content || '',
+          category: 'decision',
+          project: d.project || project || DEFAULT_PROJECT,
+          created_at: d.created_at || d.date || '',
+        })),
+        ...allPatterns.map((p: any) => ({
+          id: p.id,
+          content: p.description || p.document || p.content || '',
+          category: p.pattern_type || 'pattern',
+          project: p.project || project || DEFAULT_PROJECT,
+          created_at: p.created_at || '',
+        })),
+        ...allCorrections.map((c: any) => ({
+          id: c.id,
+          content: c.original || c.document || c.content || '',
+          category: 'correction',
+          project: c.project || project || DEFAULT_PROJECT,
+          created_at: c.created_at || '',
+        })),
+      ]
+
+      return allItems.filter(item => {
+        if (!item.created_at) return true // include items without dates
+        const date = new Date(item.created_at)
+        if (isNaN(date.getTime())) return true
+        return date >= start && date <= end
+      }).sort((a, b) => {
+        const dateA = new Date(a.created_at || 0).getTime()
+        const dateB = new Date(b.created_at || 0).getTime()
+        return dateB - dateA
+      })
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Phase 27: Increment access count for an observation.
+   */
+  private incrementAccess(id: string): void {
+    try {
+      const memory = getMemoryService()
+      if (memory.fts5) {
+        memory.fts5.recordAccess(id)
+      }
+    } catch {
+      // Non-critical
+    }
+  }
+
   // ===== Helpers =====
 
+  /**
+   * Phase 29: Link a stored observation to code files (non-blocking, fire-and-forget).
+   */
+  private linkToCodeFiles(observationId: string, content: string, project: string): void {
+    try {
+      const linker = getCodeLinker()
+      if (linker) {
+        linker.linkObservation(observationId, content, project).catch(err => {
+          this.logger.debug({ err }, 'Code linkage failed (non-fatal)')
+        })
+      }
+    } catch {
+      // Linker not available
+    }
+  }
+
   private async writeToVault(
     project: string,
     decision: string,
@@ -1429,6 +1815,23 @@ export class BrainRouter {
     return matches
   }
 
+  /**
+   * Phase 30: Optionally compress content before storing.
+   * Returns the (possibly compressed) content and original if compressed.
+   */
+  private async maybeCompress(content: string, category: string): Promise<{ content: string; rawContent?: string }> {
+    if (!this.compressor) return { content }
+    try {
+      const result = await this.compressor.compress(content, category)
+      if (result.compressed) {
+        return { content: result.summary, rawContent: result.original }
+      }
+    } catch {
+      // Compression failed, use original
+    }
+    return { content }
+  }
+
   private generateTaskId(title: string): string {
     return title
       .toLowerCase()