claude-code-pilot 2.0.0 → 3.1.0

package/src/commands/ccp/rust-test.md

@@ -0,0 +1,309 @@
+---
+name: ccp:rust-test
+description: Enforce TDD workflow for Rust. Write tests first, then implement. Verify 80%+ coverage with cargo-llvm-cov.
+---
+
+# Rust TDD Command
+
+This command enforces test-driven development methodology for Rust code using `#[test]`, rstest, proptest, and mockall.
+
+## What This Command Does
+
+1. **Define Types/Traits**: Scaffold function signatures with `todo!()`
+2. **Write Tests**: Create comprehensive test module (RED)
+3. **Run Tests**: Verify tests fail for the right reason
+4. **Implement Code**: Write minimal code to pass (GREEN)
+5. **Refactor**: Improve while keeping tests green
+6. **Check Coverage**: Ensure 80%+ coverage with cargo-llvm-cov
+
+## When to Use
+
+Use `/ccp:rust-test` when:
+- Implementing new Rust functions, methods, or traits
+- Adding test coverage to existing Rust code
+- Fixing bugs (write failing test first)
+- Building critical business logic
+- Learning TDD workflow in Rust
+
+## TDD Cycle
+
+```
+RED     -> Write failing test first
+GREEN   -> Implement minimal code to pass
+REFACTOR -> Improve code, tests stay green
+REPEAT  -> Next test case
+```
+
+## Example Session
+
+````text
+User: /ccp:rust-test I need a function to validate user registration
+
+Agent:
+# TDD Session: Registration Validator
+
+## Step 1: Define Interface
+
+```rust
+// src/validator.rs
+pub struct RegistrationRequest {
+    pub name: String,
+    pub email: String,
+    pub password: String,
+}
+
+pub enum ValidationResult {
+    Valid,
+    Invalid(Vec<String>),
+}
+
+pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {
+    todo!()
+}
+```
+
+## Step 2: Write Tests (RED)
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_registration_returns_valid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "alice@example.com".into(),
+            password: "SecureP@ss1".into(),
+        };
+        assert!(matches!(validate_registration(&request), ValidationResult::Valid));
+    }
+
+    #[test]
+    fn blank_name_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "".into(),
+            email: "alice@example.com".into(),
+            password: "SecureP@ss1".into(),
+        };
+        match validate_registration(&request) {
+            ValidationResult::Invalid(errors) => {
+                assert!(errors.contains(&"Name is required".to_string()));
+            }
+            ValidationResult::Valid => panic!("expected Invalid"),
+        }
+    }
+
+    #[test]
+    fn invalid_email_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "not-an-email".into(),
+            password: "SecureP@ss1".into(),
+        };
+        assert!(matches!(
+            validate_registration(&request),
+            ValidationResult::Invalid(_)
+        ));
+    }
+
+    #[test]
+    fn short_password_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "alice@example.com".into(),
+            password: "short".into(),
+        };
+        assert!(matches!(
+            validate_registration(&request),
+            ValidationResult::Invalid(_)
+        ));
+    }
+}
+```
+
+## Step 3: Run Tests — Verify FAIL
+
+```bash
+$ cargo test
+running 4 tests
+test tests::valid_registration_returns_valid ... FAILED (not yet implemented)
+test tests::blank_name_returns_invalid ... FAILED
+test tests::invalid_email_returns_invalid ... FAILED
+test tests::short_password_returns_invalid ... FAILED
+```
+
+Tests fail as expected (todo! panic).
+
+## Step 4: Implement Minimal Code (GREEN)
+
+```rust
+pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {
+    let mut errors = Vec::new();
+
+    if request.name.trim().is_empty() {
+        errors.push("Name is required".into());
+    }
+    if !request.email.contains('@') {
+        errors.push("Invalid email format".into());
+    }
+    if request.password.len() < 8 {
+        errors.push("Password must be at least 8 characters".into());
+    }
+
+    if errors.is_empty() {
+        ValidationResult::Valid
+    } else {
+        ValidationResult::Invalid(errors)
+    }
+}
+```
+
+## Step 5: Run Tests — Verify PASS
+
+```bash
+$ cargo test
+running 4 tests
+test tests::valid_registration_returns_valid ... ok
+test tests::blank_name_returns_invalid ... ok
+test tests::invalid_email_returns_invalid ... ok
+test tests::short_password_returns_invalid ... ok
+
+test result: ok. 4 passed; 0 failed
+```
+
+All tests passing!
+
+## Step 6: Check Coverage
+
+```bash
+$ cargo llvm-cov
+Coverage: 100.0% of lines
+```
+
+Coverage: 100%
+
+## TDD Complete!
+````
+
+## Test Patterns
+
+### Unit Tests
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adds_two_numbers() {
+        assert_eq!(add(2, 3), 5);
+    }
+
+    #[test]
+    fn handles_error() -> Result<(), Box<dyn std::error::Error>> {
+        let result = parse_config(r#"port = 8080"#)?;
+        assert_eq!(result.port, 8080);
+        Ok(())
+    }
+}
+```
+
+### Parameterized Tests with rstest
+
+```rust
+use rstest::{rstest, fixture};
+
+#[rstest]
+#[case("hello", 5)]
+#[case("", 0)]
+#[case("rust", 4)]
+fn test_string_length(#[case] input: &str, #[case] expected: usize) {
+    assert_eq!(input.len(), expected);
+}
+```
+
+### Async Tests
+
+```rust
+#[tokio::test]
+async fn fetches_data_successfully() {
+    let client = TestClient::new().await;
+    let result = client.get("/data").await;
+    assert!(result.is_ok());
+}
+```
+
+### Property-Based Tests
+
+```rust
+use proptest::prelude::*;
+
+proptest! {
+    #[test]
+    fn encode_decode_roundtrip(input in ".*") {
+        let encoded = encode(&input);
+        let decoded = decode(&encoded).unwrap();
+        assert_eq!(input, decoded);
+    }
+}
+```
+
+## Coverage Commands
+
+```bash
+# Summary report
+cargo llvm-cov
+
+# HTML report
+cargo llvm-cov --html
+
+# Fail if below threshold
+cargo llvm-cov --fail-under-lines 80
+
+# Run specific test
+cargo test test_name
+
+# Run with output
+cargo test -- --nocapture
+
+# Run without stopping on first failure
+cargo test --no-fail-fast
+```
+
+## Coverage Targets
+
+| Code Type | Target |
+|-----------|--------|
+| Critical business logic | 100% |
+| Public API | 90%+ |
+| General code | 80%+ |
+| Generated / FFI bindings | Exclude |
+
+## TDD Best Practices
+
+**DO:**
+- Write test FIRST, before any implementation
+- Run tests after each change
+- Use `assert_eq!` over `assert!` for better error messages
+- Use `?` in tests that return `Result` for cleaner output
+- Test behavior, not implementation
+- Include edge cases (empty, boundary, error paths)
+
+**DON'T:**
+- Write implementation before tests
+- Skip the RED phase
+- Use `#[should_panic]` when `Result::is_err()` works
+- Use `sleep()` in tests — use channels or `tokio::time::pause()`
+- Mock everything — prefer integration tests when feasible
+
+## Related Commands
+
+- `/ccp:rust-build` - Fix build errors
+- `/ccp:rust-review` - Review code after implementation
+- `/ccp:verify` - Run full verification loop
+
+## Related
+
+- Skill: `skills/rust-testing/`
+- Skill: `skills/rust-patterns/`

package/{ecc/commands → src/commands/ccp}/save-session.md

@@ -1,4 +1,5 @@
 ---
+name: ccp:save-session
 description: Save current session state to a dated file in ~/.claude/sessions/ so work can be resumed in a future session with full context.
 ---
 
@@ -270,6 +271,6 @@ Then test with Postman — the response should include a `Set-Cookie` header.
 - Each session gets its own file — never append to a previous session's file
 - The "What Did NOT Work" section is the most critical — future sessions will blindly retry failed approaches without it
 - If the user asks to save mid-session (not just at the end), save what's known so far and mark in-progress items clearly
-- The file is meant to be read by Claude at the start of the next session via `/resume-session`
+- The file is meant to be read by Claude at the start of the next session via `/ccp:resume-session`
 - Use the canonical global session store: `~/.claude/sessions/`
 - Prefer the short-id filename form (`YYYY-MM-DD-<short-id>-session.tmp`) for any new session file

package/src/commands/ccp/secure-phase.md

@@ -0,0 +1,35 @@
+---
+name: ccp:secure-phase
+description: Retroactively verify threat mitigations for a completed phase
+argument-hint: "[phase number]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+<objective>
+Verify threat mitigations for a completed phase. Three states:
+- (A) SECURITY.md exists — audit and verify mitigations
+- (B) No SECURITY.md, PLAN.md with threat model exists — run from artifacts
+- (C) Phase not executed — exit with guidance
+
+Output: updated SECURITY.md.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/secure-phase.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS — optional, defaults to last completed phase.
+</context>
+
+<process>
+Execute @~/.claude/pilot/workflows/secure-phase.md.
+Preserve all workflow gates.
+</process>

package/src/commands/ccp/session-report.md

@@ -0,0 +1,19 @@
+---
+name: ccp:session-report
+description: Generate a session report with token usage estimates, work summary, and outcomes
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+---
+<objective>
+Generate a structured SESSION_REPORT.md document capturing session outcomes, work performed, and estimated resource usage. Provides a shareable artifact for post-session review.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/session-report.md
+</execution_context>
+
+<process>
+Execute the session-report workflow from @~/.claude/pilot/workflows/session-report.md end-to-end.
+</process>

package/{ecc/commands → src/commands/ccp}/sessions.md

@@ -1,10 +1,15 @@
+---
+name: ccp:sessions
+description: "Manage Claude Code session history - list, load, alias, and edit sessions"
+---
+
 # Sessions Command
 
 Manage Claude Code session history - list, load, alias, and edit sessions stored in `~/.claude/sessions/`.
 
 ## Usage
 
-`/sessions [list|load|alias|info|help] [options]`
+`/ccp:sessions [list|load|alias|info|help] [options]`
 
 ## Actions
 
@@ -13,18 +18,18 @@ Manage Claude Code session history - list, load, alias, and edit sessions stored
 Display all sessions with metadata, filtering, and pagination.
 
 ```bash
-/sessions                              # List all sessions (default)
-/sessions list                         # Same as above
-/sessions list --limit 10              # Show 10 sessions
-/sessions list --date 2026-02-01       # Filter by date
-/sessions list --search abc            # Search by session ID
+/ccp:sessions                              # List all sessions (default)
+/ccp:sessions list                         # Same as above
+/ccp:sessions list --limit 10              # Show 10 sessions
+/ccp:sessions list --date 2026-02-01       # Filter by date
+/ccp:sessions list --search abc            # Search by session ID
 ```
 
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const result = sm.getAllSessions({ limit: 20 });
 const aliases = aa.listAliases();
@@ -53,17 +58,17 @@ for (const s of result.sessions) {
 Load and display a session's content (by ID or alias).
 
 ```bash
-/sessions load <id|alias>             # Load session
-/sessions load 2026-02-01             # By date (for no-id sessions)
-/sessions load a1b2c3d4               # By short ID
-/sessions load my-alias               # By alias name
+/ccp:sessions load <id|alias>             # Load session
+/ccp:sessions load 2026-02-01             # By date (for no-id sessions)
+/ccp:sessions load a1b2c3d4               # By short ID
+/ccp:sessions load my-alias               # By alias name
 ```
 
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 const id = process.argv[1];
 
 // First try to resolve as alias
@@ -116,21 +121,21 @@ if (session.metadata.lastUpdated) {
 Create a memorable alias for a session.
 
 ```bash
-/sessions alias <id> <name>           # Create alias
-/sessions alias 2026-02-01 today-work # Create alias named "today-work"
+/ccp:sessions alias <id> <name>           # Create alias
+/ccp:sessions alias 2026-02-01 today-work # Create alias named "today-work"
 ```
 
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const sessionId = process.argv[1];
 const aliasName = process.argv[2];
 
 if (!sessionId || !aliasName) {
-  console.log('Usage: /sessions alias <id> <name>');
+  console.log('Usage: /ccp:sessions alias <id> <name>');
   process.exit(1);
 }
 
@@ -156,18 +161,18 @@ if (result.success) {
 Delete an existing alias.
 
 ```bash
-/sessions alias --remove <name>        # Remove alias
-/sessions unalias <name>               # Same as above
+/ccp:sessions alias --remove <name>        # Remove alias
+/ccp:sessions unalias <name>               # Same as above
 ```
 
 **Script:**
 ```bash
 node -e "
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const aliasName = process.argv[1];
 if (!aliasName) {
-  console.log('Usage: /sessions alias --remove <name>');
+  console.log('Usage: /ccp:sessions alias --remove <name>');
   process.exit(1);
 }
 
@@ -186,14 +191,14 @@ if (result.success) {
 Show detailed information about a session.
 
 ```bash
-/sessions info <id|alias>              # Show session details
+/ccp:sessions info <id|alias>              # Show session details
 ```
 
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const id = process.argv[1];
 const resolved = aa.resolveAlias(id);
@@ -233,13 +238,13 @@ if (aliases.length > 0) {
 Show all session aliases.
 
 ```bash
-/sessions aliases                      # List all aliases
+/ccp:sessions aliases                      # List all aliases
 ```
 
 **Script:**
 ```bash
 node -e "
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const aliases = aa.listAliases();
 console.log('Session Aliases (' + aliases.length + '):');
@@ -279,22 +284,22 @@ $ARGUMENTS:
 
 ```bash
 # List all sessions
-/sessions list
+/ccp:sessions list
 
 # Create an alias for today's session
-/sessions alias 2026-02-01 today
+/ccp:sessions alias 2026-02-01 today
 
 # Load session by alias
-/sessions load today
+/ccp:sessions load today
 
 # Show session info
-/sessions info today
+/ccp:sessions info today
 
 # Remove alias
-/sessions alias --remove today
+/ccp:sessions alias --remove today
 
 # List all aliases
-/sessions aliases
+/ccp:sessions aliases
 ```
 
 ## Notes

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

@@ -0,0 +1,12 @@
+---
+name: ccp:set-profile
+description: Switch model profile for CCP agents (quality/balanced/budget/inherit)
+argument-hint: <profile (quality|balanced|budget|inherit)>
+model: haiku
+allowed-tools:
+  - Bash
+---
+
+Show the following output to the user verbatim, with no extra commentary:
+
+!`node "$HOME/.claude/pilot/bin/ccp-tools.cjs" config-set-model-profile $ARGUMENTS --raw`

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

@@ -1,6 +1,6 @@
 ---
-name: gsd:settings
-description: Configure GSD workflow toggles and model profile
+name: ccp:settings
+description: Configure CCP workflow toggles and model profile
 allowed-tools:
   - Read
   - Write
@@ -9,7 +9,7 @@ allowed-tools:
 ---
 
 <objective>
-Interactive configuration of GSD workflow agents and model profile via multi-question prompt.
+Interactive configuration of CCP workflow agents and model profile via multi-question prompt.
 
 Routes to the settings workflow which handles:
 - Config existence ensuring
@@ -20,11 +20,11 @@ Routes to the settings workflow which handles:
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/settings.md
+@~/.claude/pilot/workflows/settings.md
 </execution_context>
 
 <process>
-**Follow the settings workflow** from `@~/.claude/get-shit-done/workflows/settings.md`.
+**Follow the settings workflow** from `@~/.claude/pilot/workflows/settings.md`.
 
 The workflow handles all logic including:
 1. Config file creation with defaults if missing

package/src/commands/ccp/setup-pm.md

@@ -0,0 +1,81 @@
+---
+name: ccp:setup-pm
+description: Configure your preferred package manager (npm/pnpm/yarn/bun)
+disable-model-invocation: true
+---
+
+# Package Manager Setup
+
+Configure your preferred package manager for this project or globally.
+
+## Usage
+
+```bash
+# Detect current package manager
+node scripts/setup-package-manager.js --detect
+
+# Set global preference
+node scripts/setup-package-manager.js --global pnpm
+
+# Set project preference
+node scripts/setup-package-manager.js --project bun
+
+# List available package managers
+node scripts/setup-package-manager.js --list
+```
+
+## Detection Priority
+
+When determining which package manager to use, the following order is checked:
+
+1. **Environment variable**: `CLAUDE_PACKAGE_MANAGER`
+2. **Project config**: `.claude/package-manager.json`
+3. **package.json**: `packageManager` field
+4. **Lock file**: Presence of package-lock.json, yarn.lock, pnpm-lock.yaml, or bun.lockb
+5. **Global config**: `~/.claude/package-manager.json`
+6. **Fallback**: First available package manager (pnpm > bun > yarn > npm)
+
+## Configuration Files
+
+### Global Configuration
+```json
+// ~/.claude/package-manager.json
+{
+  "packageManager": "pnpm"
+}
+```
+
+### Project Configuration
+```json
+// .claude/package-manager.json
+{
+  "packageManager": "bun"
+}
+```
+
+### package.json
+```json
+{
+  "packageManager": "pnpm@8.6.0"
+}
+```
+
+## Environment Variable
+
+Set `CLAUDE_PACKAGE_MANAGER` to override all other detection methods:
+
+```bash
+# Windows (PowerShell)
+$env:CLAUDE_PACKAGE_MANAGER = "pnpm"
+
+# macOS/Linux
+export CLAUDE_PACKAGE_MANAGER=pnpm
+```
+
+## Run the Detection
+
+To see current package manager detection results, run:
+
+```bash
+node scripts/setup-package-manager.js --detect
+```