claude-self-reflect 2.8.7 → 2.8.9

package/Dockerfile.safe-watcher

@@ -21,7 +21,7 @@ RUN pip install --upgrade pip setuptools wheel
 RUN pip install --no-cache-dir \
     qdrant-client==1.15.0 \
     fastembed==0.7.1 \
-    numpy==1.26.4 \
+    numpy>=2.1.0 \
     psutil==7.0.0 \
     python-dotenv==1.0.0 \
     voyageai==0.3.4 \

package/Dockerfile.streaming-importer

@@ -25,7 +25,7 @@ RUN pip install --no-cache-dir torch==2.3.0 --index-url https://download.pytorch
 RUN pip install --no-cache-dir \
     qdrant-client==1.15.0 \
     fastembed==0.4.0 \
-    numpy==1.26.4 \
+    numpy>=2.1.0 \
     psutil==7.0.0 \
     tenacity==8.2.3 \
     python-dotenv==1.0.0 \

package/README.md

@@ -24,22 +24,22 @@
 
 Give Claude perfect memory of all your conversations. Search past discussions instantly. Never lose context again.
 
-**🔒 100% Local by Default** • **⚡ Blazing Fast Search** • **🚀 Zero Configuration** • **🏭 Production Ready**
-
-## 📑 Table of Contents
-
-- [🚀 Quick Install](#-quick-install)
-- [✨ The Magic](#-the-magic)
-- [📊 Before & After](#-before--after)
-- [💬 Real Examples](#-real-examples)
-- [🆕 NEW: Real-time Indexing Status](#-new-real-time-indexing-status-in-your-terminal)
-- [🎯 Key Features](#-key-features)
-- [🏗️ Architecture](#️-architecture)
-- [🛠️ Requirements](#️-requirements)
-- [📖 Documentation](#-documentation)
-- [📦 What's New](#-whats-new)
-- [🔧 Troubleshooting](#-troubleshooting)
-- [👥 Contributors](#-contributors)
+**100% Local by Default** • **Blazing Fast Search** • **Zero Configuration** • **Production Ready**
+
+## Table of Contents
+
+- [Quick Install](#-quick-install)
+- [The Magic](#the-magic)
+- [Before & After](#before--after)
+- [Real Examples](#real-examples)
+- [NEW: Real-time Indexing Status](#new-real-time-indexing-status-in-your-terminal)
+- [Key Features](#key-features)
+- [Architecture](#architecture)
+- [Requirements](#requirements)
+- [Documentation](#documentation)
+- [What's New](#whats-new)
+- [Troubleshooting](#troubleshooting)
+- [Contributors](#contributors)
 
 ## 🚀 Quick Install
 
@@ -71,15 +71,15 @@ claude-self-reflect setup --voyage-key=YOUR_ACTUAL_KEY_HERE
 
 </details>
 
-## ✨ The Magic
+## The Magic
 
 ![Self Reflection vs The Grind](docs/images/red-reflection.webp)
 
-## 📊 Before & After
+## Before & After
 
 ![Before and After Claude Self-Reflect](docs/diagrams/before-after-combined.webp)
 
-## 💬 Real Examples
+## Real Examples
 
 ```
 You: "What was that PostgreSQL optimization we figured out?"
@@ -98,7 +98,7 @@ Claude: "3 conversations found:
         - Nov 20: Added rate limiting per authenticated connection"
 ```
 
-## 🆕 NEW: Real-time Indexing Status in Your Terminal!
+## NEW: Real-time Indexing Status in Your Terminal
 
 See your conversation indexing progress directly in your statusline:
 
@@ -110,10 +110,32 @@ See your conversation indexing progress directly in your statusline:
 
 Works with [Claude Code Statusline](https://github.com/sirmalloc/ccstatusline) - shows progress bars, percentages, and indexing lag in real-time!
 
-## 🎯 Key Features
+## Key Features
 
 <details>
-<summary><b>📊 Statusline Integration</b></summary>
+<summary><b>MCP Tools Available to Claude</b></summary>
+
+**Search & Memory Tools:**
+- `reflect_on_past` - Search past conversations using semantic similarity with time decay
+- `store_reflection` - Store important insights or learnings for future reference
+- `quick_search` - Fast search returning only count and top result
+- `search_summary` - Get aggregated insights without individual details
+- `get_more_results` - Paginate through additional search results
+- `search_by_file` - Find conversations that analyzed specific files
+- `search_by_concept` - Search for conversations about development concepts
+- `get_full_conversation` - Retrieve complete JSONL conversation files (v2.8.8)
+
+**Status & Monitoring Tools:**
+- `get_status` - Real-time import progress and system status
+- `get_health` - Comprehensive system health check
+- `collection_status` - Check Qdrant collection health and stats
+
+All tools are automatically available when the MCP server is connected to Claude Code.
+
+</details>
+
+<details>
+<summary><b>Statusline Integration</b></summary>
 
 See your indexing progress right in your terminal! Works with [Claude Code Statusline](https://github.com/sirmalloc/ccstatusline):
 - **Progress Bar** - Visual indicator `[████████ ] 91%`
@@ -126,7 +148,7 @@ See your indexing progress right in your terminal! Works with [Claude Code Statu
 </details>
 
 <details>
-<summary><b>🔍 Project-Scoped Search</b></summary>
+<summary><b>Project-Scoped Search</b></summary>
 
 Searches are **project-aware by default**. Claude automatically searches within your current project:
 
@@ -143,7 +165,7 @@ Claude: [Searches across ALL your projects]
 </details>
 
 <details>
-<summary><b>⏱️ Memory Decay</b></summary>
+<summary><b>Memory Decay</b></summary>
 
 Recent conversations matter more. Old ones fade. Like your brain, but reliable.
 - **90-day half-life**: Recent memories stay strong
@@ -153,7 +175,7 @@ Recent conversations matter more. Old ones fade. Like your brain, but reliable.
 </details>
 
 <details>
-<summary><b>⚡ Performance at Scale</b></summary>
+<summary><b>Performance at Scale</b></summary>
 
 - **Search**: <3ms average response time
 - **Scale**: 600+ conversations across 24 projects
@@ -163,18 +185,18 @@ Recent conversations matter more. Old ones fade. Like your brain, but reliable.
 
 </details>
 
-## 🏗️ Architecture
+## Architecture
 
 <details>
 <summary><b>View Architecture Diagram & Details</b></summary>
 
 ![Import Architecture](docs/diagrams/import-architecture.png)
 
-### 🔥 HOT/WARM/COLD Intelligent Prioritization
+### HOT/WARM/COLD Intelligent Prioritization
 
-- **🔥 HOT** (< 5 minutes): 2-second intervals for near real-time import
-- **🌡️ WARM** (< 24 hours): Normal priority with starvation prevention
-- **❄️ COLD** (> 24 hours): Batch processed to prevent blocking
+- **HOT** (< 5 minutes): 2-second intervals for near real-time import
+- **WARM** (< 24 hours): Normal priority with starvation prevention
+- **COLD** (> 24 hours): Batch processed to prevent blocking
 
 Files are categorized by age and processed with priority queuing to ensure newest content gets imported quickly while preventing older files from being starved.
 
@@ -186,7 +208,7 @@ Files are categorized by age and processed with priority queuing to ensure newes
 
 </details>
 
-## 🛠️ Requirements
+## Requirements
 
 <details>
 <summary><b>System Requirements</b></summary>
@@ -204,16 +226,16 @@ Files are categorized by age and processed with priority queuing to ensure newes
 - **Docker Desktop 4.0+** for best compatibility
 
 ### Operating Systems
-- ✅ macOS 11+ (Intel & Apple Silicon)
-- ✅ Windows 10/11 with WSL2
-- ✅ Linux (Ubuntu 20.04+, Debian 11+)
+- macOS 11+ (Intel & Apple Silicon)
+- Windows 10/11 with WSL2
+- Linux (Ubuntu 20.04+, Debian 11+)
 
 </details>
 
-## 📖 Documentation
+## Documentation
 
 <details>
-<summary>🔧 Technical Stack</summary>
+<summary>Technical Stack</summary>
 
 - **Vector DB**: Qdrant (local, your data stays yours)
 - **Embeddings**: 
@@ -225,7 +247,7 @@ Files are categorized by age and processed with priority queuing to ensure newes
 </details>
 
 <details>
-<summary>📚 Advanced Topics</summary>
+<summary>Advanced Topics</summary>
 
 - [Performance tuning](docs/performance-guide.md)
 - [Security & privacy](docs/security.md)
@@ -236,7 +258,7 @@ Files are categorized by age and processed with priority queuing to ensure newes
 </details>
 
 <details>
-<summary>🐛 Troubleshooting</summary>
+<summary>Troubleshooting</summary>
 
 - [Troubleshooting Guide](docs/troubleshooting.md)
 - [GitHub Issues](https://github.com/ramakay/claude-self-reflect/issues)
@@ -245,7 +267,7 @@ Files are categorized by age and processed with priority queuing to ensure newes
 </details>
 
 <details>
-<summary>🗑️ Uninstall</summary>
+<summary>Uninstall</summary>
 
 For complete uninstall instructions, see [docs/UNINSTALL.md](docs/UNINSTALL.md).
 
@@ -263,19 +285,19 @@ npm uninstall -g claude-self-reflect
 
 </details>
 
-## 📦 What's New
+## What's New
 
 <details>
-<summary>🎉 v2.8.0 - Latest Release</summary>
+<summary>v2.8.8 - Latest Release</summary>
 
-- **🔧 Fixed MCP Indexing**: Now correctly shows 97.1% progress (was showing 0%)
-- **🔥 HOT/WARM/COLD**: Intelligent file prioritization for near real-time imports
-- **📊 Enhanced Monitoring**: Real-time status with visual indicators
+- **Full Conversation Access**: New `get_full_conversation` tool provides complete JSONL files instead of 200-char excerpts
+- **95% Value Increase**: Agents can now access entire conversations with full implementation details
+- **Direct File Access**: Returns absolute paths for efficient reading with standard tools
 
 </details>
 
 <details>
-<summary>✨ v2.5.19 - Metadata Enrichment</summary>
+<summary>v2.5.19 - Metadata Enrichment</summary>
 
 ### For Existing Users
 ```bash
@@ -298,7 +320,7 @@ docker compose run --rm importer python /app/scripts/delta-metadata-update-safe.
 </details>
 
 <details>
-<summary>📜 Release History</summary>
+<summary>Release History</summary>
 
 - **v2.5.18** - Security dependency updates
 - **v2.5.17** - Critical CPU fix and memory limit adjustment
@@ -313,7 +335,7 @@ docker compose run --rm importer python /app/scripts/delta-metadata-update-safe.
 
 </details>
 
-## 🔧 Troubleshooting
+## Troubleshooting
 
 <details>
 <summary><b>Common Issues and Solutions</b></summary>
@@ -432,7 +454,7 @@ claude-self-reflect doctor > diagnostic.txt
 
 </details>
 
-## 👥 Contributors
+## Contributors
 
 Special thanks to our contributors:
 - **[@TheGordon](https://github.com/TheGordon)** - Fixed timestamp parsing (#10)
@@ -441,4 +463,4 @@ Special thanks to our contributors:
 
 ---
 
-Built with ❤️ by [ramakay](https://github.com/ramakay) for the Claude community.
+Built with care by [ramakay](https://github.com/ramakay) for the Claude community.

package/installer/setup-wizard-docker.js

@@ -306,7 +306,7 @@ async function configureClaude() {
   const isDockerMode = process.env.USE_DOCKER_MCP === 'true';
   const mcpScript = isDockerMode 
     ? join(projectRoot, 'mcp-server', 'run-mcp-docker.sh')
-    : join(projectRoot, 'mcp-server', 'run-mcp-clean.sh');
+    : join(projectRoot, 'mcp-server', 'run-mcp.sh');
   
   if (isDockerMode) {
     // Create a script that runs the MCP server in Docker

package/mcp-server/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-self-reflect-mcp"
-version = "2.8.4"
+version = "2.8.9"
 description = "MCP server for Claude self-reflection with memory decay"
 # readme = "README.md"
 requires-python = ">=3.10"

package/mcp-server/src/server.py

@@ -10,6 +10,7 @@ import numpy as np
 import hashlib
 import time
 import logging
+from xml.sax.saxutils import escape
 
 from fastmcp import FastMCP, Context
 from .utils import normalize_project_name
@@ -47,6 +48,20 @@ QDRANT_URL = os.getenv('QDRANT_URL', 'http://localhost:6333')
 VOYAGE_API_KEY = os.getenv('VOYAGE_KEY') or os.getenv('VOYAGE_KEY-2') or os.getenv('VOYAGE_KEY_2')
 ENABLE_MEMORY_DECAY = os.getenv('ENABLE_MEMORY_DECAY', 'false').lower() == 'true'
 DECAY_WEIGHT = float(os.getenv('DECAY_WEIGHT', '0.3'))
+
+# Setup file logging
+LOG_FILE = Path.home() / '.claude-self-reflect' / 'logs' / 'mcp-server.log'
+LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+# Configure logging to both file and console
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_FILE, mode='a'),
+        logging.StreamHandler()
+    ]
+)
 DECAY_SCALE_DAYS = float(os.getenv('DECAY_SCALE_DAYS', '90'))
 USE_NATIVE_DECAY = os.getenv('USE_NATIVE_DECAY', 'false').lower() == 'true'
 
@@ -101,7 +116,7 @@ print(f"[DEBUG] env_path: {env_path}", file=sys.stderr)
 
 
 class SearchResult(BaseModel):
-    """A single search result."""
+    """A single search result with pattern intelligence."""
     id: str
     score: float
     timestamp: str
@@ -112,6 +127,11 @@ class SearchResult(BaseModel):
     base_conversation_id: Optional[str] = None
     collection_name: str
     raw_payload: Optional[Dict[str, Any]] = None  # Full Qdrant payload when debug mode enabled
+    # Pattern intelligence fields
+    code_patterns: Optional[Dict[str, List[str]]] = None  # Extracted AST patterns
+    files_analyzed: Optional[List[str]] = None  # Files referenced in conversation
+    tools_used: Optional[List[str]] = None  # Tools/commands used
+    concepts: Optional[List[str]] = None  # Domain concepts discussed
 
 
 # Initialize FastMCP instance
@@ -138,6 +158,8 @@ _indexing_cache = {"result": None, "timestamp": 0}
 
 # Setup logger
 logger = logging.getLogger(__name__)
+logger.info(f"MCP Server starting - Log file: {LOG_FILE}")
+logger.info(f"Configuration: QDRANT_URL={QDRANT_URL}, DECAY={ENABLE_MEMORY_DECAY}, VOYAGE_API_STATUS={'Configured' if VOYAGE_API_KEY else 'Not Configured'}")
 
 def normalize_path(path_str: str) -> str:
     """Normalize path for consistent comparison across platforms.
@@ -378,6 +400,86 @@ def get_collection_suffix() -> str:
         return "_local"
     else:
         return "_voyage"
+
+def aggregate_pattern_intelligence(results: List[SearchResult]) -> Dict[str, Any]:
+    """Aggregate pattern intelligence across search results."""
+    
+    # Initialize counters
+    all_patterns = {}
+    all_files = set()
+    all_tools = set()
+    all_concepts = set()
+    pattern_by_category = {}
+    
+    for result in results:
+        # Aggregate code patterns
+        if result.code_patterns:
+            for category, patterns in result.code_patterns.items():
+                if category not in pattern_by_category:
+                    pattern_by_category[category] = {}
+                for pattern in patterns:
+                    if pattern not in pattern_by_category[category]:
+                        pattern_by_category[category][pattern] = 0
+                    pattern_by_category[category][pattern] += 1
+                    
+                    # Overall pattern count
+                    if pattern not in all_patterns:
+                        all_patterns[pattern] = 0
+                    all_patterns[pattern] += 1
+        
+        # Aggregate files
+        if result.files_analyzed:
+            all_files.update(result.files_analyzed)
+        
+        # Aggregate tools
+        if result.tools_used:
+            all_tools.update(result.tools_used)
+        
+        # Aggregate concepts
+        if result.concepts:
+            all_concepts.update(result.concepts)
+    
+    # Find most common patterns
+    sorted_patterns = sorted(all_patterns.items(), key=lambda x: x[1], reverse=True)
+    most_common_patterns = sorted_patterns[:10] if sorted_patterns else []
+    
+    # Find pattern categories with most coverage
+    category_coverage = {
+        cat: sum(counts.values()) 
+        for cat, counts in pattern_by_category.items()
+    }
+    
+    # Build intelligence summary
+    intelligence = {
+        "total_unique_patterns": len(all_patterns),
+        "most_common_patterns": most_common_patterns,
+        "pattern_categories": list(pattern_by_category.keys()),
+        "category_coverage": category_coverage,
+        "files_referenced": list(all_files)[:20],  # Limit to top 20
+        "tools_used": list(all_tools),
+        "concepts_discussed": list(all_concepts)[:15],  # Limit to top 15
+        "pattern_by_category": pattern_by_category,
+        "pattern_diversity_score": len(all_patterns) / max(len(results), 1)  # Patterns per result
+    }
+    
+    # Add cross-pattern insights
+    if pattern_by_category:
+        # Check for common pattern combinations
+        async_error_combo = (
+            'async_patterns' in pattern_by_category and 
+            'error_handling' in pattern_by_category
+        )
+        react_state_combo = (
+            'react_hooks' in pattern_by_category and
+            any('useState' in p for p in pattern_by_category.get('react_hooks', {}).keys())
+        )
+        
+        intelligence["pattern_combinations"] = {
+            "async_with_error_handling": async_error_combo,
+            "react_with_state": react_state_combo
+        }
+    
+    return intelligence
     
 # Register tools
 @mcp.tool()
@@ -394,6 +496,8 @@ async def reflect_on_past(
 ) -> str:
     """Search for relevant past conversations using semantic search with optional time decay."""
     
+    logger.info(f"=== SEARCH START === Query: '{query}', Project: '{project}', Limit: {limit}")
+    
     # Start timing
     start_time = time.time()
     timing_info = {}
@@ -537,6 +641,7 @@ async def reflect_on_past(
                         continue
                 
                 query_embedding = query_embeddings[embedding_type_for_collection]
+                
                 if should_use_decay and USE_NATIVE_DECAY and NATIVE_DECAY_AVAILABLE:
                     # Use native Qdrant decay with newer API
                     await ctx.debug(f"Using NATIVE Qdrant decay (new API) for {collection_name}")
@@ -642,20 +747,37 @@ async def reflect_on_past(
                         if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
-                            if not point_project.endswith(f"-{target_project}") and point_project != target_project:
+                            # Also handle underscore/dash variations (procsolve-website vs procsolve_website)
+                            normalized_target = target_project.replace('-', '_')
+                            normalized_stored = point_project.replace('-', '_')
+                            if not (normalized_stored.endswith(f"_{normalized_target}") or 
+                                    normalized_stored == normalized_target or
+                                    point_project.endswith(f"-{target_project}") or 
+                                    point_project == target_project):
                                 continue  # Skip results from other projects
                         
                         # For reflections with project context, optionally filter by project
                         if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
                             # Only filter if the reflection has project metadata
                             reflection_project = point.payload.get('project', '')
-                            if reflection_project and not (
-                                reflection_project == target_project or 
-                                reflection_project.endswith(f"/{target_project}") or
-                                reflection_project.endswith(f"-{target_project}")
-                            ):
-                                continue  # Skip reflections from other projects
+                            if reflection_project:
+                                # Normalize both for comparison (handle underscore/dash variations)
+                                normalized_target = target_project.replace('-', '_')
+                                normalized_reflection = reflection_project.replace('-', '_')
+                                if not (
+                                    reflection_project == target_project or 
+                                    normalized_reflection == normalized_target or
+                                    reflection_project.endswith(f"/{target_project}") or
+                                    reflection_project.endswith(f"-{target_project}") or
+                                    normalized_reflection.endswith(f"_{normalized_target}") or
+                                    normalized_reflection.endswith(f"/{normalized_target}")
+                                ):
+                                    continue  # Skip reflections from other projects
                             
+                        # Log pattern data
+                        patterns = point.payload.get('code_patterns')
+                        logger.info(f"DEBUG: Creating SearchResult for point {point.id} from {collection_name}: has_patterns={bool(patterns)}, pattern_keys={list(patterns.keys()) if patterns else None}")
+                        
                         all_results.append(SearchResult(
                             id=str(point.id),
                             score=point.score,  # Score already includes decay
@@ -666,7 +788,12 @@ async def reflect_on_past(
                             conversation_id=point.payload.get('conversation_id'),
                             base_conversation_id=point.payload.get('base_conversation_id'),
                             collection_name=collection_name,
-                            raw_payload=point.payload if include_raw else None
+                            raw_payload=point.payload,  # Always include payload for metadata extraction
+                            # Pattern intelligence metadata
+                            code_patterns=point.payload.get('code_patterns'),
+                            files_analyzed=point.payload.get('files_analyzed'),
+                            tools_used=list(point.payload.get('tools_used', [])) if isinstance(point.payload.get('tools_used'), set) else point.payload.get('tools_used'),
+                            concepts=point.payload.get('concepts')
                         ))
                     
                 elif should_use_decay:
@@ -736,19 +863,32 @@ async def reflect_on_past(
                         if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
-                            if not point_project.endswith(f"-{target_project}") and point_project != target_project:
+                            # Also handle underscore/dash variations (procsolve-website vs procsolve_website)
+                            normalized_target = target_project.replace('-', '_')
+                            normalized_stored = point_project.replace('-', '_')
+                            if not (normalized_stored.endswith(f"_{normalized_target}") or 
+                                    normalized_stored == normalized_target or
+                                    point_project.endswith(f"-{target_project}") or 
+                                    point_project == target_project):
                                 continue  # Skip results from other projects
                         
                         # For reflections with project context, optionally filter by project
                         if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
                             # Only filter if the reflection has project metadata
                             reflection_project = point.payload.get('project', '')
-                            if reflection_project and not (
-                                reflection_project == target_project or 
-                                reflection_project.endswith(f"/{target_project}") or
-                                reflection_project.endswith(f"-{target_project}")
-                            ):
-                                continue  # Skip reflections from other projects
+                            if reflection_project:
+                                # Normalize both for comparison (handle underscore/dash variations)
+                                normalized_target = target_project.replace('-', '_')
+                                normalized_reflection = reflection_project.replace('-', '_')
+                                if not (
+                                    reflection_project == target_project or 
+                                    normalized_reflection == normalized_target or
+                                    reflection_project.endswith(f"/{target_project}") or
+                                    reflection_project.endswith(f"-{target_project}") or
+                                    normalized_reflection.endswith(f"_{normalized_target}") or
+                                    normalized_reflection.endswith(f"/{normalized_target}")
+                                ):
+                                    continue  # Skip reflections from other projects
                             
                         all_results.append(SearchResult(
                             id=str(point.id),
@@ -760,7 +900,12 @@ async def reflect_on_past(
                             conversation_id=point.payload.get('conversation_id'),
                             base_conversation_id=point.payload.get('base_conversation_id'),
                             collection_name=collection_name,
-                            raw_payload=point.payload if include_raw else None
+                            raw_payload=point.payload,  # Always include payload for metadata extraction
+                            # Pattern intelligence metadata
+                            code_patterns=point.payload.get('code_patterns'),
+                            files_analyzed=point.payload.get('files_analyzed'),
+                            tools_used=list(point.payload.get('tools_used', [])) if isinstance(point.payload.get('tools_used'), set) else point.payload.get('tools_used'),
+                            concepts=point.payload.get('concepts')
                         ))
                 else:
                     # Standard search without decay
@@ -787,19 +932,32 @@ async def reflect_on_past(
                         if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
-                            if not point_project.endswith(f"-{target_project}") and point_project != target_project:
+                            # Also handle underscore/dash variations (procsolve-website vs procsolve_website)
+                            normalized_target = target_project.replace('-', '_')
+                            normalized_stored = point_project.replace('-', '_')
+                            if not (normalized_stored.endswith(f"_{normalized_target}") or 
+                                    normalized_stored == normalized_target or
+                                    point_project.endswith(f"-{target_project}") or 
+                                    point_project == target_project):
                                 continue  # Skip results from other projects
                         
                         # For reflections with project context, optionally filter by project
                         if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
                             # Only filter if the reflection has project metadata
                             reflection_project = point.payload.get('project', '')
-                            if reflection_project and not (
-                                reflection_project == target_project or 
-                                reflection_project.endswith(f"/{target_project}") or
-                                reflection_project.endswith(f"-{target_project}")
-                            ):
-                                continue  # Skip reflections from other projects
+                            if reflection_project:
+                                # Normalize both for comparison (handle underscore/dash variations)
+                                normalized_target = target_project.replace('-', '_')
+                                normalized_reflection = reflection_project.replace('-', '_')
+                                if not (
+                                    reflection_project == target_project or 
+                                    normalized_reflection == normalized_target or
+                                    reflection_project.endswith(f"/{target_project}") or
+                                    reflection_project.endswith(f"-{target_project}") or
+                                    normalized_reflection.endswith(f"_{normalized_target}") or
+                                    normalized_reflection.endswith(f"/{normalized_target}")
+                                ):
+                                    continue  # Skip reflections from other projects
                         
                         # BOOST V2 CHUNKS: Apply score boost for v2 chunks (better quality)
                         original_score = point.score
@@ -816,7 +974,7 @@ async def reflect_on_past(
                         if final_score < min_score:
                             continue
                             
-                        all_results.append(SearchResult(
+                        search_result = SearchResult(
                             id=str(point.id),
                             score=final_score,
                             timestamp=clean_timestamp,
@@ -826,8 +984,15 @@ async def reflect_on_past(
                             conversation_id=point.payload.get('conversation_id'),
                             base_conversation_id=point.payload.get('base_conversation_id'),
                             collection_name=collection_name,
-                            raw_payload=point.payload if include_raw else None
-                        ))
+                            raw_payload=point.payload,  # Always include payload for metadata extraction
+                            # Pattern intelligence metadata
+                            code_patterns=point.payload.get('code_patterns'),
+                            files_analyzed=point.payload.get('files_analyzed'),
+                            tools_used=list(point.payload.get('tools_used', [])) if isinstance(point.payload.get('tools_used'), set) else point.payload.get('tools_used'),
+                            concepts=point.payload.get('concepts')
+                        )
+                        
+                        all_results.append(search_result)
             
             except Exception as e:
                 await ctx.debug(f"Error searching {collection_name}: {str(e)}")
@@ -875,9 +1040,16 @@ async def reflect_on_past(
         all_results = all_results[:limit]
         timing_info['sort_end'] = time.time()
         
+        logger.info(f"Total results: {len(all_results)}, Returning: {len(all_results[:limit])}")
+        for r in all_results[:3]:  # Log first 3
+            logger.debug(f"Result: id={r.id}, has_patterns={bool(r.code_patterns)}, pattern_keys={list(r.code_patterns.keys()) if r.code_patterns else None}")
+        
         if not all_results:
             return f"No conversations found matching '{query}'. Try different keywords or check if conversations have been imported."
         
+        # Aggregate pattern intelligence across results
+        pattern_intelligence = aggregate_pattern_intelligence(all_results)
+        
         # Update indexing status before returning results
         await update_indexing_status()
         
@@ -1031,8 +1203,181 @@ async def reflect_on_past(
                     result_text += "        </meta>\n"
                     result_text += "      </raw>\n"
                 
+                # Add patterns if they exist - with detailed logging
+                if result.code_patterns and isinstance(result.code_patterns, dict):
+                    logger.info(f"DEBUG: Point {result.id} has code_patterns dict with keys: {list(result.code_patterns.keys())}")
+                    patterns_to_show = []
+                    for category, patterns in result.code_patterns.items():
+                        if patterns and isinstance(patterns, list) and len(patterns) > 0:
+                            # Take up to 5 patterns from each category
+                            patterns_to_show.append((category, patterns[:5]))
+                            logger.info(f"DEBUG: Added category '{category}' with {len(patterns)} patterns")
+                    
+                    if patterns_to_show:
+                        logger.info(f"DEBUG: Adding patterns XML for point {result.id}")
+                        result_text += "      <patterns>\n"
+                        for category, patterns in patterns_to_show:
+                            # Escape both category name and pattern content for XML safety
+                            safe_patterns = ', '.join(escape(str(p)) for p in patterns)
+                            result_text += f"        <cat name=\"{escape(category)}\">{safe_patterns}</cat>\n"
+                        result_text += "      </patterns>\n"
+                    else:
+                        logger.info(f"DEBUG: Point {result.id} has code_patterns but no valid patterns to show")
+                else:
+                    logger.info(f"DEBUG: Point {result.id} has no patterns. code_patterns={result.code_patterns}, type={type(result.code_patterns)}")
+                
+                if result.files_analyzed and len(result.files_analyzed) > 0:
+                    result_text += f"      <files>{', '.join(result.files_analyzed[:5])}</files>\n"
+                if result.concepts and len(result.concepts) > 0:
+                    result_text += f"      <concepts>{', '.join(result.concepts[:5])}</concepts>\n"
+                
+                # Include structured metadata for agent consumption
+                # This provides clean, parsed fields that agents can easily use
+                if hasattr(result, 'raw_payload') and result.raw_payload:
+                    import json
+                    payload = result.raw_payload
+                    
+                    # Files section - structured for easy agent parsing
+                    files_analyzed = payload.get('files_analyzed', [])
+                    files_edited = payload.get('files_edited', [])
+                    if files_analyzed or files_edited:
+                        result_text += "      <files>\n"
+                        if files_analyzed:
+                            result_text += f"        <analyzed count=\"{len(files_analyzed)}\">"
+                            result_text += ", ".join(files_analyzed[:5])  # First 5 files
+                            if len(files_analyzed) > 5:
+                                result_text += f" ... and {len(files_analyzed)-5} more"
+                            result_text += "</analyzed>\n"
+                        if files_edited:
+                            result_text += f"        <edited count=\"{len(files_edited)}\">"
+                            result_text += ", ".join(files_edited[:5])  # First 5 files
+                            if len(files_edited) > 5:
+                                result_text += f" ... and {len(files_edited)-5} more"
+                            result_text += "</edited>\n"
+                        result_text += "      </files>\n"
+                    
+                    # Concepts section - clean list for agents
+                    concepts = payload.get('concepts', [])
+                    if concepts:
+                        result_text += f"      <concepts>{', '.join(concepts)}</concepts>\n"
+                    
+                    # Tools section - summarized with counts
+                    tools_used = payload.get('tools_used', [])
+                    if tools_used:
+                        # Count tool usage
+                        tool_counts = {}
+                        for tool in tools_used:
+                            tool_counts[tool] = tool_counts.get(tool, 0) + 1
+                        # Sort by frequency
+                        sorted_tools = sorted(tool_counts.items(), key=lambda x: x[1], reverse=True)
+                        tool_summary = ", ".join(f"{tool}({count})" for tool, count in sorted_tools[:5])
+                        if len(sorted_tools) > 5:
+                            tool_summary += f" ... and {len(sorted_tools)-5} more"
+                        result_text += f"      <tools>{tool_summary}</tools>\n"
+                    
+                    # Code patterns section - structured by category
+                    code_patterns = payload.get('code_patterns', {})
+                    if code_patterns:
+                        result_text += "      <code_patterns>\n"
+                        for category, patterns in code_patterns.items():
+                            if patterns:
+                                pattern_list = patterns if isinstance(patterns, list) else [patterns]
+                                # Clean up pattern names
+                                clean_patterns = []
+                                for p in pattern_list[:5]:
+                                    # Remove common prefixes like $FUNC, $VAR
+                                    clean_p = str(p).replace('$FUNC', '').replace('$VAR', '').strip()
+                                    if clean_p:
+                                        clean_patterns.append(clean_p)
+                                if clean_patterns:
+                                    result_text += f"        <{category}>{', '.join(clean_patterns)}</{category}>\n"
+                        result_text += "      </code_patterns>\n"
+                    
+                    # Pattern inheritance info - shows propagation details
+                    pattern_inheritance = payload.get('pattern_inheritance', {})
+                    if pattern_inheritance:
+                        source_chunk = pattern_inheritance.get('source_chunk', '')
+                        confidence = pattern_inheritance.get('confidence', 0)
+                        distance = pattern_inheritance.get('distance', 0)
+                        if source_chunk:
+                            result_text += f"      <pattern_source chunk=\"{source_chunk}\" confidence=\"{confidence:.2f}\" distance=\"{distance}\"/>\n"
+                    
+                    # Message stats for context
+                    msg_count = payload.get('message_count')
+                    total_length = payload.get('total_length')
+                    if msg_count or total_length:
+                        stats_attrs = []
+                        if msg_count:
+                            stats_attrs.append(f'messages="{msg_count}"')
+                        if total_length:
+                            stats_attrs.append(f'length="{total_length}"')
+                        result_text += f"      <stats {' '.join(stats_attrs)}/>\n"
+                    
+                    # Raw metadata dump for backwards compatibility
+                    # Kept minimal - only truly unique fields
+                    remaining_metadata = {}
+                    excluded_keys = {'text', 'conversation_id', 'timestamp', 'role', 'project', 'chunk_index',
+                                   'files_analyzed', 'files_edited', 'concepts', 'tools_used', 
+                                   'code_patterns', 'pattern_inheritance', 'message_count', 'total_length',
+                                   'chunking_version', 'chunk_method', 'chunk_overlap', 'migration_type'}
+                    for key, value in payload.items():
+                        if key not in excluded_keys and value is not None:
+                            if isinstance(value, set):
+                                value = list(value)
+                            remaining_metadata[key] = value
+                    
+                    if remaining_metadata:
+                        try:
+                            # Only include if there's actually extra data
+                            result_text += f"      <metadata_extra><![CDATA[{json.dumps(remaining_metadata, default=str)}]]></metadata_extra>\n"
+                        except:
+                            pass
+                
                 result_text += "    </r>\n"
             result_text += "  </results>\n"
+            
+            # Add aggregated pattern intelligence section
+            if pattern_intelligence and pattern_intelligence.get('total_unique_patterns', 0) > 0:
+                result_text += "  <pattern_intelligence>\n"
+                
+                # Summary statistics
+                result_text += f"    <summary>\n"
+                result_text += f"      <unique_patterns>{pattern_intelligence['total_unique_patterns']}</unique_patterns>\n"
+                result_text += f"      <pattern_diversity>{pattern_intelligence['pattern_diversity_score']:.2f}</pattern_diversity>\n"
+                result_text += f"    </summary>\n"
+                
+                # Most common patterns
+                if pattern_intelligence.get('most_common_patterns'):
+                    result_text += "    <common_patterns>\n"
+                    for pattern, count in pattern_intelligence['most_common_patterns'][:5]:
+                        result_text += f"      <pattern count=\"{count}\">{pattern}</pattern>\n"
+                    result_text += "    </common_patterns>\n"
+                
+                # Pattern categories
+                if pattern_intelligence.get('category_coverage'):
+                    result_text += "    <categories>\n"
+                    for category, count in pattern_intelligence['category_coverage'].items():
+                        result_text += f"      <cat name=\"{category}\" count=\"{count}\"/>\n"
+                    result_text += "    </categories>\n"
+                
+                # Pattern combinations insight
+                if pattern_intelligence.get('pattern_combinations'):
+                    combos = pattern_intelligence['pattern_combinations']
+                    if combos.get('async_with_error_handling'):
+                        result_text += "    <insight>Async patterns combined with error handling detected</insight>\n"
+                    if combos.get('react_with_state'):
+                        result_text += "    <insight>React hooks with state management patterns detected</insight>\n"
+                
+                # Files referenced across results
+                if pattern_intelligence.get('files_referenced') and len(pattern_intelligence['files_referenced']) > 0:
+                    result_text += f"    <files_across_results>{', '.join(pattern_intelligence['files_referenced'][:10])}</files_across_results>\n"
+                
+                # Concepts discussed
+                if pattern_intelligence.get('concepts_discussed') and len(pattern_intelligence['concepts_discussed']) > 0:
+                    result_text += f"    <concepts_discussed>{', '.join(pattern_intelligence['concepts_discussed'][:10])}</concepts_discussed>\n"
+                
+                result_text += "  </pattern_intelligence>\n"
+            
             result_text += "</search>"
             
         else:
@@ -1504,6 +1849,93 @@ async def search_by_concept(
 # Debug output
 print(f"[DEBUG] FastMCP server created with name: {mcp.name}")
 
+@mcp.tool()
+async def get_full_conversation(
+    ctx: Context,
+    conversation_id: str = Field(description="The conversation ID from search results (cid)"),
+    project: Optional[str] = Field(default=None, description="Optional project name to help locate the file")
+) -> str:
+    """Get the full JSONL conversation file path for a conversation ID.
+    This allows agents to read complete conversations instead of truncated excerpts."""
+    
+    # Base path for Claude conversations
+    base_path = Path.home() / '.claude/projects'
+    
+    # Build list of directories to search
+    search_dirs = []
+    
+    if project:
+        # Try various project directory name formats
+        sanitized_project = project.replace('/', '-')
+        search_dirs.extend([
+            base_path / project,
+            base_path / sanitized_project,
+            base_path / f"-Users-ramakrishnanannaswamy-projects-{project}",
+            base_path / f"-Users-ramakrishnanannaswamy-projects-{sanitized_project}"
+        ])
+    else:
+        # Search all project directories
+        search_dirs = list(base_path.glob("*"))
+    
+    # Search for the JSONL file
+    jsonl_path = None
+    for search_dir in search_dirs:
+        if not search_dir.is_dir():
+            continue
+            
+        potential_path = search_dir / f"{conversation_id}.jsonl"
+        if potential_path.exists():
+            jsonl_path = potential_path
+            break
+    
+    if not jsonl_path:
+        # Try searching all directories as fallback
+        for proj_dir in base_path.glob("*"):
+            if proj_dir.is_dir():
+                potential_path = proj_dir / f"{conversation_id}.jsonl"
+                if potential_path.exists():
+                    jsonl_path = potential_path
+                    break
+    
+    if not jsonl_path:
+        return f"""<full_conversation>
+<conversation_id>{conversation_id}</conversation_id>
+<status>not_found</status>
+<message>Conversation file not found. Searched {len(search_dirs)} directories.</message>
+<hint>Try using the project parameter or check if the conversation ID is correct.</hint>
+</full_conversation>"""
+    
+    # Get file stats
+    file_stats = jsonl_path.stat()
+    
+    # Count messages
+    try:
+        with open(jsonl_path, 'r', encoding='utf-8') as f:
+            message_count = sum(1 for _ in f)
+    except:
+        message_count = 0
+    
+    return f"""<full_conversation>
+<conversation_id>{conversation_id}</conversation_id>
+<status>found</status>
+<file_path>{jsonl_path}</file_path>
+<file_size>{file_stats.st_size}</file_size>
+<message_count>{message_count}</message_count>
+<project>{jsonl_path.parent.name}</project>
+<instructions>
+You can now use the Read tool to read the full conversation from:
+{jsonl_path}
+
+Each line in the JSONL file is a separate message with complete content.
+This gives you access to:
+- Complete code blocks (not truncated)
+- Full problem descriptions and solutions
+- Entire debugging sessions
+- Complete architectural decisions and discussions
+</instructions>
+</full_conversation>"""
+
+
 # Run the server
 if __name__ == "__main__":
     import sys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "2.8.7",
+  "version": "2.8.9",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",