get-shit-done-cc 1.9.11 → 1.10.0-experimental.0

package/commands/gsd/checkpoints.md

@@ -0,0 +1,229 @@
+---
+name: gsd:checkpoints
+description: Review and approve pending checkpoints from autopilot execution
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Interactive guided flow to review and complete pending checkpoints from autopilot.
+
+Checkpoints are human tasks created when plans need manual intervention (adding secrets, external setup, design decisions). This command walks you through each one.
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<process>
+
+## 1. Check for Pending Checkpoints
+
+```bash
+PENDING_DIR=".planning/checkpoints/pending"
+PENDING_COUNT=$(ls "$PENDING_DIR"/*.json 2>/dev/null | wc -l | tr -d ' ')
+```
+
+**If no checkpoints:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► CHECKPOINTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+No pending checkpoints.
+
+Checkpoints are created when autopilot encounters tasks that need
+your input—like adding API keys or making design decisions.
+
+Run /gsd:autopilot to start autonomous execution.
+```
+
+**Stop here if no checkpoints.**
+
+## 2. Present Checkpoint Selection
+
+Build options from pending checkpoint files. Parse each JSON to extract:
+- Phase number
+- Plan name
+- Brief description of what's awaiting
+
+Use AskUserQuestion:
+```
+question: "You have {N} pending checkpoints. Which would you like to handle?"
+header: "Checkpoint"
+options:
+  - label: "Phase {X}: {task_name}"
+    description: "{brief awaiting description}"
+  - label: "Phase {Y}: {task_name}"
+    description: "{brief awaiting description}"
+  - ... (up to 4, or summarize if more)
+  - label: "Skip for now"
+    description: "Exit without handling any checkpoints"
+```
+
+**If "Skip for now":** End with "Run /gsd:checkpoints when you're ready."
+
+## 3. Show Checkpoint Instructions
+
+For the selected checkpoint, read the full JSON and display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► CHECKPOINT: {task_name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Phase {X}, Plan {Y} paused here waiting for you.
+
+## What you need to do
+
+{instructions from checkpoint JSON, formatted as numbered steps}
+
+───────────────────────────────────────────────────────
+```
+
+## 4. Ask for Completion
+
+Use AskUserQuestion:
+```
+question: "Have you completed this task?"
+header: "Status"
+options:
+  - label: "Done"
+    description: "I've completed the steps above (Recommended)"
+  - label: "Skip this feature"
+    description: "Don't need this, continue without it"
+  - label: "Later"
+    description: "I'll handle this another time"
+```
+
+### If "Done":
+
+Ask for optional note:
+```
+question: "Any notes for the continuation? (e.g., 'Used different env var name')"
+header: "Notes"
+options:
+  - label: "No notes"
+    description: "Just continue with the plan"
+  - label: "Add a note"
+    description: "Provide context for the AI"
+```
+
+**If "Add a note":** Use AskUserQuestion with text input for the note.
+
+Create approval file:
+```json
+{
+  "phase": "{phase}",
+  "plan": "{plan}",
+  "approved": true,
+  "note": "{user note or empty}",
+  "approved_at": "{ISO timestamp}"
+}
+```
+
+Write to `.planning/checkpoints/approved/{original_filename}`
+Remove from `.planning/checkpoints/pending/`
+
+```
+✓ Checkpoint approved
+
+Autopilot will continue this plan on next run.
+```
+
+### If "Skip this feature":
+
+Create rejection file:
+```json
+{
+  "phase": "{phase}",
+  "plan": "{plan}",
+  "approved": false,
+  "reason": "User skipped - feature not needed",
+  "rejected_at": "{ISO timestamp}"
+}
+```
+
+Write to `.planning/checkpoints/approved/{original_filename}`
+Remove from `.planning/checkpoints/pending/`
+
+```
+✓ Checkpoint skipped
+
+This plan will be marked as skipped during execution.
+```
+
+### If "Later":
+
+Leave checkpoint in pending, no changes.
+
+```
+Checkpoint remains pending. Run /gsd:checkpoints when ready.
+```
+
+## 5. Offer Next Checkpoint
+
+If more pending checkpoints remain:
+
+Use AskUserQuestion:
+```
+question: "You have {N} more pending checkpoints."
+header: "Continue"
+options:
+  - label: "Handle next"
+    description: "{next checkpoint brief description}"
+  - label: "Done for now"
+    description: "Exit checkpoints"
+```
+
+**If "Handle next":** Loop back to step 3 with the next checkpoint.
+
+**If "Done for now":**
+```
+───────────────────────────────────────────────────────
+
+{N} checkpoints remaining. Run /gsd:checkpoints to continue.
+
+Autopilot will process approved checkpoints on next run,
+or run it now: bash .planning/autopilot.sh
+```
+
+</process>
+
+<checkpoint_json_format>
+Pending checkpoint files contain:
+
+```json
+{
+  "phase": "03",
+  "plan": "02",
+  "plan_name": "OAuth Integration",
+  "task_name": "Add Google OAuth credentials",
+  "instructions": "1. Go to console.cloud.google.com\n2. Create OAuth 2.0 credential\n3. Add to .env.local:\n   GOOGLE_CLIENT_ID=your-id\n   GOOGLE_CLIENT_SECRET=your-secret",
+  "context": "Plan paused after task 2. Remaining tasks need OAuth configured.",
+  "completed_tasks": [
+    {"task": 1, "commit": "abc123", "name": "Create OAuth service skeleton"},
+    {"task": 2, "commit": "def456", "name": "Add config structure"}
+  ],
+  "created_at": "2026-01-26T14:30:00Z"
+}
+```
+
+The `instructions` field is what gets shown to the user. It should be actionable steps they can follow, not a request for data to paste.
+</checkpoint_json_format>
+
+<success_criteria>
+- [ ] Graceful handling when no checkpoints exist
+- [ ] Interactive selection when multiple checkpoints pending
+- [ ] Clear instructions displayed for selected checkpoint
+- [ ] Three completion options: Done / Skip / Later
+- [ ] Optional notes on Done
+- [ ] Approval/rejection files created correctly
+- [ ] Loops to offer next checkpoint
+- [ ] No secrets stored in checkpoint files
+</success_criteria>

package/commands/gsd/design-system.md

@@ -0,0 +1,70 @@
+---
+name: gsd:design-system
+description: Establish project-wide design foundation through conversation
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - WebFetch
+  - AskUserQuestion
+---
+
+<objective>
+
+Establish the visual foundation for the entire project through conversational discovery. Creates `.planning/DESIGN-SYSTEM.md` that all UI work in the project respects.
+
+**What it does:**
+1. Optionally analyze visual references (images, URLs) for aesthetic patterns
+2. Conversationally discover design preferences (colors, typography, spacing, components)
+3. Detect project framework for appropriate patterns
+4. Generate a comprehensive design system document
+
+**Output:** `.planning/DESIGN-SYSTEM.md` — the visual foundation that `/gsd:discuss-design` and planning phases load as context
+
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/design-system.md
+@~/.claude/get-shit-done/references/ui-principles.md
+@~/.claude/get-shit-done/templates/design-system.md
+</execution_context>
+
+<context>
+
+**When to use:**
+- Starting a new project with UI
+- Before first UI phase
+- When suggested after `/gsd:new-project`
+- When visual direction needs definition
+
+</context>
+
+<process>
+
+Follow the workflow completely. Key phases:
+
+1. **Check existing** — If DESIGN-SYSTEM.md exists, offer update/replace/cancel
+2. **Detect framework** — React, SwiftUI, Python, HTML/CSS
+3. **Visual references** — Optionally analyze user-provided images/URLs
+4. **Aesthetic direction** — Conversationally discover style preferences
+5. **Color exploration** — Build or capture color palette
+6. **Typography** — Font selection and scale
+7. **Component style** — Border radius, shadows, borders
+8. **Spacing system** — Base unit and scale
+9. **Generate** — Create DESIGN-SYSTEM.md
+
+</process>
+
+<success_criteria>
+- [ ] User's aesthetic vision understood
+- [ ] Visual references analyzed (if provided)
+- [ ] Color palette defined with tokens
+- [ ] Typography scale established
+- [ ] Spacing system determined
+- [ ] Component patterns documented
+- [ ] Framework-appropriate values included
+- [ ] DESIGN-SYSTEM.md created
+- [ ] User knows how system integrates with GSD
+</success_criteria>

package/commands/gsd/discuss-design.md

@@ -0,0 +1,77 @@
+---
+name: gsd:discuss-design
+description: Design phase-specific UI through conversation before planning
+argument-hint: "<phase>"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - WebFetch
+  - AskUserQuestion
+  - Task
+---
+
+<objective>
+
+Design phase-specific UI elements through conversation, then generate visual mockups for review. Ensures design decisions are made before implementation time is spent.
+
+**What it does:**
+1. Load design system (if exists) as visual foundation
+2. Conversationally design components needed for the phase
+3. Generate framework-appropriate mockups (React, SwiftUI, HTML, Python)
+4. Iterate until user approves the visuals
+5. Create DESIGN.md that the planner automatically loads
+
+**Output:**
+- `.planning/phases/{phase}/{phase}-DESIGN.md` — component specs for planner
+- `.planning/phases/{phase}/mockups/` — visual previews
+
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/discuss-design.md
+@~/.claude/get-shit-done/references/ui-principles.md
+@~/.claude/get-shit-done/references/framework-patterns.md
+@~/.claude/get-shit-done/templates/phase-design.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+**Load design system (if exists):**
+@.planning/DESIGN-SYSTEM.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+</context>
+
+<process>
+
+Follow the workflow completely. Key phases:
+
+1. **Parse phase** — Validate phase number, load phase details
+2. **Load design system** — Use as foundation if exists
+3. **Detect framework** — React, SwiftUI, Python, HTML for mockup format
+4. **Visual references** — Optionally analyze phase-specific references
+5. **Component discovery** — Identify and spec all UI components
+6. **Layout discussion** — How components are arranged
+7. **Interaction discussion** — States, transitions, feedback
+8. **Generate mockups** — Spawn design specialist agent
+9. **Review loop** — Iterate until approved
+10. **Create DESIGN.md** — Specs for planner
+
+</process>
+
+<success_criteria>
+- [ ] Phase requirements understood
+- [ ] Design system loaded as context (if exists)
+- [ ] All UI components identified and specified
+- [ ] Component states documented (loading, error, empty, etc.)
+- [ ] Layout and responsive behavior defined
+- [ ] Framework-appropriate mockups generated
+- [ ] User approved mockups visually
+- [ ] DESIGN.md created for planner consumption
+- [ ] User knows next steps (plan or edit)
+</success_criteria>

package/commands/gsd/extend.md

@@ -0,0 +1,80 @@
+---
+name: gsd:extend
+description: Create custom GSD approaches - workflows, agents, references, templates
+argument-hint: "[list | create | remove <name>]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+<objective>
+
+Create and manage custom GSD approaches. An approach is a complete methodology - a workflow with supporting references, agents, and templates that work together.
+
+**Examples of approaches:**
+- Spike-first planning (explore before formalizing)
+- Security-focused execution (audit before each commit)
+- API-first development (OpenAPI spec drives implementation)
+- TDD-strict (enforce red-green-refactor cycle)
+
+</objective>
+
+<execution_context>
+
+@~/.claude/get-shit-done/skills/gsd-extend/SKILL.md
+
+</execution_context>
+
+<context>
+
+**Arguments:** $ARGUMENTS
+
+**Extension locations:**
+- Project: `.planning/extensions/`
+- Global: `~/.claude/gsd-extensions/`
+
+</context>
+
+<process>
+
+## Parse Arguments
+
+**If `$ARGUMENTS` is empty or "create":**
+→ Load `workflows/create-approach.md`
+→ Start conversational discovery
+
+**If `$ARGUMENTS` is "list":**
+→ Load `workflows/list-extensions.md`
+→ Show all installed extensions
+
+**If `$ARGUMENTS` starts with "remove":**
+→ Load `workflows/remove-extension.md`
+→ Parse the name and remove
+
+**If ambiguous:**
+Use AskUserQuestion:
+- header: "Action"
+- question: "What would you like to do?"
+- options:
+  - "Create an approach" - Build a custom methodology through conversation
+  - "List extensions" - See what's installed
+  - "Remove an extension" - Delete something
+
+## Execute
+
+Follow the loaded workflow completely.
+
+</process>
+
+<success_criteria>
+
+- [ ] User intent understood
+- [ ] Correct workflow loaded
+- [ ] Workflow executed successfully
+- [ ] User knows next steps
+
+</success_criteria>

package/commands/gsd/help.md

@@ -27,13 +27,7 @@ Output ONLY the reference content below. Do NOT add:
 
 ## Staying Updated
 
-GSD evolves fast. Check for updates periodically:
-
-```
-/gsd:whats-new
-```
-
-Shows what changed since your installed version. Update with:
+GSD evolves fast. Update periodically:
 
 ```bash
 npx get-shit-done-cc@latest
@@ -129,6 +123,31 @@ Execute all plans in a phase.
 
 Usage: `/gsd:execute-phase 5`
 
+### Autonomous Execution
+
+**`/gsd:autopilot`**
+Fully automated milestone execution.
+
+- Generates shell script that runs in separate terminal
+- Each phase gets fresh 200k context via `claude -p`
+- Loops: plan → execute → verify → handle gaps → next phase
+- Safe to interrupt and resume (state persists in `.planning/`)
+- Tracks cost and enforces budget limits
+
+Usage: `/gsd:autopilot`
+Then run: `bash .planning/autopilot.sh`
+
+**`/gsd:checkpoints`**
+Review and complete pending checkpoints from autopilot.
+
+- Interactive guided flow (no flags needed)
+- Shows human tasks created when plans need manual intervention
+- Checkpoints give instructions ("add these env vars") not data requests
+- Options: Done / Skip / Later
+- Approved checkpoints continue on next autopilot run
+
+Usage: `/gsd:checkpoints`
+
 ### Quick Mode
 
 **`/gsd:quick`**
@@ -333,20 +352,12 @@ Usage: `/gsd:set-profile budget`
 **`/gsd:help`**
 Show this command reference.
 
-**`/gsd:whats-new`**
-See what's changed since your installed version.
+**`/gsd:update`**
+Update GSD to latest version with changelog preview.
 
 - Shows installed vs latest version comparison
 - Displays changelog entries for versions you've missed
 - Highlights breaking changes
-- Provides update instructions when behind
-
-Usage: `/gsd:whats-new`
-
-**`/gsd:update`**
-Update GSD to latest version with changelog preview.
-
-- Shows what changed before updating
 - Confirms before running install
 - Better than raw `npx get-shit-done-cc`
 
@@ -373,6 +384,11 @@ Usage: `/gsd:join-discord`
 │   └── done/             # Completed todos
 ├── debug/                # Active debug sessions
 │   └── resolved/         # Archived resolved issues
+├── checkpoints/          # Autopilot checkpoint queue
+│   ├── pending/          # Awaiting human action
+│   ├── approved/         # Ready for continuation
+│   └── processed/        # Completed (audit trail)
+├── logs/                 # Autopilot execution logs
 ├── codebase/             # Codebase map (brownfield projects)
 │   ├── STACK.md          # Languages, frameworks, dependencies
 │   ├── ARCHITECTURE.md   # Patterns, layers, data flow
@@ -469,6 +485,19 @@ Example config:
 /gsd:new-milestone  # Start next milestone (questioning → research → requirements → roadmap)
 ```
 
+**Running autonomously (fire and forget):**
+
+```
+/gsd:autopilot                  # Generate autopilot script
+# In separate terminal:
+bash .planning/autopilot.sh     # Run attached (see output live)
+# Or for overnight runs:
+nohup bash .planning/autopilot.sh > .planning/logs/autopilot.log 2>&1 &
+
+# Check on checkpoints anytime:
+/gsd:checkpoints                # Handle any tasks needing human input
+```
+
 **Capturing ideas during work:**
 
 ```