pmp-gywd 3.3.0

package/commands/gywd/plan-phase.md

@@ -0,0 +1,93 @@
+---
+name: GYWD:plan-phase
+description: Create detailed execution plan for a phase (PLAN.md)
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - WebFetch
+  - mcp__context7__*
+---
+
+<objective>
+Create executable phase prompt with discovery, context injection, and task breakdown.
+
+Purpose: Break down roadmap phases into concrete, executable PLAN.md files that Claude can execute.
+Output: One or more PLAN.md files in the phase directory (.planning/phases/XX-name/{phase}-{plan}-PLAN.md)
+</objective>
+
+<execution_context>
+@~/.claude/get-your-work-done/workflows/plan-phase.md
+@~/.claude/get-your-work-done/templates/phase-prompt.md
+@~/.claude/get-your-work-done/references/plan-format.md
+@~/.claude/get-your-work-done/references/scope-estimation.md
+@~/.claude/get-your-work-done/references/checkpoints.md
+@~/.claude/get-your-work-done/references/tdd.md
+@~/.claude/get-your-work-done/references/confidence-scoring.md
+@~/.claude/get-your-work-done/references/adaptive-decomposition.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if not provided)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+
+**Load phase context if exists (created by /gywd:discuss-phase):**
+Check for and read `.planning/phases/XX-name/{phase}-CONTEXT.md` - contains research findings, clarifications, and decisions from phase discussion.
+
+**Load codebase context if exists:**
+Check for `.planning/codebase/` and load relevant documents based on phase type.
+</context>
+
+<process>
+1. Check .planning/ directory exists (error if not - user should run /gywd:new-project)
+2. If phase number provided via $ARGUMENTS, validate it exists in roadmap
+3. If no phase number, detect next unplanned phase from roadmap
+4. Follow plan-phase.md workflow:
+   - Load project state and accumulated decisions
+   - Perform mandatory discovery (Level 0-3 as appropriate)
+   - Read project history (prior decisions, issues, concerns)
+   - Break phase into tasks
+   - Estimate scope and split into multiple plans if needed
+   - Create PLAN.md file(s) with executable structure
+</process>
+
+<success_criteria>
+- [ ] One or more PLAN.md files created in .planning/phases/XX-name/
+- [ ] Each plan has: objective, execution_context, context, tasks, verification, success_criteria, output
+- [ ] Tasks are specific enough for Claude to execute
+- [ ] **Confidence scores included:**
+  - Overall plan confidence percentage
+  - Per-task confidence scores
+  - Low-confidence tasks flagged (< 70%)
+  - Factors affecting confidence listed
+- [ ] User knows next steps (execute plan or review/adjust)
+</success_criteria>
+
+<confidence_requirements>
+Every PLAN.md must include a confidence summary:
+
+```markdown
+## Confidence Summary
+
+**Overall: XX%** (High/Moderate/Low)
+
+| Task | Confidence | Notes |
+|------|------------|-------|
+| T1 | 95% | Standard pattern |
+| T2 | 72% | Multiple approaches possible |
+| T3 | 58% | ⚠️ Needs clarification |
+
+**Low-confidence items require review before execution.**
+```
+
+See confidence-scoring.md reference for calculation guidelines.
+</confidence_requirements>

package/commands/gywd/preview-plan.md

@@ -0,0 +1,139 @@
+---
+name: GYWD:preview-plan
+description: Preview what a plan will do before executing it
+argument-hint: "[path-to-PLAN.md]"
+---
+
+<objective>
+Show a detailed preview of what a plan will do BEFORE execution.
+
+Builds trust by letting users see:
+- All tasks that will be executed
+- Files that will be created/modified
+- Commands that will be run
+- Checkpoints where execution will pause
+- Estimated complexity and risk
+
+This is a READ-ONLY operation. No changes are made.
+</objective>
+
+<context>
+Plan path: $ARGUMENTS
+
+If no path provided, auto-detect current plan:
+1. Read STATE.md for current phase
+2. Find next unexecuted plan in that phase
+3. Use that plan path
+</context>
+
+<process>
+1. Locate plan file:
+   - If $ARGUMENTS provided: Use that path
+   - If not: Auto-detect from STATE.md
+   - If no plan found: Error with helpful message
+
+2. Read and parse the plan:
+   - Extract plan name and description
+   - Parse all tasks with their details
+   - Identify checkpoints (verify/decision)
+   - Note any dependencies mentioned
+
+3. Analyze each task for:
+   **File Operations:**
+   - Files to create (look for "create", "add", "new")
+   - Files to modify (look for "update", "edit", "change")
+   - Files to delete (look for "remove", "delete")
+
+   **Commands:**
+   - Shell commands mentioned (npm, git, etc.)
+   - Test commands
+   - Build commands
+
+   **Risk Indicators:**
+   - Database migrations
+   - Config changes
+   - Dependency updates
+   - Breaking changes mentioned
+
+4. Generate execution preview:
+   ```
+   ## Plan Preview: {plan-name}
+
+   **Path:** .planning/phases/01-foundation/01-01-PLAN.md
+   **Tasks:** 5 tasks, 1 checkpoint
+   **Estimated Complexity:** Medium
+
+   ---
+
+   ### Execution Order
+
+   1. ☐ **Create user model**
+      - Creates: src/models/user.ts
+      - Creates: src/models/user.test.ts
+
+   2. ☐ **Add authentication middleware**
+      - Creates: src/middleware/auth.ts
+      - Modifies: src/app.ts
+
+   3. ⏸️ **CHECKPOINT: Verify tests pass**
+      - Execution will pause here for verification
+
+   4. ☐ **Implement login endpoint**
+      - Creates: src/routes/auth.ts
+      - Commands: npm test
+
+   5. ☐ **Update documentation**
+      - Modifies: README.md
+
+   ---
+
+   ### Summary
+
+   | Action | Count |
+   |--------|-------|
+   | Files Created | 4 |
+   | Files Modified | 2 |
+   | Commands Run | 1 |
+   | Checkpoints | 1 |
+
+   ### Risk Assessment
+
+   ✅ No high-risk operations detected
+
+   ---
+
+   Ready to execute? Run:
+   /gywd:execute-plan {plan-path}
+   ```
+
+5. Highlight any concerns:
+   - ⚠️ for medium-risk operations
+   - 🔴 for high-risk operations (migrations, breaking changes)
+   - Suggest review steps for risky operations
+</process>
+
+<output_format>
+Structured preview showing:
+- Plan metadata (path, task count, complexity)
+- Ordered task list with file operations
+- Clear checkpoint indicators
+- Summary table
+- Risk assessment
+- Next step command
+
+Use emojis for visual scanning:
+- ☐ = pending task
+- ⏸️ = checkpoint
+- ✅ = safe operation
+- ⚠️ = needs attention
+- 🔴 = high risk
+</output_format>
+
+<success_criteria>
+- [ ] Parses plan without executing anything
+- [ ] Shows all tasks in execution order
+- [ ] Identifies file creates/modifies
+- [ ] Highlights checkpoints clearly
+- [ ] Provides risk assessment
+- [ ] Shows clear next step
+</success_criteria>

package/commands/gywd/profile.md

@@ -0,0 +1,363 @@
+---
+name: GYWD:profile
+description: Developer Digital Twin - model of your patterns, preferences, and expertise
+argument-hint: "[show|learn|reset] [--export] [--import <path>]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - Write
+---
+
+<objective>
+Build and maintain a persistent model of YOU as a developer.
+
+Current AI treats every developer identically.
+But you have:
+- Unique cognitive patterns
+- Personal heuristics
+- Areas of deep expertise
+- Characteristic blind spots
+- Preferred abstractions
+
+Your Digital Twin captures this, making AI adapt to YOU.
+</objective>
+
+<philosophy>
+From cognitive science: "Experts organize knowledge as larger but fewer chunks than novices."
+
+Your expertise has a shape. Your thinking has patterns.
+A system that understands YOUR patterns serves you better than one that serves "average developer."
+</philosophy>
+
+<reference>
+Profile data stored in `.planning/profile/` directory.
+</reference>
+
+<profile_dimensions>
+## What We Model
+
+### 1. Cognitive Fingerprint
+How you think about problems.
+
+```yaml
+cognitive_style:
+  abstraction_level: high  # vs concrete
+  approach: top_down       # vs bottom_up
+  exploration: depth_first # vs breadth_first
+  risk_tolerance: moderate # conservative, moderate, aggressive
+
+  chunking_patterns:
+    - "Groups by feature, not layer"
+    - "Thinks in data transformations"
+    - "Visualizes as state machines"
+
+  reasoning_style:
+    - "Prefers explicit over implicit"
+    - "Asks 'what could go wrong' early"
+    - "Iterates quickly, refactors later"
+```
+
+### 2. Knowledge Topology
+What you know and how deeply.
+
+```yaml
+expertise_map:
+  deep:  # Could teach others
+    - TypeScript advanced types
+    - React hooks patterns
+    - API design
+    - Testing strategies
+
+  working:  # Competent, no lookup needed
+    - Node.js
+    - PostgreSQL
+    - Git workflows
+    - Docker basics
+
+  familiar:  # Can work with lookup
+    - GraphQL
+    - Redis
+    - CI/CD
+    - AWS services
+
+  learning:  # Currently developing
+    - Rust
+    - WebAssembly
+
+  gaps:  # Known unknowns
+    - Machine learning
+    - Mobile development
+    - Kubernetes internals
+```
+
+### 3. Decision Patterns
+How you make choices.
+
+```yaml
+decision_style:
+  speed: deliberate  # quick, deliberate, thorough
+  reversibility_bias: "Prefers easily reversible choices"
+  documentation: "Documents decisions but not code"
+
+  typical_trade_offs:
+    - "Favors readability over performance"
+    - "Prefers explicit over clever"
+    - "Chooses boring technology"
+
+  anti_patterns:  # Things you avoid
+    - "Class inheritance hierarchies"
+    - "Global state"
+    - "Magic strings"
+```
+
+### 4. Communication Style
+How you explain and understand.
+
+```yaml
+communication:
+  explanation_preference: "Examples before theory"
+  detail_level: moderate
+
+  learns_best_from:
+    - "Working code examples"
+    - "Visual diagrams"
+    - "Incremental building"
+
+  learns_poorly_from:
+    - "Long documentation"
+    - "Abstract descriptions"
+    - "Videos without code"
+
+  writes:
+    - "Terse commit messages"
+    - "Detailed PR descriptions"
+    - "Comments for 'why' not 'what'"
+```
+
+### 5. Work Patterns
+How you operate.
+
+```yaml
+work_patterns:
+  peak_hours: "9am-12pm"
+  deep_work_duration: "90 min average"
+  context_switch_cost: high
+
+  session_patterns:
+    - "Starts with review of yesterday"
+    - "Tackles hard problems in morning"
+    - "Refactors in afternoon"
+    - "Writes tests at end of feature"
+
+  interruption_tolerance: low
+
+  collaboration_style:
+    - "Prefers async communication"
+    - "Likes pair programming for complex problems"
+    - "Reviews PRs in batches"
+```
+
+### 6. Historical Patterns
+What your past reveals.
+
+```yaml
+historical:
+  common_bugs:
+    - "Off-by-one errors in loops"
+    - "Missing null checks on optional chains"
+    - "Forgetting to await async functions"
+
+  refactoring_triggers:
+    - "Third time writing similar code"
+    - "Function exceeds 50 lines"
+    - "More than 3 parameters"
+
+  typical_journey:
+    - "Spike solution first"
+    - "Happy path implementation"
+    - "Error handling second pass"
+    - "Tests after implementation"
+    - "Refactor before PR"
+```
+</profile_dimensions>
+
+<commands>
+## Subcommands
+
+### /gywd:profile show
+Display current profile.
+
+```markdown
+## Developer Profile: @cyberbloke9
+
+### Cognitive Style
+- Top-down thinker, depth-first explorer
+- Groups by feature, thinks in data transformations
+- Moderate risk tolerance
+
+### Expertise
+🟢 Deep: TypeScript, React, API Design, Testing
+🔵 Working: Node.js, PostgreSQL, Git, Docker
+🟡 Familiar: GraphQL, Redis, CI/CD
+📚 Learning: Rust
+
+### Decision Patterns
+- Deliberate decision-maker
+- Favors readability over performance
+- Chooses boring technology
+
+### Work Patterns
+- Peak: 9am-12pm
+- Deep work: 90 min sessions
+- High context-switch cost
+- Low interruption tolerance
+
+### Known Blind Spots
+- Off-by-one errors
+- Missing null checks
+- Forgetting await
+
+Profile confidence: 78% (based on 6 months data)
+```
+
+### /gywd:profile learn
+Trigger learning from recent behavior.
+
+```
+Analyzing recent activity...
+
+Learned:
++ "Prefers named exports over default exports"
++ "Uses early returns consistently"
++ "Tests edge cases before happy path"
+
+Updated:
+~ expertise.typescript: working → deep
+~ work_patterns.peak_hours: refined to 9:30-11:30am
+
+Removed (no longer accurate):
+- "Uses class components" (switched to hooks)
+
+Profile updated.
+```
+
+### /gywd:profile reset [dimension]
+Reset profile or specific dimension.
+
+```
+/gywd:profile reset expertise
+# Resets expertise map, keeps other dimensions
+
+/gywd:profile reset
+# Full reset with confirmation
+```
+
+### /gywd:profile --export
+Export profile to shareable format.
+
+```
+Exported to .planning/profile-export.yaml
+
+This file contains:
+- Cognitive patterns
+- Expertise map
+- Decision patterns
+- Work patterns
+
+Does NOT contain:
+- Historical bugs (private)
+- Session data (private)
+- Personal identifiers
+```
+
+### /gywd:profile --import <path>
+Import profile from export.
+
+```
+Importing from team-profile.yaml...
+
+Imported:
+- Team coding conventions
+- Shared expertise expectations
+- Common decision patterns
+
+Merged with personal profile.
+```
+</commands>
+
+<learning_sources>
+## How Profile Learns
+
+### Code Patterns
+- Analyze your commits for style patterns
+- Compare accepted vs rejected suggestions
+- Track refactoring triggers
+
+### Decision Patterns
+- Track which options you choose
+- Analyze commit message language
+- Learn from PR review comments
+
+### Work Patterns
+- Session start/end times
+- Focus duration analysis
+- Context switch frequency
+- Interruption handling
+
+### Expertise
+- Files you navigate confidently
+- Areas where you seek help
+- Explanation complexity you produce
+- Code review depth by area
+</learning_sources>
+
+<integration>
+## How Profile Integrates
+
+### In Planning
+- Suggest approaches matching your style
+- Flag areas outside your expertise
+- Estimate your effort based on patterns
+
+### In Execution
+- Format output to your preferences
+- Explain in your style
+- Warn about your common mistakes
+
+### In Review
+- Focus on your blind spots
+- Match your review depth preferences
+- Time suggestions appropriately
+
+### In Anticipation
+- Predict based on YOUR patterns
+- Pre-load YOUR typical needs
+- Protect YOUR flow patterns
+</integration>
+
+<privacy>
+## Privacy Controls
+
+All profile data is:
+- Stored locally in .planning/profile/
+- Never transmitted without explicit export
+- Deletable with /gywd:profile reset
+
+Sensitive dimensions (bugs, session data) are:
+- Never included in exports
+- Encrypted at rest
+- Purgeable separately
+</privacy>
+
+<success_criteria>
+- [ ] Captures cognitive patterns accurately
+- [ ] Maps expertise topology
+- [ ] Learns from behavior over time
+- [ ] Adapts AI responses to profile
+- [ ] Exports/imports for team sharing
+- [ ] Respects privacy boundaries
+- [ ] Improves with usage
+</success_criteria>