gsd-cc 1.5.6 → 1.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-cc",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "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/auto/SKILL.md

@@ -4,7 +4,7 @@ description: >
   Start auto-mode. Dispatches tasks via claude -p in fresh sessions.
   Use when user says /gsd-cc-auto, /gsd-cc auto, or chooses "auto" when
   /gsd-cc offers manual vs. auto execution.
-allowed-tools: Read, Write, Bash, Glob
+allowed-tools: Read, Write, Bash, Glob, AskUserQuestion
 ---
 
 # /gsd-cc-auto — Auto-Mode
@@ -36,11 +36,12 @@ command -v jq
 ```
 If not: "jq is required for auto-mode. Install with: `brew install jq`"
 
-### claude -p works
+### claude CLI is available
 ```bash
-claude -p "echo test" --output-format json --max-turns 1
+command -v claude || which claude
 ```
-If fails: "claude -p is not working. Make sure Claude Code is installed and you're logged in with a Max plan."
+If not found: "claude CLI is not installed. Make sure Claude Code is installed and in your PATH."
+Note: The auto-loop.sh script resolves the full path to claude automatically, so PATH issues in subprocesses are handled.
 
 ### No stale lock file
 ```
@@ -71,12 +72,20 @@ Auto-mode ready.
 
 ## Step 3: Ask for Budget (Optional)
 
+Use AskUserQuestion:
+
 ```
-Set a token budget? (Enter a number, or press Enter for unlimited)
+Question: "Token-Budget setzen?"
+Header: "Budget"
+Options:
+  - label: "Unlimited (Recommended)"
+    description: "No token limit — auto-mode runs until the slice/milestone is done."
+  - label: "Set a budget"
+    description: "Limit total token usage. You'll be asked for the number."
 ```
 
-If the user provides a number, pass it as `--budget`.
-If they press Enter or say "no", no budget limit.
+→ "Unlimited" → no budget limit, proceed to Step 4
+→ "Set a budget" → ask user for the number (via AskUserQuestion with "Other" or text input), pass as `--budget`
 
 ## Step 4: Start auto-loop.sh
 

package/skills/auto/auto-loop.sh

@@ -7,6 +7,32 @@
 
 set -euo pipefail
 
+# ── macOS compatibility: timeout shim ─────────────────────────────────────────
+
+if ! command -v timeout &>/dev/null; then
+  if command -v gtimeout &>/dev/null; then
+    timeout() { gtimeout "$@"; }
+  else
+    # Fallback: ignore timeout, just run the command directly
+    timeout() { shift; "$@"; }
+  fi
+fi
+
+# ── Resolve claude CLI path ───────────────────────────────────────────────────
+
+CLAUDE_BIN="$(command -v claude 2>/dev/null || true)"
+if [[ -z "$CLAUDE_BIN" ]]; then
+  # Common locations
+  for p in "/opt/homebrew/bin/claude" "/usr/local/bin/claude" "$HOME/.claude/bin/claude"; do
+    [[ -x "$p" ]] && CLAUDE_BIN="$p" && break
+  done
+fi
+
+if [[ -z "$CLAUDE_BIN" ]]; then
+  echo "❌ claude CLI not found. Install Claude Code first."
+  exit 1
+fi
+
 # ── Configuration ──────────────────────────────────────────────────────────────
 
 GSD_DIR=".gsd"
@@ -36,11 +62,6 @@ done
 
 # ── Prerequisites ──────────────────────────────────────────────────────────────
 
-if ! command -v claude &>/dev/null; then
-  echo "❌ claude CLI not found. Install Claude Code first."
-  exit 1
-fi
-
 if ! command -v jq &>/dev/null; then
   echo "❌ jq not found. Install with: brew install jq"
   exit 1
@@ -51,6 +72,16 @@ if [[ ! -f "$GSD_DIR/STATE.md" ]]; then
   exit 1
 fi
 
+# Validate required STATE.md fields
+for field in milestone current_slice current_task phase rigor; do
+  val=$(grep "^$field:" "$GSD_DIR/STATE.md" | head -1 | sed "s/^$field:[[:space:]]*//" || true)
+  if [[ -z "$val" || "$val" == "—" ]]; then
+    echo "❌ STATE.md is missing required field: $field"
+    echo "   Run /gsd-cc to fix project state before starting auto-mode."
+    exit 1
+  fi
+done
+
 # ── Cleanup trap ───────────────────────────────────────────────────────────────
 
 cleanup() {
@@ -81,6 +112,24 @@ log_cost() {
   fi
 }
 
+# Find the next slice that needs work (no PLAN or no UNIFY)
+# Returns slice name (e.g. "S03") or empty if milestone is complete
+find_next_slice() {
+  local roadmap
+  roadmap=$(ls "$GSD_DIR"/M*-ROADMAP.md 2>/dev/null | head -1)
+  if [[ -z "$roadmap" ]]; then
+    return
+  fi
+
+  # Extract slice IDs from roadmap (### S01, ### S02, etc.)
+  grep -oE '### S[0-9]+' "$roadmap" | sed 's/### //' | while read -r slice; do
+    if [[ ! -f "$GSD_DIR/${slice}-UNIFY.md" ]]; then
+      echo "$slice"
+      return
+    fi
+  done
+}
+
 # ── Main loop ──────────────────────────────────────────────────────────────────
 
 echo "▶ GSD-CC Auto-Mode starting..."
@@ -143,7 +192,7 @@ while true; do
       cat "$PROMPTS_DIR/unify-instructions.txt" >> "$PROMPT_FILE"
 
       RESULT_FILE="/tmp/gsd-result-$$.json"
-      timeout 600 claude -p "$(cat "$PROMPT_FILE")" \
+      timeout 600 "$CLAUDE_BIN" -p "$(cat "$PROMPT_FILE")" \
         --allowedTools "Read,Write,Edit,Glob,Grep,Bash(git checkout *),Bash(git merge *),Bash(git commit *)" \
         --output-format json \
         --max-turns 15 > "$RESULT_FILE" 2>/dev/null || {
@@ -161,29 +210,28 @@ while true; do
 
   # Check if milestone is complete (all slices unified)
   if [[ "$PHASE" == "unified" ]]; then
-    # Check roadmap for remaining slices
-    NEXT_RESULT=$(claude -p "Read .gsd/STATE.md and all .gsd/M*-ROADMAP.md and .gsd/S*-UNIFY.md files. Determine the next slice that needs work (no PLAN.md or no UNIFY.md). Output ONLY valid JSON: {\"slice\":\"S01\",\"phase\":\"plan\"} or {\"done\":true} if all slices are unified." \
-      --allowedTools "Read,Glob" \
-      --output-format json --max-turns 3 2>/dev/null) || {
-      echo "❌ Failed to determine next unit."
-      break
-    }
-
-    NEXT=$(echo "$NEXT_RESULT" | jq -r '.result // empty' 2>/dev/null || echo "$NEXT_RESULT")
+    NEXT_SLICE=$(find_next_slice)
 
-    if echo "$NEXT" | jq -e '.done' > /dev/null 2>&1; then
+    if [[ -z "$NEXT_SLICE" ]]; then
       echo ""
       echo "✅ Milestone $MILESTONE complete. All slices planned, executed, and unified."
       break
     fi
 
-    SLICE=$(echo "$NEXT" | jq -r '.slice')
-    PHASE=$(echo "$NEXT" | jq -r '.phase')
+    SLICE="$NEXT_SLICE"
     TASK="T01"
 
+    # Determine phase for next slice
+    if [[ -f "$GSD_DIR/${SLICE}-PLAN.md" ]]; then
+      PHASE="plan-complete"
+    else
+      PHASE="plan"
+    fi
+
     update_state_field "current_slice" "$SLICE"
     update_state_field "phase" "$PHASE"
     update_state_field "current_task" "$TASK"
+    echo "▶ Moving to next slice: $SLICE ($PHASE)"
   fi
 
   # ── 4. Budget check ────────────────────────────────────────────────────────
@@ -272,7 +320,7 @@ while true; do
     ALLOWED_TOOLS="Read,Write,Edit,Glob,Grep,Bash(npm *),Bash(npx *),Bash(git add *),Bash(git commit *),Bash(node *),Bash(python3 *)"
   fi
 
-  timeout "$TIMEOUT" claude -p "$(cat "$PROMPT_FILE")" \
+  timeout "$TIMEOUT" "$CLAUDE_BIN" -p "$(cat "$PROMPT_FILE")" \
     --allowedTools "$ALLOWED_TOOLS" \
     --output-format json \
     --max-turns "$MAX_TURNS" > "$RESULT_FILE" 2>/dev/null || {

package/skills/config/SKILL.md

@@ -4,7 +4,7 @@ description: >
   Change GSD-CC settings like language. Updates CLAUDE.md so changes
   take effect immediately. Use when user says /gsd-cc-config, wants to
   change language, or asks about GSD-CC settings.
-allowed-tools: Read, Write, Edit, Glob
+allowed-tools: Read, Write, Edit, Glob, AskUserQuestion
 ---
 
 # /gsd-cc-config — Settings

package/skills/discuss/SKILL.md

@@ -5,7 +5,7 @@ description: >
   captures implementation decisions, and writes CONTEXT.md. Use when
   /gsd-cc routes here, when user says /gsd-cc-discuss, or before planning a
   slice that has ambiguous requirements.
-allowed-tools: Read, Write, Edit, Glob, Grep
+allowed-tools: Read, Write, Edit, Glob, Grep, AskUserQuestion
 ---
 
 # /gsd-cc-discuss — Implementation Decisions
@@ -60,9 +60,18 @@ Not every category applies to every slice. Focus on what's relevant.
 For each gray area you identify:
 
 1. **State the ambiguity clearly** — "The slice says 'user list' but doesn't specify: paginated table or infinite scroll? How many users are expected?"
-2. **Offer concrete options** — "Option A: paginated table (simpler, better for large lists). Option B: infinite scroll (smoother UX, more complex)."
-3. **Wait for the user's decision**
-4. **Confirm and move on** — "Got it: paginated table, 25 per page."
+2. **Use AskUserQuestion to present concrete options** — Build the options dynamically based on the gray area. Example:
+   ```
+   Question: "User list: how should it handle large datasets?"
+   Header: "UI"
+   Options:
+     - label: "Paginated table (Recommended)"
+       description: "Simpler, better for large lists. Classic table with page controls."
+     - label: "Infinite scroll"
+       description: "Smoother UX, more complex to implement. Loads more items as user scrolls."
+   ```
+   Always put your recommendation first with "(Recommended)" in the label.
+3. **Confirm and move on** — "Got it: paginated table, 25 per page."
 
 **Rules:**
 - One gray area at a time. Don't dump all questions at once.

package/skills/gsd-cc/SKILL.md

@@ -5,7 +5,7 @@ description: >
   next action. Use when user types /gsd-cc, mentions project planning,
   milestones, slices, or tasks. Also triggers when no .gsd/ exists
   and user wants to start a new project.
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
 ---
 
 # /gsd-cc — Main Router
@@ -50,20 +50,22 @@ IF .gsd/auto.lock exists:
 ### No Project
 ```
 IF .gsd/ does not exist:
-  → Present three starting points:
+  → Use AskUserQuestion to present starting points:
 
-  "No project found. How do you want to start?
+  Question: "No project found. How do you want to start?"
+  Header: "Start"
+  Options:
+    - label: "Explore an idea"
+      description: "I have a vague idea or a problem — let's explore it together"
+    - label: "Plan a project"
+      description: "I know what I want to build — let's plan it"
+    - label: "Import a document"
+      description: "I have an existing concept document — import it"
 
-   1) I have a vague idea or a problem — let's explore it together
-   2) I know what I want to build — let's plan it
-   3) I have an existing concept document — import it
-
-   Or just describe what's on your mind."
-
-  → "1" or signals uncertainty → delegate to /gsd-cc-ideate
-  → "2" or clear project description → delegate to /gsd-cc-seed
-  → "3" or mentions a document/file/spec → delegate to /gsd-cc-ingest
-  → If they just describe their project → delegate to /gsd-cc-seed with their description
+  → "Explore an idea" → delegate to /gsd-cc-ideate
+  → "Plan a project" or clear project description → delegate to /gsd-cc-seed
+  → "Import a document" or mentions a document/file/spec → delegate to /gsd-cc-ingest
+  → If user selects "Other" and describes their project → delegate to /gsd-cc-seed with their description
 ```
 
 ### Seed Done, No Stack
@@ -91,44 +93,22 @@ 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:
-  → Present the three execution modes with clear pros/cons:
-
-  "S{nn} is planned with {n} tasks. How do you want to execute?
-
-   1) Manual
-      You work through each task one by one, each in a fresh session.
-      + Full control — review code, run tests, adjust after each task
-      + You see exactly what happens
-      - You need to be present for every task
-      - Slowest option
-      Best for: critical slices, learning the codebase, first-time users
-
-   2) Auto (this slice)                              ← recommended
-      Claude runs all {n} tasks in this slice autonomously.
-      UNIFY runs automatically when done.
-      Before the NEXT slice, you're back for Discuss + Plan.
-      + Tasks run in the background — go grab a coffee
-      + You still decide the direction for every slice
-      + Best balance of speed and control
-      - You can't intervene between tasks within this slice
-      Best for: most situations — you decide WHAT, Claude does the HOW
-
-   3) Auto (full milestone)
-      Claude runs everything autonomously: plan, execute, UNIFY,
-      next slice, repeat — until the milestone is done.
-      Discuss is skipped. Claude makes all detail decisions.
-      + Fastest — walk away, come back when it's done
-      + Great for well-defined projects with tight rigor
-      - No input from you between slices
-      - Claude may make wrong assumptions in detail planning
-      - Higher risk of going in an unwanted direction
-      Best for: small/clear projects, utility tools, tight rigor
-
-   1, 2, or 3?"
-
-  → "1" or "manual" → delegate to /gsd-cc-apply
-  → "2" or "auto" → delegate to /gsd-cc-auto (slice mode)
-  → "3" or "full auto":
+  → First print: "S{nn} is planned with {n} tasks."
+  → Then use AskUserQuestion to present execution modes:
+
+  Question: "How do you want to execute?"
+  Header: "Mode"
+  Options:
+    - label: "Auto (this slice) (Recommended)"
+      description: "Claude runs all tasks autonomously. UNIFY runs after. You decide direction for every slice. Best balance of speed and control."
+    - label: "Manual"
+      description: "You work through each task one by one in fresh sessions. Full control — review code, run tests, adjust after each task."
+    - label: "Auto (full milestone)"
+      description: "Claude does everything autonomously: plan, execute, UNIFY, next slice, repeat. Fastest, but no input from you between slices."
+
+  → "Manual" → delegate to /gsd-cc-apply
+  → "Auto (this slice)" → delegate to /gsd-cc-auto (slice mode)
+  → "Auto (full milestone)":
     Check if .gsd/PROFILE.md exists.
     If NOT: "Full auto needs a decision profile so Claude can make
     decisions on your behalf. Run /gsd-cc-profile first (15-25 min).

package/skills/stack/SKILL.md

@@ -6,7 +6,7 @@ description: >
   beginners, debates with experts. Use when /gsd-cc routes here
   after seed, when user says /gsd-cc-stack, or when tech decisions
   need to be made.
-allowed-tools: Read, Write, Edit, Glob, WebSearch
+allowed-tools: Read, Write, Edit, Glob, WebSearch, AskUserQuestion
 ---
 
 # /gsd-cc-stack — Tech Stack Discussion
@@ -61,31 +61,32 @@ Let's start with the basics.
 Then go through each layer, one at a time:
 
 **Language / Runtime:**
-```
-First: what programming language should this be written in?
-
-For your project, I'd recommend {language} because {reason in plain
-language — e.g. "it's the most common for web apps, which means
-more examples and help available online"}.
-
-Another option would be {alternative} — {one sentence tradeoff}.
 
-My recommendation: {language}. Sound good?
+Briefly explain what a programming language choice means, then use AskUserQuestion:
 ```
-
-**Framework:**
+Question: "Which programming language?"
+Header: "Language"
+Options:
+  - label: "{language} (Recommended)"
+    description: "{reason in plain language — e.g. 'Most common for web apps, more examples and help available online'}"
+  - label: "{alternative}"
+    description: "{one sentence tradeoff}"
 ```
-Next: the framework — this is like the blueprint style for your app.
 
-{Framework} is a good fit because {reason}.
-It's {popular/stable/fast/beginner-friendly/...}.
-
-{Alternative} would also work — {tradeoff in plain language}.
+**Framework:**
 
-My recommendation: {framework}. What do you think?
+Briefly explain what a framework is, then use AskUserQuestion:
+```
+Question: "Which framework?"
+Header: "Framework"
+Options:
+  - label: "{framework} (Recommended)"
+    description: "{reason — popular/stable/fast/beginner-friendly/...}"
+  - label: "{alternative}"
+    description: "{tradeoff in plain language}"
 ```
 
-Continue for: Database, Styling, Hosting/Deployment, Authentication (if needed), and any project-specific tools.
+Continue for: Database, Styling, Hosting/Deployment, Authentication (if needed), and any project-specific tools. Always use AskUserQuestion for each decision.
 
 ### For advanced users:
 
@@ -100,12 +101,9 @@ performance needs, team size, deployment constraints, etc.}
 Here's what I'd start with and why — push back wherever you disagree.
 ```
 
-Then present your recommendations with honest tradeoffs. Expect debate. If they have unconventional preferences, explore them seriously:
+Then for each stack layer, present your analysis briefly and use AskUserQuestion with your recommendation and alternatives. Expect debate — if the user selects "Other" with an unconventional choice, explore it seriously:
 
-```
-Interesting — you want to use {unusual choice}. Most people would
-reach for {conventional choice} here. What's your reasoning?
-```
+"Interesting — you want to use {unusual choice}. Most people would reach for {conventional choice} here. What's your reasoning?"
 
 If their reasoning is sound, support it. If it's risky, explain the risk honestly but don't override them.