claude-mpm 4.15.6__py3-none-any.whl → 4.21.3__py3-none-any.whl

claude_mpm/tools/code_tree_analyzer/python_analyzer.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Python Analyzer
+===============
+
+Analyzes Python source code using AST.
+
+WHY: Python's built-in AST module provides rich structural information
+that we can leverage for detailed analysis.
+"""
+
+import ast
+from pathlib import Path
+from typing import List, Optional
+
+from ...core.logging_config import get_logger
+from ..code_tree_events import CodeNodeEvent, CodeTreeEventEmitter
+from .models import CodeNode
+
+
+class PythonAnalyzer:
+    """Analyzes Python source code using AST."""
+
+    def __init__(self, emitter: Optional[CodeTreeEventEmitter] = None):
+        self.logger = get_logger(__name__)
+        self.emitter = emitter
+
+    def analyze_file(self, file_path: Path) -> List[CodeNode]:
+        """Analyze a Python file and extract code structure.
+
+        Args:
+            file_path: Path to Python file
+
+        Returns:
+            List of code nodes found in the file
+        """
+        nodes = []
+
+        try:
+            with Path(file_path).open(
+                encoding="utf-8",
+            ) as f:
+                source = f.read()
+
+            tree = ast.parse(source, filename=str(file_path))
+            nodes = self._extract_nodes(tree, file_path, source)
+
+        except SyntaxError as e:
+            self.logger.warning(f"Syntax error in {file_path}: {e}")
+            if self.emitter:
+                self.emitter.emit_error(str(file_path), f"Syntax error: {e}")
+        except Exception as e:
+            self.logger.error(f"Error analyzing {file_path}: {e}")
+            if self.emitter:
+                self.emitter.emit_error(str(file_path), str(e))
+
+        return nodes
+
+    def _extract_nodes(
+        self, tree: ast.AST, file_path: Path, source: str
+    ) -> List[CodeNode]:
+        """Extract code nodes from AST tree.
+
+        Args:
+            tree: AST tree
+            file_path: Source file path
+            source: Source code text
+
+        Returns:
+            List of extracted code nodes
+        """
+        nodes = []
+        source.splitlines()
+
+        class NodeVisitor(ast.NodeVisitor):
+            def __init__(self, parent_name: Optional[str] = None):
+                self.parent_name = parent_name
+                self.current_class = None
+
+            def visit_ClassDef(self, node):
+                # Extract class information
+                class_node = CodeNode(
+                    file_path=str(file_path),
+                    node_type="class",
+                    name=node.name,
+                    line_start=node.lineno,
+                    line_end=node.end_lineno or node.lineno,
+                    has_docstring=bool(ast.get_docstring(node)),
+                    decorators=[self._decorator_name(d) for d in node.decorator_list],
+                    parent=self.parent_name,
+                    complexity=self._calculate_complexity(node),
+                    signature=self._get_class_signature(node),
+                )
+
+                nodes.append(class_node)
+
+                # Emit event if emitter is available
+                if self.emitter:
+                    self.emitter.emit_node(
+                        CodeNodeEvent(
+                            file_path=str(file_path),
+                            node_type="class",
+                            name=node.name,
+                            line_start=node.lineno,
+                            line_end=node.end_lineno or node.lineno,
+                            complexity=class_node.complexity,
+                            has_docstring=class_node.has_docstring,
+                            decorators=class_node.decorators,
+                            parent=self.parent_name,
+                            children_count=len(node.body),
+                        )
+                    )
+
+                # Visit class members
+                old_class = self.current_class
+                self.current_class = node.name
+                for child in node.body:
+                    if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        self.visit_FunctionDef(child, is_method=True)
+                self.current_class = old_class
+
+            def visit_FunctionDef(self, node, is_method=False):
+                # Determine node type
+                node_type = "method" if is_method else "function"
+                parent = self.current_class if is_method else self.parent_name
+
+                # Extract function information
+                func_node = CodeNode(
+                    file_path=str(file_path),
+                    node_type=node_type,
+                    name=node.name,
+                    line_start=node.lineno,
+                    line_end=node.end_lineno or node.lineno,
+                    has_docstring=bool(ast.get_docstring(node)),
+                    decorators=[self._decorator_name(d) for d in node.decorator_list],
+                    parent=parent,
+                    complexity=self._calculate_complexity(node),
+                    signature=self._get_function_signature(node),
+                )
+
+                nodes.append(func_node)
+
+                # Emit event if emitter is available
+                if self.emitter:
+                    self.emitter.emit_node(
+                        CodeNodeEvent(
+                            file_path=str(file_path),
+                            node_type=node_type,
+                            name=node.name,
+                            line_start=node.lineno,
+                            line_end=node.end_lineno or node.lineno,
+                            complexity=func_node.complexity,
+                            has_docstring=func_node.has_docstring,
+                            decorators=func_node.decorators,
+                            parent=parent,
+                            children_count=0,
+                        )
+                    )
+
+            def visit_Assign(self, node):
+                # Handle module-level variable assignments
+                if self.current_class is None:  # Only module-level assignments
+                    for target in node.targets:
+                        if isinstance(target, ast.Name):
+                            var_node = CodeNode(
+                                file_path=str(file_path),
+                                node_type="variable",
+                                name=target.id,
+                                line_start=node.lineno,
+                                line_end=node.end_lineno or node.lineno,
+                                parent=self.parent_name,
+                                complexity=0,
+                                signature=f"{target.id} = ...",
+                            )
+                            nodes.append(var_node)
+
+                            # Emit event if emitter is available
+                            if self.emitter:
+                                self.emitter.emit_node(
+                                    CodeNodeEvent(
+                                        file_path=str(file_path),
+                                        node_type="variable",
+                                        name=target.id,
+                                        line_start=node.lineno,
+                                        line_end=node.end_lineno or node.lineno,
+                                        parent=self.parent_name,
+                                    )
+                                )
+
+            def visit_AsyncFunctionDef(self, node):
+                self.visit_FunctionDef(node)
+
+            def _decorator_name(self, decorator):
+                """Extract decorator name from AST node."""
+                if isinstance(decorator, ast.Name):
+                    return decorator.id
+                if isinstance(decorator, ast.Call):
+                    if isinstance(decorator.func, ast.Name):
+                        return decorator.func.id
+                    if isinstance(decorator.func, ast.Attribute):
+                        return decorator.func.attr
+                return "unknown"
+
+            def _calculate_complexity(self, node):
+                """Calculate cyclomatic complexity of a node."""
+                complexity = 1  # Base complexity
+
+                for child in ast.walk(node):
+                    if isinstance(
+                        child, (ast.If, ast.While, ast.For, ast.ExceptHandler)
+                    ):
+                        complexity += 1
+                    elif isinstance(child, ast.BoolOp):
+                        complexity += len(child.values) - 1
+
+                return complexity
+
+            def _get_function_signature(self, node):
+                """Extract function signature."""
+                args = []
+                for arg in node.args.args:
+                    args.append(arg.arg)
+                return f"{node.name}({', '.join(args)})"
+
+            def _get_class_signature(self, node):
+                """Extract class signature."""
+                bases = []
+                for base in node.bases:
+                    if isinstance(base, ast.Name):
+                        bases.append(base.id)
+                base_str = f"({', '.join(bases)})" if bases else ""
+                return f"class {node.name}{base_str}"
+
+        # Extract imports
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    import_node = CodeNode(
+                        file_path=str(file_path),
+                        node_type="import",
+                        name=alias.name,
+                        line_start=node.lineno,
+                        line_end=node.end_lineno or node.lineno,
+                        signature=f"import {alias.name}",
+                    )
+                    nodes.append(import_node)
+
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                for alias in node.names:
+                    import_node = CodeNode(
+                        file_path=str(file_path),
+                        node_type="import",
+                        name=f"{module}.{alias.name}",
+                        line_start=node.lineno,
+                        line_end=node.end_lineno or node.lineno,
+                        signature=f"from {module} import {alias.name}",
+                    )
+                    nodes.append(import_node)
+
+        # Visit all nodes
+        visitor = NodeVisitor()
+        visitor.emitter = self.emitter
+        visitor.visit(tree)
+
+        return nodes
+
+    def _get_assignment_signature(self, node: ast.Assign, var_name: str) -> str:
+        """Get assignment signature string."""
+        try:
+            # Try to get a simple representation of the value
+            if isinstance(node.value, ast.Constant):
+                if isinstance(node.value.value, str):
+                    return f'{var_name} = "{node.value.value}"'
+                return f"{var_name} = {node.value.value}"
+            if isinstance(node.value, ast.Name):
+                return f"{var_name} = {node.value.id}"
+            if isinstance(node.value, ast.List):
+                return f"{var_name} = [...]"
+            if isinstance(node.value, ast.Dict):
+                return f"{var_name} = {{...}}"
+            return f"{var_name} = ..."
+        except Exception:
+            return f"{var_name} = ..."

claude_mpm/utils/agent_dependency_loader.py

@@ -85,7 +85,7 @@ class AgentDependencyLoader:
             deployed_agents[agent_id] = agent_file
             logger.debug(f"Found deployed agent: {agent_id}")
 
-        logger.info(f"Discovered {len(deployed_agents)} deployed agents")
+        logger.debug(f"Discovered {len(deployed_agents)} deployed agents")
         self.deployed_agents = deployed_agents
         return deployed_agents
 
@@ -121,7 +121,7 @@ class AgentDependencyLoader:
                         logger.warning(f"Failed to load config for {agent_id}: {e}")
 
         self.agent_dependencies = agent_dependencies
-        logger.info(f"Loaded dependencies for {len(agent_dependencies)} agents")
+        logger.debug(f"Loaded dependencies for {len(agent_dependencies)} agents")
         return agent_dependencies
 
     def check_python_dependency(self, package_spec: str) -> Tuple[bool, Optional[str]]:

{claude_mpm-4.15.6.dist-info → claude_mpm-4.21.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.15.6
+Version: 4.21.3
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team
@@ -31,7 +31,7 @@ Requires-Dist: requests>=2.25.0
 Requires-Dist: flask>=3.0.0
 Requires-Dist: flask-cors>=4.0.0
 Requires-Dist: watchdog>=3.0.0
-Requires-Dist: python-socketio>=5.11.0
+Requires-Dist: python-socketio>=5.14.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiohttp-cors<0.8.0,>=0.7.0
 Requires-Dist: python-engineio>=4.8.0
@@ -75,7 +75,7 @@ Requires-Dist: sphinx>=7.2.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
 Provides-Extra: monitor
-Requires-Dist: python-socketio>=5.11.0; extra == "monitor"
+Requires-Dist: python-socketio>=5.14.0; extra == "monitor"
 Requires-Dist: aiohttp>=3.9.0; extra == "monitor"
 Requires-Dist: aiohttp-cors<0.8.0,>=0.7.0; extra == "monitor"
 Requires-Dist: python-engineio>=4.8.0; extra == "monitor"
@@ -157,12 +157,12 @@ A powerful orchestration framework for **Claude Code (CLI)** that enables multi-
 ## Features
 
 - 🤖 **Multi-Agent System**: 15 specialized agents for comprehensive project management
-- 🧠 **Persistent Knowledge System**: Project-specific kuzu-memory integration for intelligent context retention
+- 🎯 **Skills System**: 20 bundled skills with auto-linking, three-tier organization (bundled/user/project), and interactive configuration
 - 🔄 **Session Management**: Resume previous sessions with `--resume`
+- 📋 **Resume Log System**: Proactive context management with automatic 10k-token session logs at 70%/85%/95% thresholds
 - 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
-- 🔌 **Smart MCP Services**: Interactive auto-install for mcp-vector-search on first use (pip/pipx choice)
-- 🔍 **Semantic Code Search**: Optional vector search with graceful fallback to grep/glob
-- 📁 **Multi-Project Support**: Per-session working directories with persistent knowledge graphs
+- 🔌 **MCP Integration**: Full support for Model Context Protocol services
+- 📁 **Multi-Project Support**: Per-session working directories
 - 🔍 **Git Integration**: View diffs and track changes across projects
 - 🎯 **Smart Task Orchestration**: PM agent intelligently routes work to specialists
 - ⚡ **Simplified Architecture**: ~3,700 lines removed for better performance and maintainability
@@ -174,8 +174,8 @@ A powerful orchestration framework for **Claude Code (CLI)** that enables multi-
 # Basic installation
 pip install claude-mpm
 
-# Install with optional MCP services (recommended)
-pip install "claude-mpm[mcp]"
+# Install with monitoring dashboard (recommended)
+pip install "claude-mpm[monitor]"
 ```
 
 Or with pipx (recommended for isolated installation):
@@ -183,30 +183,87 @@ Or with pipx (recommended for isolated installation):
 # Basic installation
 pipx install claude-mpm
 
-# Install with optional MCP services (recommended)
-pipx install "claude-mpm[mcp]"
-
-# Install with all features
-pipx install "claude-mpm[mcp,monitor]"
-
-# Configure MCP for pipx users:
-claude-mpm mcp-pipx-config
+# Install with monitoring dashboard (recommended)
+pipx install "claude-mpm[monitor]"
 ```
 
 **💡 Optional Dependencies**:
-- `[mcp]` - Include MCP services (mcp-vector-search, mcp-browser, mcp-ticketer)
 - `[monitor]` - Full monitoring dashboard with Socket.IO and async web server components
-- **Combine both**: Use `"claude-mpm[mcp,monitor]"` to install all features
-- **Note**: kuzu-memory is now a required dependency, always included with Claude MPM
-- **Auto-Install**: mcp-vector-search offers interactive installation on first use (pip/pipx choice)
-- Without pre-installed MCP dependencies, services install on-demand with user confirmation
+- `[mcp]` - Additional MCP services (mcp-browser, mcp-ticketer) - most users won't need this
 
 **🎉 Pipx Support Now Fully Functional!** Recent improvements ensure complete compatibility:
 - ✅ Socket.IO daemon script path resolution (fixed)
-- ✅ Commands directory access (fixed) 
+- ✅ Commands directory access (fixed)
 - ✅ Resource files properly packaged for pipx environments
 - ✅ Python 3.13+ fully supported
 
+## 🤝 Recommended Partner Products
+
+Claude MPM works excellently with these complementary MCP tools. While optional, we **strongly recommend** installing them for enhanced capabilities:
+
+### kuzu-memory - Advanced Memory Management
+
+**What it does**: Provides persistent, project-specific knowledge graphs that enable agents to learn and retain context across sessions. Your agents will remember project patterns, architectural decisions, and important context automatically.
+
+**Installation:**
+```bash
+pipx install kuzu-memory
+```
+
+**Benefits with Claude MPM:**
+- 🧠 **Persistent Context**: Agents remember project-specific patterns and decisions across sessions
+- 🎯 **Intelligent Prompts**: Automatically enriches agent prompts with relevant historical context
+- 📊 **Knowledge Graphs**: Structured storage of project knowledge, not just flat memory
+- 🔄 **Seamless Integration**: Works transparently in the background with zero configuration
+- 💡 **Smart Learning**: Agents improve over time as they learn your project's patterns
+
+**Perfect for**: Long-running projects, teams needing consistent context, complex codebases with deep architectural patterns.
+
+**Learn more**: [kuzu-memory on PyPI](https://pypi.org/project/kuzu-memory/) | [GitHub Repository](https://github.com/bobmatnyc/kuzu-memory)
+
+---
+
+### mcp-vector-search - Semantic Code Search
+
+**What it does**: Enables semantic code search across your entire codebase using AI embeddings. Find code by what it *does*, not just what it's *named*. Search for "authentication logic" and find relevant functions even if they're named differently.
+
+**Installation:**
+```bash
+pipx install mcp-vector-search
+```
+
+**Benefits with Claude MPM:**
+- 🔍 **Semantic Discovery**: Find code by intent and functionality, not just keywords
+- 🎯 **Context-Aware**: Understand code relationships and similarities automatically
+- ⚡ **Fast Indexing**: Efficient vector embeddings for large codebases
+- 🔄 **Live Updates**: Automatically tracks code changes and updates index
+- 📊 **Pattern Recognition**: Discover similar code patterns and potential refactoring opportunities
+
+**Use with**: `/mpm-search "authentication logic"` command in Claude Code sessions or `claude-mpm search` CLI command.
+
+**Perfect for**: Large codebases, discovering existing functionality, finding similar implementations, architectural exploration.
+
+**Learn more**: [mcp-vector-search on PyPI](https://pypi.org/project/mcp-vector-search/) | [GitHub Repository](https://github.com/bobmatnyc/mcp-vector-search)
+
+---
+
+### Quick Setup - Both Tools
+
+Install both recommended tools in one go:
+
+```bash
+pipx install kuzu-memory
+pipx install mcp-vector-search
+```
+
+Then verify they're working:
+
+```bash
+claude-mpm verify
+```
+
+**That's it!** These tools integrate automatically with Claude MPM once installed. No additional configuration needed.
+
 **That's it!** See [QUICKSTART.md](QUICKSTART.md) for immediate usage or [docs/user/installation.md](docs/user/installation.md) for advanced options.
 
 ## Quick Usage
@@ -262,8 +319,7 @@ See [QUICKSTART.md](QUICKSTART.md) for complete usage examples.
 Following Phase 3 architectural simplification in v4.4.1, Claude MPM features:
 
 - **Streamlined Rich Interface**: Removed complex TUI system (~2,500 lines) for cleaner user experience
-- **Optional MCP Services**: mcp-vector-search and kuzu-memory with automatic fallback installation
-- **Persistent Knowledge System**: Project-specific kuzu-memory databases with intelligent prompt enrichment
+- **MCP Integration**: Full support for Model Context Protocol services with automatic detection
 - **Service-Oriented Architecture**: Simplified five specialized service domains
 - **Interface-Based Contracts**: All services implement explicit interfaces
 - **Enhanced Performance**: ~3,700 lines removed for better startup time and maintainability
@@ -279,11 +335,26 @@ Claude MPM includes 15 specialized agents:
 
 #### Core Development
 - **Engineer** - Software development and implementation
-- **Research** - Code analysis and research  
+- **Research** - Code analysis and research
 - **Documentation** - Documentation creation and maintenance
 - **QA** - Testing and quality assurance
 - **Security** - Security analysis and implementation
 
+#### Language-Specific Engineers
+- **Python Engineer (v2.3.0)** - Type-safe, async-first Python with SOA patterns for non-trivial applications
+  - Service-oriented architecture with ABC interfaces for applications
+  - Lightweight script patterns for automation and one-off tasks
+  - Clear decision criteria for when to use DI/SOA vs simple functions
+  - Dependency injection containers with auto-resolution
+  - Use for: Web applications, microservices, data pipelines (DI/SOA) or scripts, CLI tools, notebooks (simple functions)
+
+- **Rust Engineer (v1.1.0)** - Memory-safe, high-performance systems with trait-based service architecture
+  - Dependency injection with traits (constructor injection, trait objects)
+  - Service-oriented architecture patterns (repository, builder)
+  - Decision criteria for when to use DI/SOA vs simple code
+  - Async programming with tokio and zero-cost abstractions
+  - Use for: Web services, microservices (DI/SOA) or CLI tools, scripts (simple code)
+
 #### Operations & Infrastructure
 - **Ops** - Operations and deployment with advanced git commit authority and security verification (v2.2.2+)
 - **Version Control** - Git and version management
@@ -305,6 +376,41 @@ Claude MPM includes 15 specialized agents:
 ### Agent Memory System
 Agents learn project-specific patterns using a simple list format and can update memories via JSON response fields (`remember` for incremental updates, `MEMORIES` for complete replacement). Initialize with `claude-mpm memory init`.
 
+### Skills System
+
+Claude MPM includes a powerful skills system that eliminates redundant agent guidance through reusable skill modules:
+
+**20 Bundled Skills** covering essential development workflows (all versioned starting at 0.1.0):
+- Git workflow, TDD, code review, systematic debugging
+- API documentation, refactoring patterns, performance profiling
+- Docker containerization, database migrations, security scanning
+- JSON/PDF/XLSX handling, async testing, ImageMagick operations
+- Local development servers: Next.js, FastAPI, Vite, Express
+- Web performance: Lighthouse metrics, Core Web Vitals optimization
+
+**Three-Tier Organization:**
+- **Bundled**: Core skills included with Claude MPM (~15,000 lines of reusable guidance)
+- **User**: Custom skills in `~/.config/claude-mpm/skills/`
+- **Project**: Project-specific skills in `.claude-mpm/skills/`
+
+**Version Tracking:**
+- All skills support semantic versioning (MAJOR.MINOR.PATCH)
+- Check versions with `/mpm-version` command in Claude Code
+- See [Skills Versioning Guide](docs/user/skills-versioning.md) for details
+
+**Quick Access:**
+```bash
+# Interactive skills management
+claude-mpm configure
+# Choose option 2: Skills Management
+
+# Auto-link skills to agents based on their roles
+# Configure custom skill assignments
+# View current skill mappings
+```
+
+Skills are automatically injected into agent prompts, reducing template size by 85% while maintaining full capability coverage.
+
 ### MCP Gateway (Model Context Protocol)
 
 Claude MPM includes a powerful MCP Gateway that enables:
@@ -327,6 +433,72 @@ claude-mpm cleanup-memory
 claude-mpm cleanup-memory --days 7
 ```
 
+### Resume Log System
+
+**NEW in v4.17.2** - Proactive context management for seamless session continuity.
+
+The Resume Log System automatically generates structured 10k-token logs when approaching Claude's context window limits, enabling you to resume work without losing important context.
+
+**Key Features**:
+- 🎯 **Graduated Thresholds**: Warnings at 70% (60k buffer), 85% (30k buffer), and 95% (10k buffer)
+- 📋 **Structured Logs**: 10k-token budget intelligently distributed across 7 key sections
+- 🔄 **Seamless Resumption**: Automatically loads previous session context on startup
+- 📁 **Human-Readable**: Markdown format for both Claude and human review
+- ⚙️ **Zero-Configuration**: Works automatically with sensible defaults
+
+**How It Works**:
+1. Monitor token usage continuously throughout session
+2. Display proactive warnings at 70%, 85%, and 95% thresholds
+3. Automatically generate resume log when approaching limits
+4. Load previous resume log when starting new session
+5. Continue work seamlessly with full context preservation
+
+**Example Resume Log Structure**:
+```markdown
+# Session Resume Log: 20251101_115000
+
+## Context Metrics (500 tokens)
+- Token usage and percentage
+
+## Mission Summary (1,000 tokens)
+- Overall goal and purpose
+
+## Accomplishments (2,000 tokens)
+- What was completed
+
+## Key Findings (2,500 tokens)
+- Important discoveries
+
+## Decisions & Rationale (1,500 tokens)
+- Why choices were made
+
+## Next Steps (1,500 tokens)
+- What to do next
+
+## Critical Context (1,000 tokens)
+- Essential state, IDs, paths
+```
+
+**Configuration** (`.claude-mpm/configuration.yaml`):
+```yaml
+context_management:
+  enabled: true
+  budget_total: 200000
+  thresholds:
+    caution: 0.70   # First warning - plan transition
+    warning: 0.85   # Strong warning - wrap up
+    critical: 0.95  # Urgent - stop new work
+  resume_logs:
+    enabled: true
+    auto_generate: true
+    max_tokens: 10000
+    storage_dir: ".claude-mpm/resume-logs"
+```
+
+**QA Status**: 40/41 tests passing (97.6% coverage), APPROVED FOR PRODUCTION ✅
+
+See [docs/user/resume-logs.md](docs/user/resume-logs.md) for complete documentation.
+
 ### Real-Time Monitoring
 The `--monitor` flag opens a web dashboard showing live agent activity, file operations, and session management.
 
@@ -365,19 +537,25 @@ See [docs/MEMORY.md](docs/MEMORY.md) and [docs/developer/11-dashboard/README.md]
 - **Single Entry Point**: [docs/README.md](docs/README.md) is your navigation hub
 - **Clear User Paths**: Organized by user type and experience level
 - **Cross-Referenced**: Links between related topics and sections
-- **Up-to-Date**: Version 4.3.3 with current information
+- **Up-to-Date**: Version 4.16.3 with web performance optimization skill
+
+## Recent Updates (v4.16.3)
+
+**Web Performance Optimization**: New `web-performance-optimization` skill for Lighthouse metrics, Core Web Vitals (LCP, INP, CLS), and framework-specific optimization patterns.
+
+## Previous Updates (v4.16.1)
 
-## Recent Updates (v4.3.3)
+**Local Development Skills**: Added 4 new toolchain-specific skills: `nextjs-local-dev`, `fastapi-local-dev`, `vite-local-dev`, and `express-local-dev` for professional local server management with PM2, HMR, and production-grade patterns.
 
-**Enhanced PM Instructions**: PM2 deployment support and mandatory web-qa verification for quality assurance.
+**Skills System Integration**: 20 bundled skills with auto-linking, three-tier organization, and interactive configuration. Eliminates 85% of redundant guidance across agent templates (~15,000 lines of reusable content).
 
-**Improved Version Management**: Better version comparison logic and agent override warnings for smoother operations.
+**Enhanced Documentation**: Complete documentation suite with PDF guides, reorganized structure, and comprehensive design documents for skills integration.
 
-**Code Quality Improvements**: Auto-fix code formatting and import management with enhanced standard tools recognition.
+**Agent Template Improvements**: Cleaned agent templates with skills integration, removing redundant guidance while maintaining full capability coverage.
 
-**Documentation Overhaul**: Unified documentation architecture with single entry point and clear navigation paths.
+**Interactive Skills Management**: New skills wizard accessible via `claude-mpm configure` for viewing, configuring, and auto-linking skills to agents.
 
-**Performance Enhancements**: Continued 50-80% performance improvements through intelligent caching and lazy loading.
+**Bug Fixes**: Resolved agent template inconsistencies and improved configuration management.
 
 See [CHANGELOG.md](CHANGELOG.md) for full history and [docs/user/MIGRATION.md](docs/user/MIGRATION.md) for upgrade instructions.