claude-code-pilot 2.0.0 → 3.0.0

package/src/pilot/workflows/plant-seed.md

@@ -0,0 +1,169 @@
+<purpose>
+Capture a forward-looking idea as a structured seed file with trigger conditions.
+Seeds auto-surface during /ccp:new-milestone when trigger conditions match the
+new milestone's scope.
+
+Seeds beat deferred items because they:
+- Preserve WHY the idea matters (not just WHAT)
+- Define WHEN to surface (trigger conditions, not manual scanning)
+- Track breadcrumbs (code references, related decisions)
+- Auto-present at the right time via new-milestone scan
+</purpose>
+
+<process>
+
+<step name="parse_idea">
+Parse `$ARGUMENTS` for the idea summary.
+
+If empty, ask:
+```
+What's the idea? (one sentence)
+```
+
+Store as `$IDEA`.
+</step>
+
+<step name="create_seed_dir">
+```bash
+mkdir -p .planning/seeds
+```
+</step>
+
+<step name="gather_context">
+Ask focused questions to build a complete seed:
+
+```
+AskUserQuestion(
+  header: "Trigger",
+  question: "When should this idea surface? (e.g., 'when we add user accounts', 'next major version', 'when performance becomes a priority')",
+  options: []  // freeform
+)
+```
+
+Store as `$TRIGGER`.
+
+```
+AskUserQuestion(
+  header: "Why",
+  question: "Why does this matter? What problem does it solve or what opportunity does it create?",
+  options: []
+)
+```
+
+Store as `$WHY`.
+
+```
+AskUserQuestion(
+  header: "Scope",
+  question: "How big is this? (rough estimate)",
+  options: [
+    { label: "Small", description: "A few hours — could be a quick task" },
+    { label: "Medium", description: "A phase or two — needs planning" },
+    { label: "Large", description: "A full milestone — significant effort" }
+  ]
+)
+```
+
+Store as `$SCOPE`.
+</step>
+
+<step name="collect_breadcrumbs">
+Search the codebase for relevant references:
+
+```bash
+# Find files related to the idea keywords
+grep -rl "$KEYWORD" --include="*.ts" --include="*.js" --include="*.md" . 2>/dev/null | head -10
+```
+
+Also check:
+- Current STATE.md for related decisions
+- ROADMAP.md for related phases
+- todos/ for related captured ideas
+
+Store relevant file paths as `$BREADCRUMBS`.
+</step>
+
+<step name="generate_seed_id">
+```bash
+# Find next seed number
+EXISTING=$( (ls .planning/seeds/SEED-*.md 2>/dev/null || true) | wc -l )
+NEXT=$((EXISTING + 1))
+PADDED=$(printf "%03d" $NEXT)
+```
+
+Generate slug from idea summary.
+</step>
+
+<step name="write_seed">
+Write `.planning/seeds/SEED-{PADDED}-{slug}.md`:
+
+```markdown
+---
+id: SEED-{PADDED}
+status: dormant
+planted: {ISO date}
+planted_during: {current milestone/phase from STATE.md}
+trigger_when: {$TRIGGER}
+scope: {$SCOPE}
+---
+
+# SEED-{PADDED}: {$IDEA}
+
+## Why This Matters
+
+{$WHY}
+
+## When to Surface
+
+**Trigger:** {$TRIGGER}
+
+This seed should be presented during `/ccp:new-milestone` when the milestone
+scope matches any of these conditions:
+- {trigger condition 1}
+- {trigger condition 2}
+
+## Scope Estimate
+
+**{$SCOPE}** — {elaboration based on scope choice}
+
+## Breadcrumbs
+
+Related code and decisions found in the current codebase:
+
+{list of $BREADCRUMBS with file paths}
+
+## Notes
+
+{any additional context from the current session}
+```
+</step>
+
+<step name="commit_seed">
+```bash
+node "$HOME/.claude/pilot/bin/ccp-tools.cjs" commit "docs: plant seed — {$IDEA}" --files .planning/seeds/SEED-{PADDED}-{slug}.md
+```
+</step>
+
+<step name="confirm">
+```
+✅ Seed planted: SEED-{PADDED}
+
+"{$IDEA}"
+Trigger: {$TRIGGER}
+Scope: {$SCOPE}
+File: .planning/seeds/SEED-{PADDED}-{slug}.md
+
+This seed will surface automatically when you run /ccp:new-milestone
+and the milestone scope matches the trigger condition.
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Seed file created in .planning/seeds/
+- [ ] Frontmatter includes status, trigger, scope
+- [ ] Breadcrumbs collected from codebase
+- [ ] Committed to git
+- [ ] User shown confirmation with trigger info
+</success_criteria>

package/src/pilot/workflows/pr-branch.md

@@ -0,0 +1,129 @@
+<purpose>
+Create a clean branch for pull requests by filtering out .planning/ commits.
+The PR branch contains only code changes — reviewers don't see CCP artifacts
+(PLAN.md, SUMMARY.md, STATE.md, CONTEXT.md, etc.).
+
+Uses git cherry-pick with path filtering to rebuild a clean history.
+</purpose>
+
+<process>
+
+<step name="detect_state">
+Parse `$ARGUMENTS` for target branch (default: `main`).
+
+```bash
+CURRENT_BRANCH=$(git branch --show-current)
+TARGET=${1:-main}
+```
+
+Check preconditions:
+- Must be on a feature branch (not main/master)
+- Must have commits ahead of target
+
+```bash
+AHEAD=$(git rev-list --count "$TARGET".."$CURRENT_BRANCH" 2>/dev/null)
+if [ "$AHEAD" = "0" ]; then
+  echo "No commits ahead of $TARGET — nothing to filter."
+  exit 0
+fi
+```
+
+Display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Pilot ► PR BRANCH
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Branch: {CURRENT_BRANCH}
+Target: {TARGET}
+Commits: {AHEAD} ahead
+```
+</step>
+
+<step name="analyze_commits">
+Classify commits:
+
+```bash
+# Get all commits ahead of target
+git log --oneline "$TARGET".."$CURRENT_BRANCH" --no-merges
+```
+
+For each commit, check if it ONLY touches .planning/ files:
+
+```bash
+# For each commit hash
+FILES=$(git diff-tree --no-commit-id --name-only -r $HASH)
+ALL_PLANNING=$(echo "$FILES" | grep -v "^\.planning/" | wc -l)
+```
+
+Classify:
+- **Code commits**: Touch at least one non-.planning/ file → INCLUDE
+- **Planning-only commits**: Touch only .planning/ files → EXCLUDE
+- **Mixed commits**: Touch both → INCLUDE (planning changes come along)
+
+Display analysis:
+```
+Commits to include: {N} (code changes)
+Commits to exclude: {N} (planning-only)
+Mixed commits: {N} (code + planning — included)
+```
+</step>
+
+<step name="create_pr_branch">
+```bash
+PR_BRANCH="${CURRENT_BRANCH}-pr"
+
+# Create PR branch from target
+git checkout -b "$PR_BRANCH" "$TARGET"
+```
+
+Cherry-pick only code commits (in order):
+
+```bash
+for HASH in $CODE_COMMITS; do
+  git cherry-pick "$HASH" --no-commit
+  # Remove any .planning/ files that came along in mixed commits
+  git rm -r --cached .planning/ 2>/dev/null || true
+  git commit -C "$HASH"
+done
+```
+
+Return to original branch:
+```bash
+git checkout "$CURRENT_BRANCH"
+```
+</step>
+
+<step name="verify">
+```bash
+# Verify no .planning/ files in PR branch
+PLANNING_FILES=$(git diff --name-only "$TARGET".."$PR_BRANCH" | grep "^\.planning/" | wc -l)
+TOTAL_FILES=$(git diff --name-only "$TARGET".."$PR_BRANCH" | wc -l)
+PR_COMMITS=$(git rev-list --count "$TARGET".."$PR_BRANCH")
+```
+
+Display results:
+```
+✅ PR branch created: {PR_BRANCH}
+
+Original: {AHEAD} commits, {ORIGINAL_FILES} files
+PR branch: {PR_COMMITS} commits, {TOTAL_FILES} files
+Planning files: {PLANNING_FILES} (should be 0)
+
+Next steps:
+  git push origin {PR_BRANCH}
+  gh pr create --base {TARGET} --head {PR_BRANCH}
+
+Or use /ccp:ship to create the PR automatically.
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] PR branch created from target
+- [ ] Planning-only commits excluded
+- [ ] No .planning/ files in PR branch diff
+- [ ] Commit messages preserved from original
+- [ ] User shown next steps
+</success_criteria>

package/{gsd/get-shit-done → src/pilot}/workflows/progress.md

@@ -12,37 +12,41 @@ Read all files referenced by the invoking prompt's execution_context before star
 **Load progress context (paths only):**
 
 ```bash
-INIT=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" init progress)
+INIT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" init progress)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
 Extract from init JSON: `project_exists`, `roadmap_exists`, `state_exists`, `phases`, `current_phase`, `next_phase`, `milestone_version`, `completed_count`, `phase_count`, `paused_at`, `state_path`, `roadmap_path`, `project_path`, `config_path`.
 
+```bash
+DISCUSS_MODE=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" config-get workflow.discuss_mode 2>/dev/null || echo "discuss")
+```
+
 If `project_exists` is false (no `.planning/` directory):
 
 ```
 No planning structure found.
 
-Run /gsd:new-project to start a new project.
+Run /ccp:new-project to start a new project.
 ```
 
 Exit.
 
-If missing STATE.md: suggest `/gsd:new-project`.
+If missing STATE.md: suggest `/ccp:new-project`.
 
 **If ROADMAP.md missing but PROJECT.md exists:**
 
 This means a milestone was completed and archived. Go to **Route F** (between milestones).
 
-If missing both ROADMAP.md and PROJECT.md: suggest `/gsd:new-project`.
+If missing both ROADMAP.md and PROJECT.md: suggest `/ccp:new-project`.
 </step>
 
 <step name="load">
-**Use structured extraction from gsd-tools:**
+**Use structured extraction from ccp-tools:**
 
 Instead of reading full files, use targeted tools to get only the data needed for the report:
-- `ROADMAP=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" roadmap analyze)`
-- `STATE=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" state-snapshot)`
+- `ROADMAP=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" roadmap analyze)`
+- `STATE=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" state-snapshot)`
 
 This minimizes orchestrator context usage.
 </step>
@@ -51,7 +55,7 @@ This minimizes orchestrator context usage.
 **Get comprehensive roadmap analysis (replaces manual parsing):**
 
 ```bash
-ROADMAP=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" roadmap analyze)
+ROADMAP=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" roadmap analyze)
 ```
 
 This returns structured JSON with:
@@ -70,7 +74,7 @@ Use this instead of manually reading/parsing ROADMAP.md.
 - Find the 2-3 most recent SUMMARY.md files
 - Use `summary-extract` for efficient parsing:
   ```bash
-  node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" summary-extract <path> --fields one_liner
+  node "$HOME/.claude/pilot/bin/ccp-tools.cjs" summary-extract <path> --fields one_liner
   ```
 - This shows "what we've been working on"
   </step>
@@ -85,11 +89,11 @@ Use this instead of manually reading/parsing ROADMAP.md.
   </step>
 
 <step name="report">
-**Generate progress bar from gsd-tools, then present rich status report:**
+**Generate progress bar from ccp-tools, then present rich status report:**
 
 ```bash
 # Get formatted progress bar
-PROGRESS_BAR=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" progress bar --raw)
+PROGRESS_BAR=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" progress bar --raw)
 ```
 
 Present:
@@ -98,7 +102,8 @@ Present:
 # [Project Name]
 
 **Progress:** {PROGRESS_BAR}
-**Profile:** [quality/balanced/budget]
+**Profile:** [quality/balanced/budget/inherit]
+**Discuss mode:** {DISCUSS_MODE}
 
 ## Recent Work
 - [Phase X, Plan Y]: [what was accomplished - 1 line from summary-extract]
@@ -118,10 +123,10 @@ CONTEXT: [✓ if has_context | - if not]
 - [e.g. jq -r '.blockers[].text' from state-snapshot]
 
 ## Pending Todos
-- [count] pending — /gsd:check-todos to review
+- [count] pending — /ccp:check-todos to review
 
 ## Active Debug Sessions
-- [count] active — /gsd:debug to continue
+- [count] active — /ccp:debug to continue
 (Only show this section if count > 0)
 
 ## What's Next
@@ -150,17 +155,47 @@ State: "This phase has {X} plans, {Y} summaries."
 Check for UAT.md files with status "diagnosed" (has gaps needing fixes).
 
 ```bash
-# Check for diagnosed UAT with gaps
-grep -l "status: diagnosed" .planning/phases/[current-phase-dir]/*-UAT.md 2>/dev/null
+# Check for diagnosed UAT with gaps or partial (incomplete) testing
+grep -l "status: diagnosed\|status: partial" .planning/phases/[current-phase-dir]/*-UAT.md 2>/dev/null
 ```
 
 Track:
 - `uat_with_gaps`: UAT.md files with status "diagnosed" (gaps need fixing)
+- `uat_partial`: UAT.md files with status "partial" (incomplete testing)
+
+**Step 1.6: Cross-phase health check**
+
+Scan ALL phases in the current milestone for outstanding verification debt using the CLI:
+
+```bash
+DEBT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" audit-uat --raw 2>/dev/null)
+```
+
+Parse JSON for `summary.total_items` and `summary.total_files`.
+
+Track: `outstanding_debt` — `summary.total_items` from the audit.
+
+**If outstanding_debt > 0:** Add a warning section to the progress report output (in the `report` step), placed between "## What's Next" and the route suggestion:
+
+```markdown
+## Verification Debt ({N} files across prior phases)
+
+| Phase | File | Issue |
+|-------|------|-------|
+| {phase} | {filename} | {pending_count} pending, {skipped_count} skipped, {blocked_count} blocked |
+| {phase} | {filename} | human_needed — {count} items |
+
+Review: `/ccp:audit-uat` — full cross-phase audit
+Resume testing: `/ccp:verify-work {phase}` — retest specific phase
+```
+
+This is a WARNING, not a blocker — routing proceeds normally. The debt is visible so the user can make an informed choice.
 
 **Step 2: Route based on counts**
 
 | Condition | Meaning | Action |
 |-----------|---------|--------|
+| uat_partial > 0 | UAT testing incomplete | Go to **Route E.2** |
 | uat_with_gaps > 0 | UAT gaps need fix plans | Go to **Route E** |
 | summaries < plans | Unexecuted plans exist | Go to **Route A** |
 | summaries = plans AND plans > 0 | Phase complete | Go to Step 3 |
@@ -180,7 +215,7 @@ Read its `<objective>` section.
 
 **{phase}-{plan}: [Plan Name]** — [objective summary from PLAN.md]
 
-`/gsd:execute-phase {phase}`
+`/ccp:execute-phase {phase}`
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -203,7 +238,7 @@ Check if `{phase_num}-CONTEXT.md` exists in phase directory.
 **Phase {N}: {Name}** — {Goal from ROADMAP.md}
 <sub>✓ Context gathered, ready to plan</sub>
 
-`/gsd:plan-phase {phase-number}`
+`/ccp:plan-phase {phase-number}`
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -219,15 +254,15 @@ Check if `{phase_num}-CONTEXT.md` exists in phase directory.
 
 **Phase {N}: {Name}** — {Goal from ROADMAP.md}
 
-`/gsd:discuss-phase {phase}` — gather context and clarify approach
+`/ccp:discuss-phase {phase}` — gather context and clarify approach
 
 <sub>`/clear` first → fresh context window</sub>
 
 ---
 
 **Also available:**
-- `/gsd:plan-phase {phase}` — skip discussion, plan directly
-- `/gsd:list-phase-assumptions {phase}` — see Claude's assumptions
+- `/ccp:plan-phase {phase}` — skip discussion, plan directly
+- `/ccp:list-phase-assumptions {phase}` — see Claude's assumptions
 
 ---
 ```
@@ -245,15 +280,41 @@ UAT.md exists with gaps (diagnosed issues). User needs to plan fixes.
 
 **{phase_num}-UAT.md** has {N} gaps requiring fixes.
 
-`/gsd:plan-phase {phase} --gaps`
+`/ccp:plan-phase {phase} --gaps`
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
+- `/ccp:execute-phase {phase}` — execute phase plans
+- `/ccp:verify-work {phase}` — run more UAT testing
+
+---
+```
+
+---
+
+**Route E.2: UAT testing incomplete (partial)**
+
+UAT.md exists with `status: partial` — testing session ended before all items resolved.
+
+```
+---
+
+## Incomplete UAT Testing
+
+**{phase_num}-UAT.md** has {N} unresolved tests (pending, blocked, or skipped).
+
+`/ccp:verify-work {phase}` — resume testing from where you left off
 
 <sub>`/clear` first → fresh context window</sub>
 
 ---
 
 **Also available:**
-- `/gsd:execute-phase {phase}` — execute phase plans
-- `/gsd:verify-work {phase}` — run more UAT testing
+- `/ccp:audit-uat` — full cross-phase UAT audit
+- `/ccp:execute-phase {phase}` — execute phase plans
 
 ---
 ```
@@ -292,15 +353,15 @@ Read ROADMAP.md to get the next phase's name and goal.
 
 **Phase {Z+1}: {Name}** — {Goal from ROADMAP.md}
 
-`/gsd:discuss-phase {Z+1}` — gather context and clarify approach
+`/ccp:discuss-phase {Z+1}` — gather context and clarify approach
 
 <sub>`/clear` first → fresh context window</sub>
 
 ---
 
 **Also available:**
-- `/gsd:plan-phase {Z+1}` — skip discussion, plan directly
-- `/gsd:verify-work {Z}` — user acceptance test before continuing
+- `/ccp:plan-phase {Z+1}` — skip discussion, plan directly
+- `/ccp:verify-work {Z}` — user acceptance test before continuing
 
 ---
 ```
@@ -320,14 +381,14 @@ All {N} phases finished!
 
 **Complete Milestone** — archive and prepare for next
 
-`/gsd:complete-milestone`
+`/ccp:complete-milestone`
 
 <sub>`/clear` first → fresh context window</sub>
 
 ---
 
 **Also available:**
-- `/gsd:verify-work` — user acceptance test before completing milestone
+- `/ccp:verify-work` — user acceptance test before completing milestone
 
 ---
 ```
@@ -351,7 +412,7 @@ Ready to plan the next milestone.
 
 **Start Next Milestone** — questioning → research → requirements → roadmap
 
-`/gsd:new-milestone`
+`/ccp:new-milestone`
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -363,10 +424,10 @@ Ready to plan the next milestone.
 <step name="edge_cases">
 **Handle edge cases:**
 
-- Phase complete but next phase not planned → offer `/gsd:plan-phase [next]`
+- Phase complete but next phase not planned → offer `/ccp:plan-phase [next]`
 - All work complete → offer milestone completion
 - Blockers present → highlight before offering to continue
-- Handoff file exists → mention it, offer `/gsd:resume-work`
+- Handoff file exists → mention it, offer `/ccp:resume-work`
   </step>
 
 </process>
@@ -376,7 +437,7 @@ Ready to plan the next milestone.
 - [ ] Rich context provided (recent work, decisions, issues)
 - [ ] Current position clear with visual progress
 - [ ] What's next clearly explained
-- [ ] Smart routing: /gsd:execute-phase if plans exist, /gsd:plan-phase if not
+- [ ] Smart routing: /ccp:execute-phase if plans exist, /ccp:plan-phase if not
 - [ ] User confirms before any action
-- [ ] Seamless handoff to appropriate gsd command
+- [ ] Seamless handoff to appropriate ccp command
       </success_criteria>