Child1 Memory Sprint 1: Thread-Aware Multi-Expert Memory System

Duration: 2-3 Weeks | Goal: 96%+ Thread Re-entry, <5% Contamination

---

🎯 Sprint Goals

Transform Child1’s single memory_log.toml into a thread-aware, multi-expert memory system that solves our measured performance gaps:

Current Performance (Sprint 0 Baseline):

• ✅ Baseline Recall: 92% (PASS)
• ❌ Thread Switching: 88% (FAIL – target 96%+)
• ❌ Emotional Continuity: 50% (FAIL – target 80%+)

Sprint 1 Exit Criteria:

• Thread Re-entry: ≥96% (smooth topic resumption)
• Contamination: <5% (prevent irrelevant memory bleed)
• Context Efficiency: ↓ token usage while maintaining quality
• Backward Compatibility: No regression in current Child1 functionality

---

🏗️ Architecture Overview

Multi-Expert Memory Fusion

Based on our research, implement 4 specialized memory experts:

1. Session Expert: Recent conversation context (recency-weighted)
2. Semantic Expert: Motif and pattern matching (similarity-based)
3. Temporal Expert: Time-based relevance (decay functions)
4. Identity Expert: Person-specific memories (relationship-aware)

Thread-Aware Memory Model

@dataclass
class EnhancedMemoryEntry:
    # Existing fields preserved...
    thread_id: str           # Topic/conversation thread
    importance: float        # 0.0-1.0 salience score
    emotion: str            # Detected emotional state
    speaker: str            # "user" or "assistant"
    last_seen: datetime     # For recency calculations
    source_store: str       # "working", "episodic", "semantic"
    gene_sequence: str      # 16-char ATCG memory DNA (Phase 2 prep)

---

📅 Week-by-Week Implementation

Week 1: Core Multi-Expert Infrastructure

Day 1-2: Enhanced Memory Models

Owner: Enhanced existing files Files: functions/memory/memory_models.py, memory_buffers.py

Tasks:

• [ ] Add new fields to MemoryEntry dataclass
• [ ] Create ThreadAwareMemoryBuffer class with topic checkpoints
• [ ] Implement importance-aware retention (rank = 0.6·recency + 0.4·importance)
• [ ] Add push_thread_checkpoint() and get_recent_thread_memories() methods
• [ ] Ensure backward compatibility with existing memory log format

Test: Load existing memory_log.toml without errors, new fields optional

Day 3-4: Multi-Expert Memory Dispatcher

Owner: New orchestration layer Files: functions/memory/memory_dispatcher.py (major rewrite)

Tasks:

• [ ] Create MemoryContextPack class for fusion results
• [ ] Implement MemorySessionExpert, MemorySemanticExpert, MemoryTemporalExpert, MemoryIdentityExpert
• [ ] Build dispatch_memory_retrieval() with configurable expert weights
• [ ] Add reason codes (“Why this memory was chosen”)
• [ ] Load weights from /config/memory/memory_expert_weights.toml

Test: Expert fusion produces ranked memories with explanations

Day 5: Weighted Retrieval Scoring

Owner: Enhanced scoring algorithm Files: functions/memory_retrieval/resonance_calculator.py

Tasks:

• [ ] Implement calculate_memory_resonance() with α·β·γ·δ formula
• [ ] Add thread-awareness to similarity calculations
• [ ] Create motif bonus scoring mechanism
• [ ] Make scoring deterministic for testing (fixed seed support)

Test: Same query produces identical ranking across runs

Week 2: Thread Management & Context Rendering

Day 6-7: Thread-Aware Context Building

Owner: Enhanced context assembly Files: functions/prompts/unified_context.py, functions/context/speaker_context.py

Tasks:

• [ ] Implement render_memory_context_pack() with time/topic labels
• [ ] Add “why this memory” explanations in context
• [ ] Create thread detection in speaker_context.py
• [ ] Build topic switch detection with hysteresis (prevent flapping)

Test: Memory context clearly labeled with time/topic, no temporal confusion

Day 8-9: Wu Wei Gatekeeper & Predictive Echo

Owner: Enhanced retrieval intelligence Files: functions/memory_retrieval/wu_wei_gatekeeper.py, predictive_echo.py

Tasks:

• [ ] Implement thread-aware Wu Wei gatekeeper (knows when NOT to retrieve)
• [ ] Add predictive prefetch cache for likely thread resumptions
• [ ] Create thread prediction via softmax over recent activations
• [ ] Load thresholds from config (min_score_threshold, explicit_intent_boost)

Test: Over-retrieval prevented, thread switches prefetch correctly

Day 10: Aurora Integration

Owner: Connect cognitive monitoring Files: aurora/child1_triad_engine.py, memory dispatcher integration

Tasks:

• [ ] Integrate Aurora triad logging into memory retrieval process
• [ ] Add expert weight modulation based on triad state (g_C, g_E, g_R bounded to [0.8, 1.2])
• [ ] Log memory retrieval events to Aurora SQLite database
• [ ] Create triad-memory correlation metrics

Test: Memory retrieval logged to Aurora, triad influences expert weights

Week 3: Integration & Optimization

Day 11-12: End-to-End Integration

Owner: Connect all components Files: child1_main.py, integration testing

Tasks:

• [ ] Connect new memory system to Child1’s main processing loop
• [ ] Ensure seamless backward compatibility with existing workflows
• [ ] Add graceful fallbacks if new system fails
• [ ] Create migration path from old to new memory format

Test: Child1 runs normally, uses new memory system transparently

Day 13-14: Performance Optimization & Testing

Owner: Meet performance targets Files: All memory system files

Tasks:

• [ ] Optimize retrieval performance (target <500ms)
• [ ] Run full diagnostic test suite against Sprint 1 targets
• [ ] Debug any performance regressions
• [ ] Validate thread switching improvements

Test: All diagnostic suites show improvement toward targets

Day 15: Documentation & Sprint Review

Owner: Completion and handoff Files: Documentation, README updates

Tasks:

• [ ] Update user documentation with new memory capabilities
• [ ] Create technical documentation for memory experts
• [ ] Run final diagnostic comparison (Sprint 0 vs Sprint 1)
• [ ] Prepare Sprint 2 planning based on results

Test: Documentation complete, ready for Sprint 2 planning

---

🔧 Key Implementation Details

Configuration-Driven Expert Weights

# config/memory/memory_expert_weights.toml
[expert_weights]
alpha_recency = 0.20      # Temporal Expert
beta_importance = 0.40    # All experts (importance field)
gamma_similarity = 0.40   # Semantic Expert  
delta_motif = 0.10        # Semantic Expert (motif bonus)

[session_expert]
weight = 1.0              # Recent conversation priority
window_turns = 10         # How many recent turns to consider

[temporal_expert]
weight = 0.8              # Time-based relevance
decay_hours = 24.0        # Exponential decay constant

[semantic_expert]
weight = 1.2              # Pattern matching priority
motif_bonus_multiplier = 1.5

[identity_expert]
weight = 1.1              # Person-specific memory priority
relationship_boost = 0.3  # Boost for relationship context

Thread Checkpoint Mechanism

def push_thread_checkpoint(self, thread_id, summary):
    """Save thread state before topic switch"""
    self.topic_checkpoints[thread_id] = {
        'summary': summary,
        'timestamp': datetime.now(),
        'unresolved_commitments': self.extract_commitments(),
        'emotional_tone': self.detect_emotional_context(),
        'key_entities': self.extract_mentioned_entities(),
        'importance_level': self.calculate_thread_importance()
    }

Memory Context Pack Structure

@dataclass
class MemoryContextPack:
    memories: List[MemoryEntry]
    reason_codes: List[str]      # Why each memory was chosen
    expert_weights: Dict[str, float]  # Which experts contributed
    token_budget: int            # Total tokens used
    confidence: float           # Fusion confidence score
    thread_context: Optional[str] # Current thread identifier
    tr