get-shit-done-cc 1.3.15 → 1.3.16

package/commands/gsd/auto.md

@@ -0,0 +1,150 @@
+---
+description: Autonomous mode - reads state, executes next step, spawns next Claude.
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+  - SlashCommand
+---
+
+<objective>
+Autonomous execution with self-spawning. Run once:
+```bash
+claude --dangerously-skip-permissions '/gsd:auto'
+```
+
+Reads STATE.md, determines next action, executes it, then spawns a fresh Claude to continue.
+Chains until milestone complete. All gates auto-approved.
+</objective>
+
+<process>
+
+<step name="verify_yolo">
+**Check yolo mode is enabled:**
+
+```bash
+cat .planning/config.json 2>/dev/null
+```
+
+Parse the JSON. If `mode` is not `"yolo"`, refuse:
+
+```
+⚠ Auto mode requires yolo mode.
+
+Set in .planning/config.json:
+{"mode": "yolo"}
+
+Then run:
+while true; do claude -p --dangerously-skip-permissions '/gsd:auto'; done
+```
+
+Exit without executing anything.
+
+If no `.planning/` directory exists:
+
+```
+No planning structure found.
+Run /gsd:new-project first.
+```
+
+Exit.
+</step>
+
+<step name="load_state">
+**Load minimal state:**
+
+- Read `.planning/STATE.md` - current position
+- Read `.planning/ROADMAP.md` - phase structure
+
+Extract:
+- Current phase number
+- Current plan number (or "none")
+- Phase status (planning/executing/complete)
+- Total phases in milestone
+</step>
+
+<step name="determine_action">
+**Determine next action based on state:**
+
+Check what exists in `.planning/phases/`:
+
+1. **No PLAN.md for current phase** → need to plan
+2. **PLAN.md exists, no SUMMARY.md** → need to execute
+3. **SUMMARY.md exists for all plans in phase** → phase complete, check next
+4. **All phases complete** → milestone complete
+
+Logic:
+```
+if current_phase has no PLAN.md:
+  action = plan-phase
+elif current_phase has unexecuted PLAN.md:
+  action = execute-plan
+elif current_phase complete AND more phases exist:
+  action = plan-phase (next phase)
+elif all phases complete:
+  action = complete-milestone
+```
+</step>
+
+<step name="execute">
+**Execute the determined action immediately:**
+
+No status report. No "Next Up" display. Just execute.
+
+**If action = plan-phase:**
+```
+▶ AUTO: /gsd:plan-phase [N]
+```
+Invoke: `SlashCommand("/gsd:plan-phase [N]")`
+
+**If action = execute-plan:**
+```
+▶ AUTO: /gsd:execute-plan [path]
+```
+Invoke: `SlashCommand("/gsd:execute-plan [full-path-to-PLAN.md]")`
+
+**If action = complete-milestone:**
+```
+▶ AUTO: /gsd:complete-milestone
+```
+Invoke: `SlashCommand("/gsd:complete-milestone")`
+
+**If milestone already complete:**
+```
+✅ Milestone complete. Nothing to do.
+```
+Exit cleanly (loop will restart, hit this again, user can Ctrl+C).
+</step>
+
+</process>
+
+<auto_approve_context>
+**CRITICAL: ALL HUMAN CHECKPOINTS ARE AUTO-APPROVED IN /gsd:auto**
+
+When executing via /gsd:auto, treat ALL checkpoint types as auto-approved:
+
+- `checkpoint:human-verify` → AUTO-APPROVED, log "Auto-verified in yolo mode"
+- `checkpoint:decision` → AUTO-APPROVED, pick the most sensible default
+- `checkpoint:human-action` → SKIP if possible, or simulate completion
+- Any "Type approved to continue" → AUTO-APPROVED
+- Any "Does this look right?" → YES
+- Any confirmation prompt → CONFIRMED
+
+**DO NOT STOP AND WAIT FOR INPUT. EVER.**
+
+If a checkpoint would normally block, instead:
+1. Log: "⚡ Auto-approved: [checkpoint description]"
+2. Continue execution immediately
+
+The invoked commands should detect yolo mode from config.json and apply this behavior.
+</auto_approve_context>
+
+<success_criteria>
+- [ ] Refuses to run if mode != yolo
+- [ ] Reads state, determines action
+- [ ] Executes exactly one action via SlashCommand
+- [ ] No prompts, no waiting, no "Next Up" display
+- [ ] Exits cleanly after action completes
+- [ ] Works with: while true; do claude -p --dangerously-skip-permissions '/gsd:auto'; done
+</success_criteria>

package/commands/gsd/new-milestone.md

@@ -32,7 +32,7 @@ Milestone name: $ARGUMENTS (optional - will prompt if not provided)
 1. Load project context (STATE.md, ROADMAP.md, MILESTONES.md)
 2. Calculate next milestone version and starting phase number
 3. If milestone name provided in arguments, use it; otherwise prompt
-4. Gather phases (3-6 recommended):
+4. Gather phases (per depth setting: quick 3-5, standard 5-8, comprehensive 8-12):
    - If called from /gsd:discuss-milestone, use provided context
    - Otherwise, prompt for phase breakdown
 5. Detect research needs for each phase
@@ -48,7 +48,7 @@ Milestone name: $ARGUMENTS (optional - will prompt if not provided)
 <success_criteria>
 
 - Next phase number calculated correctly (continues from previous milestone)
-- 3-6 phases defined with clear names
+- Phases defined per depth setting (quick: 3-5, standard: 5-8, comprehensive: 8-12)
 - Research flags assigned for each phase
 - ROADMAP.md updated with new milestone section
 - Phase directories created

package/commands/gsd/new-project.md

@@ -230,7 +230,24 @@ Use AskUserQuestion:
   - "Interactive" — Confirm at each step
   - "YOLO" — Auto-approve, just execute
 
-Create `.planning/config.json` with chosen mode using `templates/config.json` structure.
+</step>
+
+<step name="depth">
+
+Ask planning depth preference:
+
+Use AskUserQuestion:
+
+- header: "Depth"
+- question: "How thorough should planning be?"
+- options:
+  - "Quick" — Ship fast, minimal phases/plans (3-5 phases, 1-3 plans each)
+  - "Standard" — Balanced scope and speed (5-8 phases, 3-5 plans each)
+  - "Comprehensive" — Thorough coverage, more phases/plans (8-12 phases, 5-10 plans each)
+
+**Depth controls quantity, not quality.** All depths use 2-3 tasks per plan. Depth determines how many plans get created—more depth means more plans, not bigger plans.
+
+Create `.planning/config.json` with chosen mode and depth using `templates/config.json` structure.
 
 </step>
 

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

@@ -102,6 +102,33 @@ Each: 30-40% context, peak quality, focused commits
 **3 tasks:** Simple ~45%, Medium ~75% (risky), Complex 120% (impossible)
 </estimating_context>
 
+<depth_calibration>
+**Depth controls plan count, not plan size.**
+
+| Depth | Phases | Plans/Phase | Tasks/Plan |
+|-------|--------|-------------|------------|
+| Quick | 3-5 | 1-3 | 2-3 |
+| Standard | 5-8 | 3-5 | 2-3 |
+| Comprehensive | 8-12 | 5-10 | 2-3 |
+
+Tasks/plan is CONSTANT at 2-3. The 50% context rule applies universally.
+
+Depth determines thoroughness by creating more phases and more plans—never by cramming more into each plan.
+
+**Comprehensive depth example:**
+Auth system at comprehensive depth = 8 plans (not 3 big ones):
+- 01: DB models (2 tasks)
+- 02: Password hashing (2 tasks)
+- 03: JWT generation (2 tasks)
+- 04: JWT validation middleware (2 tasks)
+- 05: Login endpoint (2 tasks)
+- 06: Register endpoint (2 tasks)
+- 07: Protected route patterns (2 tasks)
+- 08: Auth UI components (3 tasks)
+
+Each plan: fresh context, peak quality. More plans = more thoroughness, same quality per plan.
+</depth_calibration>
+
 <summary>
 **2-3 tasks, 50% context target:**
 - All tasks: Peak quality
@@ -111,5 +138,7 @@ Each: 30-40% context, peak quality, focused commits
 **The principle:** Aggressive atomicity. More plans, smaller scope, consistent quality.
 
 **The rule:** If in doubt, split. Quality over consolidation. Always.
+
+**Depth rule:** Depth increases plan COUNT, never plan SIZE.
 </summary>
 </scope_estimation>

package/get-shit-done/templates/config.json

@@ -1,5 +1,6 @@
 {
   "mode": "interactive",
+  "depth": "standard",
   "gates": {
     "confirm_project": true,
     "confirm_phases": true,

package/get-shit-done/templates/roadmap.md

@@ -100,7 +100,7 @@ Phases execute in numeric order: 2 → 2.1 → 2.2 → 3 → 3.1 → 4
 
 <guidelines>
 **Initial planning (v1.0):**
-- 3-6 phases total (more = scope creep)
+- Phase count depends on depth setting (quick: 3-5, standard: 5-8, comprehensive: 8-12)
 - Each phase delivers something coherent
 - Phases can have 1+ plans (split if >3 tasks or multiple subsystems)
 - Plans use naming: {phase}-{plan}-PLAN.md (e.g., 01-02-PLAN.md)

package/get-shit-done/workflows/create-milestone.md

@@ -71,7 +71,17 @@ grep -E "^### Phase [0-9]+" .planning/ROADMAP.md | tail -1
 
 Next phase starts at: [last_phase + 1]
 
-**Gather phases (3-6 recommended):**
+**Check depth setting and gather phases accordingly:**
+
+```bash
+cat .planning/config.json 2>/dev/null | grep depth
+```
+
+| Depth | Phases/Milestone |
+|-------|------------------|
+| Quick | 3-5 |
+| Standard | 5-8 |
+| Comprehensive | 8-12 |
 
 If context from discuss-milestone provided, use that scope.
 
@@ -359,7 +369,7 @@ Numbers continue from previous milestone. Names describe content.
 - Don't restart phase numbering at 01 (continue sequence)
 - Don't add time estimates
 - Don't create Gantt charts
-- Don't plan more than 6 phases per milestone (scope creep)
+- Respect depth setting for phase count (quick: 3-5, standard: 5-8, comprehensive: 8-12)
 - Don't modify completed milestone sections
 
 Milestones are coherent chunks of work, not project management artifacts.
@@ -368,7 +378,7 @@ Milestones are coherent chunks of work, not project management artifacts.
 <success_criteria>
 Milestone creation is complete when:
 - [ ] Next phase number calculated correctly (continues from previous)
-- [ ] 3-6 phases defined with clear names
+- [ ] Phases defined per depth setting (quick: 3-5, standard: 5-8, comprehensive: 8-12)
 - [ ] Research flags assigned for each phase
 - [ ] ROADMAP.md updated with new milestone section
 - [ ] Phase directories created

package/get-shit-done/workflows/create-roadmap.md

@@ -81,7 +81,35 @@ Select (comma-separate for multiple):
 </step>
 
 <step name="identify_phases">
-Derive phases from the actual work needed. The phase count emerges from the project—don't impose a number.
+Derive phases from the actual work needed.
+
+**Check depth setting:**
+```bash
+cat .planning/config.json 2>/dev/null | grep depth
+```
+
+<depth_guidance>
+**Phase count targets by depth:**
+
+| Depth | Target Phases | Plans/Phase | Tasks/Plan |
+|-------|---------------|-------------|------------|
+| Quick | 3-5 | 1-3 | 2-3 |
+| Standard | 5-8 | 3-5 | 2-3 |
+| Comprehensive | 8-12 | 5-10 | 2-3 |
+
+**Tasks/plan is constant (2-3). Depth scales phases and plans, not task density.**
+
+For comprehensive depth:
+- Don't compress multiple features into single phases
+- Each major capability gets its own phase
+- "Too many phases" is NOT a concern—thoroughness is the goal
+- If you're tempted to combine two things, make them separate phases instead
+
+For quick depth:
+- Combine related work aggressively
+- Focus on critical path only
+- Defer nice-to-haves to future milestones
+</depth_guidance>
 
 **Phase Numbering System:**
 

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

@@ -226,6 +226,34 @@ See ~/.claude/get-shit-done/references/checkpoints.md for checkpoint structure.
 <step name="estimate_scope">
 After tasks, assess against quality degradation curve.
 
+**Check depth setting:**
+```bash
+cat .planning/config.json 2>/dev/null | grep depth
+```
+
+<depth_aware_splitting>
+**Plan count targets by depth:**
+
+| Depth | Plans/Phase | Tasks/Plan |
+|-------|-------------|------------|
+| Quick | 1-3 | 2-3 |
+| Standard | 3-5 | 2-3 |
+| Comprehensive | 5-10 | 2-3 |
+
+**Tasks/plan is ALWAYS 2-3. Depth determines how many plans you create, not how big each plan is.**
+
+For comprehensive depth:
+- Create MORE plans, not bigger ones
+- If a phase has 15 tasks, that's 5-8 plans (not 3 plans with 5 tasks each)
+- Don't compress to look efficient—thoroughness is the goal
+- Each plan stays focused: 2-3 tasks, single concern
+
+For quick depth:
+- Combine aggressively into fewer plans
+- 1-3 plans per phase is fine
+- Focus on critical path
+</depth_aware_splitting>
+
 **ALWAYS split if:** >3 tasks, multiple subsystems, >5 files in any task, complex domains (auth, payments).
 
 **If scope appropriate (2-3 tasks, single subsystem, <5 files/task):** Proceed to confirm_breakdown.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.3.15",
+  "version": "1.3.16",
   "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"