gsd-opencode 1.22.1 → 1.33.0

package/commands/gsd/gsd-next.md

@@ -0,0 +1,24 @@
+---
+name: gsd-next
+description: Automatically advance to the next logical step in the GSD workflow
+permissions:
+   read: true
+   bash: true
+   grep: true
+   glob: true
+   task: true
+---
+<objective>
+Detect the current project state and automatically invoke the next logical GSD workflow step.
+No arguments needed — reads STATE.md, ROADMAP.md, and phase directories to determine what comes next.
+
+Designed for rapid multi-project workflows where remembering which phase/step you're on is overhead.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/next.md
+</execution_context>
+
+<process>
+Execute the next workflow from @$HOME/.config/opencode/get-shit-done/workflows/next.md end-to-end.
+</process>

package/commands/gsd/gsd-note.md

@@ -0,0 +1,34 @@
+---
+name: gsd-note
+description: Zero-friction idea capture. Append, list, or promote notes to todos.
+argument-hint: "<text> | list | promote <N> [--global]"
+permissions:
+   read: true
+   write: true
+   glob: true
+   grep: true
+---
+<objective>
+Zero-friction idea capture — one write call, one confirmation line.
+
+Three subcommands:
+- **append** (default): Save a timestamped note file. No questions, no formatting.
+- **list**: Show all notes from project and global scopes.
+- **promote**: Convert a note into a structured todo.
+
+Runs inline — no task, no question, no bash.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/note.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the note workflow from @$HOME/.config/opencode/get-shit-done/workflows/note.md end-to-end.
+Capture the note, list notes, or promote to todo — depending on arguments.
+</process>

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

@@ -1,7 +1,7 @@
 ---
 name: gsd-plan-phase
 description: Create detailed phase plan (PLAN.md) with verification loop
-argument-hint: "[phase] [--auto] [--research] [--skip-research] [--gaps] [--skip-verify] [--prd <file>]"
+argument-hint: "[phase] [--auto] [--research] [--skip-research] [--gaps] [--skip-verify] [--prd <file>] [--reviews] [--text]"
 agent: gsd-planner
 permissions:
    read: true
@@ -10,6 +10,7 @@ permissions:
    glob: true
    grep: true
    task: true
+   question: true
    webfetch: true
    mcp__context7__*: true
 ---
@@ -26,6 +27,10 @@ Create executable phase prompts (PLAN.md files) for a roadmap phase with integra
 @$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. Do not skip questioning steps because `question` appears unavailable; use `vscode_askquestions` instead.
+</runtime_note>
+
 <context>
 Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omitted)
 
@@ -35,6 +40,8 @@ Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omit
 - `--gaps` — Gap closure mode (reads VERIFICATION.md, skips research)
 - `--skip-verify` — Skip verification loop
 - `--prd <file>` — Use a PRD/acceptance criteria file instead of discuss-phase. Parses requirements into CONTEXT.md automatically. Skips discuss-phase entirely.
+- `--reviews` — Replan incorporating cross-AI review feedback from REVIEWS.md (produced by `/gsd-review`)
+- `--text` — Use plain-text numbered lists instead of TUI menus (required for `/rc` remote sessions)
 
 Normalize phase input in step 2 before any directory lookups.
 </context>

package/commands/gsd/gsd-plant-seed.md

@@ -0,0 +1,28 @@
+---
+name: gsd-plant-seed
+description: Capture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone
+argument-hint: "[idea summary]"
+permissions:
+   read: true
+   write: true
+   edit: true
+   bash: true
+   question: true
+---
+
+<objective>
+Capture an idea that's too big for now but should surface automatically when the right
+milestone arrives. Seeds solve context rot: instead of a one-liner in Deferred that nobody
+reads, a seed preserves the full WHY, WHEN to surface, and breadcrumbs to details.
+
+Creates: .planning/seeds/SEED-NNN-slug.md
+Consumed by: /gsd-new-milestone (scans seeds and presents matches)
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/plant-seed.md
+</execution_context>
+
+<process>
+Execute the plant-seed workflow from @$HOME/.config/opencode/get-shit-done/workflows/plant-seed.md end-to-end.
+</process>

package/commands/gsd/gsd-pr-branch.md

@@ -0,0 +1,25 @@
+---
+name: gsd-pr-branch
+description: Create a clean PR branch by filtering out .planning/ commits — ready for code review
+argument-hint: "[target branch, default: main]"
+permissions:
+   bash: true
+   read: true
+   question: true
+---
+
+<objective>
+Create a clean branch suitable for pull requests by filtering out .planning/ commits
+from the current branch. Reviewers see only code changes, not GSD planning artifacts.
+
+This solves the problem of PR diffs being cluttered with PLAN.md, SUMMARY.md, STATE.md
+changes that are irrelevant to code review.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/pr-branch.md
+</execution_context>
+
+<process>
+Execute the pr-branch workflow from @$HOME/.config/opencode/get-shit-done/workflows/pr-branch.md end-to-end.
+</process>

package/commands/gsd/gsd-profile-user.md

@@ -0,0 +1,46 @@
+---
+name: gsd-profile-user
+description: Generate developer behavioral profile and create OpenCode-discoverable artifacts
+argument-hint: "[--questionnaire] [--refresh]"
+permissions:
+   read: true
+   write: true
+   bash: true
+   glob: true
+   grep: true
+   question: true
+   task: true
+---
+
+<objective>
+Generate a developer behavioral profile from session analysis (or questionnaire) and produce artifacts (USER-PROFILE.md, /gsd-dev-preferences, AGENTS.md section) that personalize OpenCode's responses.
+
+Routes to the profile-user workflow which orchestrates the full flow: consent gate, session analysis or questionnaire fallback, profile generation, result display, and artifact selection.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/profile-user.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+Flags from $ARGUMENTS:
+- `--questionnaire` -- Skip session analysis entirely, use questionnaire-only path
+- `--refresh` -- Rebuild profile even when one exists, backup old profile, show dimension diff
+</context>
+
+<process>
+Execute the profile-user workflow end-to-end.
+
+The workflow handles all logic including:
+1. Initialization and existing profile detection
+2. Consent gate before session analysis
+3. Session scanning and data sufficiency checks
+4. Session analysis (profiler agent) or questionnaire fallback
+5. Cross-project split resolution
+6. Profile writing to USER-PROFILE.md
+7. Result display with report card and highlights
+8. Artifact selection (dev-preferences, AGENTS.md sections)
+9. Sequential artifact generation
+10. Summary with refresh diff (if applicable)
+</process>

package/commands/gsd/gsd-quick.md

@@ -1,7 +1,7 @@
 ---
 name: gsd-quick
 description: Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
-argument-hint: "[--full] [--discuss]"
+argument-hint: "[--full] [--validate] [--discuss] [--research]"
 permissions:
    read: true
    write: true
@@ -24,9 +24,13 @@ Quick mode is the same system with a shorter path:
 
 **`--discuss` flag:** Lightweight discussion phase before planning. Surfaces assumptions, clarifies gray areas, captures decisions in CONTEXT.md. Use when the task has ambiguity worth resolving upfront.
 
-**`--full` flag:** Enables plan-checking (max 2 iterations) and post-execution verification. Use when you want quality guarantees without full milestone ceremony.
+**`--full` flag:** Enables the complete quality pipeline — discussion + research + plan-checking + verification. One flag for everything.
 
-Flags are composable: `--discuss --full` gives discussion + plan-checking + verification.
+**`--validate` flag:** Enables plan-checking (max 2 iterations) and post-execution verification only. Use when you want quality guarantees without discussion or research.
+
+**`--research` flag:** Spawns a focused research agent before planning. Investigates implementation approaches, library options, and pitfalls for the task. Use when you're unsure of the best approach.
+
+Granular flags are composable: `--discuss --research --validate` gives the same result as `--full`.
 </objective>
 
 <execution_context>

package/commands/gsd/gsd-reapply-patches.md

@@ -1,19 +1,22 @@
 ---
 name: gsd-reapply-patches
 description: Reapply local modifications after a GSD update
-permissions: read, write, edit, bash, glob, grep, question
+permissions:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
 ---
 
 <objective>
-Reapply user's local modifications to files after a GSD update reinstalls clean versions.
+After a GSD update wipes and reinstalls files, this command merges user's previously saved local modifications back into the new version. Uses three-way comparison (pristine baseline, user-modified backup, newly installed version) to reliably distinguish user customizations from version drift.
 
-When GSD performs updates, it backs up user modifications to a patches directory. This command intelligently merges those modifications back into the new file versions, handling cases where both the upstream code and user modifications may have changed.
+**Critical invariant:** Every file in `gsd-local-patches/` was backed up because the installer's hash comparison detected it was modified. The workflow must NEVER conclude "no custom content" for any backed-up file — that is a logical contradiction. When in doubt, classify as CONFLICT requiring user review, not SKIP.
 </objective>
 
-<purpose>
-After a GSD update wipes and reinstalls files, this command merges user's previously saved local modifications back into the new version. Uses intelligent comparison to handle cases where the upstream file also changed.
-</purpose>
-
 <process>
 
 ## Step 1: Detect backed-up patches
@@ -21,19 +24,90 @@ After a GSD update wipes and reinstalls files, this command merges user's previo
 Check for local patches directory:
 
 ```bash
-# Global install — detect runtime config directory
-if [ -d "$HOME/.config/opencode/gsd-local-patches" ]; then
-  PATCHES_DIR="$HOME/.config/opencode/gsd-local-patches"
-elif [ -d "$HOME/.opencode/gsd-local-patches" ]; then
-  PATCHES_DIR="$HOME/.opencode/gsd-local-patches"
-elif [ -d "$HOME/.gemini/gsd-local-patches" ]; then
-  PATCHES_DIR="$HOME/.gemini/gsd-local-patches"
-else
-  PATCHES_DIR="$HOME/.OpenCode/gsd-local-patches"
+expand_home() {
+  case "$1" in
+    "~/"*) printf '%s/%s\n' "$HOME" "${1#~/}" ;;
+    *) printf '%s\n' "$1" ;;
+  esac
+}
+
+PATCHES_DIR=""
+
+# Env overrides first — covers custom config directories used with --config-dir
+if [ -n "$KILO_CONFIG_DIR" ]; then
+  candidate="$(expand_home "$KILO_CONFIG_DIR")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+elif [ -n "$KILO_CONFIG" ]; then
+  candidate="$(dirname "$(expand_home "$KILO_CONFIG")")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+elif [ -n "$XDG_CONFIG_HOME" ]; then
+  candidate="$(expand_home "$XDG_CONFIG_HOME")/kilo/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+fi
+
+if [ -z "$PATCHES_DIR" ] && [ -n "$OPENCODE_CONFIG_DIR" ]; then
+  candidate="$(expand_home "$OPENCODE_CONFIG_DIR")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+elif [ -z "$PATCHES_DIR" ] && [ -n "$OPENCODE_CONFIG" ]; then
+  candidate="$(dirname "$(expand_home "$OPENCODE_CONFIG")")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+elif [ -z "$PATCHES_DIR" ] && [ -n "$XDG_CONFIG_HOME" ]; then
+  candidate="$(expand_home "$XDG_CONFIG_HOME")/opencode/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+fi
+
+if [ -z "$PATCHES_DIR" ] && [ -n "$GEMINI_CONFIG_DIR" ]; then
+  candidate="$(expand_home "$GEMINI_CONFIG_DIR")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+fi
+
+if [ -z "$PATCHES_DIR" ] && [ -n "$CODEX_HOME" ]; then
+  candidate="$(expand_home "$CODEX_HOME")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+fi
+
+if [ -z "$PATCHES_DIR" ] && [ -n "$CLAUDE_CONFIG_DIR" ]; then
+  candidate="$(expand_home "$CLAUDE_CONFIG_DIR")/gsd-local-patches"
+  if [ -d "$candidate" ]; then
+    PATCHES_DIR="$candidate"
+  fi
+fi
+
+# Global install — detect runtime config directory defaults
+if [ -z "$PATCHES_DIR" ]; then
+  if [ -d "$HOME/.config/kilo/gsd-local-patches" ]; then
+    PATCHES_DIR="$HOME/.config/kilo/gsd-local-patches"
+  elif [ -d "$HOME/.config/opencode/gsd-local-patches" ]; then
+    PATCHES_DIR="$HOME/.config/opencode/gsd-local-patches"
+  elif [ -d "$HOME/.opencode/gsd-local-patches" ]; then
+    PATCHES_DIR="$HOME/.opencode/gsd-local-patches"
+  elif [ -d "$HOME/.gemini/gsd-local-patches" ]; then
+    PATCHES_DIR="$HOME/.gemini/gsd-local-patches"
+  elif [ -d "$HOME/.codex/gsd-local-patches" ]; then
+    PATCHES_DIR="$HOME/.codex/gsd-local-patches"
+  else
+    PATCHES_DIR="$HOME/.OpenCode/gsd-local-patches"
+  fi
 fi
 # Local install fallback — check all runtime directories
 if [ ! -d "$PATCHES_DIR" ]; then
-  for dir in .config/opencode .opencode .gemini .OpenCode; do
+  for dir in .config/kilo .kilo .config/opencode .opencode .gemini .codex .OpenCode; do
     if [ -d "./$dir/gsd-local-patches" ]; then
       PATCHES_DIR="./$dir/gsd-local-patches"
       break
@@ -53,7 +127,43 @@ after modifying any GSD workflow, command, or agent files.
 ```
 Exit.
 
-## Step 2: Show patch summary
+## Step 2: Determine baseline for three-way comparison
+
+The quality of the merge depends on having a **pristine baseline** — the original unmodified version of each file from the pre-update GSD release. This enables three-way comparison:
+- **Pristine baseline** (original GSD file before any user edits)
+- **User's version** (backed up in `gsd-local-patches/`)
+- **New version** (freshly installed after update)
+
+Check for baseline sources in priority order:
+
+### Option A: Git history (most reliable)
+If the config directory is a git repository:
+```bash
+CONFIG_DIR=$(dirname "$PATCHES_DIR")
+if git -C "$CONFIG_DIR" rev-parse --git-dir >/dev/null 2>&1; then
+  HAS_GIT=true
+fi
+```
+When `HAS_GIT=true`, use `git log` to find the commit where GSD was originally installed (before user edits). For each file, the pristine baseline can be extracted with:
+```bash
+git -C "$CONFIG_DIR" log --diff-filter=A --format="%H" -- "{file_path}"
+```
+This gives the commit that first added the file (the install commit). Extract the pristine version:
+```bash
+git -C "$CONFIG_DIR" show {install_commit}:{file_path}
+```
+
+### Option B: Pristine snapshot directory
+Check if a `gsd-pristine/` directory exists alongside `gsd-local-patches/`:
+```bash
+PRISTINE_DIR="$CONFIG_DIR/gsd-pristine"
+```
+If it exists, the installer saved pristine copies at install time. Use these as the baseline.
+
+### Option C: No baseline available (two-way fallback)
+If neither git history nor pristine snapshots are available, fall back to two-way comparison — but with **strengthened heuristics** (see Step 3).
+
+## Step 3: Show patch summary
 
 ```
 ## Local Patches to Reapply
@@ -61,6 +171,7 @@ Exit.
 **Backed up from:** v{from_version}
 **Current version:** {read VERSION file}
 **Files modified:** {count}
+**Merge strategy:** {three-way (git) | three-way (pristine) | two-way (enhanced)}
 
 | # | File | Status |
 |---|------|--------|
@@ -68,37 +179,57 @@ Exit.
 | 2 | {file_path} | Pending |
 ```
 
-## Step 3: Merge each file
+## Step 4: Merge each file
 
 For each file in `backup-meta.json`:
 
 1. **read the backed-up version** (user's modified copy from `gsd-local-patches/`)
 2. **read the newly installed version** (current file after update)
-3. **Compare and merge:**
+3. **If available, read the pristine baseline** (from git history or `gsd-pristine/`)
 
-   - If the new file is identical to the backed-up file: skip (modification was incorporated upstream)
-   - If the new file differs: identify the user's modifications and apply them to the new version
+### Three-way merge (when baseline is available)
 
-   **Merge strategy:**
-   - read both versions fully
-   - Identify sections the user added or modified (look for additions, not just differences from path replacement)
-   - Apply user's additions/modifications to the new version
-   - If a section the user modified was also changed upstream: flag as conflict, show both versions, ask user which to keep
+Compare the three versions to isolate changes:
+- **User changes** = diff(pristine → user's version) — these are the customizations to preserve
+- **Upstream changes** = diff(pristine → new version) — these are version updates to accept
 
-4. **write merged result** to the installed location
-5. **Report status:**
-   - `Merged` — user modifications applied cleanly
-   - `Skipped` — modification already in upstream
-   - `Conflict` — user chose resolution
+**Merge rules:**
+- Sections changed only by user → apply user's version
+- Sections changed only by upstream → accept upstream version
+- Sections changed by both → flag as CONFLICT, show both, ask user
+- Sections unchanged by either → use new version (identical to all three)
 
-## Step 4: Update manifest
+### Two-way merge (fallback when no baseline)
 
-After reapplying, regenerate the file manifest so future updates correctly detect these as user modifications:
+When no pristine baseline is available, use these **strengthened heuristics**:
 
+**CRITICAL RULE: Every file in this backup directory was explicitly detected as modified by the installer's SHA-256 hash comparison. "No custom content" is never a valid conclusion.**
+
+For each file:
+a. read both versions completely
+b. Identify ALL differences, then classify each as:
+   - **Mechanical drift** — path substitutions (e.g. `/Users/xxx/.OpenCode/` → `$HOME/.OpenCode/`), variable additions (`${GSD_WS}`, `${AGENT_SKILLS_*}`), error handling additions (`|| true`)
+   - **User customization** — added steps/sections, removed sections, reordered content, changed behavior, added frontmatter fields, modified instructions
+
+c. **If ANY differences remain after filtering out mechanical drift → those are user customizations. Merge them.**
+d. **If ALL differences appear to be mechanical drift → still flag as CONFLICT.** The installer's hash check already proved this file was modified. Ask the user: "This file appears to only have path/variable differences. Were there intentional customizations?" Do NOT silently skip.
+
+### Git-enhanced two-way merge
+
+When the config directory is a git repo but the pristine install commit can't be found, use commit history to identify user changes:
 ```bash
-# The manifest will be regenerated on next /gsd-update
-# For now, just note which files were modified
+# Find non-update commits that touched this file
+git -C "$CONFIG_DIR" log --oneline --no-merges -- "{file_path}" | grep -v "gsd:update\|GSD update\|gsd-install"
 ```
+Each matching commit represents an intentional user modification. Use the commit messages and diffs to understand what was changed and why.
+
+4. **write merged result** to the installed location
+5. **Report status per file:**
+   - `Merged` — user modifications applied cleanly (show summary of what was preserved)
+   - `Conflict` — user reviewed and chose resolution
+   - `Incorporated` — user's modification was already adopted upstream (only valid when pristine baseline confirms this)
+
+**Never report `Skipped — no custom content`.** If a file is in the backup, it has custom content.
 
 ## Step 5: Cleanup option
 
@@ -111,11 +242,11 @@ Ask user:
 ```
 ## Patches Reapplied
 
-| # | File | Status |
-|---|------|--------|
-| 1 | {file_path} | ✓ Merged |
-| 2 | {file_path} | ○ Skipped (already upstream) |
-| 3 | {file_path} | ⚠ Conflict resolved |
+| # | File | Result | User Changes Preserved |
+|---|------|--------|----------------------|
+| 1 | {file_path} | Merged | Added step X, modified section Y |
+| 2 | {file_path} | Incorporated | Already in upstream v{version} |
+| 3 | {file_path} | Conflict resolved | User chose: keep custom section |
 
 {count} file(s) updated. Your local modifications are active again.
 ```
@@ -123,8 +254,10 @@ Ask user:
 </process>
 
 <success_criteria>
-- [ ] All backed-up patches processed
-- [ ] User modifications merged into new version
-- [ ] Conflicts resolved with user input
-- [ ] Status reported for each file
+- [ ] All backed-up patches processed — zero files left unhandled
+- [ ] No file classified as "no custom content" or "SKIP" — every backed-up file is definitionally modified
+- [ ] Three-way merge used when pristine baseline available (git history or gsd-pristine/)
+- [ ] User modifications identified and merged into new version
+- [ ] Conflicts surfaced to user with both versions shown
+- [ ] Status reported for each file with summary of what was preserved
 </success_criteria>

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

@@ -0,0 +1,26 @@
+---
+name: gsd-remove-workspace
+description: Remove a GSD workspace and clean up worktrees
+argument-hint: "<workspace-name>"
+permissions:
+   bash: true
+   read: true
+   question: true
+---
+<context>
+**Arguments:**
+- `<workspace-name>` (required) — Name of the workspace to remove
+</context>
+
+<objective>
+Remove a workspace directory after confirmation. For worktree strategy, runs `git worktree remove` for each member repo first. Refuses if any repo has uncommitted changes.
+</objective>
+
+<execution_context>
+@$HOME/.config/opencode/get-shit-done/workflows/remove-workspace.md
+@$HOME/.config/opencode/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<process>
+Execute the remove-workspace workflow from @$HOME/.config/opencode/get-shit-done/workflows/remove-workspace.md end-to-end.
+</process>

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

@@ -23,6 +23,11 @@ Research how to implement a phase. Spawns gsd-phase-researcher agent with phase
 **Why subagent:** Research burns context fast (websearch, Context7 queries, source verification). Fresh 200k context for investigation. Main context stays lean for user interaction.
 </objective>
 
+<available_agent_types>
+Valid GSD subagent types (use exact names — do not fall back to 'general'):
+- gsd-phase-researcher — Researches technical approaches for a phase
+</available_agent_types>
+
 <context>
 Phase number: $ARGUMENTS (required)
 
@@ -135,12 +140,7 @@ write to: .planning/phases/${PHASE}-{slug}/${PHASE}-RESEARCH.md
 ```
 
 ```
-task(
-  prompt=filled_prompt,
-  subagent_type="gsd-phase-researcher",
-  model="{researcher_model}",
-  description="Research Phase {phase}"
-)
+@gsd-phase-researcher filled_prompt
 ```
 
 ## 5. Handle Agent Return
@@ -171,12 +171,7 @@ Continue research for Phase {phase_number}: {phase_name}
 ```
 
 ```
-task(
-  prompt=continuation_prompt,
-  subagent_type="gsd-phase-researcher",
-  model="{researcher_model}",
-  description="Continue research Phase {phase}"
-)
+@gsd-phase-researcher continuation_prompt
 ```
 
 </process>

package/commands/gsd/gsd-review-backlog.md

@@ -0,0 +1,62 @@
+---
+name: gsd-review-backlog
+description: Review and promote backlog items to active milestone
+permissions:
+   read: true
+   write: true
+   bash: true
+   question: true
+---
+
+<objective>
+Review all 999.x backlog items and optionally promote them into the active
+milestone sequence or remove stale entries.
+</objective>
+
+<process>
+
+1. **List backlog items:**
+   ```bash
+   ls -d .planning/phases/999* 2>/dev/null || echo "No backlog items found"
+   ```
+
+2. **read ROADMAP.md** and extract all 999.x phase entries:
+   ```bash
+   cat .planning/ROADMAP.md
+   ```
+   Show each backlog item with its description, any accumulated context (CONTEXT.md, RESEARCH.md), and creation date.
+
+3. **Present the list to the user** via question:
+   - For each backlog item, show: phase number, description, accumulated artifacts
+   - Options per item: **Promote** (move to active), **Keep** (leave in backlog), **Remove** (delete)
+
+4. **For items to PROMOTE:**
+   - Find the next sequential phase number in the active milestone
+   - Rename the directory from `999.x-slug` to `{new_num}-slug`:
+     ```bash
+     NEW_NUM=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" phase add "${DESCRIPTION}" --raw)
+     ```
+   - Move accumulated artifacts to the new phase directory
+   - Update ROADMAP.md: move the entry from `## Backlog` section to the active phase list
+   - Remove `(BACKLOG)` marker
+   - Add appropriate `**Depends on:**` field
+
+5. **For items to REMOVE:**
+   - Delete the phase directory
+   - Remove the entry from ROADMAP.md `## Backlog` section
+
+6. **Commit changes:**
+   ```bash
+   node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" commit "docs: review backlog — promoted N, removed M" --files .planning/ROADMAP.md
+   ```
+
+7. **Report summary:**
+   ```
+   ## 📋 Backlog Review Complete
+
+   Promoted: {list of promoted items with new phase numbers}
+   Kept: {list of items remaining in backlog}
+   Removed: {list of deleted items}
+   ```
+
+</process>