gsd-cc 0.6.1 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-cc",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Get Shit Done on Claude Code — structured AI development with your Max plan",
   "author": "Philipp Briese (https://github.com/0ui-labs)",
   "homepage": "https://github.com/0ui-labs/GSD-CC#readme",

package/skills/gsd/SKILL.md

@@ -76,7 +76,24 @@ IF M*-ROADMAP.md exists AND there are slices without a S*-PLAN.md:
 ### Plan Ready, Not Executed
 ```
 IF S*-PLAN.md exists for current slice AND no T*-SUMMARY.md files for it:
-  → "S{nn} is planned with {n} tasks. Execute manually or auto?"
+  → Present the execution mode choice with a clear explanation:
+
+  "S{nn} is planned with {n} tasks. How do you want to execute?
+
+   Manual mode:
+     You work through each task one by one, each in a fresh session.
+     After each task you can review the code, run tests, and decide
+     whether to continue. More control, but you need to be present.
+
+   Auto mode:
+     Claude runs all tasks autonomously in the background via claude -p.
+     Each task gets a fresh context window. UNIFY runs automatically
+     when all tasks are done. You can walk away and come back later.
+     Runs on your Max Plan — no extra API costs.
+     Downside: you can't intervene between tasks.
+
+   manual or auto?"
+
   → "manual" → delegate to /gsd-cc-apply
   → "auto" → delegate to /gsd-cc-auto
 ```
@@ -188,3 +205,21 @@ When the user confirms roadmap creation (after PLANNING.md exists):
    - Set `current_slice: S01`
    - Set `phase: roadmap-complete`
    - Update the Progress table with all slices as `pending`
+
+6. Instruct the user to start a fresh session:
+
+```
+✓ Roadmap created. {N} slices in M001.
+
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for planning:        │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll plan the first slice in detail.       │
+└─────────────────────────────────────────────┘
+```
+
+**Do NOT continue in this session.** Each phase gets a fresh context window.

package/skills/gsd/discuss/SKILL.md

@@ -128,17 +128,27 @@ Update the `phase` field in `.gsd/STATE.md`:
 phase: discuss-complete
 ```
 
-## Step 7: Confirm and Hand Off
+## Step 7: Confirm and End Session
 
 ```
-Discussion complete for S{nn}. {n} decisions captured.
+✓ Discussion complete for S{nn}. {n} decisions captured.
 
   .gsd/S{nn}-CONTEXT.md   — {n} decisions documented
   .gsd/DECISIONS.md        — updated
 
-Next: type /gsd-cc to plan this slice in detail.
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for planning:        │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll plan this slice using your decisions. │
+└─────────────────────────────────────────────┘
 ```
 
+**Do NOT continue in this session.** Each phase gets a fresh context window.
+
 ## When to Skip Discuss
 
 Discuss is optional. The `/gsd-cc` router may skip it if:

package/skills/gsd/ideate/SKILL.md

@@ -102,15 +102,25 @@ Before handing off to Seed, do a gentle reality check:
 When the user has a clear vision:
 
 ```
-Great — your idea is clear enough to start planning.
-
-Problem: {one sentence}
-Solution: {one sentence}
-Key insight: {what makes this different from existing solutions, if anything}
-
-Next step: /gsd-cc-seed to turn this into a structured project plan.
+✓ Ideation complete.
+
+  Problem: {one sentence}
+  Solution: {one sentence}
+  Key insight: {what makes this different from existing solutions, if anything}
+
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for Seed:            │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll structure your idea into a plan.      │
+└─────────────────────────────────────────────┘
 ```
 
+**Do NOT continue in this session.** Each phase gets a fresh context window.
+
 Write a brief `.gsd/IDEATION.md` capturing the key insights from this conversation:
 
 ```markdown

package/skills/gsd/plan/SKILL.md

@@ -235,10 +235,10 @@ current_task: T01
 phase: plan-complete
 ```
 
-## Step 8: Confirm
+## Step 8: Confirm and End Session
 
 ```
-Planning complete for S{nn}: {slice name}
+✓ Planning complete for S{nn}: {slice name}
 
   {n} tasks, {m} acceptance criteria
   Boundaries defined for all tasks
@@ -250,5 +250,15 @@ Planning complete for S{nn}: {slice name}
   ...
   Branch: gsd/M{n}/S{nn}
 
-Next: type /gsd-cc to execute. (manual or auto)
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for execution:       │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll ask: manual or auto?                  │
+└─────────────────────────────────────────────┘
 ```
+
+**Do NOT continue in this session.** The planning conversation consumes context window space. Execution needs a clean slate.

package/skills/gsd/seed/SKILL.md

@@ -177,17 +177,29 @@ Initialize from the STATE.md template with:
 ### Step 7: Confirm and Hand Off
 
 ```
-Ideation complete. I've created:
+✓ Seed complete.
+
   .gsd/PLANNING.md    — your full project brief
   .gsd/PROJECT.md     — project vision
   .gsd/type.json      — {type} / {rigor}
   .gsd/STATE.md       — initialized
   .gsd/DECISIONS.md   — {n} decisions logged
 
-Quality check passed. Your plan is ready for roadmapping.
-Next: type /gsd-cc to create the roadmap.
+  Quality check passed. Ready for roadmapping.
+
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for the next phase:  │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll create the roadmap from your plan.    │
+└─────────────────────────────────────────────┘
 ```
 
+**Do NOT continue in this session.** The seed conversation consumes context window space that the next phase doesn't need. A fresh session reads only what's needed from disk.
+
 ## Safety
 
 - **Check for existing .gsd/ first.** If it exists, warn the user: "A .gsd/ directory already exists. This will overwrite it. Continue?"

package/skills/gsd/unify/SKILL.md

@@ -215,10 +215,10 @@ unify_required: false
 
 Update the Progress table: set the current slice to `done` with AC counts.
 
-## Step 12: Confirm
+## Step 12: Confirm and End Session
 
 ```
-UNIFY complete for S{nn}.
+✓ UNIFY complete for S{nn}.
 
   Plan vs. Actual: {n} tasks — {summary}
   Acceptance Criteria: {passed}/{total} passed
@@ -230,5 +230,15 @@ UNIFY complete for S{nn}.
   Merged: gsd/M{n}/S{nn} → main
   Commit: feat(M{n}/S{nn}): {slice name}
 
-Next: type /gsd-cc to continue with the next slice.
+┌─────────────────────────────────────────────┐
+│  Start a fresh session for the next slice:  │
+│                                             │
+│  1. Exit this session                       │
+│  2. Run: claude                             │
+│  3. Type: /gsd-cc                           │
+│                                             │
+│  I'll pick up with the next slice.          │
+└─────────────────────────────────────────────┘
 ```
+
+**Do NOT continue in this session.** Each phase gets a fresh context window.