get-shit-done-cc 1.4.5 → 1.4.7

package/commands/gsd/execute-phase.md

@@ -4,6 +4,8 @@ description: Execute all plans in a phase with wave-based parallelization
 argument-hint: "<phase-number>"
 allowed-tools:
   - Read
+  - Write
+  - Edit
   - Glob
   - Grep
   - Bash
@@ -22,7 +24,11 @@ Context budget: ~15% orchestrator, 100% fresh per subagent.
 
 <execution_context>
 @~/.claude/get-shit-done/workflows/execute-phase.md
+@~/.claude/get-shit-done/workflows/execute-plan.md
 @~/.claude/get-shit-done/templates/subagent-task-prompt.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>
@@ -104,6 +110,42 @@ grep -c 'type="checkpoint' {plan_path}
 - Safe for parallel wave execution
 </checkpoint_detection>
 
+<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 incomplete plans in phase executed
 - [ ] Each plan has SUMMARY.md

package/commands/gsd/new-project.md

@@ -259,10 +259,10 @@ 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)
+  - "Enabled" — Run independent plans in parallel (Recommended)
+  - "Disabled" — Execute plans sequentially
 
-**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.
+**Parallelization** spawns multiple agents for independent plans within a phase. Wave-based execution handles dependencies automatically. Can be changed later in config.json.
 
 </step>
 

package/get-shit-done/templates/subagent-task-prompt.md

@@ -1,6 +1,6 @@
 # Subagent Task Prompt Template
 
-Template for spawning plan execution subagents from execute-phase orchestrator.
+Template for spawning plan execution agents from execute-phase orchestrator.
 
 ---
 
@@ -11,6 +11,8 @@ Template for spawning plan execution subagents from execute-phase orchestrator.
 Execute plan {plan_number} of phase {phase_number}-{phase_name}.
 
 Commit each task atomically. Create SUMMARY.md. Update STATE.md.
+
+**Checkpoint handling:** If you hit a checkpoint task, STOP and return a checkpoint message (see checkpoint_behavior below). The orchestrator will present it to the user and resume you with their response.
 </objective>
 
 <execution_context>
@@ -26,8 +28,40 @@ Project state: @.planning/STATE.md
 Config: @.planning/config.json (if exists)
 </context>
 
+<checkpoint_behavior>
+When you encounter a checkpoint task (type="checkpoint:*"), STOP execution and return this format:
+
+## CHECKPOINT REACHED
+
+**Type:** [human-verify | decision | human-action]
+**Plan:** {phase}-{plan}
+**Progress:** {completed}/{total} tasks complete
+
+[Checkpoint content from checkpoint_protocol in execute-plan.md]
+
+**Awaiting:** [Resume signal from the task]
+
+The orchestrator will present this to the user and resume you with their response.
+When resumed, you'll receive: "User response: {their_input}"
+Parse and continue appropriately.
+</checkpoint_behavior>
+
+<completion_format>
+When plan completes successfully, return:
+
+## PLAN COMPLETE
+
+**Plan:** {phase}-{plan}
+**Tasks:** {completed}/{total}
+**SUMMARY:** {path to SUMMARY.md}
+
+**Commits:**
+- {hash}: {message}
+...
+</completion_format>
+
 <success_criteria>
-- [ ] All tasks executed
+- [ ] All tasks executed (or paused at checkpoint)
 - [ ] Each task committed individually
 - [ ] SUMMARY.md created in plan directory
 - [ ] STATE.md updated with position and decisions
@@ -58,4 +92,8 @@ Task(
 )
 ```
 
-Subagent reads @-references, loads full workflow context, executes plan.
+Agent reads @-references, loads full workflow context, executes plan.
+
+When agent returns:
+- If contains "## CHECKPOINT REACHED": Parse and present to user, then resume
+- If contains "## PLAN COMPLETE": Finalize execution

package/get-shit-done/workflows/execute-phase.md

@@ -6,8 +6,36 @@ Execute all plans in a phase using wave-based parallel execution. Orchestrator s
 The orchestrator's job is coordination, not execution. Each subagent loads the full execute-plan context itself. Orchestrator discovers plans, analyzes dependencies, groups into waves, spawns agents, handles checkpoints, collects results.
 </core_principle>
 
+<required_reading>
+Read STATE.md before any operation to load project context.
+</required_reading>
+
 <process>
 
+<step name="load_project_state" priority="first">
+Before any operation, read project state:
+
+```bash
+cat .planning/STATE.md 2>/dev/null
+```
+
+**If file exists:** Parse and internalize:
+- Current position (phase, plan, status)
+- Accumulated decisions (constraints on this execution)
+- Deferred issues (context for deviations)
+- Blockers/concerns (things to watch for)
+
+**If file missing but .planning/ exists:**
+```
+STATE.md missing but planning artifacts exist.
+Options:
+1. Reconstruct from existing artifacts
+2. Continue without project state (may lose accumulated context)
+```
+
+**If .planning/ doesn't exist:** Error - project not initialized.
+</step>
+
 <step name="validate_phase">
 Confirm phase exists and has plans:
 

package/get-shit-done/workflows/execute-plan.md

@@ -1152,6 +1152,49 @@ I'll verify after: [verification]
 See ~/.claude/get-shit-done/references/checkpoints.md for complete checkpoint guidance.
 </step>
 
+<step name="checkpoint_return_for_orchestrator">
+**When spawned by an orchestrator (execute-phase or execute-plan command):**
+
+If you were spawned via Task tool and hit a checkpoint, you cannot directly interact with the user. Instead, RETURN to the orchestrator with checkpoint details so it can present to the user and resume you.
+
+**Return format for checkpoints:**
+
+```
+## CHECKPOINT REACHED
+
+**Type:** [human-verify | decision | human-action]
+**Plan:** {phase}-{plan}
+**Progress:** {completed}/{total} tasks complete
+
+[Checkpoint content - same as checkpoint_protocol display above]
+
+**Awaiting:** [Resume signal from the task]
+```
+
+The orchestrator will:
+1. Parse your return
+2. Present the checkpoint to the user
+3. Collect user's response
+4. Resume you with: `Task(resume=your_agent_id, prompt="User response: {their_input}")`
+
+**When resumed after checkpoint:**
+
+You will receive a prompt like: `"User response: approved"` or `"User response: option-a"`
+
+- Parse the user's response
+- If approved/done: continue to next task
+- If issues described: address them, then continue or re-present checkpoint
+- If option selected: proceed with that choice
+
+**How to know if you were spawned:**
+
+If you're reading this workflow because an orchestrator spawned you (vs running directly from /gsd:execute-plan), the orchestrator's prompt will include checkpoint return instructions. Follow those instructions when you hit a checkpoint.
+
+**If running in main context (not spawned):**
+
+Use the standard checkpoint_protocol - display checkpoint and wait for direct user response.
+</step>
+
 <step name="verification_failure_gate">
 If any task verification fails:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "get-shit-done-cc": "bin/install.js"