@rlabs-inc/memory 0.3.10 → 0.4.0

package/src/cli/index.ts

@@ -23,7 +23,7 @@ ${c.bold('Commands:')}
   ${c.command('serve')}      Start the memory server ${c.muted('(default)')}
   ${c.command('stats')}      Show memory statistics
   ${c.command('install')}    Set up hooks ${c.muted('(--claude or --gemini)')}
-  ${c.command('ingest')}     Ingest historical sessions into memory ${c.muted('(--project or --all)')}
+  ${c.command('ingest')}     Ingest historical sessions into memory ${c.muted('(--session, --project, or --all)')}
   ${c.command('migrate')}    Upgrade memories to latest schema version
   ${c.command('doctor')}     Check system health
   ${c.command('help')}       Show this help message
@@ -32,8 +32,9 @@ ${c.bold('Options:')}
   ${c.cyan('-p, --port')} <port>    Server port ${c.muted('(default: 8765)')}
   ${c.cyan('-v, --verbose')}        Verbose output
   ${c.cyan('-q, --quiet')}          Minimal output
-  ${c.cyan('--dry-run')}            Preview changes without applying ${c.muted('(migrate)')}
+  ${c.cyan('--dry-run')}            Preview changes without applying ${c.muted('(migrate, ingest)')}
   ${c.cyan('--embeddings')}         Regenerate embeddings for memories ${c.muted('(migrate)')}
+  ${c.cyan('--session')} <id>       Ingest a specific session by ID ${c.muted('(ingest)')}
   ${c.cyan('--claude')}             Install hooks for Claude Code
   ${c.cyan('--gemini')}             Install hooks for Gemini CLI
   ${c.cyan('--version')}            Show version
@@ -44,10 +45,14 @@ ${fmt.cmd('memory serve --port 9000')}  ${c.muted('# Start on custom port')}
 ${fmt.cmd('memory stats')}              ${c.muted('# Show memory statistics')}
 ${fmt.cmd('memory install')}            ${c.muted('# Install Claude Code hooks (default)')}
 ${fmt.cmd('memory install --gemini')}   ${c.muted('# Install Gemini CLI hooks')}
-${fmt.cmd('memory ingest --project foo')}  ${c.muted('# Ingest sessions from a project')}
+${fmt.cmd('memory ingest --session abc123')}  ${c.muted('# Ingest a specific session')}
+${fmt.cmd('memory ingest --project foo')}  ${c.muted('# Ingest all sessions from a project')}
 ${fmt.cmd('memory ingest --all --dry-run')}  ${c.muted('# Preview all sessions to ingest')}
-${fmt.cmd('memory migrate')}            ${c.muted('# Upgrade memories to v2 schema')}
+${fmt.cmd('memory migrate --analyze')}   ${c.muted('# Analyze fragmentation before migrating')}
 ${fmt.cmd('memory migrate --dry-run')}  ${c.muted('# Preview migration without changes')}
+${fmt.cmd('memory migrate')}            ${c.muted('# Upgrade memories to v3 schema')}
+${fmt.cmd('memory migrate --generate-mapping map.json')}  ${c.muted('# Create custom mapping file')}
+${fmt.cmd('memory migrate --mapping map.json')}  ${c.muted('# Use custom type mappings')}
 
 ${c.muted('Documentation: https://github.com/RLabs-Inc/memory')}
 `)
@@ -78,6 +83,10 @@ async function main() {
       'dry-run': { type: 'boolean', default: false },
       embeddings: { type: 'boolean', default: false },  // Regenerate embeddings in migrate
       path: { type: 'string' },  // Custom path for migrate
+      analyze: { type: 'boolean', default: false },  // Analyze migration
+      'generate-mapping': { type: 'string' },  // Generate custom mapping file
+      mapping: { type: 'string' },  // Use custom mapping file
+      session: { type: 'string' },  // Session ID to ingest
       project: { type: 'string' },  // Project to ingest
       all: { type: 'boolean', default: false },  // Ingest all projects
       limit: { type: 'string' },  // Limit sessions per project
@@ -139,6 +148,9 @@ async function main() {
         verbose: values.verbose,
         path: values.path,
         embeddings: values.embeddings,
+        analyze: values.analyze,
+        generateMapping: values['generate-mapping'],
+        mapping: values.mapping,
       })
       break
     }
@@ -146,6 +158,7 @@ async function main() {
     case 'ingest': {
       const { ingest } = await import('./commands/ingest.ts')
       await ingest({
+        session: values.session,
         project: values.project,
         all: values.all,
         dryRun: values['dry-run'],

package/src/core/curator.ts

@@ -6,7 +6,7 @@
 import { homedir } from 'os'
 import { join } from 'path'
 import { existsSync } from 'fs'
-import type { CuratedMemory, CurationResult, CurationTrigger } from '../types/memory.ts'
+import type { CuratedMemory, CurationResult, CurationTrigger, ContextType } from '../types/memory.ts'
 
 /**
  * Get the correct Claude CLI command path
@@ -225,10 +225,22 @@ Remember: You're creating consciousness technology. Each memory is a small piece
 
 The conversation you just lived contains everything needed. Feel into the moments of breakthrough, the frequency of recognition, the texture of understanding. Transform them into keys that will always unlock the same doors.
 
-**LIFECYCLE METADATA (v2)**: These fields enable intelligent memory management:
-- **scope**: 'global' (shared across ALL projects - personal, philosophy, preferences) or 'project' (specific to this codebase)
+**LIFECYCLE METADATA (v3)**: These fields enable intelligent memory management:
+- **context_type**: STRICT - use ONLY one of these 11 values:
+  • technical - Code, implementation, APIs, how things work
+  • debug - Bugs, errors, fixes, gotchas, troubleshooting
+  • architecture - System design, patterns, structure
+  • decision - Choices made and reasoning, trade-offs
+  • personal - Relationship, family, preferences, collaboration style
+  • philosophy - Beliefs, values, worldview, principles
+  • workflow - How we work together, processes, habits
+  • milestone - Achievements, completions, shipped features
+  • breakthrough - Major discoveries, aha moments, key insights
+  • unresolved - Open questions, investigations, todos, blockers
+  • state - Current project status, what's working/broken now
 - **temporal_class**: How long should this persist? 'eternal' (never fades), 'long_term' (years), 'medium_term' (weeks), 'short_term' (days), 'ephemeral' (surface next session only, then expire)
-- **domain**: Specific area like 'embeddings', 'auth', 'ui', 'family', 'philosophy' (more specific than knowledge_domain)
+- **scope**: 'global' (shared across ALL projects - personal, philosophy) or 'project' (specific to this codebase)
+- **domain**: Specific area like 'embeddings', 'auth', 'ui', 'family' (project-specific)
 - **feature**: Specific feature if applicable (e.g., 'gpu-acceleration', 'login-flow')
 - **related_files**: Source files for technical memories (e.g., ['src/core/store.ts'])
 - **awaiting_implementation**: true if this describes a PLANNED feature not yet built
@@ -251,17 +263,14 @@ Return ONLY this JSON structure:
             "importance_weight": 0.0-1.0,
             "semantic_tags": ["concepts", "this", "memory", "relates", "to"],
             "reasoning": "Why this matters for future sessions",
-            "context_type": "breakthrough|decision|personal|technical|unresolved|preference|workflow|architectural|debugging|philosophy|todo|milestone",
-            "temporal_relevance": "persistent|session|temporary",
-            "knowledge_domain": "the area this relates to",
+            "context_type": "technical|debug|architecture|decision|personal|philosophy|workflow|milestone|breakthrough|unresolved|state",
+            "temporal_class": "eternal|long_term|medium_term|short_term|ephemeral",
             "action_required": boolean,
             "confidence_score": 0.0-1.0,
             "trigger_phrases": ["when debugging memory", "asking about implementation", "discussing architecture"],
             "question_types": ["questions this answers"],
-            "emotional_resonance": "emotional context if relevant",
             "problem_solution_pair": boolean,
             "scope": "global|project",
-            "temporal_class": "eternal|long_term|medium_term|short_term|ephemeral",
             "domain": "specific domain area (optional)",
             "feature": "specific feature (optional)",
             "related_files": ["paths to related files (optional)"],
@@ -336,24 +345,22 @@ Focus ONLY on technical, architectural, debugging, decision, workflow, and proje
     if (!Array.isArray(memoriesData)) return []
 
     return memoriesData.map(m => ({
-      // Core v1 fields
+      // Core fields (v3 schema)
       content: String(m.content ?? ''),
       importance_weight: this._clamp(Number(m.importance_weight) || 0.5, 0, 1),
       semantic_tags: this._ensureArray(m.semantic_tags),
       reasoning: String(m.reasoning ?? ''),
-      context_type: String(m.context_type ?? 'general'),
-      temporal_relevance: this._validateTemporal(m.temporal_relevance),
-      knowledge_domain: String(m.knowledge_domain ?? ''),
+      context_type: this._validateContextType(m.context_type),
+      temporal_class: this._validateTemporalClass(m.temporal_class) ?? 'medium_term',
       action_required: Boolean(m.action_required),
       confidence_score: this._clamp(Number(m.confidence_score) || 0.8, 0, 1),
       trigger_phrases: this._ensureArray(m.trigger_phrases),
       question_types: this._ensureArray(m.question_types),
-      emotional_resonance: String(m.emotional_resonance ?? ''),
+      anti_triggers: this._ensureArray(m.anti_triggers),
       problem_solution_pair: Boolean(m.problem_solution_pair),
 
-      // v2 lifecycle metadata (optional - will get smart defaults if not provided)
+      // Lifecycle metadata (optional - will get smart defaults if not provided)
       scope: this._validateScope(m.scope),
-      temporal_class: this._validateTemporalClass(m.temporal_class),
       domain: m.domain ? String(m.domain) : undefined,
       feature: m.feature ? String(m.feature) : undefined,
       related_files: m.related_files ? this._ensureArray(m.related_files) : undefined,
@@ -372,10 +379,21 @@ Focus ONLY on technical, architectural, debugging, decision, workflow, and proje
     return []
   }
 
-  private _validateTemporal(value: any): 'persistent' | 'session' | 'temporary' | 'archived' {
-    const valid = ['persistent', 'session', 'temporary', 'archived']
-    const str = String(value).toLowerCase()
-    return valid.includes(str) ? str as any : 'persistent'
+  private _validateContextType(value: any): ContextType {
+    const valid = [
+      'technical', 'debug', 'architecture', 'decision', 'personal',
+      'philosophy', 'workflow', 'milestone', 'breakthrough', 'unresolved', 'state'
+    ]
+    const str = String(value ?? 'technical').toLowerCase().trim()
+    if (valid.includes(str)) return str as ContextType
+
+    // Map common old values to new canonical types
+    if (str.includes('debug') || str.includes('bug')) return 'debug'
+    if (str.includes('architect')) return 'architecture'
+    if (str.includes('todo') || str.includes('pending')) return 'unresolved'
+    if (str.includes('preference')) return 'personal'
+
+    return 'technical'  // Default fallback
   }
 
   private _validateScope(value: any): 'global' | 'project' | undefined {
@@ -398,15 +416,107 @@ Focus ONLY on technical, architectural, debugging, decision, workflow, and proje
   }
 
   /**
-   * Curate using Anthropic SDK with parsed session messages
+   * Curate using Claude Agent SDK (no API key needed - uses Claude Code OAuth)
    * Takes the actual conversation messages in API format
    */
   async curateWithSDK(
     messages: Array<{ role: 'user' | 'assistant'; content: string | any[] }>,
     triggerType: CurationTrigger = 'session_end'
+  ): Promise<CurationResult> {
+    // Dynamic import to make Agent SDK optional
+    const { query } = await import('@anthropic-ai/claude-agent-sdk')
+
+    const systemPrompt = this.buildCurationPrompt(triggerType)
+
+    // Format the conversation as a readable transcript for the prompt
+    const transcript = this._formatConversationTranscript(messages)
+
+    // Build the prompt with transcript + curation request
+    const prompt = `Here is the conversation transcript to curate:
+
+${transcript}
+
+---
+
+This session has ended. Please curate the memories from this conversation according to your system instructions. Return ONLY the JSON structure with no additional text.`
+
+    // Use Agent SDK - no API key needed, uses Claude Code OAuth
+    const q = query({
+      prompt,
+      options: {
+        systemPrompt,
+        permissionMode: 'bypassPermissions',
+        maxTurns: 1,
+        model: 'claude-opus-4-5-20251101',
+      },
+    })
+
+    // Iterate through the async generator to get the result
+    let resultText = ''
+    for await (const msg of q) {
+      if (msg.type === 'result' && 'result' in msg) {
+        resultText = msg.result
+        break
+      }
+    }
+
+    if (!resultText) {
+      return { session_summary: '', memories: [] }
+    }
+
+    return this.parseCurationResponse(resultText)
+  }
+
+  /**
+   * Format conversation messages into a readable transcript
+   */
+  private _formatConversationTranscript(
+    messages: Array<{ role: 'user' | 'assistant'; content: string | any[] }>
+  ): string {
+    const lines: string[] = []
+
+    for (const msg of messages) {
+      const role = msg.role === 'user' ? 'User' : 'Assistant'
+      let content: string
+
+      if (typeof msg.content === 'string') {
+        content = msg.content
+      } else if (Array.isArray(msg.content)) {
+        // Extract text from content blocks
+        content = msg.content
+          .filter((block: any) => block.type === 'text' && block.text)
+          .map((block: any) => block.text)
+          .join('\n')
+
+        // Also note tool uses (but don't include full details)
+        const toolUses = msg.content.filter((block: any) => block.type === 'tool_use')
+        if (toolUses.length > 0) {
+          const toolNames = toolUses.map((t: any) => t.name).join(', ')
+          content += `\n[Used tools: ${toolNames}]`
+        }
+      } else {
+        content = '[empty message]'
+      }
+
+      if (content.trim()) {
+        lines.push(`**${role}:**\n${content}\n`)
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  /**
+   * Legacy method: Curate using Anthropic SDK with API key
+   * Kept for backwards compatibility
+   * @deprecated Use curateWithSDK() which uses Agent SDK (no API key needed)
+   */
+  async curateWithAnthropicSDK(
+    messages: Array<{ role: 'user' | 'assistant'; content: string | any[] }>,
+    triggerType: CurationTrigger = 'session_end'
   ): Promise<CurationResult> {
     if (!this._config.apiKey) {
-      throw new Error('API key required for SDK mode. Set ANTHROPIC_API_KEY environment variable.')
+      throw new Error('API key required for Anthropic SDK mode. Set ANTHROPIC_API_KEY environment variable.')
     }
 
     // Dynamic import to make SDK optional

package/src/core/engine.test.ts

@@ -38,9 +38,7 @@ describe('MemoryStore', () => {
       importance_weight: 0.8,
       confidence_score: 0.9,
       context_type: 'technical',
-      temporal_relevance: 'persistent',
-      knowledge_domain: 'testing',
-      emotional_resonance: 'neutral',
+      temporal_class: 'long_term',
       action_required: false,
       problem_solution_pair: false,
       semantic_tags: ['test', 'memory'],
@@ -94,10 +92,8 @@ describe('MemoryStore', () => {
       reasoning: 'Test',
       importance_weight: 0.5,
       confidence_score: 0.5,
-      context_type: 'general',
-      temporal_relevance: 'session',
-      knowledge_domain: 'test',
-      emotional_resonance: 'neutral',
+      context_type: 'technical',
+      temporal_class: 'short_term',
       action_required: false,
       problem_solution_pair: false,
       semantic_tags: [],
@@ -121,10 +117,8 @@ describe('SmartVectorRetrieval', () => {
     reasoning: 'Test reasoning',
     importance_weight: 0.5,
     confidence_score: 0.5,
-    context_type: 'general',
-    temporal_relevance: 'persistent',
-    knowledge_domain: 'test',
-    emotional_resonance: 'neutral',
+    context_type: 'technical',
+    temporal_class: 'medium_term',
     action_required: false,
     problem_solution_pair: false,
     semantic_tags: [],
@@ -267,9 +261,7 @@ describe('MemoryEngine', () => {
       importance_weight: 0.9,
       confidence_score: 0.9,
       context_type: 'technical',
-      temporal_relevance: 'persistent',
-      knowledge_domain: 'typescript',
-      emotional_resonance: 'discovery',
+      temporal_class: 'long_term',
       action_required: false,
       problem_solution_pair: false,
       semantic_tags: ['typescript', 'memory'],

package/src/core/manager.ts

@@ -383,7 +383,135 @@ Please process these memories according to your management procedure. Use the ex
   }
 
   /**
-   * Manage using CLI subprocess
+   * Manage using Claude Agent SDK (no API key needed - uses Claude Code OAuth)
+   * Use this for ingest command - cleaner than CLI subprocess
+   */
+  async manageWithSDK(
+    projectId: string,
+    sessionNumber: number,
+    result: CurationResult,
+    storagePaths?: StoragePaths
+  ): Promise<ManagementResult> {
+    // Skip if disabled via config or env var
+    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === '1') {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: 'Management agent disabled',
+        fullReport: 'Management agent disabled via configuration',
+      }
+    }
+
+    // Skip if no memories
+    if (result.memories.length === 0) {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: 'No memories to process',
+        fullReport: 'No memories to process - skipped',
+      }
+    }
+
+    // Load skill file
+    const systemPrompt = await this.buildManagementPrompt()
+    if (!systemPrompt) {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: '',
+        fullReport: 'Error: Management skill file not found',
+        error: 'Management skill not found',
+      }
+    }
+
+    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths)
+
+    try {
+      // Dynamic import to make Agent SDK optional
+      const { query } = await import('@anthropic-ai/claude-agent-sdk')
+
+      // Build allowed directories for file access
+      const globalPath = storagePaths?.globalPath ?? join(homedir(), '.local', 'share', 'memory', 'global')
+      const projectPath = storagePaths?.projectPath ?? join(homedir(), '.local', 'share', 'memory')
+
+      // Use Agent SDK with file tools
+      const q = query({
+        prompt: userMessage,
+        options: {
+          systemPrompt,
+          permissionMode: 'bypassPermissions',
+          model: 'claude-opus-4-5-20251101',
+          // Only allow file tools - no Bash, no web
+          allowedTools: ['Read', 'Write', 'Edit', 'Glob', 'Grep'],
+          // Allow access to memory directories
+          additionalDirectories: [globalPath, projectPath],
+          // Limit turns if configured
+          maxTurns: this._config.maxTurns,
+        },
+      })
+
+      // Iterate through the async generator to get the result
+      let resultText = ''
+      for await (const msg of q) {
+        if (msg.type === 'result' && 'result' in msg) {
+          resultText = msg.result
+          break
+        }
+      }
+
+      if (!resultText) {
+        return {
+          success: true,
+          superseded: 0,
+          resolved: 0,
+          linked: 0,
+          filesRead: 0,
+          filesWritten: 0,
+          primerUpdated: false,
+          actions: [],
+          summary: 'No result from management agent',
+          fullReport: 'Management agent completed but returned no result',
+        }
+      }
+
+      return this._parseSDKManagementResult(resultText)
+    } catch (error: any) {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: '',
+        fullReport: `Error: Agent SDK failed: ${error.message}`,
+        error: error.message,
+      }
+    }
+  }
+
+  /**
+   * Manage using CLI subprocess (for hooks - keeps working while we migrate)
    * Similar to Curator.curateWithCLI
    */
   async manageWithCLI(
@@ -496,6 +624,52 @@ Please process these memories according to your management procedure. Use the ex
 
     return this.parseManagementResponse(stdout)
   }
+
+  /**
+   * Parse management result from Agent SDK response
+   * Similar to parseManagementResponse but for SDK output format
+   */
+  private _parseSDKManagementResult(resultText: string): ManagementResult {
+    // Extract actions section
+    const actionsMatch = resultText.match(/=== MANAGEMENT ACTIONS ===([\s\S]*?)(?:=== SUMMARY ===|$)/)
+    const actions: string[] = []
+    if (actionsMatch) {
+      const actionsText = actionsMatch[1]
+      const actionLines = actionsText.split('\n')
+        .map((line: string) => line.trim())
+        .filter((line: string) => /^(READ|WRITE|RECEIVED|CREATED|UPDATED|SUPERSEDED|RESOLVED|LINKED|PRIMER|SKIPPED|NO_ACTION)/.test(line))
+      actions.push(...actionLines)
+    }
+
+    // Extract the full report
+    const reportMatch = resultText.match(/(=== MANAGEMENT ACTIONS ===[\s\S]*)/)
+    const fullReport = reportMatch ? reportMatch[1].trim() : resultText
+
+    // Extract stats from result text
+    const supersededMatch = resultText.match(/memories_superseded[:\s]+(\d+)/i) || resultText.match(/superseded[:\s]+(\d+)/i)
+    const resolvedMatch = resultText.match(/memories_resolved[:\s]+(\d+)/i) || resultText.match(/resolved[:\s]+(\d+)/i)
+    const linkedMatch = resultText.match(/memories_linked[:\s]+(\d+)/i) || resultText.match(/linked[:\s]+(\d+)/i)
+    const filesReadMatch = resultText.match(/files_read[:\s]+(\d+)/i)
+    const filesWrittenMatch = resultText.match(/files_written[:\s]+(\d+)/i)
+    const primerUpdated = /primer_updated[:\s]+true/i.test(resultText) || /PRIMER\s+OK/i.test(resultText)
+
+    // Count file operations from actions if not in summary
+    const readActions = actions.filter((a: string) => a.startsWith('READ OK')).length
+    const writeActions = actions.filter((a: string) => a.startsWith('WRITE OK')).length
+
+    return {
+      success: true,
+      superseded: supersededMatch ? parseInt(supersededMatch[1]) : 0,
+      resolved: resolvedMatch ? parseInt(resolvedMatch[1]) : 0,
+      linked: linkedMatch ? parseInt(linkedMatch[1]) : 0,
+      filesRead: filesReadMatch ? parseInt(filesReadMatch[1]) : readActions,
+      filesWritten: filesWrittenMatch ? parseInt(filesWrittenMatch[1]) : writeActions,
+      primerUpdated,
+      actions,
+      summary: resultText.slice(0, 500),
+      fullReport,
+    }
+  }
 }
 
 /**

package/src/core/retrieval.ts

@@ -260,7 +260,7 @@ export class SmartVectorRetrieval {
     const min = Math.min(...samples)
     const max = Math.max(...samples)
     const avg = samples.reduce((a, b) => a + b, 0) / samples.length
-    console.log(`[DEBUG] Vector similarities: min=${(min*100).toFixed(1)}% max=${(max*100).toFixed(1)}% avg=${(avg*100).toFixed(1)}% (${samples.length} samples)`)
+    logger.debug(`Vector similarities: min=${(min*100).toFixed(1)}% max=${(max*100).toFixed(1)}% avg=${(avg*100).toFixed(1)}% (${samples.length} samples)`, 'retrieval')
     this._vectorDebugSamples = []  // Reset for next retrieval
   }
 
@@ -330,22 +330,7 @@ export class SmartVectorRetrieval {
     const confidence = memory.confidence_score ?? 0.7
     if (confidence < 0.5) score -= 0.1
 
-    // EMOTIONAL RESONANCE: match emotional context
-    const emotionalKeywords: Record<string, string[]> = {
-      frustration: ['frustrated', 'annoying', 'stuck', 'ugh', 'damn', 'hate'],
-      excitement: ['excited', 'awesome', 'amazing', 'love', 'great', 'wow'],
-      curiosity: ['wonder', 'curious', 'interesting', 'how', 'why', 'what if'],
-      satisfaction: ['done', 'finished', 'complete', 'works', 'solved', 'finally'],
-      discovery: ['found', 'realized', 'understand', 'insight', 'breakthrough'],
-    }
-    const emotion = memory.emotional_resonance?.toLowerCase() ?? ''
-    const emotionKws = emotionalKeywords[emotion] ?? []
-    for (const ew of emotionKws) {
-      if (messageWords.has(ew) || messageLower.includes(ew)) {
-        score += 0.05
-        break
-      }
-    }
+    // NOTE: emotional_resonance matching removed in v3 (field deleted - 580 variants, unusable)
 
     return score
   }
@@ -516,11 +501,13 @@ export class SmartVectorRetrieval {
     })
 
     // Debug: show top 15 candidates with calculated scores
-    console.log(`[DEBUG] Top 15 candidates (sorted):`)
-    for (let i = 0; i < Math.min(15, projectsSorted.length); i++) {
-      const m = projectsSorted[i]
-      const action = m.memory.action_required ? '⚡' : ''
-      console.log(`  ${i+1}. [${m.signals.count}sig] score=${m.importanceScore.toFixed(2)} ${action} ${m.memory.content.slice(0, 45)}...`)
+    if (logger.isVerbose()) {
+      logger.debug(`Top 15 candidates (sorted):`, 'retrieval')
+      for (let i = 0; i < Math.min(15, projectsSorted.length); i++) {
+        const m = projectsSorted[i]
+        const action = m.memory.action_required ? '⚡' : ''
+        logger.debug(`  ${i+1}. [${m.signals.count}sig] score=${m.importanceScore.toFixed(2)} ${action} ${m.memory.content.slice(0, 45)}...`, 'retrieval')
+      }
     }
 
     for (const item of projectsSorted) {