gsd-opencode 1.10.2 → 1.20.0

package/{commands/gsd → get-shit-done/workflows}/new-project.md

@@ -1,81 +1,71 @@
----
-name: gsd-new-project
-description: Initialize a new project with deep context gathering and PROJECT.md
-tools:
-  - read
-  - bash
-  - write
-
-  - question
----
+<purpose>
+Initialize a new project through unified flow: questioning, research (optional), requirements, roadmap. This is the most leveraged moment in any project — deep questioning here means better plans, better execution, better outcomes. One workflow takes you from idea to ready-for-planning.
+</purpose>
 
-<objective>
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
 
-Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.
+<auto_mode>
+## Auto Mode Detection
 
-This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes. One command takes you from idea to ready-for-planning.
+Check if `--auto` flag is present in $ARGUMENTS.
 
-**Creates:**
-- `.planning/PROJECT.md` — project context
-- `.planning/config.json` — workflow preferences
-- `.planning/research/` — domain research (optional)
-- `.planning/REQUIREMENTS.md` — scoped requirements
-- `.planning/ROADMAP.md` — phase structure
-- `.planning/STATE.md` — project memory
+**If auto mode:**
+- Skip brownfield mapping offer (assume greenfield)
+- Skip deep questioning (extract context from provided document)
+- Config: YOLO mode is implicit (skip that question), but ask depth/git/agents FIRST (Step 2a)
+- After config: run Steps 6-9 automatically with smart defaults:
+  - Research: Always yes
+  - Requirements: Include all table stakes + features from provided document
+  - Requirements approval: Auto-approve
+  - Roadmap approval: Auto-approve
 
-**After this command:** Run `/gsd-plan-phase 1` to start execution.
+**Document requirement:**
+Auto mode requires an idea document — either:
+- File reference: `/gsd-new-project --auto @prd.md`
+- Pasted/written text in the prompt
 
-</objective>
+If no document content provided, error:
 
-<execution_context>
+```
+Error: --auto requires an idea document.
 
-@~/.config/opencode/get-shit-done/references/questioning.md
-@~/.config/opencode/get-shit-done/references/ui-brand.md
-@~/.config/opencode/get-shit-done/templates/project.md
-@~/.config/opencode/get-shit-done/templates/requirements.md
+Usage:
+  /gsd-new-project --auto @your-idea.md
+  /gsd-new-project --auto [paste or write your idea here]
 
-</execution_context>
+The document should describe what you want to build.
+```
+</auto_mode>
 
 <process>
 
-## Phase 1: Setup
+## 1. Setup
 
 **MANDATORY FIRST STEP — Execute these checks before ANY user interaction:**
 
-1. **Abort if project exists:**
-   ```bash
-   [ -f .planning/PROJECT.md ] && echo "ERROR: Project already initialized. Use /gsd-progress" && exit 1
-   ```
+```bash
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs init new-project)
+```
 
-2. **Initialize git repo in THIS directory** (required even if inside a parent repo):
-   ```bash
-   if [ -d .git ] || [ -f .git ]; then
-       echo "Git repo exists in current directory"
-   else
-       git init
-       echo "Initialized new git repo"
-   fi
-   ```
+Parse JSON for: `researcher_model`, `synthesizer_model`, `roadmapper_model`, `commit_docs`, `project_exists`, `has_codebase_map`, `planning_exists`, `has_existing_code`, `has_package_file`, `is_brownfield`, `needs_codebase_map`, `has_git`, `project_path`.
 
-3. **Detect existing code (brownfield detection):**
-   ```bash
-   CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
-   HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] || [ -f Package.swift ] && echo "yes")
-   HAS_CODEBASE_MAP=$([ -d .planning/codebase ] && echo "yes")
-   ```
+**If `project_exists` is true:** Error — project already initialized. Use `/gsd-progress`.
 
-   **You MUST run all bash commands above using the bash tool before proceeding.**
+**If `has_git` is false:** Initialize git:
+```bash
+git init
+```
 
-## Phase 2: Brownfield Offer
+## 2. Brownfield Offer
 
-**If existing code detected and .planning/codebase/ doesn't exist:**
+**If auto mode:** Skip to Step 4 (assume greenfield, synthesize PROJECT.md from provided document).
 
-Check the results from setup step:
-- If `CODE_FILES` is non-empty OR `HAS_PACKAGE` is "yes"
-- AND `HAS_CODEBASE_MAP` is NOT "yes"
+**If `needs_codebase_map` is true** (from init — existing code detected but no codebase map):
 
 Use question:
-- header: "Existing Code"
+- header: "Codebase"
 - question: "I detected existing code in this directory. Would you like to map the codebase first?"
 - options:
   - "Map codebase first" — Run /gsd-map-codebase to understand existing architecture (Recommended)
@@ -87,11 +77,131 @@ Run `/gsd-map-codebase` first, then return to `/gsd-new-project`
 ```
 Exit command.
 
-**If "Skip mapping":** Continue to Phase 3.
+**If "Skip mapping" OR `needs_codebase_map` is false:** Continue to Step 3.
+
+## 2a. Auto Mode Config (auto mode only)
+
+**If auto mode:** Collect config settings upfront before processing the idea document.
+
+YOLO mode is implicit (auto = YOLO). Ask remaining config questions:
+
+**Round 1 — Core settings (3 questions, no Mode question):**
+
+```
+question([
+  {
+    header: "Depth",
+    question: "How thorough should planning be?",
+    multiSelect: false,
+    options: [
+      { label: "Quick (Recommended)", description: "Ship fast (3-5 phases, 1-3 plans each)" },
+      { label: "Standard", description: "Balanced scope and speed (5-8 phases, 3-5 plans each)" },
+      { label: "Comprehensive", description: "Thorough coverage (8-12 phases, 5-10 plans each)" }
+    ]
+  },
+  {
+    header: "Execution",
+    question: "Run plans in parallel?",
+    multiSelect: false,
+    options: [
+      { label: "Parallel (Recommended)", description: "Independent plans run simultaneously" },
+      { label: "Sequential", description: "One plan at a time" }
+    ]
+  },
+  {
+    header: "Git Tracking",
+    question: "Commit planning docs to git?",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Planning docs tracked in version control" },
+      { label: "No", description: "Keep .planning/ local-only (add to .gitignore)" }
+    ]
+  }
+])
+```
+
+**Round 2 — Workflow agents (same as Step 5):**
+
+```
+question([
+  {
+    header: "Research",
+    question: "Research before planning each phase? (adds tokens/time)",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Investigate domain, find patterns, surface gotchas" },
+      { label: "No", description: "Plan directly from requirements" }
+    ]
+  },
+  {
+    header: "Plan Check",
+    question: "Verify plans will achieve their goals? (adds tokens/time)",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Catch gaps before execution starts" },
+      { label: "No", description: "Execute plans without verification" }
+    ]
+  },
+  {
+    header: "Verifier",
+    question: "Verify work satisfies requirements after each phase? (adds tokens/time)",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Confirm deliverables match phase goals" },
+      { label: "No", description: "Trust execution, skip verification" }
+    ]
+  },
+  {
+    header: "AI Models",
+    question: "Which AI models for planning agents?",
+    multiSelect: false,
+    options: [
+      { label: "Smart (Recommended)", description: "Two models: one for reseach and planing, other for execution and verification" },
+      { label: "Simple", description: Description: "One model for all agents (not flexible)" },
+      { label: "Custom (most flexible)", description: "Three models: different for every stage" }
+    ]
+  }
+])
+```
+
+Create `.planning/config.json` with mode set to "yolo":
+
+```json
+{
+  "mode": "yolo",
+  "depth": "[selected]",
+  "parallelization": true|false,
+  "commit_docs": true|false,
+  "model_profile": "simple|smart|custom",
+  "workflow": {
+    "research": true|false,
+    "plan_check": true|false,
+    "verifier": true|false,
+    "auto_advance": true
+  }
+}
+```
+
+**If commit_docs = No:** Add `.planning/` to `.gitignore`.
+
+**Commit config.json:**
+
+```bash
+mkdir -p .planning
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "chore: add project config" --files .planning/config.json
+```
+
+**Persist auto-advance to config (survives context compaction):**
 
-**If no existing code detected OR codebase already mapped:** Continue to Phase 3.
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs config-set workflow.auto_advance true
+```
+
+Proceed to Step 4 (skip Steps 3 and 5).
 
-## Phase 3: Deep Questioning
+## 3. Deep Questioning
+
+**If auto mode:** Skip (already handled in Step 2a). Extract project context from provided document instead and proceed to Step 4.
 
 **Display stage banner:**
 
@@ -145,7 +255,9 @@ If "Keep exploring" — ask what they want to add, or identify gaps and probe na
 
 Loop until "Create PROJECT.md" selected.
 
-## Phase 4: write PROJECT.md
+## 4. write PROJECT.md
+
+**If auto mode:** Synthesize from provided document. No "Ready?" gate was shown — proceed directly to commit.
 
 Synthesize all context into `.planning/PROJECT.md` using the template from `templates/project.md`.
 
@@ -226,16 +338,32 @@ Do not compress. Capture everything gathered.
 
 ```bash
 mkdir -p .planning
-git add .planning/PROJECT.md
-git commit -m "$(cat <<'EOF'
-docs: initialize project
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: initialize project" --files .planning/PROJECT.md
+```
+
+## 5. Workflow Preferences
+
+**If auto mode:** Skip — config was collected in Step 2a. Proceed to Step 5.5.
 
-[One-liner from PROJECT.md What This Is section]
-EOF
-)"
+**Check for global defaults** at `~/.gsd/defaults.json`. If the file exists, offer to use saved defaults:
+
+```
+question([
+  {
+    question: "Use your saved default settings? (from ~/.gsd/defaults.json)",
+    header: "Defaults",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Use saved defaults, skip settings questions" },
+      { label: "No", description: "Configure settings manually" }
+    ]
+  }
+])
 ```
 
-## Phase 5: Workflow Preferences
+If "Yes": read `~/.gsd/defaults.json`, use those values for config.json, and skip directly to **Commit config.json** below.
+
+If "No" or `~/.gsd/defaults.json` doesn't exist: proceed with the questions below.
 
 **Round 1 — Core workflow settings (4 questions):**
 
@@ -323,13 +451,13 @@ questions: [
     ]
   },
   {
-    header: "Model Profile",
+    header: "AI Models",
     question: "Which AI models for planning agents?",
     multiSelect: false,
     options: [
-      { label: "Balanced", description: "planning/verifier: opencode/glm-4.7-free, execution: opencode/minimax-m2.1-free" },
-      { label: "Quality", description: "All stages: opencode/glm-4.7-free" },
-      { label: "Budget", description: "planning/verifier: opencode/minimax-m2.1-free, execution: opencode/grok-code" }
+      { label: "Smart (Recommended)", description: "Two models: one for reseach and planing, other for execution and verification" },
+      { label: "Simple", description: Description: "One model for all agents (not flexible)" },
+      { label: "Custom (most flexible)", description: "Three models: different for every stage" }
     ]
   }
 ]
@@ -343,32 +471,7 @@ Create `.planning/config.json` with all settings:
   "depth": "quick|standard|comprehensive",
   "parallelization": true|false,
   "commit_docs": true|false,
-  "model_profile": "quality|balanced|budget",
-  "profiles": {
-    "active_profile": "balanced",
-    "presets": {
-      "quality": {
-        "planning": "opencode/glm-4.7-free",
-        "execution": "opencode/glm-4.7-free",
-        "verification": "opencode/glm-4.7-free"
-      },
-      "balanced": {
-        "planning": "opencode/glm-4.7-free",
-        "execution": "opencode/minimax-m2.1-free",
-        "verification": "opencode/glm-4.7-free"
-      },
-      "budget": {
-        "planning": "opencode/minimax-m2.1-free",
-        "execution": "opencode/grok-code",
-        "verification": "opencode/minimax-m2.1-free"
-      }
-    },
-    "custom_overrides": {
-      "quality": {},
-      "balanced": {},
-      "budget": {}
-    }
-  },
+  "model_profile": "simple|smart|custom",
   "workflow": {
     "research": true|false,
     "plan_check": true|false,
@@ -387,81 +490,18 @@ Create `.planning/config.json` with all settings:
 **Commit config.json:**
 
 ```bash
-git add .planning/config.json
-git commit -m "$(cat <<'EOF'
-chore: add project config
-
-Mode: [chosen mode]
-Depth: [chosen depth]
-Parallelization: [enabled/disabled]
-Workflow agents: research=[on/off], plan_check=[on/off], verifier=[on/off]
-EOF
-)"
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "chore: add project config" --files .planning/config.json
 ```
 
-**Generate opencode.json from active profile:**
-
-Create `opencode.json` in the project root. This is a derived config that assigns a model to each GSD agent.
-
-Use the effective stage models from `.planning/config.json`:
-
-- planning model = `profiles.presets.{active_profile}.planning` (unless overridden)
-- execution model = `profiles.presets.{active_profile}.execution` (unless overridden)
-- verification model = `profiles.presets.{active_profile}.verification` (unless overridden)
-
-Write `opencode.json`:
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "agent": {
-    "gsd-planner": { "model": "{planning model}" },
-    "gsd-plan-checker": { "model": "{planning model}" },
-    "gsd-phase-researcher": { "model": "{planning model}" },
-    "gsd-roadmapper": { "model": "{planning model}" },
-    "gsd-project-researcher": { "model": "{planning model}" },
-    "gsd-research-synthesizer": { "model": "{planning model}" },
-    "gsd-codebase-mapper": { "model": "{planning model}" },
-    "gsd-executor": { "model": "{execution model}" },
-    "gsd-debugger": { "model": "{execution model}" },
-    "gsd-verifier": { "model": "{verification model}" },
-    "gsd-integration-checker": { "model": "{verification model}" }
-  }
-}
-```
-
-**Commit opencode.json:**
-
-```bash
-git add opencode.json
-git commit -m "chore: configure opencode agent models"
-```
-
-**Important:** OpenCode loads `opencode.json` at session start and does not hot-reload. If you change profiles later via `/gsd-set-profile` or `/gsd-settings`, run `/new` (or restart OpenCode) for it to take effect.
-
 **Note:** Run `/gsd-settings` anytime to update these preferences.
 
-## Phase 5.5: Resolve Model Profile
-
-read model profile for agent spawning:
-
-```bash
-MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
-```
-
-Default to "balanced" if not set.
+## 5.5. Resolve Model Profile
 
-**Model lookup table:**
+Use models from init: `researcher_model`, `synthesizer_model`, `roadmapper_model`.
 
-| Agent | quality | balanced | budget |
-|-------|---------|----------|--------|
-| gsd-project-researcher | opus | sonnet | haiku |
-| gsd-research-synthesizer | sonnet | sonnet | haiku |
-| gsd-roadmapper | opus | sonnet | sonnet |
+## 6. Research Decision
 
-Store resolved models for use in Task calls below.
-
-## Phase 6: Research Decision
+**If auto mode:** Default to "Research first" without asking.
 
 Use question:
 - header: "Research"
@@ -501,10 +541,11 @@ Display spawning indicator:
   → Pitfalls research
 ```
 
-Spawn 4 parallel gsd-project-researcher agents with rich context:
+Spawn 4 parallel gsd-project-researcher agents with path references:
 
 ```
-Task(prompt="
+task(prompt="First, read ~/.config/opencode/agents/gsd-project-researcher.md for your role and instructions.
+
 <research_type>
 Project Research — Stack dimension for [domain].
 </research_type>
@@ -520,9 +561,9 @@ Subsequent: Research what's needed to add [target features] to an existing [doma
 What's the standard 2025 stack for [domain]?
 </question>
 
-<project_context>
-[PROJECT.md summary - core value, constraints, what they're building]
-</project_context>
+<files_to_read>
+- {project_path} (Project context and goals)
+</files_to_read>
 
 <downstream_consumer>
 Your STACK.md feeds into roadmap creation. Be prescriptive:
@@ -541,9 +582,10 @@ Your STACK.md feeds into roadmap creation. Be prescriptive:
 write to: .planning/research/STACK.md
 Use template: ~/.config/opencode/get-shit-done/templates/research-project/STACK.md
 </output>
-", subagent_type="gsd-project-researcher", model="{researcher_model}", description="Stack research")
+", subagent_type="task", model="{researcher_model}", description="Stack research")
+
+task(prompt="First, read ~/.config/opencode/agents/gsd-project-researcher.md for your role and instructions.
 
-Task(prompt="
 <research_type>
 Project Research — Features dimension for [domain].
 </research_type>
@@ -559,9 +601,9 @@ Subsequent: How do [target features] typically work? What's expected behavior?
 What features do [domain] products have? What's table stakes vs differentiating?
 </question>
 
-<project_context>
-[PROJECT.md summary]
-</project_context>
+<files_to_read>
+- {project_path} (Project context)
+</files_to_read>
 
 <downstream_consumer>
 Your FEATURES.md feeds into requirements definition. Categorize clearly:
@@ -580,9 +622,10 @@ Your FEATURES.md feeds into requirements definition. Categorize clearly:
 write to: .planning/research/FEATURES.md
 Use template: ~/.config/opencode/get-shit-done/templates/research-project/FEATURES.md
 </output>
-", subagent_type="gsd-project-researcher", model="{researcher_model}", description="Features research")
+", subagent_type="task", model="{researcher_model}", description="Features research")
+
+task(prompt="First, read ~/.config/opencode/agents/gsd-project-researcher.md for your role and instructions.
 
-Task(prompt="
 <research_type>
 Project Research — Architecture dimension for [domain].
 </research_type>
@@ -598,9 +641,9 @@ Subsequent: How do [target features] integrate with existing [domain] architectu
 How are [domain] systems typically structured? What are major components?
 </question>
 
-<project_context>
-[PROJECT.md summary]
-</project_context>
+<files_to_read>
+- {project_path} (Project context)
+</files_to_read>
 
 <downstream_consumer>
 Your ARCHITECTURE.md informs phase structure in roadmap. Include:
@@ -619,9 +662,10 @@ Your ARCHITECTURE.md informs phase structure in roadmap. Include:
 write to: .planning/research/ARCHITECTURE.md
 Use template: ~/.config/opencode/get-shit-done/templates/research-project/ARCHITECTURE.md
 </output>
-", subagent_type="gsd-project-researcher", model="{researcher_model}", description="Architecture research")
+", subagent_type="task", model="{researcher_model}", description="Architecture research")
+
+task(prompt="First, read ~/.config/opencode/agents/gsd-project-researcher.md for your role and instructions.
 
-Task(prompt="
 <research_type>
 Project Research — Pitfalls dimension for [domain].
 </research_type>
@@ -637,9 +681,9 @@ Subsequent: What are common mistakes when adding [target features] to [domain]?
 What do [domain] projects commonly get wrong? Critical mistakes?
 </question>
 
-<project_context>
-[PROJECT.md summary]
-</project_context>
+<files_to_read>
+- {project_path} (Project context)
+</files_to_read>
 
 <downstream_consumer>
 Your PITFALLS.md prevents mistakes in roadmap/planning. For each pitfall:
@@ -658,24 +702,23 @@ Your PITFALLS.md prevents mistakes in roadmap/planning. For each pitfall:
 write to: .planning/research/PITFALLS.md
 Use template: ~/.config/opencode/get-shit-done/templates/research-project/PITFALLS.md
 </output>
-", subagent_type="gsd-project-researcher", model="{researcher_model}", description="Pitfalls research")
+", subagent_type="task", model="{researcher_model}", description="Pitfalls research")
 ```
 
 After all 4 agents complete, spawn synthesizer to create SUMMARY.md:
 
 ```
-Task(prompt="
+task(prompt="
 <task>
 Synthesize research outputs into SUMMARY.md.
 </task>
 
-<research_files>
-read these files:
+<files_to_read>
 - .planning/research/STACK.md
 - .planning/research/FEATURES.md
 - .planning/research/ARCHITECTURE.md
 - .planning/research/PITFALLS.md
-</research_files>
+</files_to_read>
 
 <output>
 write to: .planning/research/SUMMARY.md
@@ -700,9 +743,9 @@ Display research complete banner and key findings:
 Files: `.planning/research/`
 ```
 
-**If "Skip research":** Continue to Phase 7.
+**If "Skip research":** Continue to Step 7.
 
-## Phase 7: Define Requirements
+## 7. Define Requirements
 
 Display stage banner:
 ```
@@ -720,7 +763,16 @@ read PROJECT.md and extract:
 
 **If research exists:** read research/FEATURES.md and extract feature categories.
 
-**Present features by category:**
+**If auto mode:**
+- Auto-include all table stakes features (users expect these)
+- Include features explicitly mentioned in provided document
+- Auto-defer differentiators not mentioned in document
+- Skip per-category question loops
+- Skip "Any additions?" question
+- Skip requirements approval gate
+- Generate REQUIREMENTS.md and commit directly
+
+**Present features by category (interactive mode only):**
 
 ```
 Here are the features for [domain]:
@@ -758,7 +810,7 @@ For each capability mentioned:
 
 For each category, use question:
 
-- header: "[Category name]"
+- header: "[Category]" (max 12 chars)
 - question: "Which [category] features are in v1?"
 - multiSelect: true
 - options:
@@ -807,7 +859,7 @@ Reject vague requirements. Push for specificity:
 - "Handle authentication" → "User can log in with email/password and stay logged in across sessions"
 - "Support sharing" → "User can share post via link that opens in recipient's browser"
 
-**Present full requirements list:**
+**Present full requirements list (interactive mode only):**
 
 Show every requirement (not counts) for user confirmation:
 
@@ -835,17 +887,10 @@ If "adjust": Return to scoping.
 **Commit requirements:**
 
 ```bash
-git add .planning/REQUIREMENTS.md
-git commit -m "$(cat <<'EOF'
-docs: define v1 requirements
-
-[X] requirements across [N] categories
-[Y] requirements deferred to v2
-EOF
-)"
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: define v1 requirements" --files .planning/REQUIREMENTS.md
 ```
 
-## Phase 8: Create Roadmap
+## 8. Create Roadmap
 
 Display stage banner:
 ```
@@ -856,23 +901,18 @@ Display stage banner:
 ◆ Spawning roadmapper...
 ```
 
-Spawn gsd-roadmapper agent with context:
+Spawn gsd-roadmapper agent with path references:
 
 ```
-Task(prompt="
+task(prompt="
 <planning_context>
 
-**Project:**
-@.planning/PROJECT.md
-
-**Requirements:**
-@.planning/REQUIREMENTS.md
-
-**Research (if exists):**
-@.planning/research/SUMMARY.md
-
-**Config:**
-@.planning/config.json
+<files_to_read>
+- .planning/PROJECT.md (Project context)
+- .planning/REQUIREMENTS.md (v1 Requirements)
+- .planning/research/SUMMARY.md (Research findings - if exists)
+- .planning/config.json (Depth and mode settings)
+</files_to_read>
 
 </planning_context>
 
@@ -937,7 +977,9 @@ Success criteria:
 ---
 ```
 
-**CRITICAL: Ask for approval before committing:**
+**If auto mode:** Skip approval gate — auto-approve and commit directly.
+
+**CRITICAL: Ask for approval before committing (interactive mode only):**
 
 Use question:
 - header: "Roadmap"
@@ -953,12 +995,14 @@ Use question:
 - Get user's adjustment notes
 - Re-spawn roadmapper with revision context:
   ```
-  Task(prompt="
+  task(prompt="
   <revision>
   User feedback on roadmap:
   [user's notes]
 
-  Current ROADMAP.md: @.planning/ROADMAP.md
+  <files_to_read>
+  - .planning/ROADMAP.md (Current roadmap to revise)
+  </files_to_read>
 
   Update the roadmap based on feedback. edit files in place.
   Return ROADMAP REVISED with changes made.
@@ -970,26 +1014,15 @@ Use question:
 
 **If "Review full file":** Display raw `cat .planning/ROADMAP.md`, then re-ask.
 
-**Commit roadmap (after approval):**
+**Commit roadmap (after approval or auto mode):**
 
 ```bash
-git add .planning/ROADMAP.md .planning/STATE.md .planning/REQUIREMENTS.md
-git commit -m "$(cat <<'EOF'
-docs: create roadmap ([N] phases)
-
-Phases:
-1. [phase-name]: [requirements covered]
-2. [phase-name]: [requirements covered]
-...
-
-All v1 requirements mapped to phases.
-EOF
-)"
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: create roadmap ([N] phases)" --files .planning/ROADMAP.md .planning/STATE.md .planning/REQUIREMENTS.md
 ```
 
-## Phase 10: Done
+## 9. Done
 
-Present completion with next steps:
+Present completion summary:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -1007,7 +1040,21 @@ Present completion with next steps:
 | Roadmap        | `.planning/ROADMAP.md`      |
 
 **[N] phases** | **[X] requirements** | Ready to build ✓
+```
+
+**If auto mode:**
 
+```
+╔══════════════════════════════════════════╗
+║  AUTO-ADVANCING → DISCUSS PHASE 1        ║
+╚══════════════════════════════════════════╝
+```
+
+Exit skill and invoke command("/gsd-discuss-phase 1 --auto")
+
+**If interactive mode:**
+
+```
 ───────────────────────────────────────────────────────────────
 
 ## ▶ Next Up