@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/.project/docs/PHASE-4-2-LEARNING-SYSTEM.md

@@ -0,0 +1,881 @@
+# Phase 4.2: Learning System - Project Goals & Feature Details
+
+**Phase:** 4.2 - Enhanced Intelligence (Learning System)
+**Status:** 📋 Planning
+**Prerequisites:** Phase 4.1 (Smart Question Filtering) ✅ Complete
+**Target Version:** v0.4.0 or v0.5.0
+**Estimated Effort:** Medium (2-3 sessions)
+
+---
+
+## 🎯 Overview
+
+Build an intelligent learning system that tracks user behavior during interviews and uses that data to continuously improve question filtering accuracy. The system learns which questions users skip manually, identifies patterns across sessions, and adapts filtering rules to match user preferences and project-specific needs.
+
+### Vision Statement
+
+"The interview should get smarter with every session, learning from user behavior to skip questions they consistently don't need, while never losing the ability to ask important questions."
+
+---
+
+## 📊 Problem Statement
+
+### Current Limitations (Phase 4.1)
+
+**Smart Filtering is Rule-Based:**
+- Fixed rules per project type (CLI skips UI, API skips frontend)
+- No personalization or adaptation
+- Can't learn from user behavior
+- May filter too aggressively or not enough
+- No cross-session memory
+
+**User Pain Points:**
+1. Users still manually skip some "relevant" questions that aren't useful for their specific use case
+2. Some questions marked as skipped might actually be important for certain hybrid projects
+3. No way to remember user preferences across sessions
+4. Generic rules don't account for team-specific workflows
+5. Can't learn from patterns (e.g., "User always skips deployment questions for prototypes")
+
+### Example Scenarios
+
+**Scenario 1: Prototype Projects**
+- User working on quick prototypes consistently skips deployment, testing, CI/CD questions
+- Current system: Asks these questions every time (they're "relevant" for the project type)
+- Desired: Learn that this user/project skips these topics and filter them proactively
+
+**Scenario 2: Solo Developer vs Team**
+- Solo developer consistently skips collaboration, code review, team size questions
+- Current system: Asks these every time
+- Desired: Detect solo developer pattern and reduce these questions
+
+**Scenario 3: Framework-Specific Workflows**
+- User with Next.js project consistently skips questions about bundlers, routing setup
+- Current system: Asks because they're web app questions
+- Desired: Learn Next.js includes these features, skip the questions
+
+---
+
+## 🎯 Goals
+
+### Primary Goals
+
+1. **Track User Behavior**
+   - Record which questions users skip manually
+   - Track which filtered questions users view/expand
+   - Measure time spent on each question
+   - Identify patterns in skip behavior
+
+2. **Learn Patterns**
+   - Identify questions consistently skipped by user
+   - Detect project-type specific patterns
+   - Learn framework-specific skip patterns
+   - Recognize user preference patterns (e.g., always brief on testing)
+
+3. **Improve Filtering**
+   - Boost relevance scores for questions user engages with
+   - Lower relevance scores for questions user consistently skips
+   - Create user-specific filtering rules
+   - Create project-specific filtering rules
+
+4. **Provide Insights**
+   - Show user what the system has learned
+   - Allow user to review and adjust learned patterns
+   - Explain why certain questions are being filtered
+   - Provide confidence scores for learned rules
+
+### Secondary Goals
+
+1. **Privacy & Control**
+   - All learning data stored locally in `.adf/`
+   - User can view, edit, or clear learning data
+   - Opt-in for cross-project learning
+   - Never send learning data externally
+
+2. **Transparency**
+   - Show "Learned from X sessions" indicators
+   - Explain filtering decisions with learning data
+   - Allow manual override of learned rules
+   - Provide learning statistics dashboard
+
+3. **Performance**
+   - Learning should not slow down interviews
+   - Minimal storage footprint
+   - Fast pattern detection
+   - Efficient data structure
+
+---
+
+## 🚀 Features
+
+### Feature 1: Skip Tracking System
+
+**Description:** Track and store every manual skip action during interviews.
+
+**Implementation Details:**
+```javascript
+// Data structure for skip tracking
+{
+  sessionId: "uuid",
+  timestamp: "2025-10-04T10:30:00Z",
+  projectType: "cli-tool",
+  frameworks: ["commander"],
+  question: {
+    id: "q_deployment_host",
+    text: "Where will you deploy this application?",
+    category: "deployment",
+    phase: "architecture"
+  },
+  action: "skipped",
+  reason: "manual" | "filtered",
+  timeViewed: 2.5  // seconds before skip
+}
+```
+
+**User Experience:**
+- Silent tracking (no UI changes)
+- Stored in `.adf/learning/skip-history.json`
+- Option to view skip history: `adf config learning`
+
+**Technical Requirements:**
+- Modify interviewer.js to track skip events
+- Create learning/skip-tracker.js module
+- Add storage to .adf/learning/ directory
+- Ensure atomic writes for data integrity
+
+---
+
+### Feature 2: Pattern Detection Engine
+
+**Description:** Analyze skip history to identify patterns and generate learned rules.
+
+**Pattern Types:**
+
+**1. Consistent Skip Pattern**
+```javascript
+// User skips same question 3+ times across different sessions
+{
+  pattern: "consistent_skip",
+  questionId: "q_deployment_host",
+  confidence: 90,  // 9 of 10 sessions skipped
+  sessions: 10,
+  skipped: 9,
+  recommendation: "Auto-filter this question"
+}
+```
+
+**2. Category Skip Pattern**
+```javascript
+// User skips 80%+ of questions in a category
+{
+  pattern: "category_skip",
+  category: "deployment",
+  confidence: 85,  // 85% skip rate
+  totalQuestions: 12,
+  skipped: 10,
+  recommendation: "Reduce relevance score for deployment questions"
+}
+```
+
+**3. Project-Type Skip Pattern**
+```javascript
+// CLI projects consistently skip certain questions
+{
+  pattern: "project_type_skip",
+  projectType: "cli-tool",
+  questionId: "q_ui_responsive",
+  confidence: 95,
+  recommendation: "Already filtered by base rules"
+}
+```
+
+**4. Framework-Specific Pattern**
+```javascript
+// Next.js projects skip routing questions
+{
+  pattern: "framework_skip",
+  framework: "Next.js",
+  questionId: "q_routing_setup",
+  confidence: 80,
+  sessions: 5,
+  recommendation: "Create framework-specific rule"
+}
+```
+
+**5. User Preference Pattern**
+```javascript
+// User always gives brief answers to testing questions
+{
+  pattern: "user_preference",
+  category: "testing",
+  answerLength: "brief",  // avg < 50 words
+  confidence: 75,
+  recommendation: "Suggest skipping detailed testing questions"
+}
+```
+
+**Implementation:**
+```javascript
+// lib/learning/pattern-detector.js
+
+class PatternDetector {
+  constructor(skipHistory, answerHistory) {
+    this.skipHistory = skipHistory;
+    this.answerHistory = answerHistory;
+  }
+
+  detectPatterns() {
+    return {
+      consistentSkips: this.findConsistentSkips(),
+      categoryPatterns: this.findCategoryPatterns(),
+      frameworkPatterns: this.findFrameworkPatterns(),
+      userPreferences: this.findUserPreferences()
+    };
+  }
+
+  findConsistentSkips() {
+    // Group by questionId, calculate skip rate
+    // Return questions with >75% skip rate across 3+ sessions
+  }
+
+  findCategoryPatterns() {
+    // Group by category, calculate skip rate per category
+    // Return categories with >70% skip rate
+  }
+
+  findFrameworkPatterns() {
+    // Group by framework + questionId
+    // Find framework-specific skip patterns
+  }
+
+  findUserPreferences() {
+    // Analyze answer length, detail level
+    // Detect user's typical response style
+  }
+}
+```
+
+---
+
+### Feature 3: Adaptive Filtering
+
+**Description:** Apply learned patterns to improve question filtering in real-time.
+
+**How It Works:**
+
+**Step 1: Load Learning Data**
+```javascript
+// On interview start
+const learningData = await loadLearningData('.adf/learning/');
+const patterns = detectPatterns(learningData);
+```
+
+**Step 2: Adjust Relevance Scores**
+```javascript
+function scoreQuestionRelevance(question, projectContext, learningData) {
+  let score = baseScore(question, projectContext);  // Phase 4.1 scoring
+
+  // Apply learned patterns
+  if (learningData.consistentSkips.includes(question.id)) {
+    score -= 30;  // Strong signal to skip
+  }
+
+  if (learningData.categorySkipRate[question.category] > 70) {
+    score -= 15;  // Moderate signal to skip
+  }
+
+  if (learningData.frameworkSkips[framework]?.includes(question.id)) {
+    score -= 20;  // Framework-specific skip
+  }
+
+  return score;
+}
+```
+
+**Step 3: Explain Decisions**
+```javascript
+// When showing filtering summary
+"🎯 Smart Filtering Results (with Learning):
+   ✓ 10 relevant questions selected
+   ○ 12 questions skipped
+     - 8 skipped by project type rules
+     - 4 skipped based on your history (learned from 5 sessions)
+   ⏱️  Estimated time saved: ~24 minutes"
+```
+
+**User Control:**
+```javascript
+// Prompt before applying learned rules
+"? I've learned from your previous 5 sessions. Apply learned preferences? (Y/n)
+  - Skip deployment questions (skipped in 4/5 sessions)
+  - Skip detailed testing questions (brief answers in 5/5 sessions)
+
+  You can review and adjust these in: adf config learning"
+```
+
+---
+
+### Feature 4: Learning Management Interface
+
+**Description:** CLI interface to view, manage, and control learning data.
+
+**Command:** `adf config learning`
+
+**Menu Options:**
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Learning System Configuration                      │
+├─────────────────────────────────────────────────────┤
+│                                                      │
+│  📊 Learning Statistics                             │
+│     Sessions analyzed: 12                           │
+│     Questions tracked: 240                          │
+│     Patterns detected: 8                            │
+│     Storage used: 145 KB                            │
+│                                                      │
+│  🎯 Detected Patterns                               │
+│     • Consistently skip deployment questions (9/10) │
+│     • Brief answers on testing (10/10)              │
+│     • Skip UI questions for CLI projects (5/5)      │
+│                                                      │
+│  ⚙️  Options                                         │
+│     1. View Skip History                            │
+│     2. Review Detected Patterns                     │
+│     3. Enable/Disable Learning (✓ Enabled)          │
+│     4. Clear Learning Data                          │
+│     5. Export Learning Data                         │
+│     6. Back to Main Menu                            │
+│                                                      │
+└─────────────────────────────────────────────────────┘
+```
+
+**Option 1: View Skip History**
+```
+Skip History (Last 20 skips):
+
+Session: 2025-10-04 10:30 AM (CLI Tool)
+  ○ "Where will you deploy?" - deployment
+  ○ "What CI/CD pipeline?" - deployment
+  ✓ "What testing framework?" - answered (brief)
+
+Session: 2025-10-03 02:15 PM (API Server)
+  ○ "Responsive design approach?" - design
+  ○ "Browser compatibility?" - frontend
+  ✓ "Database choice?" - answered (detailed)
+```
+
+**Option 2: Review Detected Patterns**
+```
+Detected Patterns:
+
+🔴 High Confidence (>80%)
+  • Skip deployment questions
+    Confidence: 90% (9 of 10 sessions)
+    Recommendation: Auto-filter deployment questions
+    [Apply] [Ignore] [Adjust]
+
+🟡 Medium Confidence (60-80%)
+  • Brief testing answers
+    Confidence: 75% (avg 35 words)
+    Recommendation: Suggest skipping detailed testing questions
+    [Apply] [Ignore] [Adjust]
+
+🟢 Low Confidence (<60%)
+  • Skip collaboration questions
+    Confidence: 50% (3 of 6 sessions)
+    Recommendation: Needs more data
+    [Track] [Ignore]
+```
+
+**Option 3: Enable/Disable Learning**
+```
+Learning System: ✓ Enabled
+
+Settings:
+  [x] Track skip actions
+  [x] Track answer quality
+  [x] Detect patterns automatically
+  [x] Apply learned filters
+  [ ] Share anonymous patterns (opt-in)
+
+Minimum sessions for pattern: 3
+Minimum confidence for auto-filter: 75%
+
+[Save] [Reset to Defaults] [Cancel]
+```
+
+**Option 4: Clear Learning Data**
+```
+⚠️  Clear Learning Data
+
+This will delete:
+  • Skip history (12 sessions)
+  • Detected patterns (8 patterns)
+  • User preferences
+
+This action cannot be undone.
+
+? Are you sure you want to clear all learning data? (y/N)
+```
+
+---
+
+### Feature 5: Learning Data Storage
+
+**Description:** Secure, efficient storage of learning data in `.adf/learning/`
+
+**Directory Structure:**
+```
+.adf/
+├── learning/
+│   ├── skip-history.json        # All skip events
+│   ├── answer-history.json      # Answer metadata (length, quality)
+│   ├── patterns.json            # Detected patterns
+│   ├── learned-rules.json       # User-approved learned rules
+│   ├── config.json              # Learning system settings
+│   └── stats.json               # Aggregate statistics
+├── .env                         # API keys
+└── sessions/                    # Session data
+```
+
+**skip-history.json:**
+```json
+{
+  "version": "1.0",
+  "sessions": [
+    {
+      "sessionId": "550e8400-e29b-41d4-a716-446655440000",
+      "timestamp": "2025-10-04T10:30:00Z",
+      "projectType": "cli-tool",
+      "frameworks": ["commander"],
+      "skips": [
+        {
+          "questionId": "q_deployment_host",
+          "text": "Where will you deploy?",
+          "category": "deployment",
+          "phase": "architecture",
+          "action": "skipped",
+          "reason": "manual",
+          "timeViewed": 2.5
+        }
+      ]
+    }
+  ]
+}
+```
+
+**patterns.json:**
+```json
+{
+  "version": "1.0",
+  "lastUpdated": "2025-10-04T10:35:00Z",
+  "patterns": [
+    {
+      "id": "pattern_001",
+      "type": "consistent_skip",
+      "questionId": "q_deployment_host",
+      "confidence": 90,
+      "sessionsAnalyzed": 10,
+      "skipCount": 9,
+      "status": "active",
+      "userApproved": true
+    },
+    {
+      "id": "pattern_002",
+      "type": "category_skip",
+      "category": "deployment",
+      "confidence": 85,
+      "totalQuestions": 12,
+      "skipCount": 10,
+      "status": "active",
+      "userApproved": false
+    }
+  ]
+}
+```
+
+**learned-rules.json:**
+```json
+{
+  "version": "1.0",
+  "rules": [
+    {
+      "id": "rule_001",
+      "type": "skip_question",
+      "questionId": "q_deployment_host",
+      "reason": "User consistently skips (90% confidence)",
+      "appliedSince": "2025-10-04T10:35:00Z",
+      "enabled": true
+    },
+    {
+      "id": "rule_002",
+      "type": "reduce_relevance",
+      "category": "deployment",
+      "adjustment": -20,
+      "reason": "Category skip rate: 85%",
+      "appliedSince": "2025-10-04T10:35:00Z",
+      "enabled": true
+    }
+  ]
+}
+```
+
+---
+
+## 🏗️ Technical Architecture
+
+### Component Diagram
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    Interviewer                          │
+│  - Runs interview questions                             │
+│  - Captures user actions                                │
+└────────────┬────────────────────────────────────────────┘
+             │
+             │ Events (skip, answer, time)
+             │
+             ▼
+┌─────────────────────────────────────────────────────────┐
+│              Skip Tracker (NEW)                          │
+│  - Records skip events                                   │
+│  - Records answer metadata                               │
+│  - Writes to skip-history.json                           │
+└────────────┬────────────────────────────────────────────┘
+             │
+             │ History data
+             │
+             ▼
+┌─────────────────────────────────────────────────────────┐
+│           Pattern Detector (NEW)                         │
+│  - Analyzes skip history                                 │
+│  - Detects consistent patterns                           │
+│  - Generates learned rules                               │
+│  - Writes to patterns.json                               │
+└────────────┬────────────────────────────────────────────┘
+             │
+             │ Patterns + Rules
+             │
+             ▼
+┌─────────────────────────────────────────────────────────┐
+│        Question Filter (Enhanced)                        │
+│  - Base relevance scoring (Phase 4.1)                    │
+│  - Apply learned rules (Phase 4.2)                       │
+│  - Adjust scores based on patterns                       │
+└────────────┬────────────────────────────────────────────┘
+             │
+             │ Filtered questions
+             │
+             ▼
+┌─────────────────────────────────────────────────────────┐
+│        Learning Manager (NEW)                            │
+│  - CLI interface for learning data                       │
+│  - View/edit/clear learning data                         │
+│  - Enable/disable learning                               │
+└─────────────────────────────────────────────────────────┘
+```
+
+### Data Flow
+
+**Interview Flow with Learning:**
+```
+1. User starts interview
+   ↓
+2. Load learning data from .adf/learning/
+   ↓
+3. Detect patterns from history
+   ↓
+4. Apply base filtering rules (Phase 4.1)
+   ↓
+5. Apply learned rules (Phase 4.2)
+   ↓
+6. Show filtering summary with learning info
+   ↓
+7. Ask questions
+   ↓
+8. Track skip events → skip-tracker
+   ↓
+9. Track answers → answer-tracker
+   ↓
+10. On session end: analyze patterns
+    ↓
+11. Update patterns.json
+    ↓
+12. Apply high-confidence patterns to learned-rules.json
+```
+
+---
+
+## 📋 Implementation Plan
+
+### Phase 4.2.1: Skip Tracking Foundation (Session 1)
+
+**Goal:** Build the tracking system to record user behavior
+
+**Tasks:**
+1. Create `lib/learning/skip-tracker.js`
+   - Track skip events
+   - Track answer metadata
+   - Write to skip-history.json
+   - Atomic file writes
+
+2. Create `lib/learning/storage.js`
+   - Ensure .adf/learning/ directory
+   - Read/write learning data files
+   - Handle file locking
+   - Data validation
+
+3. Modify `lib/frameworks/interviewer.js`
+   - Integrate skip-tracker
+   - Capture skip events
+   - Capture answer events
+   - Session metadata
+
+4. Create tests
+   - Skip tracking tests
+   - Storage tests
+   - Integration tests
+
+**Deliverables:**
+- Skip tracking system functional
+- Data stored in .adf/learning/
+- Tests passing
+
+---
+
+### Phase 4.2.2: Pattern Detection (Session 2)
+
+**Goal:** Analyze skip history to detect patterns
+
+**Tasks:**
+1. Create `lib/learning/pattern-detector.js`
+   - Consistent skip detection
+   - Category pattern detection
+   - Framework pattern detection
+   - User preference detection
+
+2. Create `lib/learning/rule-generator.js`
+   - Convert patterns to rules
+   - Calculate confidence scores
+   - Generate recommendations
+
+3. Add pattern analysis to interview end
+   - Run pattern detection
+   - Update patterns.json
+   - Generate learned-rules.json
+
+4. Create tests
+   - Pattern detection tests
+   - Rule generation tests
+   - Confidence calculation tests
+
+**Deliverables:**
+- Pattern detection working
+- Learned rules generated
+- Tests passing
+
+---
+
+### Phase 4.2.3: Adaptive Filtering (Session 3)
+
+**Goal:** Apply learned rules to improve filtering
+
+**Tasks:**
+1. Modify `lib/filters/question-filter.js`
+   - Load learned rules
+   - Apply learned rules to relevance scoring
+   - Add learning-based explanations
+
+2. Update filtering summary
+   - Show base filtering results
+   - Show learning-based filtering
+   - Explain learned rules
+
+3. Add user prompts
+   - "Apply learned preferences?"
+   - Show what will be applied
+   - Allow opt-out
+
+4. Create tests
+   - Adaptive filtering tests
+   - Score adjustment tests
+   - Integration tests
+
+**Deliverables:**
+- Learned rules applied to filtering
+- User can opt in/out
+- Tests passing
+
+---
+
+### Phase 4.2.4: Learning Management UI (Session 4)
+
+**Goal:** Build CLI interface to manage learning
+
+**Tasks:**
+1. Create `lib/learning/learning-manager.js`
+   - View skip history
+   - Review patterns
+   - Enable/disable learning
+   - Clear data
+
+2. Add to `adf config` command
+   - New "Learning System" menu option
+   - Statistics dashboard
+   - Pattern review interface
+
+3. Add data export/import
+   - Export learning data
+   - Import learning data
+   - Backup/restore
+
+4. Create tests
+   - Learning manager tests
+   - UI interaction tests
+
+**Deliverables:**
+- Learning management UI complete
+- User can control all learning features
+- Tests passing
+
+---
+
+## ✅ Success Criteria
+
+### User Experience
+- [ ] Skip events tracked without slowing down interview
+- [ ] Patterns detected after 3+ sessions
+- [ ] Learned rules improve filtering accuracy by 20%+
+- [ ] User can view and manage learning data easily
+- [ ] Clear explanations for all learning-based decisions
+
+### Technical
+- [ ] All learning data stored in `.adf/learning/`
+- [ ] Pattern detection runs in <500ms
+- [ ] Learning storage <5MB for 100 sessions
+- [ ] 90%+ test coverage for learning components
+- [ ] No data loss (atomic writes, backups)
+
+### Privacy & Control
+- [ ] All data stored locally only
+- [ ] User can disable learning anytime
+- [ ] User can clear all learning data
+- [ ] Transparent explanations for all patterns
+- [ ] Opt-in for any cross-project features
+
+---
+
+## 🎯 Key Metrics
+
+### Learning Effectiveness
+- **Pattern Detection Accuracy:** % of patterns that user approves
+- **Filtering Improvement:** Reduction in manual skips after learning
+- **Time Savings:** Additional time saved beyond Phase 4.1
+- **User Satisfaction:** Do users enable/keep learning enabled?
+
+### Performance
+- **Tracking Overhead:** Time added to interview by tracking
+- **Pattern Detection Time:** Time to analyze and detect patterns
+- **Storage Growth:** MB per session
+- **Memory Usage:** Memory overhead during interview
+
+---
+
+## 🚨 Risks & Mitigation
+
+### Risk 1: Over-Filtering
+**Risk:** System learns to skip too many questions
+**Mitigation:**
+- Require high confidence (>75%) for auto-skip
+- User review of patterns before applying
+- Easy override mechanism
+- Periodic re-evaluation of patterns
+
+### Risk 2: Privacy Concerns
+**Risk:** Users concerned about data collection
+**Mitigation:**
+- All data stored locally in .adf/
+- Clear documentation of what's tracked
+- Easy disable/clear options
+- Transparent explanations
+
+### Risk 3: Storage Growth
+**Risk:** Learning data grows too large
+**Mitigation:**
+- Compress old history (>100 sessions)
+- Archive old sessions
+- Configurable retention period
+- Warn user at 10MB+
+
+### Risk 4: Pattern Noise
+**Risk:** False patterns from limited data
+**Mitigation:**
+- Require minimum 3 sessions
+- Confidence thresholds
+- User approval for patterns
+- Decay old patterns over time
+
+---
+
+## 📚 Dependencies
+
+### Required (Phase 4.1)
+- ✅ Project analyzer (Phase 4.1)
+- ✅ Question filter (Phase 4.1)
+- ✅ Interviewer integration (Phase 4.1)
+
+### Optional
+- AI provider (for future AI-enhanced pattern detection)
+- Multi-user environments (for shared learning)
+
+---
+
+## 🔮 Future Enhancements (Post-4.2)
+
+### Phase 4.3: AI-Enhanced Learning
+- Use AI to detect subtle patterns
+- AI-powered question relevance scoring
+- Natural language pattern descriptions
+- Smart recommendations based on project goals
+
+### Phase 4.4: Cross-Project Learning
+- Learn from patterns across all user projects
+- Detect project archetypes
+- Community-driven patterns (opt-in)
+- Shared best practices
+
+### Phase 4.5: Predictive Intelligence
+- Predict likely answers based on history
+- Suggest answer completions
+- Pre-fill common responses
+- Detect answer inconsistencies
+
+---
+
+## 📖 Documentation Requirements
+
+### User Documentation
+- README: Add Learning System feature
+- CHANGELOG: Document Phase 4.2
+- New guide: "Understanding the Learning System"
+- FAQ: Common questions about learning
+
+### Technical Documentation
+- Learning System Architecture
+- Data format specifications
+- Pattern detection algorithms
+- Privacy and data handling
+
+### Session Documentation
+- Planning doc (this file)
+- Implementation session notes
+- Testing and validation results
+- Lessons learned
+
+---
+
+**Status:** 📋 Ready for Implementation
+**Next Step:** Create feature branch and begin Phase 4.2.1 (Skip Tracking Foundation)
+**Estimated Timeline:** 2-3 development sessions
+**Complexity:** Medium
+**Value:** High (personalized, adaptive filtering)