pan-wizard 2.8.1

package/pan-wizard-core/workflows/add-phase.md

@@ -0,0 +1,111 @@
+<purpose>
+Add a new integer phase to the end of the current milestone in the roadmap. Automatically calculates next phase number, creates phase directory, and updates roadmap structure.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="parse_arguments">
+Parse the command arguments:
+- All arguments become the phase description
+- Example: `/pan:add-phase Add authentication` → description = "Add authentication"
+- Example: `/pan:add-phase Fix critical performance issues` → description = "Fix critical performance issues"
+
+If no arguments provided:
+
+```
+ERROR: Phase description required
+Usage: /pan:add-phase <description>
+Example: /pan:add-phase Add authentication system
+```
+
+Exit.
+</step>
+
+<step name="init_context">
+Load phase operation context:
+
+```bash
+INIT=$(node ~/.claude/pan-wizard-core/bin/pan-tools.cjs init phase-op "0")
+```
+
+Check `roadmap_exists` from init JSON. If false:
+```
+ERROR: No roadmap found (.planning/roadmap.md)
+Run /pan:new-project to initialize.
+```
+Exit.
+</step>
+
+<step name="add_phase">
+**Delegate the phase addition to pan-tools:**
+
+```bash
+RESULT=$(node ~/.claude/pan-wizard-core/bin/pan-tools.cjs phase add "${description}")
+```
+
+The CLI handles:
+- Finding the highest existing integer phase number
+- Calculating next phase number (max + 1)
+- Generating slug from description
+- Creating the phase directory (`.planning/phases/{NN}-{slug}/`)
+- Inserting the phase entry into roadmap.md with Goal, Depends on, and Plans sections
+
+Extract from result: `phase_number`, `padded`, `name`, `slug`, `directory`.
+</step>
+
+<step name="update_project_state">
+Update state.md to reflect the new phase:
+
+1. Read `.planning/state.md`
+2. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
+   ```
+   - Phase {N} added: {description}
+   ```
+
+If "Roadmap Evolution" section doesn't exist, create it.
+</step>
+
+<step name="completion">
+Present completion summary:
+
+```
+Phase {N} added to current milestone:
+- Description: {description}
+- Directory: .planning/phases/{phase-num}-{slug}/
+- Status: Not planned yet
+
+Roadmap updated: .planning/roadmap.md
+
+---
+
+## ▶ Next Up
+
+**Phase {N}: {description}**
+
+`/pan:plan-phase {N}`
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
+- `/pan:add-phase <description>` — add another phase
+- Review roadmap
+
+---
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] `pan-tools phase add` executed successfully
+- [ ] Phase directory created
+- [ ] Roadmap updated with new phase entry
+- [ ] state.md updated with roadmap evolution note
+- [ ] User informed of next steps
+</success_criteria>

package/pan-wizard-core/workflows/assumptions.md

@@ -0,0 +1,178 @@
+<purpose>
+Surface Claude's assumptions about a phase before planning, enabling users to correct misconceptions early.
+
+Key difference from discuss-phase: This is ANALYSIS of what Claude thinks, not INTAKE of what user knows. No file output - purely conversational to prompt discussion.
+</purpose>
+
+<process>
+
+<step name="validate_phase" priority="first">
+Phase number: $ARGUMENTS (required)
+
+**If argument missing:**
+
+```
+Error: Phase number required.
+
+Usage: /pan:assumptions [phase-number]
+Example: /pan:assumptions 3
+```
+
+Exit workflow.
+
+**If argument provided:**
+Validate phase exists in roadmap:
+
+```bash
+cat .planning/roadmap.md | grep -i "Phase ${PHASE}"
+```
+
+**If phase not found:**
+
+```
+Error: Phase ${PHASE} not found in roadmap.
+
+Available phases:
+[list phases from roadmap]
+```
+
+Exit workflow.
+
+**If phase found:**
+Parse phase details from roadmap:
+
+- Phase number
+- Phase name
+- Phase description/goal
+- Any scope details mentioned
+
+Continue to analyze_phase.
+</step>
+
+<step name="analyze_phase">
+Based on roadmap description and project context, identify assumptions across five areas:
+
+**1. Technical Approach:**
+What libraries, frameworks, patterns, or tools would Claude use?
+- "I'd use X library because..."
+- "I'd follow Y pattern because..."
+- "I'd structure this as Z because..."
+
+**2. Implementation Order:**
+What would Claude build first, second, third?
+- "I'd start with X because it's foundational"
+- "Then Y because it depends on X"
+- "Finally Z because..."
+
+**3. Scope Boundaries:**
+What's included vs excluded in Claude's interpretation?
+- "This phase includes: A, B, C"
+- "This phase does NOT include: D, E, F"
+- "Boundary ambiguities: G could go either way"
+
+**4. Risk Areas:**
+Where does Claude expect complexity or challenges?
+- "The tricky part is X because..."
+- "Potential issues: Y, Z"
+- "I'd watch out for..."
+
+**5. Dependencies:**
+What does Claude assume exists or needs to be in place?
+- "This assumes X from previous phases"
+- "External dependencies: Y, Z"
+- "This will be consumed by..."
+
+Be honest about uncertainty. Mark assumptions with confidence levels:
+- "Fairly confident: ..." (clear from roadmap)
+- "Assuming: ..." (reasonable inference)
+- "Unclear: ..." (could go multiple ways)
+</step>
+
+<step name="present_assumptions">
+Present assumptions in a clear, scannable format:
+
+```
+## My Assumptions for Phase ${PHASE}: ${PHASE_NAME}
+
+### Technical Approach
+[List assumptions about how to implement]
+
+### Implementation Order
+[List assumptions about sequencing]
+
+### Scope Boundaries
+**In scope:** [what's included]
+**Out of scope:** [what's excluded]
+**Ambiguous:** [what could go either way]
+
+### Risk Areas
+[List anticipated challenges]
+
+### Dependencies
+**From prior phases:** [what's needed]
+**External:** [third-party needs]
+**Feeds into:** [what future phases need from this]
+
+---
+
+**What do you think?**
+
+Are these assumptions accurate? Let me know:
+- What I got right
+- What I got wrong
+- What I'm missing
+```
+
+Wait for user response.
+</step>
+
+<step name="gather_feedback">
+**If user provides corrections:**
+
+Acknowledge the corrections:
+
+```
+Key corrections:
+- [correction 1]
+- [correction 2]
+
+This changes my understanding significantly. [Summarize new understanding]
+```
+
+**If user confirms assumptions:**
+
+```
+Assumptions validated.
+```
+
+Continue to offer_next.
+</step>
+
+<step name="offer_next">
+Present next steps:
+
+```
+What's next?
+1. Discuss context (/pan:discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
+2. Plan this phase (/pan:plan-phase ${PHASE}) - Create detailed execution plans
+3. Re-examine assumptions - I'll analyze again with your corrections
+4. Done for now
+```
+
+Wait for user selection.
+
+If "Discuss context": Note that context.md will incorporate any corrections discussed here
+If "Plan this phase": Proceed knowing assumptions are understood
+If "Re-examine": Return to analyze_phase with updated understanding
+</step>
+
+</process>
+
+<success_criteria>
+- Phase number validated against roadmap
+- Assumptions surfaced across five areas: technical approach, implementation order, scope, risks, dependencies
+- Confidence levels marked where appropriate
+- "What do you think?" prompt presented
+- User feedback acknowledged
+- Clear next steps offered
+</success_criteria>

package/pan-wizard-core/workflows/diagnose-issues.md

@@ -0,0 +1,219 @@
+<purpose>
+Orchestrate parallel debug agents to investigate UAT gaps and find root causes.
+
+After UAT finds gaps, spawn one debug agent per gap. Each agent investigates autonomously with symptoms pre-filled from UAT. Collect root causes, update uat.md gaps with diagnosis, then hand off to plan-phase --gaps with actual diagnoses.
+
+Orchestrator stays lean: parse gaps, spawn agents, collect results, update UAT.
+</purpose>
+
+<paths>
+DEBUG_DIR=.planning/debug
+
+Debug files use the `.planning/debug/` path (hidden directory with leading dot).
+</paths>
+
+<core_principle>
+**Diagnose before planning fixes.**
+
+UAT tells us WHAT is broken (symptoms). Debug agents find WHY (root cause). plan-phase --gaps then creates targeted fixes based on actual causes, not guesses.
+
+Without diagnosis: "Comment doesn't refresh" → guess at fix → maybe wrong
+With diagnosis: "Comment doesn't refresh" → "useEffect missing dependency" → precise fix
+</core_principle>
+
+<process>
+
+<step name="parse_gaps">
+**Extract gaps from uat.md:**
+
+Read the "Gaps" section (YAML format):
+```yaml
+- truth: "Comment appears immediately after submission"
+  status: failed
+  reason: "User reported: works but doesn't show until I refresh the page"
+  severity: major
+  test: 2
+  artifacts: []
+  missing: []
+```
+
+For each gap, also read the corresponding test from "Tests" section to get full context.
+
+Build gap list:
+```
+gaps = [
+  {truth: "Comment appears immediately...", severity: "major", test_num: 2, reason: "..."},
+  {truth: "Reply button positioned correctly...", severity: "minor", test_num: 5, reason: "..."},
+  ...
+]
+```
+</step>
+
+<step name="report_plan">
+**Report diagnosis plan to user:**
+
+```
+## Diagnosing {N} Gaps
+
+Spawning parallel debug agents to investigate root causes:
+
+| Gap (Truth) | Severity |
+|-------------|----------|
+| Comment appears immediately after submission | major |
+| Reply button positioned correctly | minor |
+| Delete removes comment | blocker |
+
+Each agent will:
+1. Create DEBUG-{slug}.md with symptoms pre-filled
+2. Investigate autonomously (read code, form hypotheses, test)
+3. Return root cause
+
+This runs in parallel - all gaps investigated simultaneously.
+```
+</step>
+
+<step name="spawn_agents">
+**Spawn debug agents in parallel:**
+
+For each gap, fill the debug-subagent-prompt template and spawn:
+
+```
+Task(
+  prompt=filled_debug_subagent_prompt + "\n\n<files_to_read>\n- {phase_dir}/{phase_num}-uat.md\n- .planning/state.md\n</files_to_read>",
+  subagent_type="general-purpose",
+  description="Debug: {truth_short}"
+)
+```
+
+**All agents spawn in single message** (parallel execution).
+
+Template placeholders:
+- `{truth}`: The expected behavior that failed
+- `{expected}`: From UAT test
+- `{actual}`: Verbatim user description from reason field
+- `{errors}`: Any error messages from UAT (or "None reported")
+- `{reproduction}`: "Test {test_num} in UAT"
+- `{timeline}`: "Discovered during UAT"
+- `{goal}`: `find_root_cause_only` (UAT flow - plan-phase --gaps handles fixes)
+- `{slug}`: Generated from truth
+</step>
+
+<step name="collect_results">
+**Collect root causes from agents:**
+
+Each agent returns with:
+```
+## ROOT CAUSE FOUND
+
+**Debug Session:** ${DEBUG_DIR}/{slug}.md
+
+**Root Cause:** {specific cause with evidence}
+
+**Evidence Summary:**
+- {key finding 1}
+- {key finding 2}
+- {key finding 3}
+
+**Files Involved:**
+- {file1}: {what's wrong}
+- {file2}: {related issue}
+
+**Suggested Fix Direction:** {brief hint for plan-phase --gaps}
+```
+
+Parse each return to extract:
+- root_cause: The diagnosed cause
+- files: Files involved
+- debug_path: Path to debug session file
+- suggested_fix: Hint for gap closure plan
+
+If agent returns `## INVESTIGATION INCONCLUSIVE`:
+- root_cause: "Investigation inconclusive - manual review needed"
+- Note which issue needs manual attention
+- Include remaining possibilities from agent return
+</step>
+
+<step name="update_uat">
+**Update uat.md gaps with diagnosis:**
+
+For each gap in the Gaps section, add artifacts and missing fields:
+
+```yaml
+- truth: "Comment appears immediately after submission"
+  status: failed
+  reason: "User reported: works but doesn't show until I refresh the page"
+  severity: major
+  test: 2
+  root_cause: "useEffect in CommentList.tsx missing commentCount dependency"
+  artifacts:
+    - path: "src/components/CommentList.tsx"
+      issue: "useEffect missing dependency"
+  missing:
+    - "Add commentCount to useEffect dependency array"
+    - "Trigger re-render when new comment added"
+  debug_session: .planning/debug/comment-not-refreshing.md
+```
+
+Update status in frontmatter to "diagnosed".
+
+Commit the updated uat.md:
+```bash
+node ~/.claude/pan-wizard-core/bin/pan-tools.cjs commit "docs({phase_num}): add root causes from diagnosis" --files ".planning/phases/XX-name/{phase_num}-uat.md"
+```
+</step>
+
+<step name="report_results">
+**Report diagnosis results and hand off:**
+
+Display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PAN ► DIAGNOSIS COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+| Gap (Truth) | Root Cause | Files |
+|-------------|------------|-------|
+| Comment appears immediately | useEffect missing dependency | CommentList.tsx |
+| Reply button positioned correctly | CSS flex order incorrect | ReplyButton.tsx |
+| Delete removes comment | API missing auth header | api/comments.ts |
+
+Debug sessions: ${DEBUG_DIR}/
+
+Proceeding to plan fixes...
+```
+
+Return to verify-phase orchestrator for automatic planning.
+Do NOT offer manual next steps - verify-phase handles the rest.
+</step>
+
+</process>
+
+<context_efficiency>
+Agents start with symptoms pre-filled from UAT (no symptom gathering).
+Agents only diagnose—plan-phase --gaps handles fixes (no fix application).
+</context_efficiency>
+
+<failure_handling>
+**Agent fails to find root cause:**
+- Mark gap as "needs manual review"
+- Continue with other gaps
+- Report incomplete diagnosis
+
+**Agent times out:**
+- Check DEBUG-{slug}.md for partial progress
+- Can resume with /pan:debug
+
+**All agents fail:**
+- Something systemic (permissions, git, etc.)
+- Report for manual investigation
+- Fall back to plan-phase --gaps without root causes (less precise)
+</failure_handling>
+
+<success_criteria>
+- [ ] Gaps parsed from uat.md
+- [ ] Debug agents spawned in parallel
+- [ ] Root causes collected from all agents
+- [ ] uat.md gaps updated with artifacts and missing
+- [ ] Debug sessions saved to ${DEBUG_DIR}/
+- [ ] Hand off to verify-phase for automatic planning
+</success_criteria>