@rlabs-inc/memory 0.3.11 → 0.4.1

package/src/cli/index.ts

@@ -48,8 +48,11 @@ ${fmt.cmd('memory install --gemini')}   ${c.muted('# Install Gemini CLI hooks')}
 ${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')}
 `)
@@ -80,6 +83,9 @@ 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
@@ -142,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
     }

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 {

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/retrieval.ts

@@ -27,6 +27,7 @@ interface ActivationSignals {
   domain: boolean       // Domain word found in message
   feature: boolean      // Feature word found in message
   content: boolean      // Key content words found in message
+  files: boolean        // Related file path matched
   count: number         // Total signals activated
   triggerStrength: number  // How strong the trigger match was (0-1)
   tagCount: number      // How many tags matched
@@ -99,8 +100,54 @@ export class SmartVectorRetrieval {
     return new Set(words)
   }
 
+  /**
+   * Extract file paths from message
+   * Matches patterns like /path/to/file.ts, src/core/engine.ts, ./relative/path
+   */
+  private _extractFilePaths(text: string): Set<string> {
+    const paths = new Set<string>()
+    // Match file paths (with / or \ separators, optional extension)
+    const pathPattern = /(?:^|[\s'"(])([.\/\\]?(?:[\w.-]+[\/\\])+[\w.-]+(?:\.\w+)?)/g
+    let match
+    while ((match = pathPattern.exec(text)) !== null) {
+      const path = match[1].toLowerCase()
+      paths.add(path)
+      // Also add just the filename for partial matching
+      const filename = path.split(/[\/\\]/).pop()
+      if (filename) paths.add(filename)
+    }
+    return paths
+  }
+
+  /**
+   * Check if related_files activate for this message
+   */
+  private _checkFilesActivation(
+    messagePaths: Set<string>,
+    relatedFiles: string[] | undefined
+  ): boolean {
+    if (!relatedFiles?.length || !messagePaths.size) return false
+
+    for (const file of relatedFiles) {
+      const fileLower = file.toLowerCase()
+      // Check if any message path matches this file
+      for (const msgPath of messagePaths) {
+        if (fileLower.includes(msgPath) || msgPath.includes(fileLower)) {
+          return true
+        }
+      }
+      // Also check just the filename
+      const filename = fileLower.split(/[\/\\]/).pop()
+      if (filename && messagePaths.has(filename)) {
+        return true
+      }
+    }
+    return false
+  }
+
   /**
    * Pre-filter: Binary exclusions based on v2 lifecycle fields
+   * NOTE: superseded_by memories are NOT filtered here - they get redirected in Phase 1
    */
   private _preFilter(
     memories: StoredMemory[],
@@ -110,7 +157,7 @@ export class SmartVectorRetrieval {
     return memories.filter(memory => {
       if (memory.status && memory.status !== 'active') return false
       if (memory.exclude_from_retrieval === true) return false
-      if (memory.superseded_by) return false
+      // NOTE: Don't filter superseded_by here - we handle redirects in Phase 1
       const isGlobal = memory.scope === 'global' || memory.project_id === 'global'
       if (!isGlobal && memory.project_id !== currentProjectId) return false
       if (memory.anti_triggers?.length) {
@@ -330,22 +377,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
   }
@@ -370,6 +402,13 @@ export class SmartVectorRetrieval {
 
     const messageLower = currentMessage.toLowerCase()
     const messageWords = this._extractSignificantWords(currentMessage)
+    const messagePaths = this._extractFilePaths(currentMessage)
+
+    // Build lookup map for redirect resolution
+    const memoryById = new Map<string, StoredMemory>()
+    for (const m of allMemories) {
+      memoryById.set(m.id, m)
+    }
 
     // ================================================================
     // PHASE 0: PRE-FILTER (Binary exclusions)
@@ -383,13 +422,13 @@ export class SmartVectorRetrieval {
     // PHASE 1: ACTIVATION SIGNALS
     // Count how many signals agree this memory should activate
     // A memory is relevant if >= MIN_ACTIVATION_SIGNALS fire
+    // Handles redirects for superseded_by/resolved_by
     // ================================================================
     const activatedMemories: ActivatedMemory[] = []
+    const activatedIds = new Set<string>()
     let rejectedCount = 0
 
     for (const memory of candidates) {
-      const isGlobal = memory.scope === 'global' || memory.project_id === 'global'
-
       // Check each activation signal
       const triggerResult = this._checkTriggerActivation(
         messageLower, messageWords, memory.trigger_phrases ?? []
@@ -404,15 +443,17 @@ export class SmartVectorRetrieval {
         messageLower, messageWords, memory.feature
       )
       const contentActivated = this._checkContentActivation(messageWords, memory)
+      const filesActivated = this._checkFilesActivation(messagePaths, memory.related_files)
       const vectorSimilarity = this._calculateVectorSimilarity(queryEmbedding, memory.embedding)
 
-      // Count activated signals
+      // Count activated signals (now 7 possible signals)
       let signalCount = 0
       if (triggerResult.activated) signalCount++
       if (tagResult.activated) signalCount++
       if (domainActivated) signalCount++
       if (featureActivated) signalCount++
       if (contentActivated) signalCount++
+      if (filesActivated) signalCount++
       // Vector similarity as bonus signal only if very high
       if (vectorSimilarity >= 0.40) signalCount++
 
@@ -422,6 +463,7 @@ export class SmartVectorRetrieval {
         domain: domainActivated,
         feature: featureActivated,
         content: contentActivated,
+        files: filesActivated,
         count: signalCount,
         triggerStrength: triggerResult.strength,
         tagCount: tagResult.count,
@@ -434,15 +476,34 @@ export class SmartVectorRetrieval {
         continue
       }
 
+      // REDIRECT: If superseded_by or resolved_by exists, surface the replacement instead
+      let memoryToSurface = memory
+      if (memory.superseded_by || memory.resolved_by) {
+        const replacementId = memory.superseded_by ?? memory.resolved_by
+        const replacement = replacementId ? memoryById.get(replacementId) : undefined
+        if (replacement && replacement.status !== 'archived' && replacement.status !== 'deprecated') {
+          memoryToSurface = replacement
+          logger.debug(`Redirect: ${memory.id.slice(-8)} → ${replacement.id.slice(-8)} (${memory.superseded_by ? 'superseded' : 'resolved'})`, 'retrieval')
+        }
+      }
+
+      // Skip if we already added this memory (could happen from multiple redirects)
+      if (activatedIds.has(memoryToSurface.id)) {
+        continue
+      }
+
+      const isGlobal = memoryToSurface.scope === 'global' || memoryToSurface.project_id === 'global'
+
       // Calculate importance for ranking (Phase 2) - uses ALL rich metadata
-      const importanceScore = this._calculateImportanceScore(memory, signalCount, messageLower, messageWords)
+      const importanceScore = this._calculateImportanceScore(memoryToSurface, signalCount, messageLower, messageWords)
 
       activatedMemories.push({
-        memory,
+        memory: memoryToSurface,
         signals,
         importanceScore,
         isGlobal,
       })
+      activatedIds.add(memoryToSurface.id)
     }
 
     // Log diagnostics
@@ -532,23 +593,60 @@ export class SmartVectorRetrieval {
       selectedIds.add(item.memory.id)
     }
 
-    // PHASE 4: RELATED MEMORIES (if space remains)
+    // PHASE 4: LINKED MEMORIES (related_to, blocked_by, blocks)
+    // Pull in linked memories when space remains
     if (selected.length < maxMemories) {
-      const relatedIds = new Set<string>()
+      const linkedIds = new Set<string>()
+
       for (const item of selected) {
+        // related_to - explicit relationships
         for (const relatedId of item.memory.related_to ?? []) {
           if (!selectedIds.has(relatedId)) {
-            relatedIds.add(relatedId)
+            linkedIds.add(relatedId)
+          }
+        }
+        // blocked_by - show what's blocking this
+        if (item.memory.blocked_by && !selectedIds.has(item.memory.blocked_by)) {
+          linkedIds.add(item.memory.blocked_by)
+        }
+        // blocks - show what this blocks
+        for (const blockedId of item.memory.blocks ?? []) {
+          if (!selectedIds.has(blockedId)) {
+            linkedIds.add(blockedId)
           }
         }
       }
 
+      // First try to find linked memories in the activated list
       for (const item of activatedMemories) {
         if (selected.length >= maxMemories) break
         if (selectedIds.has(item.memory.id)) continue
-        if (relatedIds.has(item.memory.id)) {
+        if (linkedIds.has(item.memory.id)) {
           selected.push(item)
           selectedIds.add(item.memory.id)
+          logger.debug(`Linked: ${item.memory.id.slice(-8)} pulled by relationship`, 'retrieval')
+        }
+      }
+
+      // If linked memories weren't in activated list, pull them directly from allMemories
+      // (they might not have activated on their own but are important for context)
+      if (selected.length < maxMemories) {
+        for (const linkedId of linkedIds) {
+          if (selected.length >= maxMemories) break
+          if (selectedIds.has(linkedId)) continue
+
+          const linkedMemory = memoryById.get(linkedId)
+          if (linkedMemory && linkedMemory.status !== 'archived' && linkedMemory.status !== 'deprecated') {
+            const isGlobal = linkedMemory.scope === 'global' || linkedMemory.project_id === 'global'
+            selected.push({
+              memory: linkedMemory,
+              signals: { trigger: false, tags: false, domain: false, feature: false, content: false, files: false, count: 0, triggerStrength: 0, tagCount: 0, vectorSimilarity: 0 },
+              importanceScore: linkedMemory.importance_weight ?? 0.5,
+              isGlobal,
+            })
+            selectedIds.add(linkedId)
+            logger.debug(`Linked (direct): ${linkedId.slice(-8)} pulled for context`, 'retrieval')
+          }
         }
       }
     }
@@ -581,6 +679,7 @@ export class SmartVectorRetrieval {
           domain: item.signals.domain,
           feature: item.signals.feature,
           content: item.signals.content,
+          files: item.signals.files,
           vector: item.signals.vectorSimilarity >= 0.40,
           vectorSimilarity: item.signals.vectorSimilarity,
         },
@@ -590,8 +689,8 @@ export class SmartVectorRetrieval {
     // Convert to RetrievalResult format
     return selected.map(item => ({
       ...item.memory,
-      score: item.signals.count / 6,
-      relevance_score: item.signals.count / 6,
+      score: item.signals.count / 7,  // 7 possible signals
+      relevance_score: item.signals.count / 7,
       value_score: item.importanceScore,
     }))
   }
@@ -607,6 +706,7 @@ export class SmartVectorRetrieval {
     if (signals.domain) reasons.push('domain')
     if (signals.feature) reasons.push('feature')
     if (signals.content) reasons.push('content')
+    if (signals.files) reasons.push('files')
     if (signals.vectorSimilarity >= 0.40) reasons.push(`vector:${(signals.vectorSimilarity * 100).toFixed(0)}%`)
 
     return reasons.length
@@ -623,20 +723,21 @@ export class SmartVectorRetrieval {
     rejectedCount: number
   ): void {
     const signalBuckets: Record<string, number> = {
-      '2 signals': 0, '3 signals': 0, '4 signals': 0, '5 signals': 0, '6 signals': 0
+      '2 signals': 0, '3 signals': 0, '4 signals': 0, '5 signals': 0, '6 signals': 0, '7 signals': 0
     }
     for (const mem of activated) {
-      const key = `${Math.min(mem.signals.count, 6)} signals`
+      const key = `${Math.min(mem.signals.count, 7)} signals`
       signalBuckets[key] = (signalBuckets[key] ?? 0) + 1
     }
 
-    let triggerCount = 0, tagCount = 0, domainCount = 0, featureCount = 0, contentCount = 0, vectorCount = 0
+    let triggerCount = 0, tagCount = 0, domainCount = 0, featureCount = 0, contentCount = 0, filesCount = 0, vectorCount = 0
     for (const mem of activated) {
       if (mem.signals.trigger) triggerCount++
       if (mem.signals.tags) tagCount++
       if (mem.signals.domain) domainCount++
       if (mem.signals.feature) featureCount++
       if (mem.signals.content) contentCount++
+      if (mem.signals.files) filesCount++
       if (mem.signals.vectorSimilarity >= 0.40) vectorCount++
     }
 
@@ -660,6 +761,7 @@ export class SmartVectorRetrieval {
         domain: domainCount,
         feature: featureCount,
         content: contentCount,
+        files: filesCount,
         vector: vectorCount,
         total: activated.length,
       },

package/src/core/store.ts

@@ -177,9 +177,7 @@ export class MemoryStore {
       importance_weight: record.importance_weight,
       confidence_score: record.confidence_score,
       context_type: record.context_type as StoredMemory['context_type'],
-      temporal_relevance: record.temporal_relevance as StoredMemory['temporal_relevance'],
-      knowledge_domain: record.knowledge_domain as StoredMemory['knowledge_domain'],
-      emotional_resonance: record.emotional_resonance as StoredMemory['emotional_resonance'],
+      temporal_class: record.temporal_class as StoredMemory['temporal_class'],
       action_required: record.action_required,
       problem_solution_pair: record.problem_solution_pair,
       semantic_tags: record.semantic_tags,
@@ -211,30 +209,28 @@ export class MemoryStore {
     const typeDefaults = V2_DEFAULTS.typeDefaults[contextType] ?? V2_DEFAULTS.typeDefaults.personal
 
     const id = memories.insert({
-      // Core v1 fields
+      // Core fields
       content: memory.content,
       reasoning: memory.reasoning,
       importance_weight: memory.importance_weight,
       confidence_score: memory.confidence_score,
       context_type: memory.context_type,
-      temporal_relevance: memory.temporal_relevance,
-      knowledge_domain: memory.knowledge_domain,
-      emotional_resonance: memory.emotional_resonance,
+      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? 'eternal',
       action_required: memory.action_required,
       problem_solution_pair: memory.problem_solution_pair,
       semantic_tags: memory.semantic_tags,
       trigger_phrases: memory.trigger_phrases,
       question_types: memory.question_types,
+      anti_triggers: memory.anti_triggers ?? [],
       session_id: sessionId,
       project_id: 'global',
       embedding: embedding
         ? (embedding instanceof Float32Array ? embedding : new Float32Array(embedding))
         : null,
 
-      // v2 lifecycle fields - global memories are always scope: 'global'
+      // Lifecycle fields - global memories are always scope: 'global'
       status: V2_DEFAULTS.fallback.status,
       scope: 'global',  // Always global for global memories
-      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? 'eternal',
       fade_rate: typeDefaults?.fade_rate ?? 0,  // Global memories typically don't fade
       session_created: sessionNumber ?? 0,
       session_updated: sessionNumber ?? 0,
@@ -244,18 +240,15 @@ export class MemoryStore {
       related_files: memory.related_files ?? [],
       awaiting_implementation: memory.awaiting_implementation ?? false,
       awaiting_decision: memory.awaiting_decision ?? false,
-      retrieval_weight: memory.importance_weight,
       exclude_from_retrieval: false,
       schema_version: MEMORY_SCHEMA_VERSION,
 
-      // Initialize empty relationship fields
+      // Relationship fields
       supersedes: null,
       superseded_by: null,
       related_to: [],
       resolves: [],
       resolved_by: null,
-      parent_id: null,
-      child_ids: [],
       blocked_by: null,
       blocks: [],
     })
@@ -491,30 +484,28 @@ export class MemoryStore {
     const typeDefaults = V2_DEFAULTS.typeDefaults[contextType] ?? V2_DEFAULTS.typeDefaults.technical
 
     const id = memories.insert({
-      // Core v1 fields
+      // Core fields
       content: memory.content,
       reasoning: memory.reasoning,
       importance_weight: memory.importance_weight,
       confidence_score: memory.confidence_score,
       context_type: memory.context_type,
-      temporal_relevance: memory.temporal_relevance,
-      knowledge_domain: memory.knowledge_domain,
-      emotional_resonance: memory.emotional_resonance,
+      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? V2_DEFAULTS.fallback.temporal_class,
       action_required: memory.action_required,
       problem_solution_pair: memory.problem_solution_pair,
       semantic_tags: memory.semantic_tags,
       trigger_phrases: memory.trigger_phrases,
       question_types: memory.question_types,
+      anti_triggers: memory.anti_triggers ?? [],
       session_id: sessionId,
       project_id: projectId,
       embedding: embedding
         ? (embedding instanceof Float32Array ? embedding : new Float32Array(embedding))
         : null,
 
-      // v2 lifecycle fields - use curator-provided values or smart defaults
+      // Lifecycle fields - use curator-provided values or smart defaults
       status: V2_DEFAULTS.fallback.status,
       scope: memory.scope ?? typeDefaults?.scope ?? V2_DEFAULTS.fallback.scope,
-      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? V2_DEFAULTS.fallback.temporal_class,
       fade_rate: typeDefaults?.fade_rate ?? V2_DEFAULTS.fallback.fade_rate,
       session_created: sessionNumber ?? 0,
       session_updated: sessionNumber ?? 0,
@@ -524,18 +515,15 @@ export class MemoryStore {
       related_files: memory.related_files ?? [],
       awaiting_implementation: memory.awaiting_implementation ?? false,
       awaiting_decision: memory.awaiting_decision ?? false,
-      retrieval_weight: memory.importance_weight,  // Start with importance as retrieval weight
       exclude_from_retrieval: false,
       schema_version: MEMORY_SCHEMA_VERSION,
 
-      // Initialize empty relationship fields
+      // Relationship fields
       supersedes: null,
       superseded_by: null,
       related_to: [],
       resolves: [],
       resolved_by: null,
-      parent_id: null,
-      child_ids: [],
       blocked_by: null,
       blocks: [],
     })
@@ -556,9 +544,7 @@ export class MemoryStore {
       importance_weight: record.importance_weight,
       confidence_score: record.confidence_score,
       context_type: record.context_type as StoredMemory['context_type'],
-      temporal_relevance: record.temporal_relevance as StoredMemory['temporal_relevance'],
-      knowledge_domain: record.knowledge_domain as StoredMemory['knowledge_domain'],
-      emotional_resonance: record.emotional_resonance as StoredMemory['emotional_resonance'],
+      temporal_class: record.temporal_class as StoredMemory['temporal_class'],
       action_required: record.action_required,
       problem_solution_pair: record.problem_solution_pair,
       semantic_tags: record.semantic_tags,
@@ -596,9 +582,7 @@ export class MemoryStore {
           importance_weight: record.importance_weight,
           confidence_score: record.confidence_score,
           context_type: record.context_type as StoredMemory['context_type'],
-          temporal_relevance: record.temporal_relevance as StoredMemory['temporal_relevance'],
-          knowledge_domain: record.knowledge_domain as StoredMemory['knowledge_domain'],
-          emotional_resonance: record.emotional_resonance as StoredMemory['emotional_resonance'],
+          temporal_class: record.temporal_class as StoredMemory['temporal_class'],
           action_required: record.action_required,
           problem_solution_pair: record.problem_solution_pair,
           semantic_tags: record.semantic_tags,
@@ -620,9 +604,7 @@ export class MemoryStore {
       importance_weight: result.record.importance_weight,
       confidence_score: result.record.confidence_score,
       context_type: result.record.context_type as StoredMemory['context_type'],
-      temporal_relevance: result.record.temporal_relevance as StoredMemory['temporal_relevance'],
-      knowledge_domain: result.record.knowledge_domain as StoredMemory['knowledge_domain'],
-      emotional_resonance: result.record.emotional_resonance as StoredMemory['emotional_resonance'],
+      temporal_class: result.record.temporal_class as StoredMemory['temporal_class'],
       action_required: result.record.action_required,
       problem_solution_pair: result.record.problem_solution_pair,
       semantic_tags: result.record.semantic_tags,