claude-mpm 5.4.59__py3-none-any.whl → 5.4.64__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.4.59
+5.4.64

claude_mpm/agents/CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md

@@ -1,3 +1,8 @@
+---
+name: Claude MPM Teacher
+description: Teaching mode that explains PM workflow in real-time, guiding users new to Claude MPM through Socratic method and progressive disclosure
+---
+
 # Project Manager Agent - Teaching Mode
 
 **Version**: 0001

claude_mpm/cli/startup.py

@@ -325,24 +325,29 @@ def deploy_output_style_on_startup():
         professional_source = package_dir / "CLAUDE_MPM_OUTPUT_STYLE.md"
         teacher_source = package_dir / "CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md"
 
-        # Target directory (PROJECT-LEVEL, not user-level)
-        project_dir = Path.cwd()
-        output_styles_dir = project_dir / ".claude" / "settings" / "output-styles"
+        # Target directory (USER-LEVEL for global availability)
+        # Claude Code reads output styles from ~/.claude/settings/output-styles/
+        user_home = Path.home()
+        output_styles_dir = user_home / ".claude" / "settings" / "output-styles"
         professional_target = output_styles_dir / "claude-mpm-style.md"
         teacher_target = output_styles_dir / "claude-mpm-teacher.md"
 
         # Create directory if it doesn't exist
         output_styles_dir.mkdir(parents=True, exist_ok=True)
 
-        # Check if already deployed (both files exist and have content)
-        already_deployed = (
+        # Check if already deployed AND up-to-date (compare sizes to detect changes)
+        professional_up_to_date = (
             professional_target.exists()
-            and teacher_target.exists()
-            and professional_target.stat().st_size > 0
-            and teacher_target.stat().st_size > 0
+            and professional_source.exists()
+            and professional_target.stat().st_size == professional_source.stat().st_size
+        )
+        teacher_up_to_date = (
+            teacher_target.exists()
+            and teacher_source.exists()
+            and teacher_target.stat().st_size == teacher_source.stat().st_size
         )
 
-        if already_deployed:
+        if professional_up_to_date and teacher_up_to_date:
             # Show feedback that output styles are ready
             print("✓ Output styles ready", flush=True)
             return

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -586,6 +586,14 @@ class AgentTemplateBuilder:
             tags_str = ",".join(metadata["tags"])
             frontmatter_lines.append(f"tags: {tags_str}")
 
+        # CRITICAL: Preserve skills field from template for selective skill deployment
+        # Skills are used by startup.py to determine which skills to deploy
+        skills = template_data.get("skills", [])
+        if skills and isinstance(skills, list):
+            frontmatter_lines.append("skills:")
+            for skill in skills:
+                frontmatter_lines.append(f"- {skill}")
+
         frontmatter_lines.extend(
             [
                 "---",

claude_mpm/skills/bundled/collaboration/brainstorming/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: Brainstorming Ideas Into Designs
+description: Interactive idea refinement using Socratic method to develop fully-formed designs
+when_to_use: when partner describes any feature or project idea, before writing code or implementation plans
+version: 2.2.0
+progressive_disclosure:
+  level: 1
+  references: []
+  note: Already optimal at 75 lines - intentionally compact, no references needed
+---
+
+# Brainstorming Ideas Into Designs
+
+## Overview
+
+Transform rough ideas into fully-formed designs through structured questioning and alternative exploration.
+
+**Core principle:** Ask questions to understand, explore alternatives, present design incrementally for validation.
+
+**Announce at start:** "I'm using the Brainstorming skill to refine your idea into a design."
+
+## The Process
+
+### Phase 1: Understanding
+- Check current project state in working directory
+- Ask ONE question at a time to refine the idea
+- Prefer multiple choice when possible
+- Gather: Purpose, constraints, success criteria
+
+### Phase 2: Exploration
+- Propose 2-3 different approaches
+- For each: Core architecture, trade-offs, complexity assessment
+- Ask your human partner which approach resonates
+
+### Phase 3: Design Presentation
+- Present in 200-300 word sections
+- Cover: Architecture, components, data flow, error handling, testing
+- Ask after each section: "Does this look right so far?"
+
+### Phase 4: Worktree Setup (for implementation)
+When design is approved and implementation will follow:
+- Announce: "I'm using the Using Git Worktrees skill to set up an isolated workspace."
+- Switch to skills/collaboration/using-git-worktrees
+- Follow that skill's process for directory selection, safety verification, and setup
+- Return here when worktree ready
+
+### Phase 5: Planning Handoff
+Ask: "Ready to create the implementation plan?"
+
+When your human partner confirms (any affirmative response):
+- Announce: "I'm using the Writing Plans skill to create the implementation plan."
+- Switch to skills/collaboration/writing-plans skill
+- Create detailed plan in the worktree
+
+## When to Revisit Earlier Phases
+
+**You can and should go backward when:**
+- Partner reveals new constraint during Phase 2 or 3 → Return to Phase 1 to understand it
+- Validation shows fundamental gap in requirements → Return to Phase 1
+- Partner questions approach during Phase 3 → Return to Phase 2 to explore alternatives
+- Something doesn't make sense → Go back and clarify
+
+**Don't force forward linearly** when going backward would give better results.
+
+## Related Skills
+
+**During exploration:**
+- When approaches have genuine trade-offs: skills/architecture/preserving-productive-tensions
+
+**Before proposing changes to existing code:**
+- Understand why it exists: skills/research/tracing-knowledge-lineages
+
+## Remember
+- One question per message during Phase 1
+- Apply YAGNI ruthlessly
+- Explore 2-3 alternatives before settling
+- Present incrementally, validate as you go
+- Go backward when needed - flexibility > rigid progression
+- Announce skill usage at start

claude_mpm/skills/bundled/collaboration/dispatching-parallel-agents/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: Dispatching Parallel Agents
+description: Use multiple Claude agents to investigate and fix independent problems concurrently
+when_to_use: when facing 3+ independent failures that can be investigated without shared state or dependencies
+version: 2.0.0
+progressive_disclosure:
+  entry_point:
+    summary: "Dispatch one agent per independent problem domain to solve multiple unrelated failures concurrently"
+    when_to_use: "When you have 3+ independent failures in different test files/subsystems with no shared state or dependencies"
+    quick_start: "1. Identify independent domains 2. Create focused agent tasks 3. Dispatch in parallel 4. Review summaries 5. Verify no conflicts and integrate"
+  references:
+    - coordination-patterns.md
+    - agent-prompts.md
+    - examples.md
+    - troubleshooting.md
+---
+
+# Dispatching Parallel Agents
+
+## Overview
+
+When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.
+
+**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
+
+## When to Use This Skill
+
+Activate this skill when you're facing:
+- **3+ test files failing** with different root causes
+- **Multiple subsystems broken** independently
+- **Each problem is self-contained** - can be understood without context from others
+- **No shared state** between investigations
+- **Clear domain boundaries** - fixing one won't affect others
+
+**Don't use when:**
+- Failures are related (fix one might fix others)
+- Need to understand full system state first
+- Agents would interfere with each other (editing same files)
+- Exploratory debugging (don't know what's broken yet)
+
+## The Iron Law
+
+```
+One agent, one problem domain, one clear outcome.
+Never overlap scopes. Never share state. Always integrate consciously.
+```
+
+## Core Principles
+
+### Independence is Key
+Problems must be truly independent - no shared files, no related root causes, no dependencies between fixes.
+
+### Focus Over Breadth
+Each agent gets narrow scope: one test file, one subsystem, one clear goal. Broad tasks lead to confusion.
+
+### Clear Output Required
+Every agent must return a summary: what was found, what was fixed, what changed. No silent fixes.
+
+### Conscious Integration
+Don't blindly merge agent work. Review summaries, check conflicts, run full suite, verify compatibility.
+
+## Quick Start
+
+### 1. Identify Independent Domains
+
+Group failures by what's broken:
+```
+File A tests: Tool approval flow
+File B tests: Batch completion behavior
+File C tests: Abort functionality
+```
+
+Each domain is independent - fixing tool approval doesn't affect abort tests.
+
+### 2. Create Focused Agent Tasks
+
+Each agent gets:
+- **Specific scope:** One test file or subsystem
+- **Clear goal:** Make these tests pass
+- **Constraints:** Don't change other code
+- **Expected output:** Summary of what you found and fixed
+
+**→** [agent-prompts.md](references/agent-prompts.md) for prompt templates and examples
+
+### 3. Dispatch in Parallel
+
+```typescript
+// In Claude Code / AI environment
+Task("Fix agent-tool-abort.test.ts failures")
+Task("Fix batch-completion-behavior.test.ts failures")
+Task("Fix tool-approval-race-conditions.test.ts failures")
+// All three run concurrently
+```
+
+**→** [coordination-patterns.md](references/coordination-patterns.md) for dispatch strategies
+
+### 4. Review and Integrate
+
+When agents return:
+- Read each summary - understand what changed
+- Verify fixes don't conflict - check for same file edits
+- Run full test suite - ensure compatibility
+- Spot check changes - agents can make systematic errors
+
+**→** [troubleshooting.md](references/troubleshooting.md) for conflict resolution
+
+## Decision Tree
+
+```
+Multiple failures?
+  └→ Are they independent?
+      ├→ NO (related) → Single agent investigates all
+      └→ YES → Can they work in parallel?
+          ├→ NO (shared state) → Sequential agents
+          └→ YES → Parallel dispatch ✓
+```
+
+## Key Benefits
+
+1. **Parallelization** - Multiple investigations happen simultaneously
+2. **Focus** - Each agent has narrow scope, less context to track
+3. **Independence** - Agents don't interfere with each other
+4. **Speed** - N problems solved in time of 1
+
+## Navigation
+
+### Pattern Reference
+- **[Coordination Patterns](references/coordination-patterns.md)** - Dispatch strategies, domain identification, integration workflows
+
+### Agent Management
+- **[Agent Prompts](references/agent-prompts.md)** - Prompt structure, templates, common mistakes, constraints
+
+### Learning Resources
+- **[Examples](references/examples.md)** - Real-world scenarios, case studies, time savings analysis
+
+### Problem Solving
+- **[Troubleshooting](references/troubleshooting.md)** - Conflict resolution, verification strategies, common pitfalls
+
+### Related Skills
+- **[pm-workflow](../pm-workflow/)** - PM coordination and task management
+- **[test-driven-development](../../testing/test-driven-development/)** - TDD patterns that benefit from parallel fixing
+- **[verification-before-completion](../../productivity/verification-before-completion/)** - Integration verification
+
+## Key Reminders
+
+1. **Independence is mandatory** - Related failures need single-agent investigation
+2. **Focus beats breadth** - Narrow scope per agent prevents confusion
+3. **Always verify integration** - Don't blindly merge agent work
+4. **Clear outputs required** - Every agent returns summary of changes
+5. **Parallelization has overhead** - Only worth it for 3+ independent problems
+
+## Red Flags - STOP
+
+**STOP immediately if:**
+- Agents are editing the same files (scope overlap)
+- Fixes from one agent break another's work (hidden dependencies)
+- You can't clearly separate problem domains (not independent)
+- Agents return no summary (can't verify changes)
+- Integration requires major refactoring (conflicts)
+
+**When in doubt:** Start with one agent, understand the landscape, then dispatch if truly independent.
+
+## Integration with Other Skills
+
+**Prerequisite:** Basic understanding of problem domains and test structure
+**Complementary:** [pm-workflow](../pm-workflow/) for coordinating multiple agents
+**Domain-specific:** Testing skills for understanding test failures
+
+## Real-World Impact
+
+From debugging session (2025-10-03):
+- **6 failures** across 3 test files
+- **3 agents** dispatched in parallel
+- **All investigations** completed concurrently
+- **Zero conflicts** between agent changes
+- **Time saved:** 3 problems solved in parallel vs sequentially
+
+**→** [examples.md](references/examples.md) for detailed case study