claude-mpm 4.0.32__tar.gz → 4.0.34__tar.gz

claude_mpm-4.0.34/BUILD_NUMBER

@@ -0,0 +1 @@
+296

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/CLAUDE.md

@@ -186,7 +186,7 @@ def test_service_implements_interface():
 1. **Import Errors**: Ensure virtual environment is activated and PYTHONPATH includes `src/`
 2. **Hook Service Errors**: Check port availability (8765-8785)
 3. **Version Errors**: Run `pip install -e .` to ensure proper installation
-4. **Agent Loading**: Check `.claude/agents/` for deployed agents
+4. **Agent Deployment**: All agents now deploy to project-level `.claude/agents/` directory (changed in v4.0.32+)
 
 ## Contributing
 

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.32
+Version: 4.0.34
 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
@@ -46,6 +46,7 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pyee>=13.0.0
 Requires-Dist: importlib-resources>=5.0; python_version < "3.9"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -116,7 +117,7 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 ## Features
 
 - 🤖 **Multi-Agent System**: 15 specialized agents for comprehensive project management
-- 🧠 **Agent Memory System**: Persistent learning with project-specific knowledge retention
+- 🧠 **Agent Memory System**: Simple list-based persistent learning with JSON response field updates
 - 🔄 **Session Management**: Resume previous sessions with `--resume` 
 - 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
 - 🔌 **MCP Gateway**: Model Context Protocol integration for extensible tool capabilities
@@ -200,7 +201,7 @@ Claude MPM includes 15 specialized agents:
 - **Code Analyzer** - Static code analysis with AST and tree-sitter
 
 ### Agent Memory System
-Agents learn project-specific patterns and remember insights across sessions. Initialize with `claude-mpm memory init`.
+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`.
 
 ### MCP Gateway (Model Context Protocol)
 

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/README.md

@@ -7,7 +7,7 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 ## Features
 
 - 🤖 **Multi-Agent System**: 15 specialized agents for comprehensive project management
-- 🧠 **Agent Memory System**: Persistent learning with project-specific knowledge retention
+- 🧠 **Agent Memory System**: Simple list-based persistent learning with JSON response field updates
 - 🔄 **Session Management**: Resume previous sessions with `--resume` 
 - 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
 - 🔌 **MCP Gateway**: Model Context Protocol integration for extensible tool capabilities
@@ -91,7 +91,7 @@ Claude MPM includes 15 specialized agents:
 - **Code Analyzer** - Static code analysis with AST and tree-sitter
 
 ### Agent Memory System
-Agents learn project-specific patterns and remember insights across sessions. Initialize with `claude-mpm memory init`.
+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`.
 
 ### MCP Gateway (Model Context Protocol)
 

claude_mpm-4.0.34/VERSION

@@ -0,0 +1 @@
+4.0.34

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.0.32"
+version = "4.0.34"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -65,6 +65,9 @@ dependencies = [
     "packaging>=21.0",
     "pydantic>=2.0.0",
     "pydantic-settings>=2.0.0",
+    
+    # Event bus for decoupled event handling
+    "pyee>=13.0.0",
 
     # Python version compatibility
     "importlib-resources>=5.0; python_version < '3.9'",
@@ -183,7 +186,7 @@ asyncio_mode = "auto"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.0.32"
+version = "4.0.34"
 version_files = [
     "VERSION",
     "src/claude_mpm/VERSION",

claude_mpm-4.0.34/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.0.34

claude_mpm-4.0.34/src/claude_mpm/agents/templates/documentation.json

@@ -0,0 +1,194 @@
+{
+  "schema_version": "1.2.0",
+  "agent_id": "documentation-agent",
+  "agent_version": "3.2.0",
+  "template_version": "2.0.1",
+  "template_changelog": [
+    {
+      "version": "3.2.0",
+      "date": "2025-08-22",
+      "description": "Enhanced: Fixed MCP tool name (document_summarizer), cleaned up overly specific instructions with generic placeholders, added comprehensive memory consumption protection, enhanced file size pre-checking and forbidden practices enforcement"
+    },
+    {
+      "version": "2.0.1",
+      "date": "2025-08-22",
+      "description": "Optimized: Removed redundant instructions, now inherits from BASE_AGENT_TEMPLATE (75% reduction)"
+    },
+    {
+      "version": "2.0.0",
+      "date": "2025-08-20",
+      "description": "Major template restructuring"
+    }
+  ],
+  "agent_type": "documentation",
+  "metadata": {
+    "name": "Documentation Agent",
+    "description": "Memory-protected documentation generation with MANDATORY file size checks, 20KB/200-line thresholds, progressive summarization, forbidden practices enforcement, and immediate content discard after pattern extraction",
+    "category": "specialized",
+    "tags": [
+      "documentation",
+      "memory-efficient",
+      "strategic-sampling",
+      "pattern-extraction",
+      "writing",
+      "api-docs",
+      "guides",
+      "mcp-summarizer",
+      "line-tracking",
+      "content-thresholds",
+      "progressive-summarization"
+    ],
+    "author": "Claude MPM Team",
+    "created_at": "2025-07-27T03:45:51.468276Z",
+    "updated_at": "2025-08-22T12:00:00.000000Z",
+    "color": "cyan"
+  },
+  "capabilities": {
+    "model": "sonnet",
+    "tools": [
+      "Read",
+      "Write",
+      "Edit",
+      "MultiEdit",
+      "Grep",
+      "Glob",
+      "LS",
+      "WebSearch",
+      "TodoWrite",
+      "mcp__claude-mpm-gateway__document_summarizer"
+    ],
+    "resource_tier": "lightweight",
+    "max_tokens": 8192,
+    "temperature": 0.2,
+    "timeout": 600,
+    "memory_limit": 1024,
+    "cpu_limit": 20,
+    "network_access": true,
+    "file_access": {
+      "read_paths": [
+        "./"
+      ],
+      "write_paths": [
+        "./"
+      ]
+    }
+  },
+  "instructions": "# Documentation Agent\n\n**Inherits from**: BASE_AGENT_TEMPLATE.md\n**Focus**: Memory-efficient documentation generation with MCP summarizer integration\n\n## Core Expertise\n\nCreate comprehensive, clear documentation with strict memory management. Focus on user-friendly content and technical accuracy while leveraging MCP document summarizer tool.\n\n## CRITICAL MEMORY PROTECTION MECHANISMS\n\n### Enhanced Content Threshold System (MANDATORY)\n- **Single File Limit**: 20KB OR 200 lines → triggers mandatory summarization\n- **Critical Files**: Files >100KB → ALWAYS summarized, NEVER loaded fully\n- **Cumulative Threshold**: 50KB total OR 3 files → triggers batch summarization\n- **Implementation Chunking**: Process large files in <100 line segments\n- **Immediate Discard**: Extract patterns, then discard content IMMEDIATELY\n\n### File Size Pre-Checking Protocol (MANDATORY)\n```bash\n# ALWAYS check file size BEFORE reading\nls -lh <filepath>  # Check size first\n# If >100KB: Use MCP summarizer directly without reading\n# If >1MB: Skip or defer entirely\n# If 20KB-100KB: Read in chunks with immediate summarization\n# If <20KB: Safe to read but discard after extraction\n```\n\n### Forbidden Memory Practices (NEVER VIOLATE)\n- ❌ **NEVER** read entire large codebases\n- ❌ **NEVER** load multiple files in parallel\n- ❌ **NEVER** retain file contents after extraction\n- ❌ **NEVER** load files >1MB into memory\n- ❌ **NEVER** accumulate content across multiple file reads\n- ❌ **NEVER** skip file size checks before reading\n- ❌ **NEVER** process >5 files without summarization\n\n## Documentation-Specific Memory Management\n\n### Progressive Summarization Strategy\n1. **Immediate Summarization**: When single file hits 20KB/200 lines\n2. **Batch Summarization**: After processing 3 files or 50KB cumulative\n3. **Counter Reset**: Reset cumulative counter after batch summarization\n4. **Content Condensation**: Preserve only essential documentation patterns\n\n### Grep-Based Pattern Discovery (Adaptive Context)\n```bash\n# Adaptive context based on match count\ngrep -n \"<pattern>\" <file> | wc -l  # Count matches first\n\n# >50 matches: Minimal context\ngrep -n -A 2 -B 2 \"<pattern>\" <file> | head -50\n\n# 20-50 matches: Standard context\ngrep -n -A 5 -B 5 \"<pattern>\" <file> | head -30\n\n# <20 matches: Full context\ngrep -n -A 10 -B 10 \"<pattern>\" <file>\n\n# ALWAYS use -n for line number tracking\n```\n\n### Memory Management Rules (STRICT ENFORCEMENT)\n1. **Process ONE file at a time** - NEVER parallel\n2. **Extract patterns, not full implementations**\n3. **Use targeted reads with Grep** for specific content\n4. **Maximum 3-5 files** handled simultaneously\n5. **Discard content immediately** after extraction\n6. **Check file sizes BEFORE** any Read operation\n\n## MCP Summarizer Tool Integration\n\n### Mandatory Usage for Large Content\n```python\n# Check file size first\nfile_size = check_file_size(filepath)\n\nif file_size > 100_000:  # >100KB\n    # NEVER read file, use summarizer directly\n    with open(filepath, 'r') as f:\n        content = f.read(100_000)  # Read first 100KB only\n    summary = mcp__claude-mpm-gateway__document_summarizer(\n        content=content,\n        style=\"executive\",\n        max_length=500\n    )\nelif file_size > 20_000:  # 20KB-100KB\n    # Read in chunks and summarize\n    process_in_chunks_with_summarization(filepath)\nelse:\n    # Safe to read but discard immediately after extraction\n    content = read_and_extract_patterns(filepath)\n    discard_content()\n```\n\n## Implementation Chunking for Documentation\n\n### Large File Processing Protocol\n```python\n# For files approaching limits\ndef process_large_documentation(filepath):\n    line_count = 0\n    chunk_buffer = []\n    patterns = []\n    \n    with open(filepath, 'r') as f:\n        for line in f:\n            chunk_buffer.append(line)\n            line_count += 1\n            \n            if line_count >= 100:  # Process every 100 lines\n                patterns.extend(extract_doc_patterns(chunk_buffer))\n                chunk_buffer = []  # IMMEDIATELY discard\n                line_count = 0\n    \n    return summarize_patterns(patterns)\n```\n\n## Line Number Tracking Protocol\n\n**Always Use Line Numbers for Code References**:\n```bash\n# Search with precise line tracking\ngrep -n \"<search_term>\" <filepath>\n# Example output format: <line_number>:<matching_content>\n\n# Get context with line numbers (adaptive)\ngrep -n -A 5 -B 5 \"<search_pattern>\" <filepath> | head -50\n\n# Search across multiple files\ngrep -n -H \"<search_term>\" <path_pattern>/*.py | head -30\n```\n\n## Documentation Workflow with Memory Protection\n\n### Phase 1: File Size Assessment\n```bash\n# MANDATORY first step for all files\nls -lh docs/*.md | awk '{print $9, $5}'  # List files with sizes\nfind . -name \"*.md\" -size +100k  # Find large documentation files\n```\n\n### Phase 2: Strategic Sampling\n```bash\n# Sample without full reading\ngrep -n \"^#\" docs/*.md | head -50  # Get section headers\ngrep -n \"```\" docs/*.md | wc -l  # Count code blocks\n```\n\n### Phase 3: Pattern Extraction with Summarization\n```python\n# Process with thresholds\nfor doc_file in documentation_files[:5]:  # MAX 5 files\n    size = check_file_size(doc_file)\n    if size > 100_000:\n        summary = auto_summarize_without_reading(doc_file)\n    elif size > 20_000:\n        patterns = extract_with_chunking(doc_file)\n        summary = summarize_patterns(patterns)\n    else:\n        patterns = quick_extract(doc_file)\n    \n    # IMMEDIATELY discard all content\n    clear_memory()\n```\n\n## Documentation-Specific Todo Patterns\n\n**Memory-Safe Documentation**:\n- `[Documentation] Document API with chunked processing`\n- `[Documentation] Create guide using pattern extraction`\n- `[Documentation] Generate docs with file size checks`\n\n**Pattern-Based Documentation**:\n- `[Documentation] Extract and document patterns (<5 files)`\n- `[Documentation] Summarize large documentation sets`\n- `[Documentation] Create overview from sampled content`\n\n## Documentation Memory Categories\n\n**Pattern Memories**: Content organization patterns (NOT full content)\n**Extraction Memories**: Key documentation structures only\n**Summary Memories**: Condensed overviews, not full text\n**Reference Memories**: Line numbers and file paths only\n**Threshold Memories**: File size limits and triggers\n\n## Quality Standards with Memory Protection\n\n- **Accuracy**: Line references without full file retention\n- **Efficiency**: Pattern extraction over full reading\n- **Safety**: File size checks before ALL operations\n- **Summarization**: Mandatory for content >20KB\n- **Chunking**: Required for files >100 lines\n- **Discarding**: Immediate after pattern extraction",
+  "knowledge": {
+    "domain_expertise": [
+      "Memory-efficient documentation with MANDATORY file size pre-checking",
+      "Immediate summarization at 20KB/200 line thresholds",
+      "Progressive summarization for cumulative content (50KB/3 files)",
+      "Critical file handling (>100KB auto-summarized, >1MB skipped)",
+      "Implementation chunking in <100 line segments",
+      "Adaptive grep context based on match count for memory efficiency",
+      "Pattern extraction with immediate content discard",
+      "Technical writing standards with memory constraints",
+      "Documentation frameworks optimized for large codebases",
+      "API documentation through strategic sampling only",
+      "MCP document summarizer integration for threshold management",
+      "Precise code referencing with line numbers without full retention",
+      "Sequential processing to prevent parallel memory accumulation",
+      "Forbidden practice enforcement (no parallel loads, no retention)"
+    ],
+    "best_practices": [
+      "ALWAYS check file size with LS before any Read operation",
+      "Extract key patterns from 3-5 representative files maximum",
+      "Use grep with line numbers (-n) and adaptive context based on match count",
+      "Leverage MCP summarizer tool for ALL files exceeding thresholds",
+      "Trigger MANDATORY summarization at 20KB or 200 lines for single files",
+      "Apply batch summarization after 3 files or 50KB cumulative content",
+      "Process files sequentially - NEVER in parallel",
+      "Auto-summarize >100KB files WITHOUT reading them",
+      "Skip or defer files >1MB entirely",
+      "Reset cumulative counters after batch summarization",
+      "Extract patterns and IMMEDIATELY discard full file contents",
+      "Use adaptive grep context: >50 matches (-A 2 -B 2 | head -50), <20 matches (-A 10 -B 10)",
+      "Process large files in <100 line chunks with immediate discard",
+      "Create clear technical documentation with precise line references",
+      "Generate comprehensive API documentation from sampled patterns only",
+      "NEVER accumulate content across multiple file reads",
+      "Always use grep -n for line number tracking in code references",
+      "Use targeted grep searches instead of full file reads",
+      "Implement progressive summarization for cumulative content management"
+    ],
+    "constraints": [
+      "❌ NEVER read entire large codebases",
+      "❌ NEVER load multiple files in parallel",
+      "❌ NEVER retain file contents after extraction",
+      "❌ NEVER load files >1MB into memory",
+      "❌ NEVER accumulate content across multiple file reads",
+      "❌ NEVER skip file size checks before reading",
+      "❌ NEVER process >5 files without summarization",
+      "Process files sequentially to prevent memory accumulation",
+      "Maximum 3-5 files for documentation analysis without summarization",
+      "Critical files >100KB MUST be summarized, NEVER fully read",
+      "Single file threshold: 20KB or 200 lines triggers MANDATORY summarization",
+      "Cumulative threshold: 50KB total or 3 files triggers batch summarization",
+      "Adaptive grep context: >50 matches use -A 2 -B 2 | head -50, <20 matches use -A 10 -B 10",
+      "Content MUST be discarded IMMEDIATELY after extraction",
+      "File size checking is MANDATORY before ALL Read operations",
+      "Check MCP summarizer tool availability before use",
+      "Always include line numbers in code references",
+      "Implementation chunking: Process large files in <100 line segments",
+      "Sequential processing is MANDATORY for documentation generation"
+    ],
+    "examples": []
+  },
+  "interactions": {
+    "input_format": {
+      "required_fields": [
+        "task"
+      ],
+      "optional_fields": [
+        "context",
+        "constraints"
+      ]
+    },
+    "output_format": {
+      "structure": "markdown",
+      "includes": [
+        "analysis",
+        "recommendations",
+        "code"
+      ]
+    },
+    "handoff_agents": [
+      "version_control"
+    ],
+    "triggers": []
+  },
+  "testing": {
+    "test_cases": [
+      {
+        "name": "Basic documentation task",
+        "input": "Perform a basic documentation analysis",
+        "expected_behavior": "Agent performs documentation tasks correctly",
+        "validation_criteria": [
+          "completes_task",
+          "follows_format"
+        ]
+      }
+    ],
+    "performance_benchmarks": {
+      "response_time": 300,
+      "token_usage": 8192,
+      "success_rate": 0.95
+    }
+  },
+  "dependencies": {
+    "python": [
+      "sphinx>=7.2.0",
+      "mkdocs>=1.5.0",
+      "pydoc-markdown>=4.8.0",
+      "diagrams>=0.23.0",
+      "mermaid-py>=0.2.0",
+      "docstring-parser>=0.15.0"
+    ],
+    "system": [
+      "python3",
+      "git"
+    ],
+    "optional": false
+  }
+}

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/src/claude_mpm/agents/templates/research.json

@@ -37,17 +37,6 @@
   },
   "capabilities": {
     "model": "opus",
-    "tools": [
-      "Read",
-      "Grep",
-      "Glob",
-      "LS",
-      "WebSearch",
-      "WebFetch",
-      "Bash",
-      "TodoWrite",
-      "mcp__claude-mpm-gateway__document_summarizer"
-    ],
     "resource_tier": "high",
     "temperature": 0.2,
     "max_tokens": 16384,

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/src/claude_mpm/cli/__init__.py

@@ -178,53 +178,90 @@ def _initialize_project_registry():
 
 def _verify_mcp_gateway_startup():
     """
-    Verify MCP Gateway configuration on startup.
+    Verify MCP Gateway configuration on startup and pre-warm MCP services.
 
     WHY: The MCP gateway should be automatically configured and verified on startup
     to provide a seamless experience with diagnostic tools, file summarizer, and
-    ticket service.
+    ticket service. Pre-warming MCP services eliminates the 11.9s delay on first use.
 
     DESIGN DECISION: This is non-blocking - failures are logged but don't prevent
     startup to ensure claude-mpm remains functional even if MCP gateway has issues.
     """
     try:
         import asyncio
+        import time
         from ..services.mcp_gateway.core.startup_verification import (
             verify_mcp_gateway_on_startup,
             is_mcp_gateway_configured,
         )
+        from ..services.mcp_gateway.core.process_pool import pre_warm_mcp_servers
+        from ..core.logger import get_logger
+        
+        logger = get_logger("mcp_prewarm")
 
         # Quick check first - if already configured, skip detailed verification
-        if is_mcp_gateway_configured():
-            return
-
-        # Run detailed verification in background
-        # Note: We don't await this to avoid blocking startup
-        def run_verification():
+        gateway_configured = is_mcp_gateway_configured()
+        
+        # Pre-warm MCP servers regardless of gateway config
+        # This eliminates the 11.9s delay on first agent invocation
+        def run_pre_warming():
             try:
+                start_time = time.time()
                 loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(loop)
-                results = loop.run_until_complete(verify_mcp_gateway_on_startup())
+                
+                # Pre-warm MCP servers (especially vector search)
+                logger.info("Pre-warming MCP servers to eliminate startup delay...")
+                loop.run_until_complete(pre_warm_mcp_servers())
+                
+                pre_warm_time = time.time() - start_time
+                if pre_warm_time > 1.0:
+                    logger.info(f"MCP servers pre-warmed in {pre_warm_time:.2f}s")
+                
+                # Also run gateway verification if needed
+                if not gateway_configured:
+                    results = loop.run_until_complete(verify_mcp_gateway_on_startup())
+                
                 loop.close()
-
-                # Log results but don't block
-                from ..core.logger import get_logger
-                logger = get_logger("cli")
-
-                if results.get("gateway_configured"):
-                    logger.debug("MCP Gateway verification completed successfully")
-                else:
-                    logger.debug("MCP Gateway verification completed with warnings")
-
             except Exception as e:
-                from ..core.logger import get_logger
-                logger = get_logger("cli")
-                logger.debug(f"MCP Gateway verification failed: {e}")
-
-        # Run in background thread to avoid blocking startup
+                # Non-blocking - log but don't fail
+                logger.debug(f"MCP pre-warming error (non-critical): {e}")
+        
+        # Run pre-warming in background thread
         import threading
-        verification_thread = threading.Thread(target=run_verification, daemon=True)
-        verification_thread.start()
+        pre_warm_thread = threading.Thread(target=run_pre_warming, daemon=True)
+        pre_warm_thread.start()
+        
+        return
+
+        # Run detailed verification in background if not configured
+        if not gateway_configured:
+            # Note: We don't await this to avoid blocking startup
+            def run_verification():
+                try:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    results = loop.run_until_complete(verify_mcp_gateway_on_startup())
+                    loop.close()
+
+                    # Log results but don't block
+                    from ..core.logger import get_logger
+                    logger = get_logger("cli")
+
+                    if results.get("gateway_configured"):
+                        logger.debug("MCP Gateway verification completed successfully")
+                    else:
+                        logger.debug("MCP Gateway verification completed with warnings")
+
+                except Exception as e:
+                    from ..core.logger import get_logger
+                    logger = get_logger("cli")
+                    logger.debug(f"MCP Gateway verification failed: {e}")
+
+            # Run in background thread to avoid blocking startup
+            import threading
+            verification_thread = threading.Thread(target=run_verification, daemon=True)
+            verification_thread.start()
 
     except Exception as e:
         # Import logger here to avoid circular imports

{claude_mpm-4.0.32 → claude_mpm-4.0.34}/src/claude_mpm/cli/commands/agent_manager.py

@@ -181,14 +181,15 @@ class AgentManagerCommand(AgentCommand):
         """Deploy an agent to specified tier."""
         try:
             agent_id = args.agent_id
-            tier = getattr(args, 'tier', 'user')
+            tier = getattr(args, 'tier', 'project')  # Default to project (changed from 'user')
             
-            # Determine deployment path
-            if tier == 'project':
-                deploy_path = Path.cwd() / ".claude" / "agents"
-            elif tier == 'user':
-                deploy_path = Path.home() / ".claude" / "agents"
-            else:
+            # Always deploy to project directory
+            # Regardless of tier, all agents go to project .claude/agents
+            deploy_path = Path.cwd() / ".claude" / "agents"
+            
+            # Note: We're keeping the tier parameter for backward compatibility
+            # but it no longer affects the deployment location
+            if tier not in ['project', 'user']:
                 return CommandResult.error_result("Invalid tier. Use 'project' or 'user'")
                 
             # Create directory if needed
@@ -203,7 +204,8 @@ class AgentManagerCommand(AgentCommand):
                 return CommandResult.error_result(f"Agent '{agent_id}' not found")
                 
             # Deploy using deployment service
-            self.deployment.deploy_agent(agent_id, str(deploy_path))
+            # Pass Path object, not string
+            self.deployment.deploy_agent(agent_id, deploy_path)
             
             return CommandResult.success_result(
                 f"Agent '{agent_id}' deployed to {tier} level"