gsd-opencode 1.10.2 → 1.20.0

package/get-shit-done/references/decimal-phase-calculation.md

@@ -0,0 +1,65 @@
+# Decimal Phase Calculation
+
+Calculate the next decimal phase number for urgent insertions.
+
+## Using gsd-tools
+
+```bash
+# Get next decimal phase after phase 6
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phase next-decimal 6
+```
+
+Output:
+```json
+{
+  "found": true,
+  "base_phase": "06",
+  "next": "06.1",
+  "existing": []
+}
+```
+
+With existing decimals:
+```json
+{
+  "found": true,
+  "base_phase": "06",
+  "next": "06.3",
+  "existing": ["06.1", "06.2"]
+}
+```
+
+## Extract Values
+
+```bash
+DECIMAL_INFO=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phase next-decimal "${AFTER_PHASE}")
+DECIMAL_PHASE=$(echo "$DECIMAL_INFO" | jq -r '.next')
+BASE_PHASE=$(echo "$DECIMAL_INFO" | jq -r '.base_phase')
+```
+
+Or with --raw flag:
+```bash
+DECIMAL_PHASE=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phase next-decimal "${AFTER_PHASE}" --raw)
+# Returns just: 06.1
+```
+
+## Examples
+
+| Existing Phases | Next Phase |
+|-----------------|------------|
+| 06 only | 06.1 |
+| 06, 06.1 | 06.2 |
+| 06, 06.1, 06.2 | 06.3 |
+| 06, 06.1, 06.3 (gap) | 06.4 |
+
+## Directory Naming
+
+Decimal phase directories use the full decimal number:
+
+```bash
+SLUG=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs generate-slug "$DESCRIPTION" --raw)
+PHASE_DIR=".planning/phases/${DECIMAL_PHASE}-${SLUG}"
+mkdir -p "$PHASE_DIR"
+```
+
+Example: `.planning/phases/06.1-fix-critical-auth-bug/`

package/get-shit-done/references/git-integration.md

@@ -17,7 +17,7 @@ The git log should read like a changelog of what shipped, not a diary of plannin
 | PLAN.md created         | NO      | Intermediate - commit with plan completion       |
 | RESEARCH.md created     | NO      | Intermediate                                     |
 | DISCOVERY.md created    | NO      | Intermediate                                     |
-| **Task completed**      | YES     | Atomic unit of work (1 commit per task)         |
+| **task completed**      | YES     | Atomic unit of work (1 commit per task)         |
 | **Plan completed**      | YES     | Metadata commit (SUMMARY + STATE + ROADMAP)     |
 | Handoff created         | YES     | WIP state preserved                              |
 
@@ -51,14 +51,13 @@ Phases:
 What to commit:
 
 ```bash
-git add .planning/
-git commit
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: initialize [project-name] ([N] phases)" --files .planning/
 ```
 
 </format>
 
 <format name="task-completion">
-## Task Completion (During Plan Execution)
+## task Completion (During Plan Execution)
 
 Each task gets its own commit immediately after completion.
 
@@ -120,9 +119,9 @@ After all tasks committed, one final metadata commit captures plan completion.
 docs({phase}-{plan}): complete [plan-name] plan
 
 Tasks completed: [N]/[N]
-- [Task 1 name]
-- [Task 2 name]
-- [Task 3 name]
+- [task 1 name]
+- [task 2 name]
+- [task 3 name]
 
 SUMMARY: .planning/phases/XX-name/{phase}-{plan}-SUMMARY.md
 ```
@@ -130,11 +129,7 @@ SUMMARY: .planning/phases/XX-name/{phase}-{plan}-SUMMARY.md
 What to commit:
 
 ```bash
-git add .planning/phases/XX-name/{phase}-{plan}-PLAN.md
-git add .planning/phases/XX-name/{phase}-{plan}-SUMMARY.md
-git add .planning/STATE.md
-git add .planning/ROADMAP.md
-git commit
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs({phase}-{plan}): complete [plan-name] plan" --files .planning/phases/XX-name/{phase}-{plan}-PLAN.md .planning/phases/XX-name/{phase}-{plan}-SUMMARY.md .planning/STATE.md .planning/ROADMAP.md
 ```
 
 **Note:** Code files NOT included - already committed per-task.
@@ -154,8 +149,7 @@ Current: [task name]
 What to commit:
 
 ```bash
-git add .planning/
-git commit
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "wip: [phase-name] paused at task [X]/[Y]" --files .planning/
 ```
 
 </format>
@@ -228,7 +222,7 @@ Each plan produces 2-4 commits (tasks + metadata). Clear, granular, bisectable.
 
 <commit_strategy_rationale>
 
-## Why Per-Task Commits?
+## Why Per-task Commits?
 
 **Context engineering for AI:**
 - Git history becomes primary context source for future OpenCode sessions
@@ -237,7 +231,7 @@ Each plan produces 2-4 commits (tasks + metadata). Clear, granular, bisectable.
 - Less reliance on parsing SUMMARY.md = more context for actual work
 
 **Failure recovery:**
-- Task 1 committed ✅, Task 2 failed ❌
+- task 1 committed ✅, task 2 failed ❌
 - OpenCode in next session: sees task 1 complete, can retry task 2
 - Can `git reset --hard` to last successful task
 

package/get-shit-done/references/git-planning-commit.md

@@ -0,0 +1,38 @@
+# Git Planning Commit
+
+Commit planning artifacts using the gsd-tools CLI, which automatically checks `commit_docs` config and gitignore status.
+
+## Commit via CLI
+
+Always use `gsd-tools.cjs commit` for `.planning/` files — it handles `commit_docs` and gitignore checks automatically:
+
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs({scope}): {description}" --files .planning/STATE.md .planning/ROADMAP.md
+```
+
+The CLI will return `skipped` (with reason) if `commit_docs` is `false` or `.planning/` is gitignored. No manual conditional checks needed.
+
+## Amend previous commit
+
+To fold `.planning/` file changes into the previous commit:
+
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "" --files .planning/codebase/*.md --amend
+```
+
+## Commit Message Patterns
+
+| Command | Scope | Example |
+|---------|-------|---------|
+| plan-phase | phase | `docs(phase-03): create authentication plans` |
+| execute-phase | phase | `docs(phase-03): complete authentication phase` |
+| new-milestone | milestone | `docs: start milestone v1.1` |
+| remove-phase | chore | `chore: remove phase 17 (dashboard)` |
+| insert-phase | phase | `docs: insert phase 16.1 (critical fix)` |
+| add-phase | phase | `docs: add phase 07 (settings page)` |
+
+## When to Skip
+
+- `commit_docs: false` in config
+- `.planning/` is gitignored
+- No changes to commit (check with `git status --porcelain .planning/`)

package/get-shit-done/references/model-profile-resolution.md

@@ -0,0 +1,34 @@
+# Model Profile Resolution
+
+Resolve model profile once at the start of orchestration, then use it for all task spawns.
+
+## Resolution Pattern
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+Default: `simple` if not set or config missing.
+
+## Lookup Table
+
+@~/.config/opencode/get-shit-done/references/model-profiles.md
+
+Look up the agent in the table for the resolved profile. Pass the model parameter to task calls:
+
+```
+task(
+  prompt="...",
+  subagent_type="gsd-planner",
+  model="{resolved_model}"  # "inherit", "sonnet", or "haiku"
+)
+```
+
+**Note:** Opus-tier agents resolve to `"inherit"` (not `"opus"`). This causes the agent to use the parent session's model, avoiding conflicts with organization policies that may block specific opus versions.
+
+## Usage
+
+1. Resolve once at orchestration start
+2. Store the profile value
+3. Look up each agent's model from the table when spawning
+4. Pass model parameter to each task call (values: `"inherit"`, `"sonnet"`, `"haiku"`)

package/get-shit-done/references/model-profiles.md

@@ -2,103 +2,91 @@
 
 Model profiles control which OpenCode model each GSD agent uses. This allows balancing quality vs token spend.
 
-## Stage-to-Agent Mapping
-
-Agents are grouped by stage. Each profile assigns a model to each stage:
-
-| Stage | Agents |
-|-------|--------|
-| Planning | gsd-planner, gsd-plan-checker, gsd-phase-researcher, gsd-roadmapper, gsd-project-researcher, gsd-research-synthesizer, gsd-codebase-mapper |
-| Execution | gsd-executor, gsd-debugger |
-| Verification | gsd-verifier, gsd-integration-checker, gsd-set-profile, gsd-settings |
-
-## Profile Configuration
-
-Models are **user-configured**, not hardcoded. OpenCode supports multiple providers (Anthropic, OpenAI, local models, etc.), so available models vary per installation.
-
-On first run, `/gsd-settings` runs the **Preset Setup Wizard**:
-
-1. Queries `opencode models` to discover available models
-2. Prompts user to select models for each profile/stage combination
-3. Saves to `.planning/config.json`
-
-Configuration structure:
-
-```json
-{
-  "profiles": {
-    "active_profile": "balanced",
-    "presets": {
-      "quality": { "planning": "...", "execution": "...", "verification": "..." },
-      "balanced": { "planning": "...", "execution": "...", "verification": "..." },
-      "budget": { "planning": "...", "execution": "...", "verification": "..." }
-    }
-  }
-}
-```
+## Profile Definitions
+
+| Agent | `quality` | `balanced` | `budget` |
+|-------|-----------|------------|----------|
+| gsd-planner | opus | opus | sonnet |
+| gsd-roadmapper | opus | sonnet | sonnet |
+| gsd-executor | opus | sonnet | sonnet |
+| gsd-phase-researcher | opus | sonnet | haiku |
+| gsd-project-researcher | opus | sonnet | haiku |
+| gsd-research-synthesizer | sonnet | sonnet | haiku |
+| gsd-debugger | opus | sonnet | sonnet |
+| gsd-codebase-mapper | sonnet | haiku | haiku |
+| gsd-verifier | sonnet | sonnet | haiku |
+| gsd-plan-checker | sonnet | sonnet | haiku |
+| gsd-integration-checker | sonnet | sonnet | haiku |
 
 ## Profile Philosophy
 
-When configuring presets, consider these guidelines:
-
 **quality** - Maximum reasoning power
-
-- Use your most capable model for all stages
+- Opus for all decision-making agents
+- Sonnet for read-only verification
 - Use when: quota available, critical architecture work
 
 **balanced** (default) - Smart allocation
-
-- Strong model for planning (where architecture decisions happen)
-- Mid-tier model for execution (follows explicit instructions)
-- Mid-tier model for verification (needs reasoning, not just pattern matching)
+- Opus only for planning (where architecture decisions happen)
+- Sonnet for execution and research (follows explicit instructions)
+- Sonnet for verification (needs reasoning, not just pattern matching)
 - Use when: normal development, good balance of quality and cost
 
-**budget** - Minimal token spend
-
-- Mid-tier model for anything that writes code
-- Lightweight model for research and verification
+**budget** - Minimal Opus usage
+- Sonnet for anything that writes code
+- Haiku for research and verification
 - Use when: conserving quota, high-volume work, less critical phases
 
 ## Resolution Logic
 
 Orchestrators resolve model before spawning:
 
-```text
-1. Read .planning/config.json
-2. Get active_profile (default: "balanced")
-3. Look up preset[profile][stage] for the agent's stage
-4. Apply any custom_overrides[profile][stage] if set
-5. Pass model parameter to Task call
+```
+1. read .planning/config.json
+2. Check model_overrides for agent-specific override
+3. If no override, look up agent in profile table
+4. Pass model parameter to task call
 ```
 
-Agent-to-model mappings are written to `opencode.json` by `/gsd-set-profile` and `/gsd-settings`.
+## Per-Agent Overrides
 
-## Switching Profiles
+Override specific agents without changing the entire profile:
 
-Runtime: `/gsd-set-profile <profile>`
+```json
+{
+  "model_profile": "balanced",
+  "model_overrides": {
+    "gsd-executor": "opus",
+    "gsd-planner": "haiku"
+  }
+}
+```
 
-Interactive settings: `/gsd-settings`
+Overrides take precedence over the profile. Valid values: `opus`, `sonnet`, `haiku`.
 
-Per-project default stored in `.planning/config.json`:
+## Switching Profiles
 
+Runtime: `/gsd-set-profile <profile>`
+
+Per-project default: Set in `.planning/config.json`:
 ```json
 {
-  "profiles": {
-    "active_profile": "balanced"
-  }
+  "model_profile": "balanced"
 }
 ```
 
 ## Design Rationale
 
-**Why use your strongest model for planning?**
+**Why Opus for gsd-planner?**
 Planning involves architecture decisions, goal decomposition, and task design. This is where model quality has the highest impact.
 
-**Why mid-tier for execution?**
+**Why Sonnet for gsd-executor?**
 Executors follow explicit PLAN.md instructions. The plan already contains the reasoning; execution is implementation.
 
-**Why mid-tier (not lightweight) for verification?**
-Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Mid-tier models handle this well; lightweight models may miss subtle gaps.
+**Why Sonnet (not Haiku) for verifiers in balanced?**
+Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Sonnet handles this well; Haiku may miss subtle gaps.
+
+**Why Haiku for gsd-codebase-mapper?**
+read-only exploration and pattern extraction. No reasoning required, just structured output from file contents.
 
-**Why lightweight for codebase mapping?**
-Read-only exploration and pattern extraction. No complex reasoning required, just structured output from file contents.
+**Why `inherit` instead of passing `opus` directly?**
+OpenCode's `"opus"` alias maps to a specific model version. Organizations may block older opus versions while allowing newer ones. GSD returns `"inherit"` for opus-tier agents, causing them to use whatever opus version the user has configured in their session. This avoids version conflicts and silent fallbacks to Sonnet.

package/get-shit-done/references/phase-argument-parsing.md

@@ -0,0 +1,61 @@
+# Phase Argument Parsing
+
+Parse and normalize phase arguments for commands that operate on phases.
+
+## Extraction
+
+From `$ARGUMENTS`:
+- Extract phase number (first numeric argument)
+- Extract flags (prefixed with `--`)
+- Remaining text is description (for insert/add commands)
+
+## Using gsd-tools
+
+The `find-phase` command handles normalization and validation in one step:
+
+```bash
+PHASE_INFO=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs find-phase "${PHASE}")
+```
+
+Returns JSON with:
+- `found`: true/false
+- `directory`: Full path to phase directory
+- `phase_number`: Normalized number (e.g., "06", "06.1")
+- `phase_name`: Name portion (e.g., "foundation")
+- `plans`: Array of PLAN.md files
+- `summaries`: Array of SUMMARY.md files
+
+## Manual Normalization (Legacy)
+
+Zero-pad integer phases to 2 digits. Preserve decimal suffixes.
+
+```bash
+# Normalize phase number
+if [[ "$PHASE" =~ ^[0-9]+$ ]]; then
+  # Integer: 8 → 08
+  PHASE=$(printf "%02d" "$PHASE")
+elif [[ "$PHASE" =~ ^([0-9]+)\.([0-9]+)$ ]]; then
+  # Decimal: 2.1 → 02.1
+  PHASE=$(printf "%02d.%s" "${BASH_REMATCH[1]}" "${BASH_REMATCH[2]}")
+fi
+```
+
+## Validation
+
+Use `roadmap get-phase` to validate phase exists:
+
+```bash
+PHASE_CHECK=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs roadmap get-phase "${PHASE}")
+if [ "$(echo "$PHASE_CHECK" | jq -r '.found')" = "false" ]; then
+  echo "ERROR: Phase ${PHASE} not found in roadmap"
+  exit 1
+fi
+```
+
+## Directory Lookup
+
+Use `find-phase` for directory lookup:
+
+```bash
+PHASE_DIR=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs find-phase "${PHASE}" --raw)
+```

package/get-shit-done/references/planning-config.md

@@ -7,6 +7,11 @@ Configuration options for `.planning/` directory behavior.
 "planning": {
   "commit_docs": true,
   "search_gitignored": false
+},
+"git": {
+  "branching_strategy": "none",
+  "phase_branch_template": "gsd/phase-{phase}-{slug}",
+  "milestone_branch_template": "gsd/{milestone}-{slug}"
 }
 ```
 
@@ -14,6 +19,9 @@ Configuration options for `.planning/` directory behavior.
 |--------|---------|-------------|
 | `commit_docs` | `true` | Whether to commit planning artifacts to git |
 | `search_gitignored` | `false` | Add `--no-ignore` to broad rg searches |
+| `git.branching_strategy` | `"none"` | Git branching approach: `"none"`, `"phase"`, or `"milestone"` |
+| `git.phase_branch_template` | `"gsd/phase-{phase}-{slug}"` | Branch template for phase strategy |
+| `git.milestone_branch_template` | `"gsd/{milestone}-{slug}"` | Branch template for milestone strategy |
 </config_schema>
 
 <commit_docs_behavior>
@@ -28,27 +36,31 @@ Configuration options for `.planning/` directory behavior.
 - User must add `.planning/` to `.gitignore`
 - Useful for: OSS contributions, client projects, keeping planning private
 
-**Checking the config:**
+**Using gsd-tools.cjs (preferred):**
 
 ```bash
-# Check config.json first
-COMMIT_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+# Commit with automatic commit_docs + gitignore checks:
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: update state" --files .planning/STATE.md
+
+# Load config via state load (returns JSON):
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs state load)
+# commit_docs is available in the JSON output
 
-# Auto-detect gitignored (overrides config)
-git check-ignore -q .planning 2>/dev/null && COMMIT_DOCS=false
+# Or use init commands which include commit_docs:
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs init execute-phase "1")
+# commit_docs is included in all init command outputs
 ```
 
 **Auto-detection:** If `.planning/` is gitignored, `commit_docs` is automatically `false` regardless of config.json. This prevents git errors when users have `.planning/` in `.gitignore`.
 
-**Conditional git operations:**
+**Commit via CLI (handles checks automatically):**
 
 ```bash
-if [ "$COMMIT_DOCS" = "true" ]; then
-  git add .planning/STATE.md
-  git commit -m "docs: update state"
-fi
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs: update state" --files .planning/STATE.md
 ```
 
+The CLI checks `commit_docs` config and gitignore status internally — no manual conditionals needed.
+
 </commit_docs_behavior>
 
 <search_behavior>
@@ -89,6 +101,96 @@ To use uncommitted mode:
    git commit -m "chore: stop tracking planning docs"
    ```
 
+4. **Branch merges:** When using `branching_strategy: phase` or `milestone`, the `complete-milestone` workflow automatically strips `.planning/` files from staging before merge commits when `commit_docs: false`.
+
 </setup_uncommitted_mode>
 
+<branching_strategy_behavior>
+
+**Branching Strategies:**
+
+| Strategy | When branch created | Branch scope | Merge point |
+|----------|---------------------|--------------|-------------|
+| `none` | Never | N/A | N/A |
+| `phase` | At `execute-phase` start | Single phase | User merges after phase |
+| `milestone` | At first `execute-phase` of milestone | Entire milestone | At `complete-milestone` |
+
+**When `git.branching_strategy: "none"` (default):**
+- All work commits to current branch
+- Standard GSD behavior
+
+**When `git.branching_strategy: "phase"`:**
+- `execute-phase` creates/switches to a branch before execution
+- Branch name from `phase_branch_template` (e.g., `gsd/phase-03-authentication`)
+- All plan commits go to that branch
+- User merges branches manually after phase completion
+- `complete-milestone` offers to merge all phase branches
+
+**When `git.branching_strategy: "milestone"`:**
+- First `execute-phase` of milestone creates the milestone branch
+- Branch name from `milestone_branch_template` (e.g., `gsd/v1.0-mvp`)
+- All phases in milestone commit to same branch
+- `complete-milestone` offers to merge milestone branch to main
+
+**Template variables:**
+
+| Variable | Available in | Description |
+|----------|--------------|-------------|
+| `{phase}` | phase_branch_template | Zero-padded phase number (e.g., "03") |
+| `{slug}` | Both | Lowercase, hyphenated name |
+| `{milestone}` | milestone_branch_template | Milestone version (e.g., "v1.0") |
+
+**Checking the config:**
+
+Use `init execute-phase` which returns all config as JSON:
+```bash
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs init execute-phase "1")
+# JSON output includes: branching_strategy, phase_branch_template, milestone_branch_template
+```
+
+Or use `state load` for the config values:
+```bash
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs state load)
+# Parse branching_strategy, phase_branch_template, milestone_branch_template from JSON
+```
+
+**Branch creation:**
+
+```bash
+# For phase strategy
+if [ "$BRANCHING_STRATEGY" = "phase" ]; then
+  PHASE_SLUG=$(echo "$PHASE_NAME" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+  BRANCH_NAME=$(echo "$PHASE_BRANCH_TEMPLATE" | sed "s/{phase}/$PADDED_PHASE/g" | sed "s/{slug}/$PHASE_SLUG/g")
+  git checkout -b "$BRANCH_NAME" 2>/dev/null || git checkout "$BRANCH_NAME"
+fi
+
+# For milestone strategy
+if [ "$BRANCHING_STRATEGY" = "milestone" ]; then
+  MILESTONE_SLUG=$(echo "$MILESTONE_NAME" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+  BRANCH_NAME=$(echo "$MILESTONE_BRANCH_TEMPLATE" | sed "s/{milestone}/$MILESTONE_VERSION/g" | sed "s/{slug}/$MILESTONE_SLUG/g")
+  git checkout -b "$BRANCH_NAME" 2>/dev/null || git checkout "$BRANCH_NAME"
+fi
+```
+
+**Merge options at complete-milestone:**
+
+| Option | Git command | Result |
+|--------|-------------|--------|
+| Squash merge (recommended) | `git merge --squash` | Single clean commit per branch |
+| Merge with history | `git merge --no-ff` | Preserves all individual commits |
+| Delete without merging | `git branch -D` | Discard branch work |
+| Keep branches | (none) | Manual handling later |
+
+Squash merge is recommended — keeps main branch history clean while preserving the full development history in the branch (until deleted).
+
+**Use cases:**
+
+| Strategy | Best for |
+|----------|----------|
+| `none` | Solo development, simple projects |
+| `phase` | Code review per phase, granular rollback, team collaboration |
+| `milestone` | Release branches, staging environments, PR per version |
+
+</branching_strategy_behavior>
+
 </planning_config>

package/get-shit-done/references/questioning.md

@@ -79,6 +79,7 @@ Use question to help users think by presenting concrete options to react to.
 - Generic categories ("Technical", "Business", "Other")
 - Leading options that presume an answer
 - Too many options (2-4 is ideal)
+- Headers longer than 12 characters (hard limit — validation will reject them)
 
 **Example — vague answer:**
 User says "it should be fast"
@@ -94,6 +95,9 @@ User mentions "frustrated with current tools"
 - question: "What specifically frustrates you?"
 - options: ["Too many clicks", "Missing features", "Unreliable", "Let me explain"]
 
+**Tip for users — modifying an option:**
+Users who want a slightly modified version of an option can select "Other" and reference the option by number: `#1 but for finger joints only` or `#2 with pagination disabled`. This avoids retyping the full option text.
+
 </using_askuserquestion>
 
 <context_checklist>

package/get-shit-done/references/ui-brand.md

@@ -69,7 +69,7 @@ User action required. 62-character width.
 Progress: ████████░░ 80%
 ```
 
-**Task level:**
+**task level:**
 ```
 Tasks: 2/4 complete
 ```

package/get-shit-done/templates/UAT.md

@@ -1,6 +1,6 @@
 # UAT Template
 
-Template for `.planning/phases/XX-name/{phase}-UAT.md` — persistent UAT session tracking.
+Template for `.planning/phases/XX-name/{phase_num}-UAT.md` — persistent UAT session tracking.
 
 ---