claude-mpm 4.7.5__py3-none-any.whl → 4.7.6__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.7.5
+4.7.6

claude_mpm/cli/commands/configure.py

@@ -374,7 +374,9 @@ class ConfigureCommand(BaseCommand):
         self.console.print(menu_panel)
         self.console.print()
 
-        return Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        # Strip whitespace to handle leading/trailing spaces
+        return choice.strip().lower()
 
     def _manage_agents(self) -> None:
         """Agent management interface."""
@@ -425,7 +427,7 @@ class ConfigureCommand(BaseCommand):
         table.add_column("ID", style="dim", width=3)
         table.add_column("Name", style="cyan", width=22)
         table.add_column("Status", width=12)
-        table.add_column("Description", style="white", width=45)
+        table.add_column("Description", style="bold cyan", width=45)
         table.add_column("Model/Tools", style="dim", width=20)
 
         for idx, agent in enumerate(agents, 1):
@@ -456,12 +458,11 @@ class ConfigureCommand(BaseCommand):
                 except Exception:
                     tools_display = "Default"
 
-            # Truncate description for table display
-            desc_display = (
-                agent.description[:42] + "..."
-                if len(agent.description) > 42
-                else agent.description
-            )
+            # Truncate description for table display with bright styling
+            if len(agent.description) > 42:
+                desc_display = f"[cyan]{agent.description[:42]}[/cyan][dim]...[/dim]"
+            else:
+                desc_display = f"[cyan]{agent.description}[/cyan]"
 
             table.add_row(str(idx), agent.name, status, desc_display, tools_display)
 
@@ -821,6 +822,61 @@ class ConfigureCommand(BaseCommand):
         with self.console.pager():
             self.console.print(syntax)
 
+    def _reset_agent_defaults(self, agents: List[AgentConfig]) -> None:
+        """Reset an agent to default enabled state and remove custom template.
+
+        This method:
+        - Prompts for agent ID
+        - Resets agent to enabled state
+        - Removes any custom template overrides
+        - Shows success/error messages
+        """
+        agent_id = Prompt.ask("Enter agent ID to reset to defaults")
+
+        try:
+            idx = int(agent_id) - 1
+            if 0 <= idx < len(agents):
+                agent = agents[idx]
+
+                # Confirm the reset action
+                if not Confirm.ask(
+                    f"[yellow]Reset '{agent.name}' to defaults? This will:[/yellow]\n"
+                    "  - Enable the agent\n"
+                    "  - Remove custom template (if any)\n"
+                    "[yellow]Continue?[/yellow]"
+                ):
+                    self.console.print("[yellow]Reset cancelled.[/yellow]")
+                    Prompt.ask("Press Enter to continue")
+                    return
+
+                # Enable the agent
+                self.agent_manager.set_agent_enabled(agent.name, True)
+
+                # Remove custom template if exists
+                template_path = self._get_agent_template_path(agent.name)
+                if template_path.exists() and not str(template_path).startswith(
+                    str(self.agent_manager.templates_dir)
+                ):
+                    # This is a custom template, remove it
+                    template_path.unlink(missing_ok=True)
+                    self.console.print(
+                        f"[green]✓ Removed custom template for '{agent.name}'[/green]"
+                    )
+
+                self.console.print(
+                    f"[green]✓ Agent '{agent.name}' reset to defaults![/green]"
+                )
+                self.console.print(
+                    "[dim]Agent is now enabled with system template.[/dim]"
+                )
+            else:
+                self.console.print("[red]Invalid agent ID.[/red]")
+
+        except ValueError:
+            self.console.print("[red]Invalid input. Please enter a number.[/red]")
+
+        Prompt.ask("Press Enter to continue")
+
     def _view_agent_details(self, agents: List[AgentConfig]) -> None:
         """View detailed information about an agent."""
         agent_id = Prompt.ask("Enter agent ID to view")
@@ -1331,7 +1387,7 @@ class ConfigureCommand(BaseCommand):
             table.add_column("ID", style="dim", width=5)
             table.add_column("Agent", style="cyan", width=25)
             table.add_column("Status", width=15)
-            table.add_column("Description", style="white", width=45)
+            table.add_column("Description", style="bold cyan", width=45)
 
             for idx, agent in enumerate(agents, 1):
                 # Agent is ENABLED if NOT in disabled list
@@ -1341,11 +1397,13 @@ class ConfigureCommand(BaseCommand):
                     if is_enabled
                     else "[red]✗ Disabled[/red]"
                 )
-                desc_display = (
-                    agent.description[:42] + "..."
-                    if len(agent.description) > 42
-                    else agent.description
-                )
+                # Format description with bright styling
+                if len(agent.description) > 42:
+                    desc_display = (
+                        f"[cyan]{agent.description[:42]}[/cyan][dim]...[/dim]"
+                    )
+                else:
+                    desc_display = f"[cyan]{agent.description}[/cyan]"
                 table.add_row(str(idx), agent.name, status, desc_display)
 
             self.console.print(table)

claude_mpm/hooks/__init__.py

@@ -1,13 +1,19 @@
 """Hook system for claude-mpm."""
 
 from .base_hook import BaseHook, HookContext, HookResult, HookType
+from .kuzu_enrichment_hook import KuzuEnrichmentHook, get_kuzu_enrichment_hook
 from .kuzu_memory_hook import KuzuMemoryHook, get_kuzu_memory_hook
+from .kuzu_response_hook import KuzuResponseHook, get_kuzu_response_hook
 
 __all__ = [
     "BaseHook",
     "HookContext",
     "HookResult",
     "HookType",
+    "KuzuEnrichmentHook",
     "KuzuMemoryHook",
+    "KuzuResponseHook",
+    "get_kuzu_enrichment_hook",
     "get_kuzu_memory_hook",
+    "get_kuzu_response_hook",
 ]

claude_mpm/hooks/kuzu_enrichment_hook.py

@@ -0,0 +1,263 @@
+"""
+Kuzu-Memory Pre-Delegation Enrichment Hook
+==========================================
+
+Enriches agent delegation context with relevant memories from kuzu-memory
+before the agent receives the task. This is the READ side of bidirectional
+enrichment.
+
+WHY: Agents need access to relevant historical knowledge when performing tasks.
+This hook retrieves memories from kuzu-memory and injects them into the
+delegation context.
+
+DESIGN DECISIONS:
+- Priority 10 to run early, before other context modifications
+- Reuses KuzuMemoryHook's retrieval methods for consistency
+- Injects memories as a dedicated section in agent context
+- Falls back gracefully if kuzu-memory is not available
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from claude_mpm.hooks.base_hook import HookContext, HookResult, PreDelegationHook
+from claude_mpm.hooks.kuzu_memory_hook import get_kuzu_memory_hook
+
+logger = logging.getLogger(__name__)
+
+
+class KuzuEnrichmentHook(PreDelegationHook):
+    """
+    Hook that enriches agent delegation context with kuzu-memory.
+
+    This hook:
+    1. Extracts the task/prompt from delegation context
+    2. Retrieves relevant memories from kuzu-memory
+    3. Injects memories into agent context
+    4. Formats memories for optimal agent understanding
+    """
+
+    def __init__(self):
+        """Initialize the kuzu-memory enrichment hook."""
+        super().__init__(name="kuzu_memory_enrichment", priority=10)
+
+        # Reuse the kuzu-memory hook instance for retrieval
+        self.kuzu_hook = get_kuzu_memory_hook()
+        self.enabled = self.kuzu_hook.enabled
+
+        if not self.enabled:
+            logger.info(
+                "Kuzu-memory enrichment hook disabled (kuzu-memory not available)"
+            )
+        else:
+            logger.info("Kuzu-memory enrichment hook enabled")
+
+    def validate(self, context: HookContext) -> bool:
+        """
+        Validate if hook should process this context.
+
+        Args:
+            context: Hook context to validate
+
+        Returns:
+            True if hook should execute
+        """
+        if not self.enabled:
+            return False
+
+        # Check base validation (enabled, correct hook type, has agent)
+        if not super().validate(context):
+            return False
+
+        # Must have agent and context data
+        if not context.data.get("agent"):
+            return False
+
+        return True
+
+    def execute(self, context: HookContext) -> HookResult:
+        """
+        Enrich delegation context with relevant memories.
+
+        Args:
+            context: Hook context containing delegation data
+
+        Returns:
+            HookResult with enriched context
+        """
+        if not self.enabled:
+            return HookResult(success=True, data=context.data, modified=False)
+
+        try:
+            # Extract query for memory retrieval
+            query = self._extract_query_from_context(context.data)
+
+            if not query:
+                logger.debug("No query extracted from context for memory retrieval")
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Retrieve relevant memories
+            memories = self.kuzu_hook._retrieve_memories(query)
+
+            if not memories:
+                logger.debug("No relevant memories found")
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Enrich context with memories
+            enriched_data = self._enrich_delegation_context(
+                context.data, memories, context.data.get("agent", "Agent")
+            )
+
+            logger.info(
+                f"Enriched delegation context with {len(memories)} memories for {context.data.get('agent')}"
+            )
+
+            return HookResult(
+                success=True,
+                data=enriched_data,
+                modified=True,
+                metadata={
+                    "memories_added": len(memories),
+                    "memory_source": "kuzu",
+                    "agent": context.data.get("agent"),
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Error in kuzu enrichment hook: {e}")
+            # Don't fail the delegation if memory enrichment fails
+            return HookResult(
+                success=True,
+                data=context.data,
+                modified=False,
+                error=f"Memory enrichment failed: {e}",
+            )
+
+    def _extract_query_from_context(self, data: Dict[str, Any]) -> Optional[str]:
+        """
+        Extract query text for memory retrieval.
+
+        Args:
+            data: Delegation context data
+
+        Returns:
+            Query string or None
+        """
+        # Try various context fields
+        delegation_context = data.get("context", {})
+
+        # Handle string context
+        if isinstance(delegation_context, str):
+            return delegation_context
+
+        # Handle dict context
+        if isinstance(delegation_context, dict):
+            # Try common fields
+            for field in ["prompt", "task", "query", "user_request", "description"]:
+                if field in delegation_context:
+                    value = delegation_context[field]
+                    if isinstance(value, str):
+                        return value
+
+            # If no specific field, join all string values
+            text_parts = [
+                str(v) for v in delegation_context.values() if isinstance(v, str)
+            ]
+            if text_parts:
+                return " ".join(text_parts)
+
+        # Fallback: try to get task or instruction directly
+        if "task" in data and isinstance(data["task"], str):
+            return data["task"]
+
+        if "instruction" in data and isinstance(data["instruction"], str):
+            return data["instruction"]
+
+        return None
+
+    def _enrich_delegation_context(
+        self, original_data: Dict[str, Any], memories: list, agent_name: str
+    ) -> Dict[str, Any]:
+        """
+        Enrich delegation context with memories.
+
+        Args:
+            original_data: Original delegation data
+            memories: Retrieved memories
+            agent_name: Name of the agent
+
+        Returns:
+            Enriched delegation data
+        """
+        # Format memories
+        memory_section = self._format_memory_section(memories, agent_name)
+
+        # Create enriched data
+        enriched_data = original_data.copy()
+
+        # Get existing context
+        delegation_context = enriched_data.get("context", {})
+        if isinstance(delegation_context, str):
+            delegation_context = {"prompt": delegation_context}
+
+        # Add memory section
+        if isinstance(delegation_context, dict):
+            # Prepend memory section to context
+            delegation_context["kuzu_memories"] = memory_section
+
+            # If there's a main prompt/task, prepend memory note
+            for field in ["prompt", "task", "instruction"]:
+                if field in delegation_context and isinstance(
+                    delegation_context[field], str
+                ):
+                    delegation_context[field] = (
+                        f"{memory_section}\n\n{delegation_context[field]}"
+                    )
+                    break
+        else:
+            # If context is not dict, create new dict with memory
+            delegation_context = {
+                "kuzu_memories": memory_section,
+                "original_context": delegation_context,
+            }
+
+        enriched_data["context"] = delegation_context
+        enriched_data["_kuzu_enriched"] = True
+
+        return enriched_data
+
+    def _format_memory_section(self, memories: list, agent_name: str) -> str:
+        """
+        Format memories into a readable section.
+
+        Args:
+            memories: List of memory dictionaries
+            agent_name: Name of the agent
+
+        Returns:
+            Formatted memory section
+        """
+        memory_text = self.kuzu_hook._format_memories(memories)
+
+        return f"""
+=== RELEVANT KNOWLEDGE FROM KUZU MEMORY ===
+{agent_name}, you have access to these relevant memories from the knowledge graph:
+
+{memory_text}
+
+INSTRUCTIONS: Review these memories before proceeding. Apply learned patterns and avoid known mistakes.
+Use this knowledge to provide more informed and contextual responses.
+===========================================
+"""
+
+
+# Create a singleton instance
+_kuzu_enrichment_hook = None
+
+
+def get_kuzu_enrichment_hook() -> KuzuEnrichmentHook:
+    """Get the singleton kuzu-memory enrichment hook instance."""
+    global _kuzu_enrichment_hook
+    if _kuzu_enrichment_hook is None:
+        _kuzu_enrichment_hook = KuzuEnrichmentHook()
+    return _kuzu_enrichment_hook

claude_mpm/hooks/kuzu_memory_hook.py

@@ -157,9 +157,13 @@ class KuzuMemoryHook(SubmitHook):
             List of relevant memory dictionaries
         """
         try:
-            # Use kuzu-memory recall command
+            # Type narrowing: ensure kuzu_memory_cmd is not None before using
+            if self.kuzu_memory_cmd is None:
+                return []
+
+            # Use kuzu-memory recall command (v1.2.7+ syntax)
             result = subprocess.run(
-                [self.kuzu_memory_cmd, "recall", query, "--format", "json"],
+                [self.kuzu_memory_cmd, "memory", "recall", query, "--format", "json"],
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -168,10 +172,21 @@ class KuzuMemoryHook(SubmitHook):
             )
 
             if result.returncode == 0 and result.stdout:
-                memories = json.loads(result.stdout)
-                return memories if isinstance(memories, list) else []
-
-        except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception) as e:
+                try:
+                    # Parse JSON with strict=False to handle control characters
+                    data = json.loads(result.stdout, strict=False)
+                    # v1.2.7 returns dict with 'memories' key, not array
+                    if isinstance(data, dict):
+                        memories = data.get("memories", [])
+                    else:
+                        memories = data if isinstance(data, list) else []
+                    return memories
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Failed to parse kuzu-memory JSON output: {e}")
+                    logger.debug(f"Raw output: {result.stdout[:200]}")
+                    return []  # Graceful fallback
+
+        except (subprocess.TimeoutExpired, Exception) as e:
             logger.debug(f"Memory retrieval failed: {e}")
 
         return []
@@ -255,12 +270,12 @@ Note: Use the memories above to provide more informed and contextual responses.
         Returns:
             True if storage was successful
         """
-        if not self.enabled:
+        if not self.enabled or self.kuzu_memory_cmd is None:
             return False
 
         try:
-            # Use kuzu-memory remember command (synchronous)
-            cmd = [self.kuzu_memory_cmd, "remember", content]
+            # Use kuzu-memory store command (v1.2.7+ syntax)
+            cmd = [self.kuzu_memory_cmd, "memory", "store", content]
 
             # Execute store command in project directory
             result = subprocess.run(
@@ -273,8 +288,10 @@ Note: Use the memories above to provide more informed and contextual responses.
             )
 
             if result.returncode == 0:
-                logger.debug(f"Stored memory: {content[:50]}...")
+                logger.debug(f"Stored memory in kuzu: {content[:50]}...")
                 return True
+            logger.warning(f"Failed to store memory in kuzu: {result.stderr}")
+            return False
 
         except Exception as e:
             logger.error(f"Failed to store memory: {e}")

claude_mpm/hooks/kuzu_response_hook.py

@@ -0,0 +1,183 @@
+"""
+Kuzu-Memory Response Learning Hook
+===================================
+
+Captures assistant responses and extracts learnings to store in kuzu-memory.
+This completes the bidirectional enrichment cycle:
+- KuzuMemoryHook enriches prompts with memories (READ)
+- KuzuResponseHook stores learnings from responses (WRITE)
+
+WHY: To automatically capture and persist important information from agent
+responses, enabling continuous learning across conversations.
+
+DESIGN DECISIONS:
+- Priority 80 to run late after main processing
+- Reuses KuzuMemoryHook's storage methods for consistency
+- Graceful degradation if kuzu-memory is not available
+- Extracts structured learnings using patterns and AI
+"""
+
+import logging
+from typing import Any, Optional
+
+from claude_mpm.hooks.base_hook import (
+    HookContext,
+    HookResult,
+    PostDelegationHook,
+)
+from claude_mpm.hooks.kuzu_memory_hook import get_kuzu_memory_hook
+
+logger = logging.getLogger(__name__)
+
+
+class KuzuResponseHook(PostDelegationHook):
+    """
+    Hook that captures agent responses and stores learnings in kuzu-memory.
+
+    This hook:
+    1. Processes agent responses after delegation completes
+    2. Extracts important learnings and information
+    3. Stores memories in kuzu-memory for future retrieval
+    4. Tags memories for better categorization
+    """
+
+    def __init__(self):
+        """Initialize the kuzu-memory response learning hook."""
+        super().__init__(name="kuzu_response_learner", priority=80)
+
+        # Reuse the kuzu-memory hook instance for storage
+        self.kuzu_hook = get_kuzu_memory_hook()
+        self.enabled = self.kuzu_hook.enabled
+
+        if not self.enabled:
+            logger.info(
+                "Kuzu-memory response hook disabled (kuzu-memory not available)"
+            )
+        else:
+            logger.info("Kuzu-memory response learning hook enabled")
+
+    def validate(self, context: HookContext) -> bool:
+        """
+        Validate if hook should process this context.
+
+        Args:
+            context: Hook context to validate
+
+        Returns:
+            True if hook should execute
+        """
+        if not self.enabled:
+            return False
+
+        # Check base validation (enabled, correct hook type, has result)
+        if not super().validate(context):
+            return False
+
+        # Must have result data to extract learnings from
+        result_data = context.data.get("result")
+        if not result_data:
+            return False
+
+        return True
+
+    def execute(self, context: HookContext) -> HookResult:
+        """
+        Extract and store learnings from agent responses.
+
+        Args:
+            context: Hook context containing response data
+
+        Returns:
+            HookResult with success status and metadata
+        """
+        if not self.enabled:
+            return HookResult(success=True, data=context.data, modified=False)
+
+        try:
+            # Extract response content from various possible formats
+            result_data = context.data.get("result", {})
+            response_content = self._extract_response_content(result_data)
+
+            if not response_content:
+                logger.debug("No response content found for learning extraction")
+                return HookResult(success=True, data=context.data, modified=False)
+
+            # Extract and store learnings
+            count = self.kuzu_hook.extract_and_store_learnings(response_content)
+
+            if count > 0:
+                logger.info(f"Stored {count} learnings from agent response")
+                return HookResult(
+                    success=True,
+                    data=context.data,
+                    modified=False,
+                    metadata={"learnings_stored": count, "memory_backend": "kuzu"},
+                )
+
+            return HookResult(success=True, data=context.data, modified=False)
+
+        except Exception as e:
+            logger.error(f"Error in kuzu response hook: {e}")
+            # Don't fail the operation if learning extraction fails
+            return HookResult(
+                success=True,
+                data=context.data,
+                modified=False,
+                error=f"Learning extraction failed: {e}",
+            )
+
+    def _extract_response_content(self, result_data: Any) -> Optional[str]:
+        """
+        Extract response content from various result formats.
+
+        Args:
+            result_data: Result data in various possible formats
+
+        Returns:
+            Extracted response content as string, or None
+        """
+        if not result_data:
+            return None
+
+        # Handle dict format
+        if isinstance(result_data, dict):
+            # Try common response fields
+            for field in ["content", "text", "response", "output", "message"]:
+                if field in result_data:
+                    content = result_data[field]
+                    if isinstance(content, str):
+                        return content
+                    if isinstance(content, dict):
+                        # Recursively extract from nested dict
+                        return self._extract_response_content(content)
+
+            # If dict has no recognizable fields, try converting to string
+            return str(result_data)
+
+        # Handle string format
+        if isinstance(result_data, str):
+            return result_data
+
+        # Handle list format (concatenate items)
+        if isinstance(result_data, list):
+            items = []
+            for item in result_data:
+                extracted = self._extract_response_content(item)
+                if extracted:
+                    items.append(extracted)
+            return "\n\n".join(items) if items else None
+
+        # Fallback to string conversion
+        return str(result_data) if result_data else None
+
+
+# Create a singleton instance
+_kuzu_response_hook = None
+
+
+def get_kuzu_response_hook() -> KuzuResponseHook:
+    """Get the singleton kuzu-memory response hook instance."""
+    global _kuzu_response_hook
+    if _kuzu_response_hook is None:
+        _kuzu_response_hook = KuzuResponseHook()
+    return _kuzu_response_hook

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -495,7 +495,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                     base_cmd = config["mcp_command"]
                     if len(base_cmd) > 0 and base_cmd[0] == config["package"]:
                         # Simple case where first command is the package name
-                        mcp_command = ["pipx", "run", config["package"]] + base_cmd[1:]
+                        mcp_command = ["pipx", "run", config["package"], *base_cmd[1:]]
                     else:
                         # Complex case - just try running the package with mcp arg
                         mcp_command = ["pipx", "run", config["package"], "mcp"]
@@ -509,7 +509,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                     base_cmd = config["mcp_command"]
                     if service_name == "kuzu-memory":
                         # Special case for kuzu-memory with args
-                        mcp_command = ["pipx", "run", base_cmd[0]] + base_cmd[1:]
+                        mcp_command = ["pipx", "run", base_cmd[0], *base_cmd[1:]]
                     else:
                         mcp_command = ["pipx", "run", *base_cmd]
             else:

claude_mpm/services/mcp_service_verifier.py

@@ -550,7 +550,7 @@ class MCPServiceVerifier:
 
         try:
             # Build test command - add --help to test without side effects
-            test_cmd = [command] + args[:2] if args else [command]  # Include base args
+            test_cmd = [command, *args[:2]] if args else [command]  # Include base args
             test_cmd.append("--help")
 
             result = subprocess.run(

claude_mpm/services/memory_hook_service.py

@@ -41,8 +41,8 @@ class MemoryHookService(BaseService, MemoryHookInterface):
         These hooks ensure memory is properly managed and persisted.
 
         DESIGN DECISION: We register hooks for key lifecycle events:
-        - Before Claude interaction: Load relevant memories
-        - After Claude interaction: Save new memories
+        - Before Claude interaction: Load relevant memories (kuzu-memory + legacy)
+        - After Claude interaction: Save new memories (kuzu-memory + legacy)
         - On error: Ensure memory state is preserved
         """
         if not self.hook_service:
@@ -90,11 +90,93 @@ class MemoryHookService(BaseService, MemoryHookInterface):
             if success2:
                 self.registered_hooks.append("memory_save")
 
-            self.logger.debug("Memory hooks registered successfully")
+            self.logger.debug("Legacy memory hooks registered successfully")
+
+            # Register kuzu-memory hooks if available
+            self._register_kuzu_memory_hooks()
 
         except Exception as e:
             self.logger.warning(f"Failed to register memory hooks: {e}")
 
+    def _register_kuzu_memory_hooks(self):
+        """Register kuzu-memory bidirectional enrichment hooks.
+
+        WHY: Kuzu-memory provides persistent knowledge graph storage that works
+        across conversations. This enables:
+        1. Delegation context enrichment with relevant memories (READ)
+        2. Automatic learning extraction from responses (WRITE)
+
+        DESIGN DECISION: These hooks are separate from legacy memory hooks to
+        allow independent evolution and configuration. Both systems can coexist.
+        """
+        try:
+            # Check if kuzu-memory is enabled in config
+            from claude_mpm.core.config import Config
+
+            config = Config()
+            kuzu_config = config.get("memory.kuzu", {})
+            if isinstance(kuzu_config, dict):
+                kuzu_enabled = kuzu_config.get("enabled", True)
+                enrichment_enabled = kuzu_config.get("enrichment", True)
+                learning_enabled = kuzu_config.get("learning", True)
+            else:
+                # Default to enabled if config section doesn't exist
+                kuzu_enabled = True
+                enrichment_enabled = True
+                learning_enabled = True
+
+            if not kuzu_enabled:
+                self.logger.debug("Kuzu-memory disabled in configuration")
+                return
+
+            from claude_mpm.hooks import (
+                get_kuzu_enrichment_hook,
+                get_kuzu_response_hook,
+            )
+
+            # Get kuzu-memory hooks
+            enrichment_hook = get_kuzu_enrichment_hook()
+            learning_hook = get_kuzu_response_hook()
+
+            # Register enrichment hook (PreDelegationHook) if enabled
+            if enrichment_hook.enabled and enrichment_enabled:
+                success = self.hook_service.register_hook(enrichment_hook)
+                if success:
+                    self.registered_hooks.append("kuzu_memory_enrichment")
+                    self.logger.info(
+                        "✅ Kuzu-memory enrichment enabled (prompts → memories)"
+                    )
+                else:
+                    self.logger.warning(
+                        "Failed to register kuzu-memory enrichment hook"
+                    )
+            elif not enrichment_enabled:
+                self.logger.debug("Kuzu-memory enrichment disabled in configuration")
+
+            # Register learning hook (PostDelegationHook) if enabled
+            if learning_hook.enabled and learning_enabled:
+                success = self.hook_service.register_hook(learning_hook)
+                if success:
+                    self.registered_hooks.append("kuzu_response_learner")
+                    self.logger.info(
+                        "✅ Kuzu-memory learning enabled (responses → memories)"
+                    )
+                else:
+                    self.logger.warning("Failed to register kuzu-memory learning hook")
+            elif not learning_enabled:
+                self.logger.debug("Kuzu-memory learning disabled in configuration")
+
+            # If neither hook is enabled, kuzu-memory is not available
+            if not enrichment_hook.enabled and not learning_hook.enabled:
+                self.logger.debug(
+                    "Kuzu-memory not available. Install with: pipx install kuzu-memory"
+                )
+
+        except ImportError as e:
+            self.logger.debug(f"Kuzu-memory hooks not available: {e}")
+        except Exception as e:
+            self.logger.warning(f"Failed to register kuzu-memory hooks: {e}")
+
     def _load_relevant_memories_hook(self, context):
         """Hook function to load relevant memories before Claude interaction.
 

claude_mpm/utils/agent_dependency_loader.py

@@ -14,7 +14,7 @@ import logging
 import subprocess
 import sys
 import time
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from packaging.requirements import InvalidRequirement, Requirement
 
@@ -72,7 +72,7 @@ class AgentDependencyLoader:
         Returns:
             Dictionary mapping agent IDs to their file paths
         """
-        deployed_agents = {}
+        deployed_agents: Dict[str, Path] = {}
         claude_agents_dir = Path.cwd() / ".claude" / "agents"
 
         if not claude_agents_dir.exists():
@@ -409,7 +409,7 @@ class AgentDependencyLoader:
         Returns:
             Analysis results including missing and satisfied dependencies
         """
-        results = {
+        results: Dict[str, Any] = {
             "agents": {},
             "summary": {
                 "total_agents": len(self.deployed_agents),
@@ -422,7 +422,7 @@ class AgentDependencyLoader:
         }
 
         for agent_id, deps in self.agent_dependencies.items():
-            agent_result = {
+            agent_result: Dict[str, Dict[str, List[str]]] = {
                 "python": {"satisfied": [], "missing": [], "outdated": []},
                 "system": {"satisfied": [], "missing": []},
             }
@@ -476,8 +476,8 @@ class AgentDependencyLoader:
         """
         import sys
 
-        compatible = []
-        incompatible = []
+        compatible: List[str] = []
+        incompatible: List[str] = []
 
         for dep in dependencies:
             try:
@@ -593,20 +593,37 @@ class AgentDependencyLoader:
             try:
                 cmd = [sys.executable, "-m", "pip", "install"]
 
-                # Check for PEP 668 managed environment
+                # Check environment and add appropriate flags
+                import os
                 import sysconfig
 
-                stdlib_path = sysconfig.get_path("stdlib")
-                marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
-                parent_marker = marker_file.parent.parent / "EXTERNALLY-MANAGED"
+                # Check if in virtualenv
+                in_virtualenv = (
+                    (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)
+                    or (hasattr(sys, "real_prefix"))
+                    or (os.environ.get("VIRTUAL_ENV") is not None)
+                )
 
-                if marker_file.exists() or parent_marker.exists():
-                    logger.warning(
-                        "PEP 668 managed environment detected. "
-                        "Installing with --break-system-packages --user flags. "
-                        "Consider using a virtual environment instead."
-                    )
-                    cmd.extend(["--break-system-packages", "--user"])
+                if in_virtualenv:
+                    # In virtualenv - no special flags needed
+                    logger.debug("Installing in virtualenv (no special flags)")
+                else:
+                    # Check for PEP 668 managed environment
+                    stdlib_path = sysconfig.get_path("stdlib")
+                    marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
+                    parent_marker = marker_file.parent.parent / "EXTERNALLY-MANAGED"
+
+                    if marker_file.exists() or parent_marker.exists():
+                        logger.warning(
+                            "PEP 668 managed environment detected. "
+                            "Installing with --break-system-packages flag. "
+                            "Consider using a virtual environment instead."
+                        )
+                        cmd.append("--break-system-packages")
+                    else:
+                        # Normal system Python - use --user
+                        cmd.append("--user")
+                        logger.debug("Installing with --user flag")
 
                 cmd.extend(compatible)
 
@@ -946,13 +963,16 @@ class AgentDependencyLoader:
 
 def check_deployed_agent_dependencies(
     auto_install: bool = False, verbose: bool = False
-) -> None:
+) -> int:
     """
     Check dependencies for currently deployed agents.
 
     Args:
         auto_install: If True, automatically install missing Python dependencies
         verbose: If True, enable verbose logging
+
+    Returns:
+        Status code: 0 if all dependencies satisfied, 1 if missing dependencies
     """
     if verbose:
         logging.getLogger().setLevel(logging.DEBUG)

claude_mpm/utils/robust_installer.py

@@ -9,6 +9,7 @@ DESIGN DECISION: We implement exponential backoff for retries and provide
 multiple installation strategies (pip, conda, source) to maximize success rate.
 """
 
+import os
 import re
 import subprocess
 import sys
@@ -80,6 +81,7 @@ class RobustPackageInstaller:
         self.use_cache = use_cache
         self.attempts: List[InstallAttempt] = []
         self.success_cache: Dict[str, bool] = {}
+        self.in_virtualenv = self._check_virtualenv()
         self.is_pep668_managed = self._check_pep668_managed()
         self.pep668_warning_shown = False
 
@@ -201,6 +203,35 @@ class RobustPackageInstaller:
         except Exception as e:
             return False, f"Unexpected error: {e!s}"
 
+    def _check_virtualenv(self) -> bool:
+        """
+        Check if running inside a virtual environment.
+
+        WHY: Virtual environments are already isolated and don't need
+        --user or --break-system-packages flags. In fact, using --user
+        in a virtualenv causes errors.
+
+        Returns:
+            True if in a virtualenv, False otherwise
+        """
+        # Multiple ways to detect virtualenv
+        return (
+            (
+                # venv creates sys.base_prefix
+                hasattr(sys, "base_prefix")
+                and sys.base_prefix != sys.prefix
+            )
+            or (
+                # virtualenv creates sys.real_prefix
+                hasattr(sys, "real_prefix")
+            )
+            or (
+                # VIRTUAL_ENV environment variable
+                os.environ.get("VIRTUAL_ENV")
+                is not None
+            )
+        )
+
     def _check_pep668_managed(self) -> bool:
         """
         Check if Python environment is PEP 668 externally managed.
@@ -211,6 +242,11 @@ class RobustPackageInstaller:
         Returns:
             True if PEP 668 managed, False otherwise
         """
+        # If in virtualenv, PEP 668 doesn't apply
+        if self.in_virtualenv:
+            logger.debug("Running in virtualenv, PEP 668 restrictions don't apply")
+            return False
+
         # Check for EXTERNALLY-MANAGED marker file
         stdlib_path = sysconfig.get_path("stdlib")
         marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
@@ -240,7 +276,7 @@ class RobustPackageInstaller:
                 "Your Python installation is marked as externally managed (PEP 668).\n"
                 "This typically means you're using a system Python managed by Homebrew, apt, etc.\n"
                 "\n"
-                "Installing packages with --break-system-packages --user flags...\n"
+                "Installing packages with --break-system-packages flag...\n"
                 "\n"
                 "RECOMMENDED: Use a virtual environment instead:\n"
                 "  python -m venv .venv\n"
@@ -255,8 +291,10 @@ class RobustPackageInstaller:
         """
         Build the installation command for a given strategy.
 
-        WHY: PEP 668 support added to handle externally managed Python
-        environments by adding appropriate flags when needed.
+        WHY: Proper environment detection ensures we use the right pip flags:
+        - Virtualenv: No special flags needed (already isolated)
+        - PEP 668 system: Use --break-system-packages only
+        - Normal system: Use --user for user-local install
 
         Args:
             package_spec: Package specification
@@ -267,14 +305,19 @@ class RobustPackageInstaller:
         """
         base_cmd = [sys.executable, "-m", "pip", "install"]
 
-        # Add PEP 668 bypass flags if needed
-        if self.is_pep668_managed:
+        # Determine appropriate flags based on environment
+        if self.in_virtualenv:
+            # In virtualenv - no special flags needed
+            logger.debug("Installing in virtualenv (no special flags)")
+        elif self.is_pep668_managed:
+            # System Python with PEP 668 - use --break-system-packages only
             self._show_pep668_warning()
-            # Add flags to bypass PEP 668 restrictions
-            base_cmd.extend(["--break-system-packages", "--user"])
-            logger.debug(
-                "Added --break-system-packages --user flags for PEP 668 environment"
-            )
+            base_cmd.append("--break-system-packages")
+            logger.debug("Added --break-system-packages flag for PEP 668 environment")
+        else:
+            # Normal system Python - use --user for user-local install
+            base_cmd.append("--user")
+            logger.debug("Added --user flag for user-local installation")
 
         # Add cache control
         if not self.use_cache:
@@ -612,11 +655,16 @@ class RobustPackageInstaller:
         try:
             cmd = [sys.executable, "-m", "pip", "install"]
 
-            # Add PEP 668 bypass flags if needed
-            if self.is_pep668_managed:
+            # Add appropriate flags based on environment
+            if self.in_virtualenv:
+                logger.debug("Batch install in virtualenv (no special flags)")
+            elif self.is_pep668_managed:
                 self._show_pep668_warning()
-                cmd.extend(["--break-system-packages", "--user"])
-                logger.debug("Added PEP 668 flags for batch installation")
+                cmd.append("--break-system-packages")
+                logger.debug("Added --break-system-packages for batch installation")
+            else:
+                cmd.append("--user")
+                logger.debug("Added --user flag for batch installation")
 
             cmd.extend(packages)
 
@@ -654,12 +702,18 @@ class RobustPackageInstaller:
         lines.append("INSTALLATION REPORT")
         lines.append("=" * 60)
 
-        # Add PEP 668 status
-        if self.is_pep668_managed:
-            lines.append("")
+        # Add environment status
+        lines.append("")
+        if self.in_virtualenv:
+            lines.append("✓ Environment: Virtual Environment (isolated)")
+            lines.append("  No special pip flags needed")
+        elif self.is_pep668_managed:
             lines.append("⚠️  PEP 668 Managed Environment: YES")
-            lines.append("   Installations used --break-system-packages --user flags")
+            lines.append("   Installations used --break-system-packages flag")
             lines.append("   Consider using a virtual environment for better isolation")
+        else:
+            lines.append("Environment: System Python")
+            lines.append("   Installations used --user flag for user-local install")
 
         # Summary
         total_attempts = len(self.attempts)
@@ -672,7 +726,7 @@ class RobustPackageInstaller:
         lines.append("")
 
         # Details by package
-        packages = {}
+        packages: Dict[str, List[InstallAttempt]] = {}
         for attempt in self.attempts:
             if attempt.package not in packages:
                 packages[attempt.package] = []

{claude_mpm-4.7.5.dist-info → claude_mpm-4.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.7.5
+Version: 4.7.6
 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

{claude_mpm-4.7.5.dist-info → claude_mpm-4.7.6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=9JfxhnDtr-8l3kCP2U5TVXSErptHoga8m7XA8zqgGOc,4
-claude_mpm/VERSION,sha256=S1_5LwX4BqRmj3UoBp6ODrFMvkFt5xvcn9wfpuFze9Y,6
+claude_mpm/VERSION,sha256=gVLWgYgcXVc7Af4ejsObqWB0dhZ1OktjUoRmgOIPx1M,6
 claude_mpm/__init__.py,sha256=UCw6j9e_tZQ3kJtTqmdfNv7MHyw9nD1jkj80WurwM2g,2064
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=cChN3myrAcF3jC-6DvHnBFTEnwlDk-TAsIXPvUZr_yw,5953
@@ -79,7 +79,7 @@ claude_mpm/cli/commands/analyze_code.py,sha256=yWZpG0aL4XlhcthtvbUqnFSlnvvseWO3V
 claude_mpm/cli/commands/cleanup.py,sha256=TukZoPVfAFSF4ICfKCQUibczDE73EJP8nbEbfuT8GhE,19768
 claude_mpm/cli/commands/cleanup_orphaned_agents.py,sha256=JR8crvgrz7Sa6d-SI-gKywok5S9rwc_DzDVk_h85sVs,4467
 claude_mpm/cli/commands/config.py,sha256=Yfi8WO-10_MYz2QipFw-yEzVvHKNQ6iSQXeyW5J85Cg,18559
-claude_mpm/cli/commands/configure.py,sha256=xmej2tajCm9J1jG3358vwpGHNWKJlVLQwD6B6bOdfh4,79973
+claude_mpm/cli/commands/configure.py,sha256=22wvCVGeIUFk2mBvvG9Lhd-Jzq8GRLmGg0W9mndxMOY,82489
 claude_mpm/cli/commands/dashboard.py,sha256=4jPTmTl97DRNNJlYREWeE1iDdkct1uL-vv24MZn9fj4,11403
 claude_mpm/cli/commands/debug.py,sha256=YCfJ3aYf6hOCvLW_grdfINdEqI4RXVS28VJ7tkZBFS8,47115
 claude_mpm/cli/commands/doctor.py,sha256=nNKLZG3Qv_UsHNgrmetrWKgS7Pe2Jn5vq5aXyl60wKQ,7310
@@ -368,10 +368,12 @@ claude_mpm/experimental/__init__.py,sha256=R_aclOvWpvSTHWAx9QXyg9OIPVK2dXT5tQJhx
 claude_mpm/experimental/cli_enhancements.py,sha256=PfAt-SI-crBoE0Dtx1JecpS5_6OT_0apJbo28KS6HUI,11541
 claude_mpm/generators/__init__.py,sha256=rG8vwF_BjPmeMKvyMXpUA8uJ-7mtW2HTNfalZzgRlNk,153
 claude_mpm/generators/agent_profile_generator.py,sha256=yTEFdZPUt4lAfXlQuIIxzRwOrWMaJhEJ3Z6Ofm48Rlc,5740
-claude_mpm/hooks/__init__.py,sha256=rVD-1bitn454djWzRN3wNNcM7xrXU-YiufVFD2T4H0Y,303
+claude_mpm/hooks/__init__.py,sha256=y-mfGUb4xTCENUIj4RfAhK2oJTIL0qMI2gDatdf52nc,567
 claude_mpm/hooks/base_hook.py,sha256=wKbT_0g3dhvkA48pTz4GJpZQw8URhaT0LpZnCc7CEas,5026
 claude_mpm/hooks/instruction_reinforcement.py,sha256=PnjfDSZ_72gbzHnRoug7qtXfpW5d1cxnmittpnPd2ws,11059
-claude_mpm/hooks/kuzu_memory_hook.py,sha256=S_yngWlwCey1GXoTQFQ6ce8SFnTWRIQe1Z_9RsLlBbU,11342
+claude_mpm/hooks/kuzu_enrichment_hook.py,sha256=jghoEZX8fA6HZ1kM_5l93cuCyy-AMBjWp-nPW5EgaTk,8729
+claude_mpm/hooks/kuzu_memory_hook.py,sha256=ockbKXXc69Yiryq2uWNCAUpSxtN8eqAec9i5BB1MRaI,12265
+claude_mpm/hooks/kuzu_response_hook.py,sha256=iyVrsOrGpp-VFOjKC5GUnXro088Ftex-vHmfHsmAUv8,6136
 claude_mpm/hooks/memory_integration_hook.py,sha256=F8Hf35hmbmhxi-qHQJac4zoWIr60ob3PCHa4P_rbxO8,16635
 claude_mpm/hooks/tool_call_interceptor.py,sha256=tYUBJHjbtaI5-HSWcz0aeUW0CaiQPypuDOTULQ0BCNI,7506
 claude_mpm/hooks/validation_hooks.py,sha256=i5uOaXifItwJfIdjjLCxAwrkKdkmo2Qa4qMc5-dwsKw,6465
@@ -416,8 +418,8 @@ claude_mpm/services/exceptions.py,sha256=5lVZETr_6-xk0ItH7BTfYUiX5RlckS1e8ah_Ual
 claude_mpm/services/hook_installer_service.py,sha256=x3H3bFVlmhK4Ue1K279f44lwMEw3W1p3zoETGfjIH_w,19708
 claude_mpm/services/hook_service.py,sha256=I6JILbackBsdvrDNQ9TeGSB7XNqozNRP26T4E9_ROtU,15693
 claude_mpm/services/mcp_config_manager.py,sha256=W_zlFXzaQ64BoM4FuOJ47ywUUw0Rcf_u_ivvrpt2ZZY,67241
-claude_mpm/services/mcp_service_verifier.py,sha256=r1mNWmDT_-OtRuCbquCeDbT4lDc41jZxkZHNMutMw74,25604
-claude_mpm/services/memory_hook_service.py,sha256=pRlTClkRcw30Jhwbha4BC8IMdzKZxF8aWqf52JlntgY,11600
+claude_mpm/services/mcp_service_verifier.py,sha256=xOo1SqbQ1J07TnJ_aNN7yCjna4UBZwnQQu6RrNCgoNc,25604
+claude_mpm/services/memory_hook_service.py,sha256=BZhCYFpWV_7FguDL0MY4k8JOZJFmCbYWNMfDywM9G5Q,15304
 claude_mpm/services/monitor_build_service.py,sha256=8gWR9CaqgXdG6-OjOFXGpk28GCcJTlHhojkUYnMCebI,12160
 claude_mpm/services/orphan_detection.py,sha256=cEFE96FhC6EJSa53rUjbgjDj_E1_Ej-0KoYDQST22t0,26339
 claude_mpm/services/port_manager.py,sha256=83GJ1uSF9pXsECXHtf4M8jBHzOptdh3Lpt7t0GyY2Wc,22838
@@ -567,7 +569,7 @@ claude_mpm/services/diagnostics/checks/filesystem_check.py,sha256=V5HoHDYlSuoK2l
 claude_mpm/services/diagnostics/checks/installation_check.py,sha256=JdTqZreriAavN8gkHTaaKwclwnvfaRw87Np9mDfUXlk,19548
 claude_mpm/services/diagnostics/checks/instructions_check.py,sha256=VbgBorl0RpFvxKQ_SC1gibTmGSiXaKSp-vVZt6hbH1g,16290
 claude_mpm/services/diagnostics/checks/mcp_check.py,sha256=eG8BVWclwRRYh6G1ew1Z_DE1ksRirRxEy3fIe3cu58k,12174
-claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=o9ex5LYHtqiqXlU0qORwsmH-p0-gr2pM5G1md2UGf10,43776
+claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=y6hpDMl3ZoT9WXIgxgbPaebgPqmgfiFruoed7224xos,43776
 claude_mpm/services/diagnostics/checks/monitor_check.py,sha256=hZk301gvM8XAnfcOdtzE-e9XMBW3hgmDwSVxVSmF9CY,10097
 claude_mpm/services/diagnostics/checks/startup_log_check.py,sha256=qQQI9Ezk7Sa5NpvJrtDY_0bWhoLPASZJn0hpNR8pEsI,12341
 claude_mpm/services/event_bus/__init__.py,sha256=ETCo4a6puIeyVWAv55uCDjjhzNyUwbVAHEcAVkVapx8,688
@@ -761,7 +763,7 @@ claude_mpm/tools/code_tree_builder.py,sha256=8EaW94NjEObraiW811dDoQ8xKixrzCr4YoL
 claude_mpm/tools/code_tree_events.py,sha256=10tf9ZGkPIXzWqYvwq0SIJdIOwKNnxgKWYOmRzVGeLc,13396
 claude_mpm/tools/socketio_debug.py,sha256=QpG_GoN9VY8OZ0tcg8bqIF2oB_ZbKTjGp0oD0xYmsFo,22226
 claude_mpm/utils/__init__.py,sha256=rkxNE0tDfKEN2lr2LLBuToNSvkF-yjF38607eUXL1vk,353
-claude_mpm/utils/agent_dependency_loader.py,sha256=DeqPJMFEjhmTzsSBNLrhjYpystjuRP_J05CluXKFo90,35685
+claude_mpm/utils/agent_dependency_loader.py,sha256=A_OliEjBIwJn2e2N_7RLsh2zIhC5KdDLQTlMMV2DByc,36678
 claude_mpm/utils/common.py,sha256=6hcs3Y6lx596Oj4H3CEQId-NIn8XEZJw1Ud3GAKwXKA,14341
 claude_mpm/utils/config_manager.py,sha256=iWsPM0uo31Ela-XhFe9DIw3RuVxJf94_yFQ1HkibAlY,15876
 claude_mpm/utils/console.py,sha256=2Agd91xj5NSMgvfUFJIUwVnpghnKjrd8EYH7inF12M4,279
@@ -778,15 +780,15 @@ claude_mpm/utils/import_migration_example.py,sha256=sKlV-apfkHDJzzez6uubHXjx91YF
 claude_mpm/utils/imports.py,sha256=IGcW0W6V-2jTmkVlO-l0Zodo3LRA3zkaumD9J2qn7dE,6654
 claude_mpm/utils/log_cleanup.py,sha256=1d8K1V2uOFPGJJKFOk6E_AMj22sifAibOg-VQyGooWo,22301
 claude_mpm/utils/path_operations.py,sha256=gvd6Ye5rMFxIKnFzWwIL6jYy8wGkjSH3onYAan6zXkA,10869
-claude_mpm/utils/robust_installer.py,sha256=R-sg2XiQzVUl2Lk2eWhcDHiP0gbl3wJRLeK3_1Nw614,24898
+claude_mpm/utils/robust_installer.py,sha256=ixif5ExezKr5eOtgoY7W629tcDm-lZtUe5_Igkq7ZYQ,27108
 claude_mpm/utils/session_logging.py,sha256=_6eoyCvVKhu2OhgRzC5FvMfFnD9et75lzCqARbd_i-k,3059
 claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalNmfX9KlM,10443
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=GprtAvu80VyMXcKGsK_VhYiXWA6BjKHv7O6HKx0AB9w,20917
 claude_mpm/validation/frontmatter_validator.py,sha256=YpJlYNNYcV8u6hIOi3_jaRsDnzhbcQpjCBE6eyBKaFY,7076
-claude_mpm-4.7.5.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.7.5.dist-info/METADATA,sha256=hq04JsKoSrZIIOVtawIlwapyPzZOkFxDl2BhsNcOFR0,17517
-claude_mpm-4.7.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.7.5.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
-claude_mpm-4.7.5.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.7.5.dist-info/RECORD,,
+claude_mpm-4.7.6.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.7.6.dist-info/METADATA,sha256=zrxNvScK7d0H2C78k6Wuq_mJ3rQHbjCWTfzoC0JvWNQ,17517
+claude_mpm-4.7.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.7.6.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
+claude_mpm-4.7.6.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.7.6.dist-info/RECORD,,