gsd-opencode 1.22.1 → 1.33.0

package/commands/gsd/gsd-autonomous.md

@@ -0,0 +1,45 @@
+---
+name: gsd-autonomous
+description: Run all remaining phases autonomously — discuss→plan→execute per phase
+argument-hint: "[--from N] [--to N] [--only N] [--interactive]"
+permissions:
+   read: true
+   write: true
+   bash: true
+   glob: true
+   grep: true
+   question: true
+   task: true
+---
+<objective>
+Execute all remaining milestone phases autonomously. For each phase: discuss → plan → execute. Pauses only for user decisions (grey area acceptance, blockers, validation requests).
+
+Uses ROADMAP.md phase discovery and skill() flat invocations for each phase command. After all phases complete: milestone audit → complete → cleanup.
+
+**Creates/Updates:**
+- `.planning/STATE.md` — updated after each phase
+- `.planning/ROADMAP.md` — progress updated after each phase
+- Phase artifacts — CONTEXT.md, PLANs, SUMMARYs per phase
+
+**After:** Milestone is complete and cleaned up.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/autonomous.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+Optional flags:
+- `--from N` — start from phase N instead of the first incomplete phase.
+- `--to N` — stop after phase N completes (halt instead of advancing to next phase).
+- `--only N` — execute only phase N (single-phase mode).
+- `--interactive` — run discuss inline with questions (not auto-answered), then dispatch plan→execute as background agents. Keeps the main context lean while preserving user input on decisions.
+
+Project context, phase list, and state are resolved inside the workflow using init commands (`gsd-tools.cjs init milestone-op`, `gsd-tools.cjs roadmap analyze`). No upfront context loading needed.
+</context>
+
+<process>
+Execute the autonomous workflow from @$HOME/.config/opencode/get-shit-done/workflows/autonomous.md end-to-end.
+Preserve all workflow gates (phase discovery, per-phase execution, blocker handling, progress display).
+</process>

package/commands/gsd/gsd-cleanup.md

@@ -1,6 +1,11 @@
 ---
 name: gsd-cleanup
 description: Archive accumulated phase directories from completed milestones
+permissions:
+   read: true
+   write: true
+   bash: true
+   question: true
 ---
 <objective>
 Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`.

package/commands/gsd/gsd-debug.md

@@ -1,7 +1,7 @@
 ---
 name: gsd-debug
 description: Systematic debugging with persistent state across context resets
-argument-hint: [issue description]
+argument-hint: [--diagnose] [issue description]
 permissions:
    read: true
    bash: true
@@ -15,11 +15,23 @@ Debug issues using scientific method with subagent isolation.
 **Orchestrator role:** Gather symptoms, spawn gsd-debugger agent, handle checkpoints, spawn continuations.
 
 **Why subagent:** Investigation burns context fast (reading files, forming hypotheses, testing). Fresh 200k context per investigation. Main context stays lean for user interaction.
+
+**Flags:**
+- `--diagnose` — Diagnose only. Find root cause without applying a fix. Returns a structured Root Cause Report. Use when you want to validate the diagnosis before committing to a fix.
 </objective>
 
+<available_agent_types>
+Valid GSD subagent types (use exact names — do not fall back to 'general'):
+- gsd-debugger — Diagnoses and fixes issues
+</available_agent_types>
+
 <context>
 User's issue: $ARGUMENTS
 
+Parse flags from $ARGUMENTS:
+- If `--diagnose` is present, set `diagnose_only=true` and remove the flag from the issue description.
+- Otherwise, `diagnose_only=false`.
+
 Check for active sessions:
 ```bash
 ls .planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
@@ -82,7 +94,7 @@ timeline: {timeline}
 
 <mode>
 symptoms_prefilled: true
-goal: find_and_fix
+goal: {if diagnose_only: "find_root_cause_only", else: "find_and_fix"}
 </mode>
 
 <debug_file>
@@ -91,22 +103,23 @@ Create: .planning/debug/{slug}.md
 ```
 
 ```
-task(
-  prompt=filled_prompt,
-  subagent_type="gsd-debugger",
-  model="{debugger_model}",
-  description="Debug {slug}"
-)
+@gsd-debugger filled_prompt
 ```
 
 ## 4. Handle Agent Return
 
-**If `## ROOT CAUSE FOUND`:**
-- Display root cause and evidence summary
+**If `## ROOT CAUSE FOUND` (diagnose-only mode):**
+- Display root cause, confidence level, files involved, and suggested fix strategies
+- Offer options:
+  - "Fix now" — spawn a continuation agent with `goal: find_and_fix` to apply the fix (see step 5)
+  - "Plan fix" — suggest `/gsd-plan-phase --gaps`
+  - "Manual fix" — done
+
+**If `## DEBUG COMPLETE` (find_and_fix mode):**
+- Display root cause and fix summary
 - Offer options:
-  - "Fix now" - spawn fix subagent
-  - "Plan fix" - suggest /gsd-plan-phase --gaps
-  - "Manual fix" - done
+  - "Plan fix" — suggest `/gsd-plan-phase --gaps` if further work needed
+  - "Done" — mark resolved
 
 **If `## CHECKPOINT REACHED`:**
 - Present checkpoint details to user
@@ -123,9 +136,9 @@ task(
   - "Manual investigation" - done
   - "Add more context" - gather more symptoms, spawn again
 
-## 5. Spawn Continuation Agent (After Checkpoint)
+## 5. Spawn Continuation Agent (After Checkpoint or "Fix now")
 
-When user responds to checkpoint, spawn fresh agent:
+When user responds to checkpoint OR selects "Fix now" from diagnose-only results, spawn fresh agent:
 
 ```markdown
 <objective>
@@ -149,12 +162,7 @@ goal: find_and_fix
 ```
 
 ```
-task(
-  prompt=continuation_prompt,
-  subagent_type="gsd-debugger",
-  model="{debugger_model}",
-  description="Continue debug {slug}"
-)
+@gsd-debugger continuation_prompt
 ```
 
 </process>

package/commands/gsd/gsd-discuss-phase.md

@@ -1,7 +1,7 @@
 ---
 name: gsd-discuss-phase
-description: Gather phase context through adaptive questioning before planning
-argument-hint: "<phase> [--auto]"
+description: Gather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (OpenCode picks recommended defaults). Use --chain for interactive discuss followed by automatic plan+execute. Use --power for bulk question generation into a file-based UI (answer at your own pace).
+argument-hint: "<phase> [--auto] [--chain] [--batch] [--analyze] [--text] [--power]"
 permissions:
    read: true
    write: true
@@ -30,9 +30,15 @@ Extract implementation decisions that downstream agents need — researcher and
 
 <execution_context>
 @$HOME/.config/opencode/get-shit-done/workflows/discuss-phase.md
+@$HOME/.config/opencode/get-shit-done/workflows/discuss-phase-assumptions.md
+@$HOME/.config/opencode/get-shit-done/workflows/discuss-phase-power.md
 @$HOME/.config/opencode/get-shit-done/templates/context.md
 </execution_context>
 
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
 <context>
 Phase number: $ARGUMENTS (required)
 
@@ -40,43 +46,16 @@ Context files are resolved in-workflow using `init phase-op` and roadmap/state t
 </context>
 
 <process>
-1. Validate phase number (error if missing or not in roadmap)
-2. Check if CONTEXT.md exists (offer update/view/skip if yes)
-3. **Load prior context** — read PROJECT.md, REQUIREMENTS.md, STATE.md, and all prior CONTEXT.md files
-4. **Scout codebase** — Find reusable assets, patterns, and integration points
-5. **Analyze phase** — Check prior decisions, skip already-decided areas, generate remaining gray areas
-6. **Present gray areas** — Multi-select: which to discuss? Annotate with prior decisions + code context
-7. **Deep-dive each area** — 4 questions per area, code-informed options, Context7 for library choices
-8. **write CONTEXT.md** — Sections match areas discussed + code_context section
-9. Offer next steps (research or plan)
-
-**CRITICAL: Scope guardrail**
-- Phase boundary from ROADMAP.md is FIXED
-- Discussion clarifies HOW to implement, not WHETHER to add more
-- If user suggests new capabilities: "That's its own phase. I'll note it for later."
-- Capture deferred ideas — don't lose them, don't act on them
-
-**Domain-aware gray areas:**
-Gray areas depend on what's being built. Analyze the phase goal:
-- Something users SEE → layout, density, interactions, states
-- Something users CALL → responses, errors, auth, versioning
-- Something users RUN → output format, flags, modes, error handling
-- Something users READ → structure, tone, depth, flow
-- Something being ORGANIZED → criteria, grouping, naming, exceptions
+**Mode routing:**
+```bash
+DISCUSS_MODE=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" config-get workflow.discuss_mode 2>/dev/null || echo "discuss")
+```
 
-Generate 3-4 **phase-specific** gray areas, not generic categories.
+If `DISCUSS_MODE` is `"assumptions"`: read and execute @$HOME/.config/opencode/get-shit-done/workflows/discuss-phase-assumptions.md end-to-end.
 
-**Probing depth:**
-- Ask 4 questions per area before checking
-- "More questions about [area], or move to next?"
-- If more → ask 4 more, check again
-- After all areas → "Ready to create context?"
+If `DISCUSS_MODE` is `"discuss"` (or unset, or any other value): read and execute @$HOME/.config/opencode/get-shit-done/workflows/discuss-phase.md end-to-end.
 
-**Do NOT ask about (OpenCode handles these):**
-- Technical implementation
-- Architecture choices
-- Performance concerns
-- Scope expansion
+**MANDATORY:** The execution_context files listed above ARE the instructions. read the workflow file BEFORE taking any action. The objective and success_criteria sections in this command file are summaries — the workflow file contains the complete step-by-step process with all required behaviors, config checks, and interaction patterns. Do not improvise from the summary.
 </process>
 
 <success_criteria>

package/commands/gsd/gsd-do.md

@@ -0,0 +1,30 @@
+---
+name: gsd-do
+description: Route freeform text to the right GSD command automatically
+argument-hint: "<description of what you want to do>"
+permissions:
+   read: true
+   bash: true
+   question: true
+---
+<objective>
+Analyze freeform natural language input and dispatch to the most appropriate GSD command.
+
+Acts as a smart dispatcher — never does the work itself. Matches intent to the best GSD command using routing rules, confirms the match, then hands off.
+
+Use when you know what you want but don't know which `/gsd-*` command to run.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/do.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the do workflow from @$HOME/.config/opencode/get-shit-done/workflows/do.md end-to-end.
+Route user intent to the best GSD command and invoke it.
+</process>

package/commands/gsd/gsd-docs-update.md

@@ -0,0 +1,48 @@
+---
+name: gsd-docs-update
+description: Generate or update project documentation verified against the codebase
+argument-hint: "[--force] [--verify-only]"
+permissions:
+   read: true
+   write: true
+   edit: true
+   bash: true
+   glob: true
+   grep: true
+   task: true
+   question: true
+---
+<objective>
+Generate and update up to 9 documentation files for the current project. Each doc type is written by a gsd-doc-writer subagent that explores the codebase directly — no hallucinated paths, phantom endpoints, or stale signatures.
+
+Flag handling rule:
+- The optional flags documented below are available behaviors, not implied active behaviors
+- A flag is active only when its literal token appears in `$ARGUMENTS`
+- If a documented flag is absent from `$ARGUMENTS`, treat it as inactive
+- `--force`: skip preservation prompts, regenerate all docs regardless of existing content or GSD markers
+- `--verify-only`: check existing docs for accuracy against codebase, no generation (full verification requires Phase 4 verifier)
+- If `--force` and `--verify-only` both appear in `$ARGUMENTS`, `--force` takes precedence
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/docs-update.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Available optional flags (documentation only — not automatically active):**
+- `--force` — Regenerate all docs. Overwrites hand-written and GSD docs alike. No preservation prompts.
+- `--verify-only` — Check existing docs for accuracy against the codebase. No files are written. Reports VERIFY marker count. Full codebase fact-checking requires the gsd-doc-verifier agent (Phase 4).
+
+**Active flags must be derived from `$ARGUMENTS`:**
+- `--force` is active only if the literal `--force` token is present in `$ARGUMENTS`
+- `--verify-only` is active only if the literal `--verify-only` token is present in `$ARGUMENTS`
+- If neither token appears, run the standard full-phase generation flow
+- Do not infer that a flag is active just because it is documented in this prompt
+</context>
+
+<process>
+Execute the docs-update workflow from @$HOME/.config/opencode/get-shit-done/workflows/docs-update.md end-to-end.
+Preserve all workflow gates (preservation_check, flag handling, wave execution, monorepo dispatch, commit, reporting).
+</process>

package/commands/gsd/gsd-execute-phase.md

@@ -1,7 +1,7 @@
 ---
 name: gsd-execute-phase
 description: Execute all plans in a phase with wave-based parallelization
-argument-hint: "<phase-number> [--gaps-only]"
+argument-hint: "<phase-number> [--wave N] [--gaps-only] [--interactive]"
 permissions:
    read: true
    write: true
@@ -18,6 +18,15 @@ Execute all plans in a phase using wave-based parallel execution.
 
 Orchestrator stays lean: discover plans, analyze dependencies, group into waves, spawn subagents, collect results. Each subagent loads the full execute-plan context and handles its own plan.
 
+Optional wave filter:
+- `--wave N` executes only Wave `N` for pacing, quota management, or staged rollout
+- phase verification/completion still only happens when no incomplete plans remain after the selected wave finishes
+
+Flag handling rule:
+- The optional flags documented below are available behaviors, not implied active behaviors
+- A flag is active only when its literal token appears in `$ARGUMENTS`
+- If a documented flag is absent from `$ARGUMENTS`, treat it as inactive
+
 Context budget: ~15% orchestrator, 100% fresh per subagent.
 </objective>
 
@@ -26,11 +35,24 @@ Context budget: ~15% orchestrator, 100% fresh per subagent.
 @$HOME/.config/opencode/get-shit-done/references/ui-brand.md
 </execution_context>
 
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
 <context>
 Phase: $ARGUMENTS
 
-**Flags:**
+**Available optional flags (documentation only — not automatically active):**
+- `--wave N` — Execute only Wave `N` in the phase. Use when you want to pace execution or stay inside usage limits.
 - `--gaps-only` — Execute only gap closure plans (plans with `gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
+- `--interactive` — Execute plans sequentially inline (no subagents) with user checkpoints between tasks. Lower token usage, pair-programming style. Best for small phases, bug fixes, and verification gaps.
+
+**Active flags must be derived from `$ARGUMENTS`:**
+- `--wave N` is active only if the literal `--wave` token is present in `$ARGUMENTS`
+- `--gaps-only` is active only if the literal `--gaps-only` token is present in `$ARGUMENTS`
+- `--interactive` is active only if the literal `--interactive` token is present in `$ARGUMENTS`
+- If none of these tokens appear, run the standard full-phase execution flow with no flag-specific filtering
+- Do not infer that a flag is active just because it is documented in this prompt
 
 Context files are resolved inside the workflow via `gsd-tools init execute-phase` and per-subagent `<files_to_read>` blocks.
 </context>

package/commands/gsd/gsd-fast.md

@@ -0,0 +1,30 @@
+---
+name: gsd-fast
+description: Execute a trivial task inline — no subagents, no planning overhead
+argument-hint: "[task description]"
+permissions:
+   read: true
+   write: true
+   edit: true
+   bash: true
+   grep: true
+   glob: true
+---
+
+<objective>
+Execute a trivial task directly in the current context without spawning subagents
+or generating PLAN.md files. For tasks too small to justify planning overhead:
+typo fixes, config changes, small refactors, forgotten commits, simple additions.
+
+This is NOT a replacement for /gsd-quick — use /gsd-quick for anything that
+needs research, multi-step planning, or verification. /gsd-fast is for tasks
+you could describe in one sentence and execute in under 2 minutes.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/fast.md
+</execution_context>
+
+<process>
+Execute the fast workflow from @$HOME/.config/opencode/get-shit-done/workflows/fast.md end-to-end.
+</process>

package/commands/gsd/gsd-forensics.md

@@ -0,0 +1,56 @@
+---
+type: prompt
+name: gsd-forensics
+description: Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
+argument-hint: "[problem description]"
+permissions:
+   read: true
+   write: true
+   bash: true
+   grep: true
+   glob: true
+---
+
+<objective>
+Investigate what went wrong during a GSD workflow execution. Analyzes git history, `.planning/` artifacts, and file system state to detect anomalies and generate a structured diagnostic report.
+
+Purpose: Diagnose failed or stuck workflows so the user can understand root cause and take corrective action.
+Output: Forensic report saved to `.planning/forensics/`, presented inline, with optional issue creation.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/forensics.md
+</execution_context>
+
+<context>
+**Data sources:**
+- `git log` (recent commits, patterns, time gaps)
+- `git status` / `git diff` (uncommitted work, conflicts)
+- `.planning/STATE.md` (current position, session history)
+- `.planning/ROADMAP.md` (phase scope and progress)
+- `.planning/phases/*/` (PLAN.md, SUMMARY.md, VERIFICATION.md, CONTEXT.md)
+- `.planning/reports/SESSION_REPORT.md` (last session outcomes)
+
+**User input:**
+- Problem description: $ARGUMENTS (optional — will ask if not provided)
+</context>
+
+<process>
+read and execute the forensics workflow from @$HOME/.config/opencode/get-shit-done/workflows/forensics.md end-to-end.
+</process>
+
+<success_criteria>
+- Evidence gathered from all available data sources
+- At least 4 anomaly types checked (stuck loop, missing artifacts, abandoned work, crash/interruption)
+- Structured forensic report written to `.planning/forensics/report-{timestamp}.md`
+- Report presented inline with findings, anomalies, and recommendations
+- Interactive investigation offered for deeper analysis
+- GitHub issue creation offered if actionable findings exist
+</success_criteria>
+
+<critical_rules>
+- **read-only investigation:** Do not modify project source files during forensics. Only write the forensic report and update STATE.md session tracking.
+- **Redact sensitive data:** Strip absolute paths, API keys, tokens from reports and issues.
+- **Ground findings in evidence:** Every anomaly must cite specific commits, files, or state data.
+- **No speculation without evidence:** If data is insufficient, say so — do not fabricate root causes.
+</critical_rules>

package/commands/gsd/gsd-help.md

@@ -1,6 +1,8 @@
 ---
 name: gsd-help
 description: Show available GSD commands and usage guide
+permissions:
+   read: true
 ---
 <objective>
 Display the complete GSD command reference.

package/commands/gsd/gsd-join-discord.md

@@ -1,6 +1,7 @@
 ---
 name: gsd-join-discord
 description: Join the GSD Discord community
+permissions: []
 ---
 
 <objective>
@@ -12,7 +13,7 @@ Display the Discord invite link for the GSD community server.
 
 Connect with other GSD users, get help, share what you're building, and stay updated.
 
-**Invite link:** https://discord.gg/gsd
+**Invite link:** https://discord.gg/mYgfVNfA2r
 
 Click the link or paste it into your browser to join.
 </output>

package/commands/gsd/gsd-list-workspaces.md

@@ -0,0 +1,19 @@
+---
+name: gsd-list-workspaces
+description: List active GSD workspaces and their status
+permissions:
+   bash: true
+   read: true
+---
+<objective>
+Scan `~/gsd-workspaces/` for workspace directories containing `WORKSPACE.md` manifests. Display a summary table with name, path, repo count, strategy, and GSD project status.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/list-workspaces.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<process>
+Execute the list-workspaces workflow from @$HOME/.config/opencode/get-shit-done/workflows/list-workspaces.md end-to-end.
+</process>

package/commands/gsd/gsd-manager.md

@@ -0,0 +1,40 @@
+---
+name: gsd-manager
+description: Interactive command center for managing multiple phases from one terminal
+permissions:
+   read: true
+   write: true
+   bash: true
+   glob: true
+   grep: true
+   question: true
+  - skill
+   task: true
+---
+<objective>
+Single-terminal command center for managing a milestone. Shows a dashboard of all phases with visual status indicators, recommends optimal next actions, and dispatches work — discuss runs inline, plan/execute run as background agents.
+
+Designed for power users who want to parallelize work across phases from one terminal: discuss a phase while another plans or executes in the background.
+
+**Creates/Updates:**
+- No files created directly — dispatches to existing GSD commands via skill() and background task agents.
+- Reads `.planning/STATE.md`, `.planning/ROADMAP.md`, phase directories for status.
+
+**After:** User exits when done managing, or all phases complete and milestone lifecycle is suggested.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/manager.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+No arguments required. Requires an active milestone with ROADMAP.md and STATE.md.
+
+Project context, phase list, dependencies, and recommendations are resolved inside the workflow using `gsd-tools.cjs init manager`. No upfront context loading needed.
+</context>
+
+<process>
+Execute the manager workflow from @$HOME/.config/opencode/get-shit-done/workflows/manager.md end-to-end.
+Maintain the dashboard refresh loop until the user exits or all phases complete.
+</process>

package/commands/gsd/gsd-milestone-summary.md

@@ -0,0 +1,51 @@
+---
+type: prompt
+name: gsd-milestone-summary
+description: Generate a comprehensive project summary from milestone artifacts for team onboarding and review
+argument-hint: "[version]"
+permissions:
+   read: true
+   write: true
+   bash: true
+   grep: true
+   glob: true
+---
+
+<objective>
+Generate a structured milestone summary for team onboarding and project review. Reads completed milestone artifacts (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION files) and produces a human-friendly overview of what was built, how, and why.
+
+Purpose: Enable new team members to understand a completed project by reading one document and asking follow-up questions.
+Output: MILESTONE_SUMMARY written to `.planning/reports/`, presented inline, optional interactive Q&A.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/milestone-summary.md
+</execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/PROJECT.md`
+- `.planning/STATE.md`
+- `.planning/RETROSPECTIVE.md`
+- `.planning/milestones/v{version}-ROADMAP.md` (if archived)
+- `.planning/milestones/v{version}-REQUIREMENTS.md` (if archived)
+- `.planning/phases/*-*/` (SUMMARY.md, VERIFICATION.md, CONTEXT.md, RESEARCH.md)
+
+**User input:**
+- Version: $ARGUMENTS (optional — defaults to current/latest milestone)
+</context>
+
+<process>
+read and execute the milestone-summary workflow from @$HOME/.config/opencode/get-shit-done/workflows/milestone-summary.md end-to-end.
+</process>
+
+<success_criteria>
+- Milestone version resolved (from args, STATE.md, or archive scan)
+- All available artifacts read (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION, RESEARCH, RETROSPECTIVE)
+- Summary document written to `.planning/reports/MILESTONE_SUMMARY-v{version}.md`
+- All 7 sections generated (Overview, Architecture, Phases, Decisions, Requirements, Tech Debt, Getting Started)
+- Summary presented inline to user
+- Interactive Q&A offered
+- STATE.md updated
+</success_criteria>

package/commands/gsd/gsd-new-project.md

@@ -9,6 +9,10 @@ permissions:
    task: true
    question: true
 ---
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
 <context>
 **Flags:**
 - `--auto` — Automatic mode. After config questions, runs research → requirements → roadmap without further interaction. Expects idea document via @ reference.

package/commands/gsd/gsd-new-workspace.md

@@ -0,0 +1,44 @@
+---
+name: gsd-new-workspace
+description: Create an isolated workspace with repo copies and independent .planning/
+argument-hint: "--name <name> [--repos repo1,repo2] [--path /target] [--strategy worktree|clone] [--branch name] [--auto]"
+permissions:
+   read: true
+   bash: true
+   write: true
+   question: true
+---
+<context>
+**Flags:**
+- `--name` (required) — Workspace name
+- `--repos` — Comma-separated repo paths or names. If omitted, interactive selection from child git repos in cwd
+- `--path` — Target directory. Defaults to `~/gsd-workspaces/<name>`
+- `--strategy` — `worktree` (default, lightweight) or `clone` (fully independent)
+- `--branch` — Branch to checkout. Defaults to `workspace/<name>`
+- `--auto` — Skip interactive questions, use defaults
+</context>
+
+<objective>
+Create a physical workspace directory containing copies of specified git repos (as worktrees or clones) with an independent `.planning/` directory for isolated GSD sessions.
+
+**Use cases:**
+- Multi-repo orchestration: work on a subset of repos in parallel with isolated GSD state
+- Feature branch isolation: create a worktree of the current repo with its own `.planning/`
+
+**Creates:**
+- `<path>/WORKSPACE.md` — workspace manifest
+- `<path>/.planning/` — independent planning directory
+- `<path>/<repo>/` — git worktree or clone for each specified repo
+
+**After this command:** `cd` into the workspace and run `/gsd-new-project` to initialize GSD.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/new-workspace.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<process>
+Execute the new-workspace workflow from @$HOME/.config/opencode/get-shit-done/workflows/new-workspace.md end-to-end.
+Preserve all workflow gates (validation, approvals, commits, routing).
+</process>