claude-code-pilot 2.0.0 → 3.0.0

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

@@ -13,7 +13,7 @@ Parse the command arguments:
 - First argument: integer phase number to insert after
 - Remaining arguments: phase description
 
-Example: `/gsd:insert-phase 72 Fix critical auth bug`
+Example: `/ccp:insert-phase 72 Fix critical auth bug`
 -> after = 72
 -> description = "Fix critical auth bug"
 
@@ -21,8 +21,8 @@ If arguments missing:
 
 ```
 ERROR: Both phase number and description required
-Usage: /gsd:insert-phase <after> <description>
-Example: /gsd:insert-phase 72 Fix critical auth bug
+Usage: /ccp:insert-phase <after> <description>
+Example: /ccp:insert-phase 72 Fix critical auth bug
 ```
 
 Exit.
@@ -34,7 +34,7 @@ Validate first argument is an integer.
 Load phase operation context:
 
 ```bash
-INIT=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" init phase-op "${after_phase}")
+INIT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" init phase-op "${after_phase}")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
@@ -46,10 +46,10 @@ Exit.
 </step>
 
 <step name="insert_phase">
-**Delegate the phase insertion to gsd-tools:**
+**Delegate the phase insertion to ccp-tools:**
 
 ```bash
-RESULT=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" phase insert "${after_phase}" "${description}")
+RESULT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" phase insert "${after_phase}" "${description}")
 ```
 
 The CLI handles:
@@ -93,7 +93,7 @@ Project state updated: .planning/STATE.md
 
 **Phase {decimal_phase}: {description}** -- urgent insertion
 
-`/gsd:plan-phase {decimal_phase}`
+`/ccp:plan-phase {decimal_phase}`
 
 <sub>`/clear` first -> fresh context window</sub>
 
@@ -111,18 +111,18 @@ Project state updated: .planning/STATE.md
 
 <anti_patterns>
 
-- Don't use this for planned work at end of milestone (use /gsd:add-phase)
+- Don't use this for planned work at end of milestone (use /ccp:add-phase)
 - Don't insert before Phase 1 (decimal 0.1 makes no sense)
 - Don't renumber existing phases
 - Don't modify the target phase content
-- Don't create plans yet (that's /gsd:plan-phase)
+- Don't create plans yet (that's /ccp:plan-phase)
 - Don't commit changes (user decides when to commit)
 </anti_patterns>
 
 <success_criteria>
 Phase insertion is complete when:
 
-- [ ] `gsd-tools phase insert` executed successfully
+- [ ] `ccp-tools phase insert` executed successfully
 - [ ] Phase directory created
 - [ ] Roadmap updated with new phase entry (includes "(INSERTED)" marker)
 - [ ] STATE.md updated with roadmap evolution note

package/{gsd/get-shit-done → src/pilot}/workflows/list-phase-assumptions.md

@@ -14,8 +14,8 @@ Phase number: $ARGUMENTS (required)
 ```
 Error: Phase number required.
 
-Usage: /gsd:list-phase-assumptions [phase-number]
-Example: /gsd:list-phase-assumptions 3
+Usage: /ccp:list-phase-assumptions [phase-number]
+Example: /ccp:list-phase-assumptions 3
 ```
 
 Exit workflow.
@@ -153,8 +153,8 @@ Present next steps:
 
 ```
 What's next?
-1. Discuss context (/gsd:discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
-2. Plan this phase (/gsd:plan-phase ${PHASE}) - Create detailed execution plans
+1. Discuss context (/ccp:discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
+2. Plan this phase (/ccp:plan-phase ${PHASE}) - Create detailed execution plans
 3. Re-examine assumptions - I'll analyze again with your corrections
 4. Done for now
 ```

package/src/pilot/workflows/manager.md

@@ -0,0 +1,362 @@
+<purpose>
+
+Interactive command center for managing a milestone from a single terminal. Shows a dashboard of all phases with visual status, dispatches discuss inline and plan/execute as background agents, and loops back to the dashboard after each action. Enables parallel phase work from one terminal.
+
+</purpose>
+
+<required_reading>
+
+Read all files referenced by the invoking prompt's execution_context before starting.
+
+</required_reading>
+
+<process>
+
+<step name="initialize" priority="first">
+
+## 1. Initialize
+
+Bootstrap via manager init:
+
+```bash
+INIT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" init manager)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON for: `milestone_version`, `milestone_name`, `phase_count`, `completed_count`, `in_progress_count`, `phases`, `recommended_actions`, `all_complete`, `waiting_signal`.
+
+**If error:** Display the error message and exit.
+
+Display startup banner:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Pilot ► MANAGER
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ {milestone_version} — {milestone_name}
+ {phase_count} phases · {completed_count} complete
+
+ ✓ Discuss → inline    ◆ Plan/Execute → background
+ Dashboard auto-refreshes when background work is active.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Proceed to dashboard step.
+
+</step>
+
+<step name="dashboard">
+
+## 2. Dashboard (Refresh Point)
+
+**Every time this step is reached**, re-read state from disk to pick up changes from background agents:
+
+```bash
+INIT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" init manager)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse the full JSON. Build the dashboard display.
+
+Build dashboard from JSON. Symbols: `✓` done, `◆` active, `○` pending, `·` queued. Progress bar: 20-char `█░`.
+
+**Status mapping** (disk_status → D P E Status):
+
+- `complete` → `✓ ✓ ✓` `✓ Complete`
+- `partial` → `✓ ✓ ◆` `◆ Executing...`
+- `planned` → `✓ ✓ ○` `○ Ready to execute`
+- `discussed` → `✓ ○ ·` `○ Ready to plan`
+- `researched` → `◆ · ·` `○ Ready to plan`
+- `empty`/`no_directory` + `is_next_to_discuss` → `○ · ·` `○ Ready to discuss`
+- `empty`/`no_directory` otherwise → `· · ·` `· Up next`
+- If `is_active`, replace status icon with `◆` and append `(active)`
+
+If any `is_active` phases, show: `◆ Background: {action} Phase {N}, ...` above grid.
+
+Use `display_name` (not `name`) for the Phase column — it's pre-truncated to 20 chars with `…` if clipped. Pad all phase names to the same width for alignment.
+
+Use `deps_display` from init JSON for the Deps column — shows which phases this phase depends on (e.g. `1,3`) or `—` for none.
+
+Example output:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Pilot ► DASHBOARD
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ████████████░░░░░░░░ 60%  (3/5 phases)
+ ◆ Background: Planning Phase 4
+ | # | Phase                | Deps | D | P | E | Status              |
+ |---|----------------------|------|---|---|---|---------------------|
+ | 1 | Foundation           | —    | ✓ | ✓ | ✓ | ✓ Complete          |
+ | 2 | API Layer            | 1    | ✓ | ✓ | ◆ | ◆ Executing (active)|
+ | 3 | Auth System          | 1    | ✓ | ✓ | ○ | ○ Ready to execute  |
+ | 4 | Dashboard UI & Set…  | 1,2  | ✓ | ◆ | · | ◆ Planning (active) |
+ | 5 | Notifications        | —    | ○ | · | · | ○ Ready to discuss  |
+ | 6 | Polish & Final Mail… | 1-5  | · | · | · | · Up next           |
+```
+
+**Recommendations section:**
+
+If `all_complete` is true:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  MILESTONE COMPLETE                                          ║
+╚══════════════════════════════════════════════════════════════╝
+
+All {phase_count} phases done. Ready for final steps:
+  → /ccp:verify-work — run acceptance testing
+  → /ccp:complete-milestone — archive and wrap up
+```
+
+Ask user via AskUserQuestion:
+- **question:** "All phases complete. What next?"
+- **options:** "Verify work" / "Complete milestone" / "Exit manager"
+
+Handle responses:
+- "Verify work": `Skill(skill="ccp:verify-work")`  then loop to dashboard.
+- "Complete milestone": `Skill(skill="ccp:complete-milestone")` then exit.
+- "Exit manager": Go to exit step.
+
+**If NOT all_complete**, build compound options from `recommended_actions`:
+
+**Compound option logic:** Group background actions (plan/execute) together, and pair them with the single inline action (discuss) when one exists. The goal is to present the fewest options possible — one option can dispatch multiple background agents plus one inline action.
+
+**Building options:**
+
+1. Collect all background actions (execute and plan recommendations) — there can be multiple of each.
+2. Collect the inline action (discuss recommendation, if any — there will be at most one since discuss is sequential).
+3. Build compound options:
+
+   **If there are ANY recommended actions (background, inline, or both):**
+   Create ONE primary "Continue" option that dispatches ALL of them together:
+   - Label: `"Continue"` — always this exact word
+   - Below the label, list every action that will happen. Enumerate ALL recommended actions — do not cap or truncate:
+     ```
+     Continue:
+       → Execute Phase 32 (background)
+       → Plan Phase 34 (background)
+       → Discuss Phase 35 (inline)
+     ```
+   - This dispatches all background agents first, then runs the inline discuss (if any).
+   - If there is no inline discuss, the dashboard refreshes after spawning background agents.
+
+   **Important:** The Continue option must include EVERY action from `recommended_actions` — not just 2. If there are 3 actions, list 3. If there are 5, list 5.
+
+4. Always add:
+   - `"Refresh dashboard"`
+   - `"Exit manager"`
+
+Display recommendations compactly:
+
+```
+───────────────────────────────────────────────────────────────
+▶ Next Steps
+───────────────────────────────────────────────────────────────
+
+Continue:
+  → Execute Phase 32 (background)
+  → Plan Phase 34 (background)
+  → Discuss Phase 35 (inline)
+```
+
+**Auto-refresh:** If background agents are running (`is_active` is true for any phase), set a 60-second auto-refresh cycle. After presenting the action menu, if no user input is received within 60 seconds, automatically refresh the dashboard. This interval is configurable via `manager_refresh_interval` in CCP config (default: 60 seconds, set to 0 to disable).
+
+Present via AskUserQuestion:
+- **question:** "What would you like to do?"
+- **options:** (compound options as built above + refresh + exit, AskUserQuestion auto-adds "Other")
+
+**On "Other" (free text):** Parse intent — if it mentions a phase number and action, dispatch accordingly. If unclear, display available actions and loop to action_menu.
+
+Proceed to handle_action step with the selected action.
+
+</step>
+
+<step name="handle_action">
+
+## 4. Handle Action
+
+### Refresh Dashboard
+
+Loop back to dashboard step.
+
+### Exit Manager
+
+Go to exit step.
+
+### Compound Action (background + inline)
+
+When the user selects a compound option:
+
+1. **Spawn all background agents first** (plan/execute) — dispatch them in parallel using the Plan Phase N / Execute Phase N handlers below.
+2. **Then run the inline discuss:**
+
+```
+Skill(skill="ccp:discuss-phase", args="{PHASE_NUM}")
+```
+
+After discuss completes, loop back to dashboard step (background agents continue running).
+
+### Discuss Phase N
+
+Discussion is interactive — needs user input. Run inline:
+
+```
+Skill(skill="ccp:discuss-phase", args="{PHASE_NUM}")
+```
+
+After discuss completes, loop back to dashboard step.
+
+### Plan Phase N
+
+Planning runs autonomously. Spawn a background agent:
+
+```
+Task(
+  description="Plan phase {N}: {phase_name}",
+  run_in_background=true,
+  prompt="You are running the CCP plan-phase workflow for phase {N} of the project.
+
+Working directory: {cwd}
+Phase: {N} — {phase_name}
+Goal: {goal}
+
+Steps:
+1. Read the plan-phase workflow: cat ~/.claude/pilot/workflows/plan-phase.md
+2. Run: node \"$HOME/.claude/pilot/bin/ccp-tools.cjs\" init plan-phase {N}
+3. Follow the workflow steps to produce PLAN.md files for this phase.
+4. If research is enabled in config, run the research step first.
+5. Spawn a ccp-planner subagent via Task() to create the plans.
+6. If plan-checker is enabled, spawn a ccp-plan-checker subagent to verify.
+7. Commit plan files when complete.
+
+Important: You are running in the background. Do NOT use AskUserQuestion — make autonomous decisions based on project context. If you hit a blocker, write it to STATE.md as a blocker and stop. Do NOT silently work around permission or file access errors — let them fail so the manager can surface them with resolution hints."
+)
+```
+
+Display:
+
+```
+◆ Spawning planner for Phase {N}: {phase_name}...
+```
+
+Loop back to dashboard step.
+
+### Execute Phase N
+
+Execution runs autonomously. Spawn a background agent:
+
+```
+Task(
+  description="Execute phase {N}: {phase_name}",
+  run_in_background=true,
+  prompt="You are running the CCP execute-phase workflow for phase {N} of the project.
+
+Working directory: {cwd}
+Phase: {N} — {phase_name}
+Goal: {goal}
+
+Steps:
+1. Read the execute-phase workflow: cat ~/.claude/pilot/workflows/execute-phase.md
+2. Run: node \"$HOME/.claude/pilot/bin/ccp-tools.cjs\" init execute-phase {N}
+3. Follow the workflow steps: discover plans, analyze dependencies, group into waves.
+4. For each wave, spawn ccp-executor subagents via Task() to execute plans in parallel.
+5. After all waves complete, spawn a ccp-verifier subagent if verifier is enabled.
+6. Update ROADMAP.md and STATE.md with progress.
+7. Commit all changes.
+
+Important: You are running in the background. Do NOT use AskUserQuestion — make autonomous decisions. Use --no-verify on git commits. If you hit a permission error, file lock, or any access issue, do NOT work around it — let it fail and write the error to STATE.md as a blocker so the manager can surface it with resolution guidance."
+)
+```
+
+Display:
+
+```
+◆ Spawning executor for Phase {N}: {phase_name}...
+```
+
+Loop back to dashboard step.
+
+</step>
+
+<step name="background_completion">
+
+## 5. Background Agent Completion
+
+When notified that a background agent completed:
+
+1. Read the result message from the agent.
+2. Display a brief notification:
+
+```
+✓ {description}
+  {brief summary from agent result}
+```
+
+3. Loop back to dashboard step.
+
+**If the agent reported an error or blocker:**
+
+Classify the error:
+
+**Permission / tool access error** (e.g. tool not allowed, permission denied, sandbox restriction):
+- Parse the error to identify which tool or command was blocked.
+- Display the error clearly, then offer to fix it:
+  - **question:** "Phase {N} failed — permission denied for `{tool_or_command}`. Want me to add it to settings.local.json so it's allowed?"
+  - **options:** "Add permission and retry" / "Run this phase inline instead" / "Skip and continue"
+  - "Add permission and retry": Use `Skill(skill="update-config")` to add the permission to `settings.local.json`, then re-spawn the background agent. Loop to dashboard.
+  - "Run this phase inline instead": Dispatch the same action (plan/execute) inline via `Skill()` instead of a background Task. Loop to dashboard after.
+  - "Skip and continue": Loop to dashboard (phase stays in current state).
+
+**Other errors** (git lock, file conflict, logic error, etc.):
+- Display the error, then offer options via AskUserQuestion:
+  - **question:** "Background agent for Phase {N} encountered an issue: {error}. What next?"
+  - **options:** "Retry" / "Run inline instead" / "Skip and continue" / "View details"
+  - "Retry": Re-spawn the same background agent. Loop to dashboard.
+  - "Run inline instead": Dispatch the action inline via `Skill()`. Loop to dashboard after.
+  - "Skip and continue": Loop to dashboard (phase stays in current state).
+  - "View details": Read STATE.md blockers section, display, then re-present options.
+
+</step>
+
+<step name="exit">
+
+## 6. Exit
+
+Display final status with progress bar:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Pilot ► SESSION END
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ {milestone_version} — {milestone_name}
+ {PROGRESS_BAR} {progress_pct}%  ({completed_count}/{phase_count} phases)
+
+ Resume anytime: /ccp:manager
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Note:** Any background agents still running will continue to completion. Their results will be visible on next `/ccp:manager` or `/ccp:progress` invocation.
+
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Dashboard displays all phases with correct status indicators (D/P/E/V columns)
+- [ ] Progress bar shows accurate completion percentage
+- [ ] Dependency resolution: blocked phases show which deps are missing
+- [ ] Recommendations prioritize: execute > plan > discuss
+- [ ] Discuss phases run inline via Skill() — interactive questions work
+- [ ] Plan phases spawn background Task agents — return to dashboard immediately
+- [ ] Execute phases spawn background Task agents — return to dashboard immediately
+- [ ] Dashboard refreshes pick up changes from background agents via disk state
+- [ ] Background agent completion triggers notification and dashboard refresh
+- [ ] Background agent errors present retry/skip options
+- [ ] All-complete state offers verify-work and complete-milestone
+- [ ] Exit shows final status with resume instructions
+- [ ] "Other" free-text input parsed for phase number and action
+- [ ] Manager loop continues until user exits or milestone completes
+</success_criteria>

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

@@ -6,6 +6,11 @@ Each agent has fresh context, explores a specific focus area, and **writes docum
 Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
 </purpose>
 
+<available_agent_types>
+Valid CCP subagent types (use exact names — do not fall back to 'general-purpose'):
+- ccp-codebase-mapper — Maps project structure and dependencies
+</available_agent_types>
+
 <philosophy>
 **Why dedicated mapper agents:**
 - Fresh context per domain (no token contamination)
@@ -26,8 +31,9 @@ Documents are reference material for Claude when planning/executing. Always incl
 Load codebase mapping context:
 
 ```bash
-INIT=$(node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" init map-codebase)
+INIT=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" init map-codebase)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+AGENT_SKILLS_MAPPER=$(node "$HOME/.claude/pilot/bin/ccp-tools.cjs" agent-skills ccp-codebase-mapper 2>/dev/null)
 ```
 
 Extract from init JSON: `mapper_model`, `commit_docs`, `codebase_dir`, `existing_maps`, `has_maps`, `codebase_dir_exists`.
@@ -83,17 +89,17 @@ Continue to spawn_agents.
 </step>
 
 <step name="spawn_agents">
-Spawn 4 parallel gsd-codebase-mapper agents.
+Spawn 4 parallel ccp-codebase-mapper agents.
 
-Use Task tool with `subagent_type="gsd-codebase-mapper"`, `model="{mapper_model}"`, and `run_in_background=true` for parallel execution.
+Use Task tool with `subagent_type="ccp-codebase-mapper"`, `model="{mapper_model}"`, and `run_in_background=true` for parallel execution.
 
-**CRITICAL:** Use the dedicated `gsd-codebase-mapper` agent, NOT `Explore`. The mapper agent writes documents directly.
+**CRITICAL:** Use the dedicated `ccp-codebase-mapper` agent, NOT `Explore`. The mapper agent writes documents directly.
 
 **Agent 1: Tech Focus**
 
 ```
 Task(
-  subagent_type="gsd-codebase-mapper",
+  subagent_type="ccp-codebase-mapper",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase tech stack",
@@ -105,7 +111,8 @@ Write these documents to .planning/codebase/:
 - STACK.md - Languages, runtime, frameworks, dependencies, configuration
 - INTEGRATIONS.md - External APIs, databases, auth providers, webhooks
 
-Explore thoroughly. Write documents directly using templates. Return confirmation only."
+Explore thoroughly. Write documents directly using templates. Return confirmation only.
+${AGENT_SKILLS_MAPPER}"
 )
 ```
 
@@ -113,7 +120,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 
 ```
 Task(
-  subagent_type="gsd-codebase-mapper",
+  subagent_type="ccp-codebase-mapper",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase architecture",
@@ -125,7 +132,8 @@ Write these documents to .planning/codebase/:
 - ARCHITECTURE.md - Pattern, layers, data flow, abstractions, entry points
 - STRUCTURE.md - Directory layout, key locations, naming conventions
 
-Explore thoroughly. Write documents directly using templates. Return confirmation only."
+Explore thoroughly. Write documents directly using templates. Return confirmation only.
+${AGENT_SKILLS_MAPPER}"
 )
 ```
 
@@ -133,7 +141,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 
 ```
 Task(
-  subagent_type="gsd-codebase-mapper",
+  subagent_type="ccp-codebase-mapper",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase conventions",
@@ -145,7 +153,8 @@ Write these documents to .planning/codebase/:
 - CONVENTIONS.md - Code style, naming, patterns, error handling
 - TESTING.md - Framework, structure, mocking, coverage
 
-Explore thoroughly. Write documents directly using templates. Return confirmation only."
+Explore thoroughly. Write documents directly using templates. Return confirmation only.
+${AGENT_SKILLS_MAPPER}"
 )
 ```
 
@@ -153,7 +162,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 
 ```
 Task(
-  subagent_type="gsd-codebase-mapper",
+  subagent_type="ccp-codebase-mapper",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase concerns",
@@ -164,7 +173,8 @@ Analyze this codebase for technical debt, known issues, and areas of concern.
 Write this document to .planning/codebase/:
 - CONCERNS.md - Tech debt, bugs, security, performance, fragile areas
 
-Explore thoroughly. Write document directly using template. Return confirmation only."
+Explore thoroughly. Write document directly using template. Return confirmation only.
+${AGENT_SKILLS_MAPPER}"
 )
 ```
 
@@ -251,7 +261,7 @@ Continue to commit_codebase_map.
 Commit the codebase map:
 
 ```bash
-node "$HOME/.claude/get-shit-done/bin/gsd-tools.cjs" commit "docs: map existing codebase" --files .planning/codebase/*.md
+node "$HOME/.claude/pilot/bin/ccp-tools.cjs" commit "docs: map existing codebase" --files .planning/codebase/*.md
 ```
 
 Continue to offer_next.
@@ -286,14 +296,14 @@ Created .planning/codebase/:
 
 **Initialize project** — use codebase context for planning
 
-`/gsd:new-project`
+`/ccp:new-project`
 
 <sub>`/clear` first → fresh context window</sub>
 
 ---
 
 **Also available:**
-- Re-run mapping: `/gsd:map-codebase`
+- Re-run mapping: `/ccp:map-codebase`
 - Review specific file: `cat .planning/codebase/STACK.md`
 - Edit any document before proceeding
 
@@ -307,10 +317,10 @@ End workflow.
 
 <success_criteria>
 - .planning/codebase/ directory created
-- 4 parallel gsd-codebase-mapper agents spawned with run_in_background=true
+- 4 parallel ccp-codebase-mapper agents spawned with run_in_background=true
 - Agents write documents directly (orchestrator doesn't receive document contents)
 - Read agent output files to collect confirmations
 - All 7 codebase documents exist
 - Clear completion summary with line counts
-- User offered clear next steps in GSD style
+- User offered clear next steps in CCP style
 </success_criteria>