claude-code-pilot 2.0.0 → 3.1.0

package/src/commands/ccp/orchestrate.md

@@ -0,0 +1,232 @@
+---
+name: ccp:orchestrate
+description: Sequential and tmux/worktree orchestration guidance for multi-agent workflows.
+---
+
+# Orchestrate Command
+
+Sequential agent workflow for complex tasks.
+
+## Usage
+
+`/ccp:orchestrate [workflow-type] [task-description]`
+
+## Workflow Types
+
+### feature
+Full feature implementation workflow:
+```
+planner -> tdd-guide -> code-reviewer -> security-reviewer
+```
+
+### bugfix
+Bug investigation and fix workflow:
+```
+planner -> tdd-guide -> code-reviewer
+```
+
+### refactor
+Safe refactoring workflow:
+```
+architect -> code-reviewer -> tdd-guide
+```
+
+### security
+Security-focused review:
+```
+security-reviewer -> code-reviewer -> architect
+```
+
+## Execution Pattern
+
+For each agent in the workflow:
+
+1. **Invoke agent** with context from previous agent
+2. **Collect output** as structured handoff document
+3. **Pass to next agent** in chain
+4. **Aggregate results** into final report
+
+## Handoff Document Format
+
+Between agents, create handoff document:
+
+```markdown
+## HANDOFF: [previous-agent] -> [next-agent]
+
+### Context
+[Summary of what was done]
+
+### Findings
+[Key discoveries or decisions]
+
+### Files Modified
+[List of files touched]
+
+### Open Questions
+[Unresolved items for next agent]
+
+### Recommendations
+[Suggested next steps]
+```
+
+## Example: Feature Workflow
+
+```
+/ccp:orchestrate feature "Add user authentication"
+```
+
+Executes:
+
+1. **Planner Agent**
+   - Analyzes requirements
+   - Creates implementation plan
+   - Identifies dependencies
+   - Output: `HANDOFF: planner -> tdd-guide`
+
+2. **TDD Guide Agent**
+   - Reads planner handoff
+   - Writes tests first
+   - Implements to pass tests
+   - Output: `HANDOFF: tdd-guide -> code-reviewer`
+
+3. **Code Reviewer Agent**
+   - Reviews implementation
+   - Checks for issues
+   - Suggests improvements
+   - Output: `HANDOFF: code-reviewer -> security-reviewer`
+
+4. **Security Reviewer Agent**
+   - Security audit
+   - Vulnerability check
+   - Final approval
+   - Output: Final Report
+
+## Final Report Format
+
+```
+ORCHESTRATION REPORT
+====================
+Workflow: feature
+Task: Add user authentication
+Agents: planner -> tdd-guide -> code-reviewer -> security-reviewer
+
+SUMMARY
+-------
+[One paragraph summary]
+
+AGENT OUTPUTS
+-------------
+Planner: [summary]
+TDD Guide: [summary]
+Code Reviewer: [summary]
+Security Reviewer: [summary]
+
+FILES CHANGED
+-------------
+[List all files modified]
+
+TEST RESULTS
+------------
+[Test pass/fail summary]
+
+SECURITY STATUS
+---------------
+[Security findings]
+
+RECOMMENDATION
+--------------
+[SHIP / NEEDS WORK / BLOCKED]
+```
+
+## Parallel Execution
+
+For independent checks, run agents in parallel:
+
+```markdown
+### Parallel Phase
+Run simultaneously:
+- code-reviewer (quality)
+- security-reviewer (security)
+- architect (design)
+
+### Merge Results
+Combine outputs into single report
+```
+
+For external tmux-pane workers with separate git worktrees, use `node scripts/orchestrate-worktrees.js plan.json --execute`. The built-in orchestration pattern stays in-process; the helper is for long-running or cross-harness sessions.
+
+When workers need to see dirty or untracked local files from the main checkout, add `seedPaths` to the plan file. The orchestrator overlays only those selected paths into each worker worktree after `git worktree add`, which keeps the branch isolated while still exposing in-flight local scripts, plans, or docs.
+
+```json
+{
+  "sessionName": "workflow-e2e",
+  "seedPaths": [
+    "scripts/orchestrate-worktrees.js",
+    "scripts/lib/tmux-worktree-orchestrator.js",
+    ".claude/plan/workflow-e2e-test.json"
+  ],
+  "workers": [
+    { "name": "docs", "task": "Update orchestration docs." }
+  ]
+}
+```
+
+To export a control-plane snapshot for a live tmux/worktree session, run:
+
+```bash
+node scripts/orchestration-status.js .claude/plan/workflow-visual-proof.json
+```
+
+The snapshot includes session activity, tmux pane metadata, worker states, objectives, seeded overlays, and recent handoff summaries in JSON form.
+
+## Operator Command-Center Handoff
+
+When the workflow spans multiple sessions, worktrees, or tmux panes, append a control-plane block to the final handoff:
+
+```markdown
+CONTROL PLANE
+-------------
+Sessions:
+- active session ID or alias
+- branch + worktree path for each active worker
+- tmux pane or detached session name when applicable
+
+Diffs:
+- git status summary
+- git diff --stat for touched files
+- merge/conflict risk notes
+
+Approvals:
+- pending user approvals
+- blocked steps awaiting confirmation
+
+Telemetry:
+- last activity timestamp or idle signal
+- estimated token or cost drift
+- policy events raised by hooks or reviewers
+```
+
+This keeps planner, implementer, reviewer, and loop workers legible from the operator surface.
+
+## Arguments
+
+$ARGUMENTS:
+- `feature <description>` - Full feature workflow
+- `bugfix <description>` - Bug fix workflow
+- `refactor <description>` - Refactoring workflow
+- `security <description>` - Security review workflow
+- `custom <agents> <description>` - Custom agent sequence
+
+## Custom Workflow Example
+
+```
+/ccp:orchestrate custom "architect,tdd-guide,code-reviewer" "Redesign caching layer"
+```
+
+## Tips
+
+1. **Start with planner** for complex features
+2. **Always include code-reviewer** before merge
+3. **Use security-reviewer** for auth/payment/PII
+4. **Keep handoffs concise** - focus on what next agent needs
+5. **Run verification** between agents if needed

package/{gsd/commands-gsd → src/commands/ccp}/pause-work.md

@@ -1,5 +1,5 @@
 ---
-name: gsd:pause-work
+name: ccp:pause-work
 description: Create context handoff when pausing work mid-phase
 allowed-tools:
   - Read
@@ -19,7 +19,7 @@ Routes to the pause-work workflow which handles:
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/pause-work.md
+@~/.claude/pilot/workflows/pause-work.md
 </execution_context>
 
 <context>
@@ -27,7 +27,7 @@ State and phase progress are gathered in-workflow with targeted reads.
 </context>
 
 <process>
-**Follow the pause-work workflow** from `@~/.claude/get-shit-done/workflows/pause-work.md`.
+**Follow the pause-work workflow** from `@~/.claude/pilot/workflows/pause-work.md`.
 
 The workflow handles all logic including:
 1. Phase directory detection

package/{gsd/commands-gsd → src/commands/ccp}/plan-milestone-gaps.md

@@ -1,5 +1,5 @@
 ---
-name: gsd:plan-milestone-gaps
+name: ccp:plan-milestone-gaps
 description: Create phases to close all gaps identified by milestone audit
 allowed-tools:
   - Read
@@ -10,15 +10,15 @@ allowed-tools:
   - AskUserQuestion
 ---
 <objective>
-Create all phases necessary to close gaps identified by `/gsd:audit-milestone`.
+Create all phases necessary to close gaps identified by `/ccp:audit-milestone`.
 
 Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase.
 
-One command creates all fix phases — no manual `/gsd:add-phase` per gap.
+One command creates all fix phases — no manual `/ccp:add-phase` per gap.
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/plan-milestone-gaps.md
+@~/.claude/pilot/workflows/plan-milestone-gaps.md
 </execution_context>
 
 <context>
@@ -29,6 +29,6 @@ Original intent and current planning state are loaded on demand inside the workf
 </context>
 
 <process>
-Execute the plan-milestone-gaps workflow from @~/.claude/get-shit-done/workflows/plan-milestone-gaps.md end-to-end.
+Execute the plan-milestone-gaps workflow from @~/.claude/pilot/workflows/plan-milestone-gaps.md end-to-end.
 Preserve all workflow gates (audit loading, prioritization, phase grouping, user confirmation, roadmap updates).
 </process>

package/{gsd/commands-gsd → src/commands/ccp}/plan-phase.md

@@ -1,8 +1,8 @@
 ---
-name: gsd:plan-phase
+name: ccp:plan-phase
 description: Create detailed phase plan (PLAN.md) with verification loop
-argument-hint: "[phase] [--auto] [--research] [--skip-research] [--gaps] [--skip-verify] [--prd <file>]"
-agent: gsd-planner
+argument-hint: "[phase] [--auto] [--research] [--skip-research] [--gaps] [--skip-verify] [--prd <file>] [--reviews] [--text]"
+agent: ccp-planner
 allowed-tools:
   - Read
   - Write
@@ -18,12 +18,12 @@ Create executable phase prompts (PLAN.md files) for a roadmap phase with integra
 
 **Default flow:** Research (if needed) → Plan → Verify → Done
 
-**Orchestrator role:** Parse arguments, validate phase, research domain (unless skipped), spawn gsd-planner, verify with gsd-plan-checker, iterate until pass or max iterations, present results.
+**Orchestrator role:** Parse arguments, validate phase, research domain (unless skipped), spawn ccp-planner, verify with ccp-plan-checker, iterate until pass or max iterations, present results.
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/plan-phase.md
-@~/.claude/get-shit-done/references/ui-brand.md
+@~/.claude/pilot/workflows/plan-phase.md
+@~/.claude/pilot/references/ui-brand.md
 </execution_context>
 
 <context>
@@ -35,11 +35,13 @@ Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omit
 - `--gaps` — Gap closure mode (reads VERIFICATION.md, skips research)
 - `--skip-verify` — Skip verification loop
 - `--prd <file>` — Use a PRD/acceptance criteria file instead of discuss-phase. Parses requirements into CONTEXT.md automatically. Skips discuss-phase entirely.
+- `--reviews` — Replan incorporating cross-AI review feedback from REVIEWS.md (produced by `/ccp:review`)
+- `--text` — Use plain-text numbered lists instead of TUI menus (required for `/rc` remote sessions)
 
 Normalize phase input in step 2 before any directory lookups.
 </context>
 
 <process>
-Execute the plan-phase workflow from @~/.claude/get-shit-done/workflows/plan-phase.md end-to-end.
+Execute the plan-phase workflow from @~/.claude/pilot/workflows/plan-phase.md end-to-end.
 Preserve all workflow gates (validation, research, planning, verification loop, routing).
 </process>

package/src/commands/ccp/plan.md

@@ -0,0 +1,115 @@
+---
+name: ccp:plan
+description: Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.
+---
+
+# Plan Command
+
+This command invokes the **planner** agent to create a comprehensive implementation plan before writing any code.
+
+## What This Command Does
+
+1. **Restate Requirements** - Clarify what needs to be built
+2. **Identify Risks** - Surface potential issues and blockers
+3. **Create Step Plan** - Break down implementation into phases
+4. **Wait for Confirmation** - MUST receive user approval before proceeding
+
+## When to Use
+
+Use `/ccp:plan` when:
+- Starting a new feature
+- Making significant architectural changes
+- Working on complex refactoring
+- Multiple files/components will be affected
+- Requirements are unclear or ambiguous
+
+## How It Works
+
+The planner agent will:
+
+1. **Analyze the request** and restate requirements in clear terms
+2. **Break down into phases** with specific, actionable steps
+3. **Identify dependencies** between components
+4. **Assess risks** and potential blockers
+5. **Estimate complexity** (High/Medium/Low)
+6. **Present the plan** and WAIT for your explicit confirmation
+
+## Example Usage
+
+```
+User: /ccp:plan I need to add real-time notifications when markets resolve
+
+Agent (planner):
+# Implementation Plan: Real-Time Market Resolution Notifications
+
+## Requirements Restatement
+- Send notifications to users when markets they're watching resolve
+- Support multiple notification channels (in-app, email, webhook)
+- Ensure notifications are delivered reliably
+- Include market outcome and user's position result
+
+## Implementation Phases
+
+### Phase 1: Database Schema
+- Add notifications table with columns: id, user_id, market_id, type, status, created_at
+- Add user_notification_preferences table for channel preferences
+- Create indexes on user_id and market_id for performance
+
+### Phase 2: Notification Service
+- Create notification service in lib/notifications.ts
+- Implement notification queue using BullMQ/Redis
+- Add retry logic for failed deliveries
+- Create notification templates
+
+### Phase 3: Integration Points
+- Hook into market resolution logic (when status changes to "resolved")
+- Query all users with positions in market
+- Enqueue notifications for each user
+
+### Phase 4: Frontend Components
+- Create NotificationBell component in header
+- Add NotificationList modal
+- Implement real-time updates via Supabase subscriptions
+- Add notification preferences page
+
+## Dependencies
+- Redis (for queue)
+- Email service (SendGrid/Resend)
+- Supabase real-time subscriptions
+
+## Risks
+- HIGH: Email deliverability (SPF/DKIM required)
+- MEDIUM: Performance with 1000+ users per market
+- MEDIUM: Notification spam if markets resolve frequently
+- LOW: Real-time subscription overhead
+
+## Estimated Complexity: MEDIUM
+- Backend: 4-6 hours
+- Frontend: 3-4 hours
+- Testing: 2-3 hours
+- Total: 9-13 hours
+
+**WAITING FOR CONFIRMATION**: Proceed with this plan? (yes/no/modify)
+```
+
+## Important Notes
+
+**CRITICAL**: The planner agent will **NOT** write any code until you explicitly confirm the plan with "yes" or "proceed" or similar affirmative response.
+
+If you want changes, respond with:
+- "modify: [your changes]"
+- "different approach: [alternative]"
+- "skip phase 2 and do phase 3 first"
+
+## Integration with Other Commands
+
+After planning:
+- Use `/ccp:tdd` to implement with test-driven development
+- Use `/ccp:build-fix` if build errors occur
+- Use `/ccp:code-review` to review completed implementation
+
+## Related Agents
+
+This command invokes the `planner` agent.
+
+Source file: `~/.claude/agents/planner.md`

package/src/commands/ccp/plant-seed.md

@@ -0,0 +1,28 @@
+---
+name: ccp:plant-seed
+description: Capture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone
+argument-hint: "[idea summary]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Capture an idea that's too big for now but should surface automatically when the right
+milestone arrives. Seeds solve context rot: instead of a one-liner in Deferred that nobody
+reads, a seed preserves the full WHY, WHEN to surface, and breadcrumbs to details.
+
+Creates: .planning/seeds/SEED-NNN-slug.md
+Consumed by: /ccp:new-milestone (scans seeds and presents matches)
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/plant-seed.md
+</execution_context>
+
+<process>
+Execute the plant-seed workflow from @~/.claude/pilot/workflows/plant-seed.md end-to-end.
+</process>

package/src/commands/ccp/pr-branch.md

@@ -0,0 +1,25 @@
+---
+name: ccp:pr-branch
+description: Create a clean PR branch by filtering out .planning/ commits — ready for code review
+argument-hint: "[target branch, default: main]"
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+<objective>
+Create a clean branch suitable for pull requests by filtering out .planning/ commits
+from the current branch. Reviewers see only code changes, not CCP planning artifacts.
+
+This solves the problem of PR diffs being cluttered with PLAN.md, SUMMARY.md, STATE.md
+changes that are irrelevant to code review.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/pr-branch.md
+</execution_context>
+
+<process>
+Execute the pr-branch workflow from @~/.claude/pilot/workflows/pr-branch.md end-to-end.
+</process>

package/src/commands/ccp/profile-user.md

@@ -0,0 +1,46 @@
+---
+name: ccp:profile-user
+description: Generate developer behavioral profile and create Claude-discoverable artifacts
+argument-hint: "[--questionnaire] [--refresh]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - Task
+---
+
+<objective>
+Generate a developer behavioral profile from session analysis (or questionnaire) and produce artifacts (USER-PROFILE.md, /ccp:dev-preferences, CLAUDE.md section) that personalize Claude's responses.
+
+Routes to the profile-user workflow which orchestrates the full flow: consent gate, session analysis or questionnaire fallback, profile generation, result display, and artifact selection.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/profile-user.md
+@~/.claude/pilot/references/ui-brand.md
+</execution_context>
+
+<context>
+Flags from $ARGUMENTS:
+- `--questionnaire` -- Skip session analysis entirely, use questionnaire-only path
+- `--refresh` -- Rebuild profile even when one exists, backup old profile, show dimension diff
+</context>
+
+<process>
+Execute the profile-user workflow end-to-end.
+
+The workflow handles all logic including:
+1. Initialization and existing profile detection
+2. Consent gate before session analysis
+3. Session scanning and data sufficiency checks
+4. Session analysis (profiler agent) or questionnaire fallback
+5. Cross-project split resolution
+6. Profile writing to USER-PROFILE.md
+7. Result display with report card and highlights
+8. Artifact selection (dev-preferences, CLAUDE.md sections)
+9. Sequential artifact generation
+10. Summary with refresh diff (if applicable)
+</process>

package/{gsd/commands-gsd → src/commands/ccp}/progress.md

@@ -1,5 +1,5 @@
 ---
-name: gsd:progress
+name: ccp:progress
 description: Check project progress, show context, and route to next action (execute or plan)
 allowed-tools:
   - Read
@@ -15,10 +15,10 @@ Provides situational awareness before continuing work.
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/progress.md
+@~/.claude/pilot/workflows/progress.md
 </execution_context>
 
 <process>
-Execute the progress workflow from @~/.claude/get-shit-done/workflows/progress.md end-to-end.
+Execute the progress workflow from @~/.claude/pilot/workflows/progress.md end-to-end.
 Preserve all routing logic (Routes A through F) and edge case handling.
 </process>

package/src/commands/ccp/prompt-optimize.md

@@ -0,0 +1,39 @@
+---
+name: ccp:prompt-optimize
+description: Analyze a draft prompt and output an optimized version ready to paste and run. Does NOT execute the task — outputs advisory analysis only.
+---
+
+# /ccp:prompt-optimize
+
+Analyze and optimize the following prompt for maximum effectiveness.
+
+## Your Task
+
+Apply the **prompt-optimizer** skill to the user's input below. Follow the 6-phase analysis pipeline:
+
+0. **Project Detection** — Read CLAUDE.md, detect tech stack from project files (package.json, go.mod, pyproject.toml, etc.)
+1. **Intent Detection** — Classify the task type (new feature, bug fix, refactor, research, testing, review, documentation, infrastructure, design)
+2. **Scope Assessment** — Evaluate complexity (TRIVIAL / LOW / MEDIUM / HIGH / EPIC), using codebase size as signal if detected
+3. **Component Matching** — Map to specific skills, commands, agents, and model tier
+4. **Missing Context Detection** — Identify gaps. If 3+ critical items missing, ask the user to clarify before generating
+5. **Workflow & Model** — Determine lifecycle position, recommend model tier, and split into multiple prompts if HIGH/EPIC
+
+## Output Requirements
+
+- Present diagnosis, recommended components, and an optimized prompt using the Output Format from the prompt-optimizer skill
+- Provide both **Full Version** (detailed) and **Quick Version** (compact, varied by intent type)
+- Respond in the same language as the user's input
+- The optimized prompt must be complete and ready to copy-paste into a new session
+- End with a footer offering adjustment or a clear next step for starting a separate execution request
+
+## CRITICAL
+
+Do NOT execute the user's task. Output ONLY the analysis and optimized prompt.
+If the user asks for direct execution, explain that `/ccp:prompt-optimize` only produces advisory output and tell them to start a normal task request instead.
+
+Note: `blueprint` is a **skill**, not a slash command. Write "Use the blueprint skill"
+instead of presenting it as a `/...` command.
+
+## User Input
+
+$ARGUMENTS

package/src/commands/ccp/prune.md

@@ -0,0 +1,25 @@
+---
+name: ccp:prune
+description: Delete pending instincts older than 30 days that were never promoted
+command: true
+---
+
+# Prune Pending Instincts
+
+Remove expired pending instincts that were auto-generated but never reviewed or promoted.
+
+## Implementation
+
+Run the instinct CLI:
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py prune
+```
+
+## Usage
+
+```
+/ccp:prune                    # Delete instincts older than 30 days
+/ccp:prune --max-age 60      # Custom age threshold (days)
+/ccp:prune --dry-run         # Preview without deleting
+```