get-shit-done-cc 1.3.34 → 1.4.1

package/README.md

@@ -177,6 +177,13 @@ Produces:
 
 Each phase breaks into 2-3 atomic tasks. Each task runs in a fresh subagent context — 200k tokens purely for implementation, zero degradation.
 
+**For multi-plan phases:**
+```
+/gsd:execute-phase 1   # Run all plans in parallel, "walk away" execution
+```
+
+Use `/gsd:execute-plan` for interactive single-plan execution with checkpoints. Use `/gsd:execute-phase` when you have multiple plans and want parallel "walk away" automation.
+
 ### 4. Ship and iterate
 
 ```
@@ -316,7 +323,9 @@ You're never locked in. The system adapts.
 | `/gsd:create-roadmap` | Create roadmap and state tracking |
 | `/gsd:map-codebase` | Map existing codebase for brownfield projects |
 | `/gsd:plan-phase [N]` | Generate task plans for phase |
-| `/gsd:execute-plan` | Run plan via subagent |
+| `/gsd:execute-plan` | Run single plan via subagent |
+| `/gsd:execute-phase <N>` | Execute all plans in phase N with parallel agents |
+| `/gsd:status [--wait]` | Check background agent status from parallel execution |
 | `/gsd:progress` | Where am I? What's next? |
 | `/gsd:verify-work [N]` | User acceptance test of phase or plan ¹ |
 | `/gsd:plan-fix [plan]` | Plan fixes for UAT issues from verify-work |

package/commands/gsd/execute-phase.md

@@ -0,0 +1,120 @@
+---
+name: gsd:execute-phase
+description: Execute all plans in a phase with intelligent parallelization
+argument-hint: "<phase-number>"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - TaskOutput
+  - AskUserQuestion
+  - SlashCommand
+---
+
+<objective>
+Execute all unexecuted plans in a phase with parallel agent spawning.
+
+Analyzes plan dependencies to identify independent plans that can run concurrently.
+Spawns background agents for parallel execution, each agent commits its own tasks atomically.
+
+**Critical constraint:** One subagent per plan, always. This is for context isolation, not parallelization. Even strictly sequential plans spawn separate subagents so each starts with fresh 200k context at 0%.
+
+Use this command when:
+- Phase has 2+ unexecuted plans
+- Want "walk away, come back to completed work" execution
+- Plans have clear dependency boundaries
+</objective>
+
+<execution_context>
+@~/.claude/get-shit-done/workflows/execute-plan.md
+@~/.claude/get-shit-done/workflows/execute-phase.md
+@~/.claude/get-shit-done/templates/summary.md
+@~/.claude/get-shit-done/references/checkpoints.md
+@~/.claude/get-shit-done/references/tdd.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+@.planning/STATE.md
+@.planning/config.json
+</context>
+
+<process>
+1. Validate phase exists in roadmap
+2. Find all PLAN.md files without matching SUMMARY.md
+3. If 0 or 1 plans: suggest /gsd:execute-plan instead
+4. If 2+ plans: follow execute-phase.md workflow
+5. Monitor parallel agents until completion
+6. Present results and next steps
+</process>
+
+<execution_strategies>
+**Strategy A: Fully Autonomous** (no checkpoints)
+
+- Spawn subagent to execute entire plan
+- Subagent creates SUMMARY.md and commits
+- Main context: orchestration only (~5% usage)
+
+**Strategy B: Segmented** (has verify-only checkpoints)
+
+- Execute in segments between checkpoints
+- Subagent for autonomous segments
+- Main context for checkpoints
+- Aggregate results → SUMMARY → commit
+
+**Strategy C: Decision-Dependent** (has decision checkpoints)
+
+- Execute in main context
+- Decision outcomes affect subsequent tasks
+- Quality maintained through small scope (2-3 tasks per plan)
+</execution_strategies>
+
+<deviation_rules>
+During execution, handle discoveries automatically:
+
+1. **Auto-fix bugs** - Fix immediately, document in Summary
+2. **Auto-add critical** - Security/correctness gaps, add and document
+3. **Auto-fix blockers** - Can't proceed without fix, do it and document
+4. **Ask about architectural** - Major structural changes, stop and ask user
+5. **Log enhancements** - Nice-to-haves, log to ISSUES.md, continue
+
+Only rule 4 requires user intervention.
+</deviation_rules>
+
+<commit_rules>
+**Per-Task Commits:**
+
+After each task completes:
+1. Stage only files modified by that task
+2. Commit with format: `{type}({phase}-{plan}): {task-name}`
+3. Types: feat, fix, test, refactor, perf, chore
+4. Record commit hash for SUMMARY.md
+
+**Plan Metadata Commit:**
+
+After all tasks complete:
+1. Stage planning artifacts only: PLAN.md, SUMMARY.md, STATE.md, ROADMAP.md
+2. Commit with format: `docs({phase}-{plan}): complete [plan-name] plan`
+3. NO code files (already committed per-task)
+
+**NEVER use:**
+- `git add .`
+- `git add -A`
+- `git add src/` or any broad directory
+
+**Always stage files individually.**
+</commit_rules>
+
+<success_criteria>
+- [ ] All independent plans executed in parallel
+- [ ] Dependent plans executed after dependencies complete
+- [ ] Each task committed individually (feat/fix/test/refactor)
+- [ ] All SUMMARY.md files created
+- [ ] Metadata committed by orchestrator
+- [ ] Phase progress updated
+</success_criteria>

package/commands/gsd/execute-plan.md

@@ -28,7 +28,7 @@ Uses intelligent segmentation:
   </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/execute-phase.md
+@~/.claude/get-shit-done/workflows/execute-plan.md
 @~/.claude/get-shit-done/templates/summary.md
 @~/.claude/get-shit-done/references/checkpoints.md
 @~/.claude/get-shit-done/references/tdd.md
@@ -49,7 +49,7 @@ Plan path: $ARGUMENTS
 2. Verify plan at $ARGUMENTS exists
 3. Check if SUMMARY.md already exists (plan already executed?)
 4. Load workflow config for mode (interactive/yolo)
-5. Follow execute-phase.md workflow:
+5. Follow execute-plan.md workflow:
    - Parse plan and determine execution strategy (A/B/C)
    - Execute tasks (via subagent or main context as appropriate)
    - Handle checkpoints and deviations

package/commands/gsd/help.md

@@ -107,15 +107,38 @@ Result: Creates `.planning/phases/01-foundation/01-01-PLAN.md`
 ### Execution
 
 **`/gsd:execute-plan <path>`**
-Execute a PLAN.md file directly.
+Execute a single PLAN.md file.
 
 - Runs plan tasks sequentially
 - Creates SUMMARY.md after completion
 - Updates STATE.md with accumulated context
-- Fast execution without loading full skill context
+- Use for interactive execution with checkpoints
 
 Usage: `/gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md`
 
+**`/gsd:execute-phase <phase-number>`**
+Execute all unexecuted plans in a phase with parallel background agents.
+
+- Analyzes plan dependencies and spawns independent plans concurrently
+- Use when phase has 2+ plans and you want "walk away" execution
+- Respects max_concurrent_agents from config.json
+
+Usage: `/gsd:execute-phase 5`
+
+Options (via `.planning/config.json` parallelization section):
+- `max_concurrent_agents`: Limit parallel agents (default: 3)
+- `skip_checkpoints`: Skip human checkpoints in background (default: true)
+- `min_plans_for_parallel`: Minimum plans to trigger parallelization (default: 2)
+
+**`/gsd:status [--wait]`**
+Check status of background agents from parallel execution.
+
+- Shows running/completed agents from agent-history.json
+- Uses TaskOutput to poll agent status
+- With `--wait`: blocks until all agents complete
+
+Usage: `/gsd:status` or `/gsd:status --wait`
+
 ### Roadmap Management
 
 **`/gsd:add-phase <description>`**

package/commands/gsd/new-project.md

@@ -248,7 +248,27 @@ Use AskUserQuestion:
 
 **Depth controls compression tolerance, not artificial inflation.** All depths use 2-3 tasks per plan. Comprehensive means "don't compress complex work"—it doesn't mean "pad simple work to hit a number."
 
-Create `.planning/config.json` with chosen mode and depth using `templates/config.json` structure.
+</step>
+
+<step name="parallelization">
+
+Ask parallel execution preference:
+
+Use AskUserQuestion:
+
+- header: "Parallelization"
+- question: "Enable parallel phase execution?"
+- options:
+  - "Disabled" — Execute plans sequentially (Recommended)
+  - "Enabled" — Run independent plans in parallel (experimental, may not yield best results)
+
+**Parallelization is experimental.** When enabled, `/gsd:execute-phase` spawns multiple agents for independent plans. Still being refined—sequential execution is more reliable. Can be changed later in config.json.
+
+</step>
+
+<step name="config">
+
+Create `.planning/config.json` with chosen mode, depth, and parallelization using `templates/config.json` structure.
 
 </step>
 
@@ -309,7 +329,7 @@ Project initialized:
 - [ ] PROJECT.md captures full context with evolutionary structure
 - [ ] Requirements initialized as hypotheses (greenfield) or with inferred Validated (brownfield)
 - [ ] Key Decisions table initialized
-- [ ] config.json has workflow mode
+- [ ] config.json has workflow mode, depth, and parallelization
 - [ ] All committed to git
 
 </success_criteria>

package/commands/gsd/plan-fix.md

@@ -126,7 +126,7 @@ Priority: {critical count} critical, {major count} major, {minor count} minor
 </objective>
 
 <execution_context>
-@~/.claude/get-shit-done/workflows/execute-phase.md
+@~/.claude/get-shit-done/workflows/execute-plan.md
 @~/.claude/get-shit-done/templates/summary.md
 </execution_context>
 

package/commands/gsd/resume-task.md

@@ -16,7 +16,7 @@ Resume an interrupted subagent execution using the Task tool's resume parameter.
 
 When a session ends mid-execution, subagents may be left in an incomplete state. This command allows users to continue that work without starting over.
 
-Uses the agent ID tracking infrastructure from execute-phase to identify and resume agents.
+Uses the agent ID tracking infrastructure from execute-plan to identify and resume agents.
 </objective>
 
 <execution_context>

package/commands/gsd/status.md

@@ -0,0 +1,161 @@
+---
+name: gsd:status
+description: Check status of background agents from parallel execution
+argument-hint: "[--wait]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - TaskOutput
+---
+
+<objective>
+Monitor background agent status from /gsd:execute-phase parallel execution.
+
+Shows running/completed agents from agent-history.json.
+Uses TaskOutput to check status of background tasks.
+With --wait flag, blocks until all agents complete.
+</objective>
+
+<context>
+Arguments: $ARGUMENTS
+</context>
+
+<process>
+
+<step name="load_history">
+**Load agent history:**
+
+```bash
+cat .planning/agent-history.json 2>/dev/null || echo '{"entries":[]}'
+```
+
+If file doesn't exist or has no entries:
+```
+No background agents tracked.
+
+Run /gsd:execute-phase to spawn parallel agents.
+```
+Exit.
+</step>
+
+<step name="filter_agents">
+**Find background agents:**
+
+Filter entries where:
+- `execution_mode` is "parallel" or "background"
+- `status` is "spawned" (still running) or recently completed
+
+Group by `parallel_group` if present.
+</step>
+
+<step name="check_running">
+**Check status of running agents:**
+
+For each agent with `status === "spawned"`:
+
+Use TaskOutput tool:
+```
+task_id: [agent_id]
+block: false
+timeout: 1000
+```
+
+**If TaskOutput returns completed result:**
+- Update agent-history.json: status → "completed"
+- Set completion_timestamp
+- Parse files_modified from output if present
+
+**If TaskOutput returns "still running":**
+- Keep as spawned (running)
+
+**If TaskOutput returns error:**
+- Update agent-history.json: status → "failed"
+</step>
+
+<step name="display">
+**Show status table:**
+
+```
+Background Agents
+════════════════════════════════════════
+
+| Plan   | Status      | Elapsed  | Agent ID      |
+|--------|-------------|----------|---------------|
+| 10-01  | ✓ Complete  | 2m 15s   | agent_01H...  |
+| 10-02  | ⏳ Running   | 1m 30s   | agent_01H...  |
+| 10-04  | ✓ Complete  | 1m 45s   | agent_01H...  |
+
+Progress: 2/3 complete
+
+════════════════════════════════════════
+Wait for all: /gsd:status --wait
+```
+
+**Status icons:**
+- ✓ Complete
+- ⏳ Running
+- ✗ Failed
+- ⏸ Queued (waiting for dependency)
+</step>
+
+<step name="wait_mode">
+**If --wait flag provided:**
+
+For each agent with status "spawned":
+
+Use TaskOutput with blocking:
+```
+task_id: [agent_id]
+block: true
+timeout: 600000
+```
+
+Report as each completes:
+```
+⏳ Waiting for 3 agents...
+
+✓ [1/3] 10-01 complete (2m 15s)
+✓ [2/3] 10-04 complete (1m 45s)
+✓ [3/3] 10-02 complete (3m 30s)
+
+════════════════════════════════════════
+All agents complete!
+
+Total time: 3m 30s (parallel)
+Sequential estimate: 7m 30s
+Time saved: ~4m (53%)
+════════════════════════════════════════
+```
+
+Update agent-history.json with completion status for each.
+</step>
+
+<step name="next_steps">
+**After all complete (or if already complete):**
+
+```
+---
+
+## ▶ Next Up
+
+All parallel agents finished. Review results:
+
+`/gsd:progress`
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Reads agent-history.json for background agents
+- [ ] Uses TaskOutput to check running agent status
+- [ ] Updates history with current status
+- [ ] Shows simple status table
+- [ ] --wait flag blocks until all complete
+- [ ] Reports time savings vs sequential
+</success_criteria>

package/get-shit-done/references/scope-estimation.md

@@ -87,6 +87,94 @@ See `~/.claude/get-shit-done/references/tdd.md` for TDD plan structure.
 **By verification:** Deploy → 01: Vercel setup (checkpoint), 02: Env config (auto), 03: CI/CD (checkpoint)
 </splitting_strategies>
 
+<parallel_aware_splitting>
+**When parallelization is enabled, optimize for plan independence.**
+
+<philosophy_shift>
+| Aspect | Sequential Planning | Parallel-Aware Planning |
+|--------|---------------------|------------------------|
+| Grouping | By workflow stage | By vertical slice |
+| Dependencies | Implicit (later plans reference earlier) | Explicit (only when genuinely needed) |
+| File ownership | Overlap acceptable | Exclusive where possible |
+| SUMMARY refs | Chain pattern (02 refs 01, 03 refs 02) | Minimal (only for real data deps) |
+| Wave result | Most plans in Wave 2+ | More plans in Wave 1 |
+</philosophy_shift>
+
+<vertical_slice_example>
+**Sequential (creates chain):**
+```
+Plan 01: Create User model, Product model, Order model
+Plan 02: Create /api/users, /api/products, /api/orders
+Plan 03: Create UserList UI, ProductList UI, OrderList UI
+```
+Result: 02 depends on 01 (needs models), 03 depends on 02 (needs APIs)
+Waves: [01] → [02] → [03] (fully sequential)
+
+**Parallel-aware (creates independence):**
+```
+Plan 01: User feature (model + API + UI)
+Plan 02: Product feature (model + API + UI)
+Plan 03: Order feature (model + API + UI)
+```
+Result: Each plan self-contained, no file overlap
+Waves: [01, 02, 03] (all parallel)
+</vertical_slice_example>
+
+<when_to_restructure>
+**Restructure for vertical slices when:**
+- Phase has 3+ features that are independent
+- No shared infrastructure requirements
+- Each feature touches different files
+- Features can be tested independently
+
+**Keep sequential when:**
+- Genuine data dependencies (Order needs User type)
+- Shared foundation required (auth setup before protected features)
+- Single feature being built incrementally
+- Phase is already a vertical slice
+</when_to_restructure>
+
+<file_ownership>
+**Explicit file ownership prevents conflicts:**
+
+```yaml
+# Plan 01 frontmatter
+files_exclusive: [src/models/user.ts, src/api/users.ts, src/components/UserList.tsx]
+
+# Plan 02 frontmatter
+files_exclusive: [src/models/product.ts, src/api/products.ts, src/components/ProductList.tsx]
+```
+
+**If file appears in multiple plans:** Later plan depends on earlier (by plan number).
+**If file cannot be split:** Plans must be sequential for that file.
+</file_ownership>
+
+<summary_references>
+**Minimize SUMMARY references when parallel-aware:**
+
+**Before (sequential habit):**
+```markdown
+<context>
+@.planning/phases/05-features/05-01-SUMMARY.md  # Always reference prior
+@.planning/phases/05-features/05-02-SUMMARY.md  # Chain continues
+</context>
+```
+
+**After (parallel-aware):**
+```markdown
+<context>
+# Only reference if this plan ACTUALLY needs decisions from prior plan
+# Most parallel plans don't need any SUMMARY references
+</context>
+```
+
+**Include SUMMARY only when:**
+- Prior plan made a decision that affects this plan's approach
+- Prior plan created types/interfaces this plan imports
+- Prior plan's output is input to this plan
+</summary_references>
+</parallel_aware_splitting>
+
 <anti_patterns>
 **Bad - Comprehensive plan:**
 ```