gsd-opencode 1.22.0 → 1.30.0

package/get-shit-done/workflows/help.md

@@ -1,6 +1,6 @@
-<purpose>
+<objective>
 Display the complete GSD command reference. Output ONLY the reference content. Do NOT add project-specific analysis, git status, next-step suggestions, or any commentary beyond the reference.
-</purpose>
+</objective>
 
 <reference>
 # GSD Command Reference
@@ -66,8 +66,11 @@ Help articulate your vision for a phase before planning.
 - Captures how you imagine this phase working
 - Creates CONTEXT.md with your vision, essentials, and boundaries
 - Use when you have ideas about how something should look/feel
+- Optional `--batch` asks 2-5 related questions at a time instead of one-by-one
 
 Usage: `/gsd-discuss-phase 2`
+Usage: `/gsd-discuss-phase 2 --batch`
+Usage: `/gsd-discuss-phase 2 --batch=3`
 
 **`/gsd-research-phase <number>`**
 Comprehensive ecosystem research for niche/complex domains.
@@ -104,30 +107,67 @@ Result: Creates `.planning/phases/01-foundation/01-01-PLAN.md`
 ### Execution
 
 **`/gsd-execute-phase <phase-number>`**
-Execute all plans in a phase.
+Execute all plans in a phase, or run a specific wave.
 
 - Groups plans by wave (from frontmatter), executes waves sequentially
 - Plans within each wave run in parallel via task tool
+- Optional `--wave N` flag executes only Wave `N` and stops unless the phase is now fully complete
 - Verifies phase goal after all plans complete
 - Updates REQUIREMENTS.md, ROADMAP.md, STATE.md
 
 Usage: `/gsd-execute-phase 5`
+Usage: `/gsd-execute-phase 5 --wave 2`
+
+### Smart Router
+
+**`/gsd-do <description>`**
+Route freeform text to the right GSD command automatically.
+
+- Analyzes natural language input to find the best matching GSD command
+- Acts as a dispatcher — never does the work itself
+- Resolves ambiguity by asking you to pick between top matches
+- Use when you know what you want but don't know which `/gsd-*` command to run
+
+Usage: `/gsd-do fix the login button`
+Usage: `/gsd-do refactor the auth system`
+Usage: `/gsd-do I want to start a new milestone`
 
 ### Quick Mode
 
-**`/gsd-quick`**
+**`/gsd-quick [--full] [--discuss] [--research]`**
 Execute small, ad-hoc tasks with GSD guarantees but skip optional agents.
 
 Quick mode uses the same system with a shorter path:
-- Spawns planner + executor (skips researcher, checker, verifier)
+- Spawns planner + executor (skips researcher, checker, verifier by default)
 - Quick tasks live in `.planning/quick/` separate from planned phases
 - Updates STATE.md tracking (not ROADMAP.md)
 
-Use when you know exactly what to do and the task is small enough to not need research or verification.
+Flags enable additional quality steps:
+- `--discuss` — Lightweight discussion to surface gray areas before planning
+- `--research` — Focused research agent investigates approaches before planning
+- `--full` — Adds plan-checking (max 2 iterations) and post-execution verification
+
+Flags are composable: `--discuss --research --full` gives the complete quality pipeline for a single task.
 
 Usage: `/gsd-quick`
+Usage: `/gsd-quick --research --full`
 Result: Creates `.planning/quick/NNN-slug/PLAN.md`, `.planning/quick/NNN-slug/SUMMARY.md`
 
+---
+
+**`/gsd-fast [description]`**
+Execute a trivial task inline — no subagents, no planning files, no overhead.
+
+For tasks too small to justify planning: typo fixes, config changes, forgotten commits, simple additions. Runs in the current context, makes the change, commits, and logs to STATE.md.
+
+- No PLAN.md or SUMMARY.md created
+- No subagent spawned (runs inline)
+- ≤ 3 file edits — redirects to `/gsd-quick` if task is non-trivial
+- Atomic commit with conventional message
+
+Usage: `/gsd-fast "fix the typo in README"`
+Usage: `/gsd-fast "add .env to gitignore"`
+
 ### Roadmap Management
 
 **`/gsd-add-phase <description>`**
@@ -169,10 +209,12 @@ Start a new milestone through unified flow.
 - Optional domain research (spawns 4 parallel researcher agents)
 - Requirements definition with scoping
 - Roadmap creation with phase breakdown
+- Optional `--reset-phase-numbers` flag restarts numbering at Phase 1 and archives old phase dirs first for safety
 
 Mirrors `/gsd-new-project` flow for brownfield projects (existing PROJECT.md).
 
 Usage: `/gsd-new-milestone "v2.0 Features"`
+Usage: `/gsd-new-milestone --reset-phase-numbers "v2.0 Features"`
 
 **`/gsd-complete-milestone <version>`**
 Archive completed milestone and prepare for next version.
@@ -232,6 +274,21 @@ Systematic debugging with persistent state across context resets.
 Usage: `/gsd-debug "login button doesn't work"`
 Usage: `/gsd-debug` (resume active session)
 
+### Quick Notes
+
+**`/gsd-note <text>`**
+Zero-friction idea capture — one command, instant save, no questions.
+
+- Saves timestamped note to `.planning/notes/` (or `$HOME/.config/opencode/notes/` globally)
+- Three subcommands: append (default), list, promote
+- Promote converts a note into a structured todo
+- Works without a project (falls back to global scope)
+
+Usage: `/gsd-note refactor the hook system`
+Usage: `/gsd-note list`
+Usage: `/gsd-note promote 3`
+Usage: `/gsd-note --global cross-project idea`
+
 ### Todo Management
 
 **`/gsd-add-todo [description]`**
@@ -270,6 +327,65 @@ Validate built features through conversational UAT.
 
 Usage: `/gsd-verify-work 3`
 
+### Ship Work
+
+**`/gsd-ship [phase]`**
+Create a PR from completed phase work with an auto-generated body.
+
+- Pushes branch to remote
+- Creates PR with summary from SUMMARY.md, VERIFICATION.md, REQUIREMENTS.md
+- Optionally requests code review
+- Updates STATE.md with shipping status
+
+Prerequisites: Phase verified, `gh` CLI installed and authenticated.
+
+Usage: `/gsd-ship 4` or `/gsd-ship 4 --draft`
+
+---
+
+**`/gsd-review --phase N [--gemini] [--OpenCode] [--codex] [--all]`**
+Cross-AI peer review — invoke external AI CLIs to independently review phase plans.
+
+- Detects available CLIs (gemini, OpenCode, codex)
+- Each CLI reviews plans independently with the same structured prompt
+- Produces REVIEWS.md with per-reviewer feedback and consensus summary
+- Feed reviews back into planning: `/gsd-plan-phase N --reviews`
+
+Usage: `/gsd-review --phase 3 --all`
+
+---
+
+**`/gsd-pr-branch [target]`**
+Create a clean branch for pull requests by filtering out .planning/ commits.
+
+- Classifies commits: code-only (include), planning-only (exclude), mixed (include sans .planning/)
+- Cherry-picks code commits onto a clean branch
+- Reviewers see only code changes, no GSD artifacts
+
+Usage: `/gsd-pr-branch` or `/gsd-pr-branch main`
+
+---
+
+**`/gsd-plant-seed [idea]`**
+Capture a forward-looking idea with trigger conditions for automatic surfacing.
+
+- Seeds preserve WHY, WHEN to surface, and breadcrumbs to related code
+- Auto-surfaces during `/gsd-new-milestone` when trigger conditions match
+- Better than deferred items — triggers are checked, not forgotten
+
+Usage: `/gsd-plant-seed "add real-time notifications when we build the events system"`
+
+---
+
+**`/gsd-audit-uat`**
+Cross-phase audit of all outstanding UAT and verification items.
+- Scans every phase for pending, skipped, blocked, and human_needed items
+- Cross-references against codebase to detect stale documentation
+- Produces prioritized human test plan grouped by testability
+- Use before starting a new milestone to clear verification debt
+
+Usage: `/gsd-audit-uat`
+
 ### Milestone Auditing
 
 **`/gsd-audit-milestone [version]`**
@@ -298,7 +414,7 @@ Usage: `/gsd-plan-milestone-gaps`
 Configure workflow toggles and model profile interactively.
 
 - Toggle researcher, plan checker, verifier agents
-- Select model profile (simple/smart/genius)
+- Select model profile (simple/smart/genius/inherit)
 - Updates `.planning/config.json`
 
 Usage: `/gsd-settings`
@@ -309,6 +425,7 @@ Quick switch model profile for GSD agents.
 - `quality` — Opus everywhere except verification
 - `balanced` — Opus for planning, Sonnet for execution (default)
 - `budget` — Sonnet for writing, Haiku for research/verification
+- `inherit` — Use current session model for all agents (OpenCode `/model`)
 
 Usage: `/gsd-set-profile budget`
 

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

@@ -1,6 +1,6 @@
-<purpose>
+<objective>
 Insert a decimal phase for urgent work discovered mid-milestone between existing integer phases. Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions without renumbering the entire roadmap.
-</purpose>
+</objective>
 
 <required_reading>
 read all files referenced by the invoking prompt's execution_context before starting.

package/get-shit-done/workflows/list-phase-assumptions.md

@@ -1,8 +1,8 @@
-<purpose>
+<objective>
 Surface OpenCode's assumptions about a phase before planning, enabling users to correct misconceptions early.
 
 Key difference from discuss-phase: This is ANALYSIS of what OpenCode thinks, not INTAKE of what user knows. No file output - purely conversational to prompt discussion.
-</purpose>
+</objective>
 
 <process>
 

package/get-shit-done/workflows/list-workspaces.md

@@ -0,0 +1,56 @@
+<objective>
+List all GSD workspaces found in ~/gsd-workspaces/ with their status.
+</objective>
+
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+## 1. Setup
+
+```bash
+INIT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" init list-workspaces)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON for: `workspace_base`, `workspaces`, `workspace_count`.
+
+## 2. Display
+
+**If `workspace_count` is 0:**
+
+```
+No workspaces found in ~/gsd-workspaces/
+
+Create one with:
+  /gsd-new-workspace --name my-workspace --repos repo1,repo2
+```
+
+Done.
+
+**If workspaces exist:**
+
+Display a table:
+
+```
+GSD Workspaces (~/gsd-workspaces/)
+
+| Name | Repos | Strategy | GSD Project |
+|------|-------|----------|-------------|
+| feature-a | 3 | worktree | Yes |
+| feature-b | 2 | clone | No |
+
+Manage:
+  cd ~/gsd-workspaces/<name>     # Enter a workspace
+  /gsd-remove-workspace <name>   # Remove a workspace
+```
+
+For each workspace, show:
+- **Name** — directory name
+- **Repos** — count from init data
+- **Strategy** — from WORKSPACE.md
+- **GSD Project** — whether `.planning/PROJECT.md` exists (Yes/No)
+
+</process>

package/get-shit-done/workflows/manager.md

@@ -0,0 +1,362 @@
+<objective>
+
+Interactive command center for managing a milestone from a single terminal. Shows a dashboard of all phases with visual status, dispatches discuss inline and plan/execute as background agents, and loops back to the dashboard after each action. Enables parallel phase work from one terminal.
+
+</objective>
+
+<required_reading>
+
+read all files referenced by the invoking prompt's execution_context before starting.
+
+</required_reading>
+
+<process>
+
+<step name="initialize" priority="first">
+
+## 1. Initialize
+
+Bootstrap via manager init:
+
+```bash
+INIT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" init manager)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON for: `milestone_version`, `milestone_name`, `phase_count`, `completed_count`, `in_progress_count`, `phases`, `recommended_actions`, `all_complete`, `waiting_signal`.
+
+**If error:** Display the error message and exit.
+
+Display startup banner:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► MANAGER
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ {milestone_version} — {milestone_name}
+ {phase_count} phases · {completed_count} complete
+
+ ✓ Discuss → inline    ◆ Plan/Execute → background
+ Dashboard auto-refreshes when background work is active.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Proceed to dashboard step.
+
+</step>
+
+<step name="dashboard">
+
+## 2. Dashboard (Refresh Point)
+
+**Every time this step is reached**, re-read state from disk to pick up changes from background agents:
+
+```bash
+INIT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" init manager)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse the full JSON. Build the dashboard display.
+
+Build dashboard from JSON. Symbols: `✓` done, `◆` active, `○` pending, `·` queued. Progress bar: 20-char `█░`.
+
+**Status mapping** (disk_status → D P E Status):
+
+- `complete` → `✓ ✓ ✓` `✓ Complete`
+- `partial` → `✓ ✓ ◆` `◆ Executing...`
+- `planned` → `✓ ✓ ○` `○ Ready to execute`
+- `discussed` → `✓ ○ ·` `○ Ready to plan`
+- `researched` → `◆ · ·` `○ Ready to plan`
+- `empty`/`no_directory` + `is_next_to_discuss` → `○ · ·` `○ Ready to discuss`
+- `empty`/`no_directory` otherwise → `· · ·` `· Up next`
+- If `is_active`, replace status icon with `◆` and append `(active)`
+
+If any `is_active` phases, show: `◆ Background: {action} Phase {N}, ...` above grid.
+
+Use `display_name` (not `name`) for the Phase column — it's pre-truncated to 20 chars with `…` if clipped. Pad all phase names to the same width for alignment.
+
+Use `deps_display` from init JSON for the Deps column — shows which phases this phase depends on (e.g. `1,3`) or `—` for none.
+
+Example output:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► DASHBOARD
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ████████████░░░░░░░░ 60%  (3/5 phases)
+ ◆ Background: Planning Phase 4
+ | # | Phase                | Deps | D | P | E | Status              |
+ |---|----------------------|------|---|---|---|---------------------|
+ | 1 | Foundation           | —    | ✓ | ✓ | ✓ | ✓ Complete          |
+ | 2 | API Layer            | 1    | ✓ | ✓ | ◆ | ◆ Executing (active)|
+ | 3 | Auth System          | 1    | ✓ | ✓ | ○ | ○ Ready to execute  |
+ | 4 | Dashboard UI & Set…  | 1,2  | ✓ | ◆ | · | ◆ Planning (active) |
+ | 5 | Notifications        | —    | ○ | · | · | ○ Ready to discuss  |
+ | 6 | Polish & Final Mail… | 1-5  | · | · | · | · Up next           |
+```
+
+**Recommendations section:**
+
+If `all_complete` is true:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  MILESTONE COMPLETE                                          ║
+╚══════════════════════════════════════════════════════════════╝
+
+All {phase_count} phases done. Ready for final steps:
+  → /gsd-verify-work — run acceptance testing
+  → /gsd-complete-milestone — archive and wrap up
+```
+
+Ask user via question:
+- **question:** "All phases complete. What next?"
+- **options:** "Verify work" / "Complete milestone" / "Exit manager"
+
+Handle responses:
+- "Verify work": `skill(skill="gsd-verify-work")`  then loop to dashboard.
+- "Complete milestone": `skill(skill="gsd-complete-milestone")` then exit.
+- "Exit manager": Go to exit step.
+
+**If NOT all_complete**, build compound options from `recommended_actions`:
+
+**Compound option logic:** Group background actions (plan/execute) together, and pair them with the single inline action (discuss) when one exists. The goal is to present the fewest options possible — one option can dispatch multiple background agents plus one inline action.
+
+**Building options:**
+
+1. Collect all background actions (execute and plan recommendations) — there can be multiple of each.
+2. Collect the inline action (discuss recommendation, if any — there will be at most one since discuss is sequential).
+3. Build compound options:
+
+   **If there are ANY recommended actions (background, inline, or both):**
+   Create ONE primary "Continue" option that dispatches ALL of them together:
+   - Label: `"Continue"` — always this exact word
+   - Below the label, list every action that will happen. Enumerate ALL recommended actions — do not cap or truncate:
+     ```
+     Continue:
+       → Execute Phase 32 (background)
+       → Plan Phase 34 (background)
+       → Discuss Phase 35 (inline)
+     ```
+   - This dispatches all background agents first, then runs the inline discuss (if any).
+   - If there is no inline discuss, the dashboard refreshes after spawning background agents.
+
+   **Important:** The Continue option must include EVERY action from `recommended_actions` — not just 2. If there are 3 actions, list 3. If there are 5, list 5.
+
+4. Always add:
+   - `"Refresh dashboard"`
+   - `"Exit manager"`
+
+Display recommendations compactly:
+
+```
+───────────────────────────────────────────────────────────────
+▶ Next Steps
+───────────────────────────────────────────────────────────────
+
+Continue:
+  → Execute Phase 32 (background)
+  → Plan Phase 34 (background)
+  → Discuss Phase 35 (inline)
+```
+
+**Auto-refresh:** If background agents are running (`is_active` is true for any phase), set a 60-second auto-refresh cycle. After presenting the action menu, if no user input is received within 60 seconds, automatically refresh the dashboard. This interval is configurable via `manager_refresh_interval` in GSD config (default: 60 seconds, set to 0 to disable).
+
+Present via question:
+- **question:** "What would you like to do?"
+- **options:** (compound options as built above + refresh + exit, question auto-adds "Other")
+
+**On "Other" (free text):** Parse intent — if it mentions a phase number and action, dispatch accordingly. If unclear, display available actions and loop to action_menu.
+
+Proceed to handle_action step with the selected action.
+
+</step>
+
+<step name="handle_action">
+
+## 4. Handle Action
+
+### Refresh Dashboard
+
+Loop back to dashboard step.
+
+### Exit Manager
+
+Go to exit step.
+
+### Compound Action (background + inline)
+
+When the user selects a compound option:
+
+1. **Spawn all background agents first** (plan/execute) — dispatch them in parallel using the Plan Phase N / Execute Phase N handlers below.
+2. **Then run the inline discuss:**
+
+```
+skill(skill="gsd-discuss-phase", args="{PHASE_NUM}")
+```
+
+After discuss completes, loop back to dashboard step (background agents continue running).
+
+### Discuss Phase N
+
+Discussion is interactive — needs user input. Run inline:
+
+```
+skill(skill="gsd-discuss-phase", args="{PHASE_NUM}")
+```
+
+After discuss completes, loop back to dashboard step.
+
+### Plan Phase N
+
+Planning runs autonomously. Spawn a background agent:
+
+```
+task(
+  description="Plan phase {N}: {phase_name}",
+  run_in_background=true,
+  prompt="You are running the GSD plan-phase workflow for phase {N} of the project.
+
+Working directory: {cwd}
+Phase: {N} — {phase_name}
+Goal: {goal}
+
+Steps:
+1. read the plan-phase workflow: cat $HOME/.config/opencode/get-shit-done/workflows/plan-phase.md
+2. Run: node \"$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs\" init plan-phase {N}
+3. Follow the workflow steps to produce PLAN.md files for this phase.
+4. If research is enabled in config, run the research step first.
+5. Spawn a gsd-planner subagent via task() to create the plans.
+6. If plan-checker is enabled, spawn a gsd-plan-checker subagent to verify.
+7. Commit plan files when complete.
+
+Important: You are running in the background. Do NOT use question — make autonomous decisions based on project context. If you hit a blocker, write it to STATE.md as a blocker and stop. Do NOT silently work around permission or file access errors — let them fail so the manager can surface them with resolution hints."
+)
+```
+
+Display:
+
+```
+◆ Spawning planner for Phase {N}: {phase_name}...
+```
+
+Loop back to dashboard step.
+
+### Execute Phase N
+
+Execution runs autonomously. Spawn a background agent:
+
+```
+task(
+  description="Execute phase {N}: {phase_name}",
+  run_in_background=true,
+  prompt="You are running the GSD execute-phase workflow for phase {N} of the project.
+
+Working directory: {cwd}
+Phase: {N} — {phase_name}
+Goal: {goal}
+
+Steps:
+1. read the execute-phase workflow: cat $HOME/.config/opencode/get-shit-done/workflows/execute-phase.md
+2. Run: node \"$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs\" init execute-phase {N}
+3. Follow the workflow steps: discover plans, analyze dependencies, group into waves.
+4. For each wave, spawn gsd-executor subagents via task() to execute plans in parallel.
+5. After all waves complete, spawn a gsd-verifier subagent if verifier is enabled.
+6. Update ROADMAP.md and STATE.md with progress.
+7. Commit all changes.
+
+Important: You are running in the background. Do NOT use question — make autonomous decisions. Use --no-verify on git commits. If you hit a permission error, file lock, or any access issue, do NOT work around it — let it fail and write the error to STATE.md as a blocker so the manager can surface it with resolution guidance."
+)
+```
+
+Display:
+
+```
+◆ Spawning executor for Phase {N}: {phase_name}...
+```
+
+Loop back to dashboard step.
+
+</step>
+
+<step name="background_completion">
+
+## 5. Background Agent Completion
+
+When notified that a background agent completed:
+
+1. read the result message from the agent.
+2. Display a brief notification:
+
+```
+✓ {description}
+  {brief summary from agent result}
+```
+
+3. Loop back to dashboard step.
+
+**If the agent reported an error or blocker:**
+
+Classify the error:
+
+**Permission / tool access error** (e.g. tool not allowed, permission denied, sandbox restriction):
+- Parse the error to identify which tool or command was blocked.
+- Display the error clearly, then offer to fix it:
+  - **question:** "Phase {N} failed — permission denied for `{tool_or_command}`. Want me to add it to settings.local.json so it's allowed?"
+  - **options:** "Add permission and retry" / "Run this phase inline instead" / "Skip and continue"
+  - "Add permission and retry": Use `skill(skill="update-config")` to add the permission to `settings.local.json`, then re-spawn the background agent. Loop to dashboard.
+  - "Run this phase inline instead": Dispatch the same action (plan/execute) inline via `skill()` instead of a background task. Loop to dashboard after.
+  - "Skip and continue": Loop to dashboard (phase stays in current state).
+
+**Other errors** (git lock, file conflict, logic error, etc.):
+- Display the error, then offer options via question:
+  - **question:** "Background agent for Phase {N} encountered an issue: {error}. What next?"
+  - **options:** "Retry" / "Run inline instead" / "Skip and continue" / "View details"
+  - "Retry": Re-spawn the same background agent. Loop to dashboard.
+  - "Run inline instead": Dispatch the action inline via `skill()`. Loop to dashboard after.
+  - "Skip and continue": Loop to dashboard (phase stays in current state).
+  - "View details": read STATE.md blockers section, display, then re-present options.
+
+</step>
+
+<step name="exit">
+
+## 6. Exit
+
+Display final status with progress bar:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► SESSION END
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ {milestone_version} — {milestone_name}
+ {PROGRESS_BAR} {progress_pct}%  ({completed_count}/{phase_count} phases)
+
+ Resume anytime: /gsd-manager
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Note:** Any background agents still running will continue to completion. Their results will be visible on next `/gsd-manager` or `/gsd-progress` invocation.
+
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Dashboard displays all phases with correct status indicators (D/P/E/V columns)
+- [ ] Progress bar shows accurate completion percentage
+- [ ] Dependency resolution: blocked phases show which deps are missing
+- [ ] Recommendations prioritize: execute > plan > discuss
+- [ ] Discuss phases run inline via skill() — interactive questions work
+- [ ] Plan phases spawn background task agents — return to dashboard immediately
+- [ ] Execute phases spawn background task agents — return to dashboard immediately
+- [ ] Dashboard refreshes pick up changes from background agents via disk state
+- [ ] Background agent completion triggers notification and dashboard refresh
+- [ ] Background agent errors present retry/skip options
+- [ ] All-complete state offers verify-work and complete-milestone
+- [ ] Exit shows final status with resume instructions
+- [ ] "Other" free-text input parsed for phase number and action
+- [ ] Manager loop continues until user exits or milestone completes
+</success_criteria>