get-shit-done-cc 1.4.8 → 1.4.10

package/commands/gsd/discuss-phase.md

@@ -7,7 +7,7 @@ argument-hint: "[phase]"
 <objective>
 Help the user articulate their vision for a phase through collaborative thinking.
 
-Purpose: Understand HOW the user imagines this phase working — what it looks like, what's essential, what's out of scope. You're a thinking partner helping them crystallize their vision, not an interviewer gathering technical requirements.
+Purpose: Understand HOW the user imagines this phase working — what it looks like, what's essential. You're a thinking partner helping them crystallize their vision, not an interviewer gathering technical requirements.
 
 Output: {phase}-CONTEXT.md capturing the user's vision for the phase
 </objective>
@@ -36,7 +36,6 @@ Phase number: $ARGUMENTS (required)
    - Use AskUserQuestion: "How do you imagine this working?" with interpretation options
    - Use AskUserQuestion to follow their thread — probe what excites them
    - Use AskUserQuestion to sharpen the core — what's essential for THIS phase
-   - Use AskUserQuestion to find boundaries — what's explicitly out of scope
    - Use AskUserQuestion for decision gate (ready / ask more / let me add context)
    - Create CONTEXT.md capturing their vision
 5. Offer next steps (research or plan the phase)
@@ -55,6 +54,6 @@ User is the visionary, you are the builder:
 
 - Phase validated against roadmap
 - Vision gathered through collaborative thinking (not interrogation)
-- CONTEXT.md captures: how it works, what's essential, what's out of scope
+- CONTEXT.md captures: how it works, what's essential
 - User knows next steps (research or plan the phase)
 </success_criteria>

package/commands/gsd/execute-phase.md

@@ -24,11 +24,7 @@ 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>

package/commands/gsd/execute-plan.md

@@ -4,126 +4,100 @@ description: Execute a PLAN.md file
 argument-hint: "[path-to-PLAN.md]"
 allowed-tools:
   - Read
-  - Write
-  - Edit
-  - Bash
   - Glob
   - Grep
+  - Bash
   - Task
+  - TodoWrite
   - AskUserQuestion
-  - SlashCommand
 ---
 
 <objective>
-Execute a PLAN.md file with per-task atomic commits, create SUMMARY.md, update project state.
+Execute a single PLAN.md file by spawning a subagent.
 
-Commit strategy:
-- Each task → 1 commit immediately after completion (feat/fix/test/refactor)
-- Plan completion → 1 metadata commit (docs: SUMMARY + STATE + ROADMAP)
+Orchestrator stays lean: validate plan, spawn subagent, handle checkpoints, report completion. Subagent loads full execute-plan workflow and handles all execution details.
 
-Uses intelligent segmentation:
-- Plans without checkpoints → spawn subagent for full autonomous execution
-- Plans with verify checkpoints → segment execution, pause at checkpoints
-- Plans with decision checkpoints → execute in main context
-  </objective>
+Context budget: ~15% orchestrator, 100% fresh for subagent.
+</objective>
 
 <execution_context>
-@~/.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
+@~/.claude/get-shit-done/templates/subagent-task-prompt.md
 </execution_context>
 
 <context>
 Plan path: $ARGUMENTS
 
-**Load project state first:**
 @.planning/STATE.md
-
-**Load workflow config:**
-@.planning/config.json
+@.planning/config.json (if exists)
 </context>
 
 <process>
-1. Check .planning/ directory exists (error if not - user should run /gsd:new-project)
-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-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
-   - Create SUMMARY.md
-   - Update STATE.md
-   - Commit changes
+1. **Validate plan exists**
+   - Confirm file at $ARGUMENTS exists
+   - Error if not found: "Plan not found: {path}"
+
+2. **Check if already executed**
+   - Derive SUMMARY path from plan path (replace PLAN.md with SUMMARY.md)
+   - If SUMMARY exists: "Plan already executed. SUMMARY: {path}"
+   - Offer: re-execute or exit
+
+3. **Parse plan identifiers**
+   Extract from path like `.planning/phases/03-auth/03-02-PLAN.md`:
+   - phase_number: `03`
+   - phase_name: `auth`
+   - plan_number: `02`
+   - plan_path: full path
+
+4. **Fill and spawn subagent**
+   - Fill subagent-task-prompt template with extracted values
+   - Spawn: `Task(prompt=filled_template, subagent_type="general-purpose")`
+
+5. **Handle subagent return**
+   - If contains "## CHECKPOINT REACHED": Execute checkpoint_handling
+   - If contains "## PLAN COMPLETE": Verify SUMMARY exists, report success
+
+6. **Report completion**
+   - Show SUMMARY path
+   - Show commits from subagent return
+   - Offer 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
+<checkpoint_handling>
+When subagent returns with checkpoint:
 
-**Strategy C: Decision-Dependent** (has decision checkpoints)
+**1. Parse return:**
+```
+## CHECKPOINT REACHED
 
-- Execute in main context
-- Decision outcomes affect subsequent tasks
-- Quality maintained through small scope (2-3 tasks per plan)
-  </execution_strategies>
+**Type:** [human-verify | decision | human-action]
+**Plan:** {phase}-{plan}
+**Progress:** {completed}/{total} tasks complete
 
-<deviation_rules>
-During execution, handle discoveries automatically:
+[Checkpoint content]
 
-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
+**Awaiting:** [Resume signal]
+```
 
-Only rule 4 requires user intervention.
-</deviation_rules>
+**2. Present to user:**
+Display the checkpoint content exactly as returned by subagent.
 
-<commit_rules>
-**Per-Task Commits:**
+**3. Collect response:**
+Wait for user input:
+- human-verify: "approved" or description of issues
+- decision: option selection
+- human-action: "done" when complete
 
-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
+**4. Resume subagent:**
+```
+Task(resume="{agent_id}", prompt="User response: {user_input}")
+```
 
-**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.**
-
-See ~/.claude/get-shit-done/references/git-integration.md for full commit strategy.
-</commit_rules>
+**5. Repeat:**
+Continue handling returns until "## PLAN COMPLETE" or user stops.
+</checkpoint_handling>
 
 <success_criteria>
-
-- [ ] All tasks executed
-- [ ] Each task committed individually (feat/fix/test/refactor)
-- [ ] SUMMARY.md created with substantive content and commit hashes
-- [ ] STATE.md updated (position, decisions, issues, session)
-- [ ] ROADMAP updated (plan count, phase status)
-- [ ] Metadata committed with docs({phase}-{plan}): complete [plan-name] plan
-- [ ] User informed of next steps
-      </success_criteria>
+- [ ] Plan executed (SUMMARY.md created)
+- [ ] All checkpoints handled
+- [ ] User informed of completion and next steps
+</success_criteria>

package/get-shit-done/templates/checkpoint-return.md

@@ -0,0 +1,204 @@
+# Checkpoint Return Template
+
+Structured format for subagent checkpoint returns. Enables orchestrator to spawn continuation agents without relying on resume.
+
+---
+
+## Template
+
+```markdown
+## CHECKPOINT REACHED
+
+**Type:** [human-verify | decision | human-action]
+**Plan:** {phase}-{plan}
+**Progress:** {completed}/{total} tasks complete
+
+### Completed Tasks
+
+| Task | Name | Commit | Files |
+|------|------|--------|-------|
+| 1 | [task name] | [hash] | [key files created/modified] |
+| 2 | [task name] | [hash] | [key files created/modified] |
+
+### Current Task
+
+**Task {N}:** [task name]
+**Status:** [blocked | awaiting verification | awaiting decision]
+**Blocked by:** [specific blocker - auth required, user verification needed, decision needed]
+
+### Checkpoint Details
+
+[Checkpoint-specific content based on type - see below]
+
+### Awaiting
+
+[What user needs to do/provide]
+```
+
+---
+
+## Checkpoint Type Details
+
+### For human-verify
+
+```markdown
+### Checkpoint Details
+
+**What was built:**
+[Description of completed work]
+
+**How to verify:**
+1. [Step 1 - exact command/URL]
+2. [Step 2 - what to check]
+3. [Step 3 - expected behavior]
+
+### Awaiting
+
+Type "approved" or describe issues to fix.
+```
+
+### For human-action
+
+```markdown
+### Checkpoint Details
+
+**Automation attempted:**
+[What Claude tried to do]
+
+**Error encountered:**
+[Exact error message or auth failure]
+
+**What you need to do:**
+1. [Step 1]
+2. [Step 2]
+
+**I'll verify after:**
+[How Claude will confirm completion]
+
+### Awaiting
+
+Type "done" when complete.
+```
+
+### For decision
+
+```markdown
+### Checkpoint Details
+
+**Decision needed:**
+[What's being decided]
+
+**Context:**
+[Why this matters]
+
+**Options:**
+
+| Option | Pros | Cons |
+|--------|------|------|
+| [option-a] | [benefits] | [tradeoffs] |
+| [option-b] | [benefits] | [tradeoffs] |
+
+### Awaiting
+
+Select: [option-a | option-b | ...]
+```
+
+---
+
+## Why This Structure
+
+**Completed Tasks table:** Orchestrator knows exactly what's done. Fresh agent won't redo work.
+
+**Commit hashes:** Verification that work was committed. Fresh agent can check git log.
+
+**Files column:** Quick reference for what exists. Fresh agent can verify state.
+
+**Current Task + Blocked by:** Precise continuation point. Fresh agent knows exactly where to pick up.
+
+**Checkpoint Details:** User-facing content. Orchestrator presents this directly.
+
+---
+
+## Example: Auth Gate
+
+```markdown
+## CHECKPOINT REACHED
+
+**Type:** human-action
+**Plan:** 01-01
+**Progress:** 1/3 tasks complete
+
+### Completed Tasks
+
+| Task | Name | Commit | Files |
+|------|------|--------|-------|
+| 1 | Initialize Next.js 15 project | d6fe73f | package.json, tsconfig.json, next.config.js, app/ |
+
+### Current Task
+
+**Task 2:** Initialize Convex backend
+**Status:** blocked
+**Blocked by:** Convex CLI authentication required
+
+### Checkpoint Details
+
+**Automation attempted:**
+Ran `npx convex dev` to initialize Convex backend
+
+**Error encountered:**
+"Error: Not authenticated. Run `npx convex login` first."
+
+**What you need to do:**
+1. Run: `npx convex login`
+2. Complete browser authentication
+3. Run: `npx convex dev`
+4. Create project named "convex-saas-community" when prompted
+
+**I'll verify after:**
+`cat .env.local | grep CONVEX` returns the Convex URL
+
+### Awaiting
+
+Type "done" when Convex is authenticated and project created.
+```
+
+---
+
+## Example: Visual Verification
+
+```markdown
+## CHECKPOINT REACHED
+
+**Type:** human-verify
+**Plan:** 03-02
+**Progress:** 2/3 tasks complete
+
+### Completed Tasks
+
+| Task | Name | Commit | Files |
+|------|------|--------|-------|
+| 1 | Create dashboard layout | a1b2c3d | src/app/dashboard/layout.tsx, src/components/Sidebar.tsx |
+| 2 | Add responsive navigation | e4f5g6h | src/components/NavBar.tsx, src/styles/nav.css |
+
+### Current Task
+
+**Task 3:** Verify responsive behavior
+**Status:** awaiting verification
+**Blocked by:** Human visual verification required
+
+### Checkpoint Details
+
+**What was built:**
+Responsive dashboard with collapsible sidebar navigation
+
+**How to verify:**
+1. Run: `npm run dev`
+2. Visit: http://localhost:3000/dashboard
+3. Desktop (>1024px): Sidebar visible on left, content on right
+4. Tablet (768px): Sidebar collapses to icons
+5. Mobile (375px): Sidebar hidden, hamburger menu appears
+
+### Awaiting
+
+Type "approved" or describe issues to fix.
+```

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

@@ -32,17 +32,6 @@ Template for `.planning/phases/XX-name/{phase}-CONTEXT.md` - captures the user's
 
 </essential>
 
-<boundaries>
-## What's Out of Scope
-
-[Explicit exclusions for this phase. What are we NOT building? Where does this phase end and the next begin?]
-
-- [Not doing X - that's Phase Y]
-- [Not including Z - deferred]
-- [Explicitly excluding W]
-
-</boundaries>
-
 <specifics>
 ## Specific Ideas
 
@@ -91,16 +80,6 @@ The main thing is seeing their active projects and what needs attention. Think o
 
 </essential>
 
-<boundaries>
-## What's Out of Scope
-
-- Team features (shared dashboards, permissions) - that's a future milestone
-- Analytics/reporting - just show what needs attention, not graphs
-- Customizable layouts - keep it simple, one good layout
-- Mobile optimization - desktop first for now
-
-</boundaries>
-
 <specifics>
 ## Specific Ideas
 

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

@@ -1,6 +1,6 @@
 # Subagent Task Prompt Template
 
-Template for spawning plan execution agents from execute-phase orchestrator.
+Template for spawning plan execution agents. Used by execute-phase (parallel) and execute-plan (single) orchestrators.
 
 ---
 

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

@@ -119,14 +119,7 @@ Use AskUserQuestion:
 - question: "What's the most important part of this phase?"
 - options: Key aspects they've mentioned + "All equally important" + "Something else"
 
-**4. Find boundaries:**
-
-Use AskUserQuestion:
-- header: "Scope"
-- question: "What's explicitly out of scope for this phase?"
-- options: Things that might be tempting + "Nothing specific" + "Let me list them"
-
-**5. Capture specifics (optional):**
+**4. Capture specifics (optional):**
 
 If they seem to have specific ideas, use AskUserQuestion:
 - header: "Specifics"
@@ -138,8 +131,9 @@ CRITICAL — What NOT to ask:
 - Codebase patterns (you read the code)
 - Success metrics (too corporate)
 - Constraints they didn't mention (don't interrogate)
+- What's out of scope (implicit from roadmap)
 
-**6. Decision gate:**
+**5. Decision gate:**
 
 Use AskUserQuestion:
 - header: "Ready?"
@@ -170,7 +164,6 @@ Populate template sections with VISION context (not technical analysis):
 
 - `<vision>`: How the user imagines this working
 - `<essential>`: What must be nailed in this phase
-- `<boundaries>`: What's explicitly out of scope
 - `<specifics>`: Any particular look/feel/behavior mentioned
 - `<notes>`: Any other context gathered
 
@@ -191,9 +184,6 @@ Created: .planning/phases/${PHASE}-${SLUG}/${PHASE}-CONTEXT.md
 ## Essential
 [What must be nailed]
 
-## Boundaries
-[What's out of scope]
-
 ---
 
 ## ▶ Next Up
@@ -240,7 +230,7 @@ Confirm: "Committed: docs(${PHASE}): capture phase context"
 
 - Phase validated against roadmap
 - Vision gathered through collaborative thinking (not interrogation)
-- User's imagination captured: how it works, what's essential, what's out of scope
+- User's imagination captured: how it works, what's essential
 - CONTEXT.md created in phase directory
 - CONTEXT.md committed to git
 - User knows next steps (typically: research or plan the phase)

package/package.json

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