feat: /gsd-ultraplan-phase [BETA] — offload plan phase to Claude Code ultraplan (#2378)

* docs: add design spec for /gsd-ultraplan-phase beta command Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * feat: add /gsd-ultraplan-phase [BETA] command Offloads GSD plan phase to Claude Code's ultraplan cloud infrastructure. Plan drafts remotely while terminal stays free; browser UI for inline comments and revisions; imports back via existing /gsd-import --from. Intentionally isolated from /gsd-plan-phase so upstream ultraplan changes cannot break the core planning pipeline. Closes #2374 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * fix: resolve 5 pre-existing test failures before PR - ARCHITECTURE.md: update command count 75→80 and workflow count 72→77 (stale doc counts; also incremented by new ultraplan-phase files) - sketch.md: add TEXT_MODE plain-text fallback for AskUserQuestion (#2012) - read-guard.test.cjs: clear CLAUDECODE env var alongside CLAUDE_SESSION_ID so positive-path hook tests pass when run inside a Claude Code session Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * docs: add BETA.md with /gsd-ultraplan-phase user documentation Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * fix: address CodeRabbit review — MD040 fence labels and sketch.md TEXT_MODE duplicate - Add language identifiers to all unlabeled fenced blocks in ultraplan-phase.md and design spec (resolves MD040) - Remove duplicate TEXT_MODE explanation from sketch.md mood_intake step (was identical to the banner step definition) - Make AskUserQuestion conditional explicit in mood_intake prose Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-04-17 14:45:03 -04:00
parent 2e97dee0d0
commit 794f7e1b0b
8 changed files with 677 additions and 6 deletions
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -113,7 +113,7 @@ User-facing entry points. Each file contains YAML frontmatter (name, description
 - **Copilot:** Slash commands (`/gsd-command-name`)
 - **Antigravity:** Skills

-**Total commands:** 79
+**Total commands:** 80

 ### Workflows (`get-shit-done/workflows/*.md`)

@@ -124,7 +124,7 @@ Orchestration logic that commands reference. Contains the step-by-step process i
 - State update patterns
 - Error handling and recovery

-**Total workflows:** 76
+**Total workflows:** 77

 ### Agents (`agents/*.md`)

@@ -409,11 +409,11 @@ UI-SPEC.md (per phase) ───────────────────

 ```
 ~/.claude/                          # Claude Code (global install)
-├── commands/gsd/*.md               # 79 slash commands
+├── commands/gsd/*.md               # 80 slash commands
 ├── get-shit-done/
 │   ├── bin/gsd-tools.cjs           # CLI utility
 │   ├── bin/lib/*.cjs               # 19 domain modules
-│   ├── workflows/*.md              # 72 workflow definitions
+│   ├── workflows/*.md              # 77 workflow definitions
 │   ├── references/*.md             # 35 shared reference docs
 │   └── templates/                  # Planning artifact templates
 ├── agents/*.md                     # 31 agent definitions
--- a/docs/BETA.md
+++ b/docs/BETA.md
@@ -0,0 +1,98 @@
+# GSD Beta Features
+
+> **Beta features are opt-in and may change or be removed without notice.** They are not covered by the stable API guarantees that apply to the rest of GSD. If a beta feature ships to stable, it will be documented in [COMMANDS.md](COMMANDS.md) and [FEATURES.md](FEATURES.md) with a changelog entry.
+
+---
+
+## `/gsd-ultraplan-phase` — Ultraplan Integration [BETA]
+
+> **Claude Code only · Requires Claude Code v2.1.91+**
+> Ultraplan is itself a Claude Code research preview — both this command and the underlying feature may change.
+
+### What it does
+
+`/gsd-ultraplan-phase` offloads GSD's plan-phase drafting to [Claude Code's ultraplan](https://code.claude.ai) cloud infrastructure. Instead of planning locally in the terminal, the plan is drafted in a browser-based session with:
+
+- An **outline sidebar** for navigating the plan structure
+- **Inline comments** for annotating and refining tasks
+- A persistent browser tab so your terminal stays free while the plan is being drafted
+
+When you're satisfied with the draft, you save it and import it back into GSD — conflict detection, format validation, and plan-checker verification all run automatically.
+
+### Why use it
+
+| Situation | Recommendation |
+|-----------|---------------|
+| Long, complex phases where you want to read and comment on the plan before it executes | Use `/gsd-ultraplan-phase` |
+| Quick phases, familiar domain, or non-Claude Code runtimes | Use `/gsd-plan-phase` (stable) |
+| You have a plan from another source (teammate, external AI) | Use `/gsd-import` |
+
+### Requirements
+
+- **Runtime:** Claude Code only. The command exits with an error on Gemini CLI, Copilot CLI, and other runtimes.
+- **Version:** Claude Code v2.1.91 or later (the `$CLAUDE_CODE_VERSION` env var must be set).
+- **Cost:** No extra charge for Pro and Max subscribers. Ultraplan is included at no additional cost.
+
+### Usage
+
+```bash
+/gsd-ultraplan-phase         # Ultraplan the next unplanned phase
+/gsd-ultraplan-phase 2       # Ultraplan a specific phase number
+```
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| `N` | No | Phase number (defaults to next unplanned phase) |
+
+### How it works
+
+1. **Initialization** — GSD runs the standard plan-phase init, resolving which phase to plan and confirming prerequisites.
+
+2. **Context assembly** — GSD reads `ROADMAP.md`, `REQUIREMENTS.md`, and any existing `RESEARCH.md` for the phase. This context is bundled into a structured prompt so ultraplan has everything it needs without you copying anything manually.
+
+3. **Return-path instructions** — Before launching ultraplan, GSD prints the import command to your terminal so it's visible in your scroll-back buffer after the browser session ends:
+   ```
+   When done: /gsd-import --from <path-to-saved-plan>
+   ```
+
+4. **Ultraplan launches** — The `/ultraplan` command hands off to the browser. Use the outline sidebar and inline comments to review and refine the draft.
+
+5. **Save the plan** — When satisfied, click **Cancel** in Claude Code. Claude Code saves the plan to a local file and returns you to the terminal.
+
+6. **Import back into GSD** — Run the import command that was printed in step 3:
+   ```bash
+   /gsd-import --from /path/to/saved-plan.md
+   ```
+   This runs conflict detection against `PROJECT.md`, converts the plan to GSD format, validates it with `gsd-plan-checker`, updates `ROADMAP.md`, and commits — the same path as any external plan import.
+
+### What gets produced
+
+| Step | Output |
+|------|--------|
+| After ultraplan | External plan file (saved by Claude Code) |
+| After `/gsd-import` | `{phase}-{N}-PLAN.md` in `.planning/phases/` |
+
+### What this command does NOT do
+
+- Write `PLAN.md` files directly — all writes go through `/gsd-import`
+- Replace `/gsd-plan-phase` — local planning is unaffected and remains the default
+- Run research agents — if you need `RESEARCH.md` first, run `/gsd-plan-phase --skip-verify` or a research-only pass before using this command
+
+### Troubleshooting
+
+**"ultraplan is not available in this runtime"**
+You're running GSD outside of Claude Code. Switch to a Claude Code terminal session, or use `/gsd-plan-phase` instead.
+
+**Ultraplan browser session never opened**
+Check your Claude Code version: `claude --version`. Requires v2.1.91+. Update with `claude update`.
+
+**`/gsd-import` reports conflicts**
+Ultraplan may have proposed something that contradicts a decision in `PROJECT.md`. The import step will prompt you to resolve each conflict before writing anything.
+
+**Plan checker fails after import**
+The imported plan has structural issues. Review the checker output, edit the saved file to fix them, and re-run `/gsd-import --from <same-file>`.
+
+### Related commands
+
+- [`/gsd-plan-phase`](COMMANDS.md#gsd-plan-phase) — standard local planning (stable, all runtimes)
+- [`/gsd-import`](COMMANDS.md#gsd-import) — import any external plan file into GSD
--- a/docs/superpowers/specs/2026-04-17-ultraplan-phase-design.md
+++ b/docs/superpowers/specs/2026-04-17-ultraplan-phase-design.md
@@ -0,0 +1,160 @@
+# Design: /gsd-ultraplan-phase [BETA]
+
+**Date:** 2026-04-17
+**Status:** Approved — ready for implementation
+**Branch:** Beta feature, isolated from core plan pipeline
+
+---
+
+## Summary
+
+A standalone `/gsd-ultraplan-phase` command that offloads GSD's research+plan phase to Claude Code's ultraplan cloud infrastructure. The plan drafts remotely while the terminal stays free, is reviewed in a rich browser UI with inline comments, then imports back into GSD via the existing `/gsd-import --from` workflow.
+
+This is a **beta of a beta**: ultraplan itself is in research preview, so this command is intentionally isolated from the core `/gsd-plan-phase` pipeline to prevent breakage if ultraplan changes.
+
+---
+
+## Scope
+
+**In scope:**
+- New `commands/gsd/ultraplan-phase.md` command
+- New `get-shit-done/workflows/ultraplan-phase.md` workflow
+- Runtime gate: Claude Code only (checks `$CLAUDE_CODE_VERSION`)
+- Builds structured ultraplan prompt from GSD phase context
+- Return path via existing `/gsd-import --from <file>` (no new import logic)
+
+**Out of scope (future):**
+- Parallel next-phase planning during `/gsd-execute-phase`
+- Auto-detection of ultraplan's saved file path
+- Text mode / non-interactive fallback
+
+---
+
+## Architecture
+
+```text
+/gsd-ultraplan-phase [phase]
+        │
+        ├─ Runtime gate (CLAUDE_CODE_VERSION check)
+        ├─ gsd-sdk query init.plan-phase → phase context
+        ├─ Build ultraplan prompt (phase scope + requirements + research)
+        ├─ Display return-path instructions card
+        └─ /ultraplan <prompt>
+                │
+                [cloud: user reviews, comments, revises]
+                │
+                [browser: Approve → teleport back to terminal]
+                │
+                [terminal: Cancel → saves to file]
+                │
+                /gsd-import --from <saved file path>
+                        │
+                        ├─ Conflict detection
+                        ├─ GSD format conversion
+                        ├─ gsd-plan-checker validation
+                        ├─ ROADMAP.md update
+                        └─ Commit
+```
+
+---
+
+## Command File (`commands/gsd/ultraplan-phase.md`)
+
+Frontmatter:
+- `name: gsd:ultraplan-phase`
+- `description:` includes `[BETA]` marker
+- `argument-hint: [phase-number]`
+- `allowed-tools:` Read, Bash, Glob, Grep
+- References: `@~/.claude/get-shit-done/workflows/ultraplan-phase.md`, ui-brand
+
+---
+
+## Workflow Steps
+
+### 1. Banner
+Display GSD `► ULTRAPLAN PHASE [BETA]` banner.
+
+### 2. Runtime Gate
+```bash
+echo $CLAUDE_CODE_VERSION
+```
+If unset/empty: print error and exit.
+```text
+⚠ /gsd-ultraplan-phase requires Claude Code.
+  /ultraplan is not available in this runtime.
+  Use /gsd-plan-phase for local planning.
+```
+
+### 3. Initialize
+```bash
+INIT=$(gsd-sdk query init.plan-phase "$PHASE")
+```
+Parse: phase number, phase name, phase slug, phase dir, roadmap path, requirements path, research path.
+
+If no `.planning/` exists: error — run `/gsd-new-project` first.
+
+### 4. Build Ultraplan Prompt
+Construct a prompt that includes:
+- Phase identification: `"Plan phase {N}: {phase name}"`
+- Phase scope block from ROADMAP.md
+- Requirements summary (if REQUIREMENTS.md exists)
+- Research summary (if RESEARCH.md exists — reduces cloud redundancy)
+- Output format instruction: produce a GSD PLAN.md with standard frontmatter fields
+
+### 5. Return-Path Instructions Card
+Display prominently before triggering (visible in terminal scroll-back):
+```text
+When ◆ ultraplan ready:
+  1. Open the session link in your browser
+  2. Review, comment, and revise the plan
+  3. When satisfied: "Approve plan and teleport back to terminal"
+  4. At the terminal dialog: choose Cancel (saves plan to file)
+  5. Run: /gsd-import --from <the file path Claude prints>
+```
+
+### 6. Trigger Ultraplan
+```text
+/ultraplan <constructed prompt>
+```
+
+---
+
+## Return Path
+
+No new code needed. The user runs `/gsd-import --from <path>` after ultraplan saves the file. That workflow handles everything: conflict detection, GSD format conversion, plan-checker, ROADMAP update, commit.
+
+---
+
+## Runtime Detection
+
+`$CLAUDE_CODE_VERSION` is set by Claude Code in the shell environment. If unset, the session is not Claude Code (Gemini CLI, Copilot, etc.) and `/ultraplan` does not exist.
+
+---
+
+## Pricing
+
+Ultraplan runs as a standard Claude Code on the web session. For Pro/Max subscribers this is included in the subscription — no extra usage billing (unlike ultrareview which bills $5–20/run). No cost gate needed.
+
+---
+
+## Beta Markers
+
+- `[BETA]` in command description
+- `⚠ BETA` in workflow banner
+- Comment in workflow noting ultraplan is in research preview
+
+---
+
+## Test Coverage
+
+`tests/ultraplan-phase.test.cjs` — structural assertions covering:
+- File existence (command + workflow)
+- Command frontmatter completeness (name, description with `[BETA]`, argument-hint)
+- Command references workflow
+- Workflow has runtime gate (`CLAUDE_CODE_VERSION`)
+- Workflow has beta warning
+- Workflow has init step (gsd-sdk query)
+- Workflow builds ultraplan prompt with phase context
+- Workflow triggers `/ultraplan`
+- Workflow has return-path instructions (Cancel path, `/gsd-import --from`)
+- Workflow does NOT directly implement plan writing (delegates to `/gsd-import`)