1.7.0

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.planning/REQUIREMENTS.md

@@ -7,24 +7,24 @@
 
 ### Command
 
-- [ ] **CMD-01**: `/gsd:quick "description"` parses description from arguments
-- [ ] **CMD-02**: Command errors if .planning/ROADMAP.md doesn't exist
-- [ ] **CMD-03**: Command calculates next decimal phase from current phase in STATE.md
-- [ ] **CMD-04**: Command creates phase directory `.planning/phases/{decimal}-{slug}/`
-- [ ] **CMD-05**: Command inserts decimal phase entry in ROADMAP.md
+- [x] **CMD-01**: `/gsd:quick "description"` parses description from arguments
+- [x] **CMD-02**: Command errors if .planning/ROADMAP.md doesn't exist
+- [x] **CMD-03**: Command calculates next decimal phase from current phase in STATE.md
+- [x] **CMD-04**: Command creates phase directory `.planning/phases/{decimal}-{slug}/`
+- [x] **CMD-05**: Command inserts decimal phase entry in ROADMAP.md
 
 ### Execution
 
-- [ ] **EXEC-01**: Command spawns gsd-planner (no researcher, no checker)
-- [ ] **EXEC-02**: Command spawns gsd-executor for each plan created
-- [ ] **EXEC-03**: Multiple plans execute in parallel waves (same as execute-phase)
-- [ ] **EXEC-04**: Executor commits only files it edits/creates
+- [x] **EXEC-01**: Command spawns gsd-planner (no researcher, no checker)
+- [x] **EXEC-02**: Command spawns gsd-executor for each plan created
+- [x] **EXEC-03**: Multiple plans execute in parallel waves (same as execute-phase)
+- [x] **EXEC-04**: Executor commits only files it edits/creates
 
 ### State
 
-- [ ] **STATE-01**: STATE.md "Last activity" updated after completion
-- [ ] **STATE-02**: STATE.md "Quick Tasks Completed" table created/updated
-- [ ] **STATE-03**: ROADMAP.md decimal phase marked complete with date
+- [x] **STATE-01**: STATE.md "Last activity" updated after completion
+- [x] **STATE-02**: STATE.md "Quick Tasks Completed" table created/updated
+- [x] **STATE-03**: ROADMAP.md decimal phase marked complete with date
 
 ### Resume
 
@@ -33,9 +33,9 @@
 
 ### Docs
 
-- [ ] **DOCS-01**: help.md lists `/gsd:quick` command
-- [ ] **DOCS-02**: README.md includes quick mode section
-- [ ] **DOCS-03**: GSD-STYLE.md documents quick mode patterns
+- [x] **DOCS-01**: help.md lists `/gsd:quick` command
+- [x] **DOCS-02**: README.md includes quick mode section
+- [x] **DOCS-03**: GSD-STYLE.md documents quick mode patterns
 
 ## v2 Requirements
 
@@ -59,23 +59,23 @@
 
 | Requirement | Phase | Status |
 |-------------|-------|--------|
-| CMD-01 | Phase 1 | Pending |
-| CMD-02 | Phase 1 | Pending |
-| CMD-03 | Phase 1 | Pending |
-| CMD-04 | Phase 1 | Pending |
-| CMD-05 | Phase 1 | Pending |
-| EXEC-01 | Phase 1 | Pending |
-| EXEC-02 | Phase 1 | Pending |
-| EXEC-03 | Phase 1 | Pending |
-| EXEC-04 | Phase 1 | Pending |
-| STATE-01 | Phase 1 | Pending |
-| STATE-02 | Phase 1 | Pending |
-| STATE-03 | Phase 1 | Pending |
+| CMD-01 | Phase 1 | Complete |
+| CMD-02 | Phase 1 | Complete |
+| CMD-03 | Phase 1 | Complete |
+| CMD-04 | Phase 1 | Complete |
+| CMD-05 | Phase 1 | Complete |
+| EXEC-01 | Phase 1 | Complete |
+| EXEC-02 | Phase 1 | Complete |
+| EXEC-03 | Phase 1 | Complete |
+| EXEC-04 | Phase 1 | Complete |
+| STATE-01 | Phase 1 | Complete |
+| STATE-02 | Phase 1 | Complete |
+| STATE-03 | Phase 1 | Complete |
 | RESUME-01 | Phase 2 | Pending |
 | RESUME-02 | Phase 2 | Pending |
-| DOCS-01 | Phase 3 | Pending |
-| DOCS-02 | Phase 3 | Pending |
-| DOCS-03 | Phase 3 | Pending |
+| DOCS-01 | Phase 2 | Complete |
+| DOCS-02 | Phase 2 | Complete |
+| DOCS-03 | Phase 2 | Complete |
 
 **Coverage:**
 - v1 requirements: 17 total

.planning/ROADMAP.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-Quick mode adds a fast-path command (`/gsd:quick`) that executes small tasks with full GSD guarantees (atomic commits, STATE.md tracking, ROADMAP.md integration) but skips optional verification agents. The roadmap delivers the command, integrates it with resume-work, and documents the feature.
+Quick mode adds a fast-path command (`/gsd:quick`) that executes small tasks with full GSD guarantees (atomic commits, STATE.md tracking) but skips optional verification agents. Quick tasks live in `.planning/quick/` separate from planned phases.
 
 ## Phases
 
@@ -10,59 +10,40 @@ Quick mode adds a fast-path command (`/gsd:quick`) that executes small tasks wit
 - Integer phases (1, 2, 3): Planned milestone work
 - Decimal phases (2.1, 2.2): Urgent insertions (marked with INSERTED)
 
-- [ ] **Phase 1: Core Command** - Complete `/gsd:quick` command end-to-end
-- [ ] **Phase 2: Resume Integration** - Update `/gsd:resume-work` for decimal phases
-- [ ] **Phase 3: Documentation** - Update help.md, README.md, and GSD-STYLE.md
+- [x] **Phase 1: Core Command** - Complete `/gsd:quick` command end-to-end
+- [x] **Phase 2: Documentation** - Update help.md, README.md, and GSD-STYLE.md
 
 ## Phase Details
 
 ### Phase 1: Core Command
-**Goal**: User can run `/gsd:quick "description"` and have it execute with full state tracking
+**Goal**: User can run `/gsd:quick` (with interactive prompt) and have it execute with full state tracking
 **Depends on**: Nothing (first phase)
-**Requirements**: CMD-01, CMD-02, CMD-03, CMD-04, CMD-05, EXEC-01, EXEC-02, EXEC-03, EXEC-04, STATE-01, STATE-02, STATE-03
-**Success Criteria** (what must be TRUE):
-  1. User can run `/gsd:quick "fix button spacing"` and it parses the description
-  2. Command fails with clear error if no ROADMAP.md exists
-  3. Decimal phase directory created (e.g., `.planning/phases/1.1-fix-button-spacing/`)
-  4. ROADMAP.md contains new decimal phase entry after command completes
-  5. STATE.md "Last activity" and "Quick Tasks Completed" table updated after execution
-**Plans**: TBD
+**Requirements**: CMD-01, CMD-02, CMD-03, CMD-04, EXEC-01, EXEC-02, EXEC-03, EXEC-04, STATE-01, STATE-02
+**Plans:** 2 plans
 
 Plans:
-- [ ] 01-01: TBD
+- [x] 01-01-PLAN.md — Quick command file with pre-flight validation and directory setup
+- [x] 01-02-PLAN.md — Quick orchestration (planner spawn, executor spawn, state update)
 
-### Phase 2: Resume Integration
-**Goal**: User can resume failed quick tasks using existing `/gsd:resume-work`
-**Depends on**: Phase 1
-**Requirements**: RESUME-01, RESUME-02
-**Success Criteria** (what must be TRUE):
-  1. `/gsd:resume-work` correctly parses decimal phase numbers (3.1, 3.2)
-  2. `/gsd:resume-work` finds and resumes decimal phase directories
-**Plans**: TBD
-
-Plans:
-- [ ] 02-01: TBD
-
-### Phase 3: Documentation
+### Phase 2: Documentation
 **Goal**: Quick mode is documented in all relevant locations
-**Depends on**: Phase 2
+**Depends on**: Phase 1
 **Requirements**: DOCS-01, DOCS-02, DOCS-03
 **Success Criteria** (what must be TRUE):
   1. help.md lists `/gsd:quick` with usage and description
   2. README.md includes quick mode section explaining when to use it
   3. GSD-STYLE.md documents quick mode patterns
-**Plans**: TBD
+**Plans:** 1 plan
 
 Plans:
-- [ ] 03-01: TBD
+- [x] 02-01-PLAN.md — Document /gsd:quick in help.md, README.md, and GSD-STYLE.md
 
 ## Progress
 
 **Execution Order:**
-Phases execute in numeric order: 1 -> 2 -> 3
+Phases execute in numeric order: 1 -> 2
 
 | Phase | Plans Complete | Status | Completed |
 |-------|----------------|--------|-----------|
-| 1. Core Command | 0/? | Not started | - |
-| 2. Resume Integration | 0/? | Not started | - |
-| 3. Documentation | 0/? | Not started | - |
+| 1. Core Command | 2/2 | Complete | 2026-01-19 |
+| 2. Documentation | 1/1 | Complete | 2026-01-19 |

.planning/STATE.md

@@ -5,36 +5,43 @@
 See: .planning/PROJECT.md (updated 2025-01-19)
 
 **Core value:** Same guarantees, 50-70% fewer tokens for simple tasks
-**Current focus:** Phase 1 - Core Command
+**Current focus:** Phase 2 - Documentation
 
 ## Current Position
 
-Phase: 1 of 3 (Core Command)
-Plan: 0 of ? in current phase
-Status: Ready to plan
-Last activity: 2025-01-19 - Roadmap created
+Phase: 2 of 2 (Documentation)
+Plan: 1 of 1 in current phase
+Status: Phase complete
+Last activity: 2026-01-19 - Completed 02-01-PLAN.md
 
-Progress: [----------] 0%
+Progress: [##########] 100%
 
 ## Performance Metrics
 
 **Velocity:**
-- Total plans completed: 0
-- Average duration: -
-- Total execution time: 0 hours
+- Total plans completed: 3
+- Average duration: 2.3 min
+- Total execution time: 7 min
 
 **By Phase:**
 
 | Phase | Plans | Total | Avg/Plan |
 |-------|-------|-------|----------|
-| - | - | - | - |
+| 1. Core Command | 2/2 | 4 min | 2 min |
+| 2. Documentation | 1/1 | 3 min | 3 min |
 
 **Recent Trend:**
-- Last 5 plans: -
-- Trend: -
+- Last 5 plans: 01-01 (1 min), 01-02 (3 min), 02-01 (3 min)
+- Trend: Stable
 
 *Updated after each plan completion*
 
+## Quick Tasks Completed
+
+| ID | Name | Commit | Date |
+|----|------|--------|------|
+| 001 | commands-html-page | a1454db | 2026-01-19 |
+
 ## Accumulated Context
 
 ### Decisions
@@ -42,7 +49,12 @@ Progress: [----------] 0%
 Decisions are logged in PROJECT.md Key Decisions table.
 Recent decisions affecting current work:
 
-- None yet
+- Quick task directory structure: `.planning/quick/NNN-slug/` (01-01)
+- Quick task validation: ROADMAP.md only, no phase status check (01-01)
+- Orchestration inline in command file, no separate workflow (01-02)
+- STATE.md Quick Tasks table created on first quick task (01-02)
+- Quick Mode section placement: after Execution in help.md (02-01)
+- README dual entry: How It Works section AND Utilities table (02-01)
 
 ### Pending Todos
 
@@ -54,6 +66,6 @@ None yet.
 
 ## Session Continuity
 
-Last session: 2025-01-19
-Stopped at: Roadmap creation complete
+Last session: 2026-01-19
+Stopped at: Completed 02-01-PLAN.md (Quick Mode Documentation)
 Resume file: None

.planning/phases/01-core-command/01-CONTEXT.md

@@ -0,0 +1,69 @@
+# Phase 1: Core Command - Context
+
+**Gathered:** 2025-01-19
+**Status:** Ready for planning
+
+<domain>
+## Phase Boundary
+
+Complete `/gsd:quick` command that executes small tasks with GSD guarantees (atomic commits, STATE.md tracking) while skipping optional agents (research, plan-checker, verifier). Quick tasks live in `.planning/quick/` separate from planned phases.
+
+</domain>
+
+<decisions>
+## Implementation Decisions
+
+### Invocation & Arguments
+- Interactive prompt for task description (no inline args)
+- No flags — keep it minimal
+- Fail with clear error if no ROADMAP.md exists
+- Can run mid-phase — quick tasks always allowed regardless of current phase status
+
+### Task Scope & Execution
+- No scope limits — user decides what's "quick"
+- Skip research agent, plan-checker agent, and verifier agent
+- On failure: no resume tracking — user re-runs `/gsd:quick` from scratch
+- Creates PLAN.md before execution (lightweight, single task)
+
+### Output & Feedback
+- Standard GSD output during execution (same task status updates)
+- Creates SUMMARY.md matching regular phase format
+- No commit if no changes (current GSD behavior)
+
+### Directory Structure
+- Quick tasks go to `.planning/quick/NNN-slug/` (NOT `.planning/phases/`)
+- 3-digit padded ascending numbers: `001-fix-button-spacing/`, `002-update-readme/`
+- Each directory contains: PLAN.md, SUMMARY.md
+
+### State Integration
+- Do NOT update ROADMAP.md — quick tasks are ad-hoc, not planned work
+- Update STATE.md with "Quick Tasks Completed" table
+- Table includes: number, description, date, commit hash, link to /quick/ dir
+
+### Claude's Discretion
+- Exact PLAN.md format for quick tasks (simplified vs full)
+- Slug generation from task description
+- Error message wording
+
+</decisions>
+
+<specifics>
+## Specific Ideas
+
+- Keep roadmap clean — it's the plan, not the execution log
+- Quick tasks are interruptions, not planned phases — structure should reflect that
+- Date is in git commit, no need in directory name
+
+</specifics>
+
+<deferred>
+## Deferred Ideas
+
+None — discussion stayed within phase scope
+
+</deferred>
+
+---
+
+*Phase: 01-core-command*
+*Context gathered: 2025-01-19*

.planning/phases/01-core-command/01-RESEARCH.md

@@ -0,0 +1,362 @@
+# Phase 1: Core Command - Research
+
+**Researched:** 2025-01-19
+**Domain:** GSD command architecture, slash command patterns, subagent orchestration
+**Confidence:** HIGH
+
+## Summary
+
+This phase implements `/gsd:quick` as a lightweight command that executes small tasks while maintaining GSD guarantees (atomic commits, STATE.md tracking) but skipping optional agents (research, plan-checker, verifier). The CONTEXT.md decisions establish a clear separation from planned phases: quick tasks live in `.planning/quick/` with their own numbering scheme (001, 002, etc.) and do NOT touch ROADMAP.md.
+
+The implementation reuses existing GSD infrastructure (gsd-planner in quick mode, gsd-executor unchanged, commit patterns from execute-plan). The main work is:
+1. The orchestrator command itself
+2. Interactive description prompting
+3. Quick directory management (`.planning/quick/NNN-slug/`)
+4. STATE.md integration (new "Quick Tasks Completed" table)
+
+**Primary recommendation:** Build as a thin orchestrator command that spawns 2 agents (planner + executor) and handles the `.planning/quick/` directory structure directly.
+
+## Standard Stack
+
+The implementation uses existing GSD components with no new libraries.
+
+### Core
+| Component | Version | Purpose | Why Standard |
+|-----------|---------|---------|--------------|
+| gsd-planner | existing | Creates PLAN.md | Already has quick mode support documented in design docs |
+| gsd-executor | existing | Executes tasks, creates SUMMARY.md | Unchanged from full mode |
+| Task tool | Claude Code native | Spawns subagents | Standard GSD orchestration pattern |
+
+### Supporting
+| Component | Version | Purpose | When to Use |
+|-----------|---------|---------|-------------|
+| AskUserQuestion | Claude Code native | Interactive description prompt | Initial task description gathering |
+| Edit tool | Claude Code native | STATE.md updates | Inserting rows in Quick Tasks table |
+| Bash tool | Claude Code native | Directory creation, git commits | File system and git operations |
+
+### Not Needed
+| Instead of | Skip | Reason |
+|------------|------|--------|
+| gsd-phase-researcher | Skip entirely | Quick tasks don't need domain research |
+| gsd-plan-checker | Skip entirely | Quick tasks trade verification for speed |
+| gsd-verifier | Skip entirely | No phase verification for quick tasks |
+| ROADMAP.md updates | Skip entirely | Quick tasks are ad-hoc, not planned work |
+| Decimal phase logic | Skip entirely | Quick tasks use separate `.planning/quick/` directory |
+
+## Architecture Patterns
+
+### Recommended Directory Structure
+```
+.planning/
+├── quick/                          # Quick task storage (separate from phases)
+│   ├── 001-fix-button-spacing/
+│   │   ├── PLAN.md
+│   │   └── SUMMARY.md
+│   ├── 002-update-readme/
+│   │   ├── PLAN.md
+│   │   └── SUMMARY.md
+│   └── ...
+├── phases/                         # Regular planned phases (unchanged)
+├── STATE.md                        # Updated with Quick Tasks table
+├── ROADMAP.md                      # NOT modified by quick tasks
+└── ...
+```
+
+### Pattern 1: Thin Orchestrator with Interactive Prompt
+**What:** Command prompts for description inline, then delegates all heavy work to subagents
+**When to use:** When user invokes `/gsd:quick`
+
+The command flow:
+1. Validate `.planning/ROADMAP.md` exists (error if not - need active project)
+2. Prompt user inline: "What do you want to do?"
+3. Calculate next quick task number (scan `.planning/quick/` directories)
+4. Create directory `.planning/quick/NNN-slug/`
+5. Spawn gsd-planner (quick mode)
+6. Spawn gsd-executor(s) for each plan created
+7. Update STATE.md "Quick Tasks Completed" table
+8. Commit artifacts
+
+### Pattern 2: Sequential Numbering with Collision Detection
+**What:** 3-digit zero-padded sequential numbers (001, 002, 003...)
+**When to use:** Determining next quick task directory name
+
+```bash
+# Find existing quick task directories
+existing=$(ls -1d .planning/quick/[0-9][0-9][0-9]-* 2>/dev/null | sort -r | head -1)
+
+if [ -z "$existing" ]; then
+  next_num="001"
+else
+  # Extract number from path like .planning/quick/042-some-task
+  current_num=$(basename "$existing" | grep -oE '^[0-9]+')
+  next_num=$(printf "%03d" $((10#$current_num + 1)))
+fi
+```
+
+### Pattern 3: STATE.md Quick Tasks Table
+**What:** Dedicated section tracking completed quick tasks
+**When to use:** After each quick task completion
+
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Directory |
+|---|-------------|------|--------|-----------|
+| 001 | Fix button spacing | 2025-01-19 | abc123f | [001-fix-button-spacing](./quick/001-fix-button-spacing/) |
+| 002 | Update readme | 2025-01-19 | def456g | [002-update-readme](./quick/002-update-readme/) |
+```
+
+**Algorithm for STATE.md update:**
+1. Find `## Accumulated Context` section
+2. Find or create `### Quick Tasks Completed` subsection
+3. Find or create the table with headers
+4. Append new row with task details
+5. If section doesn't exist, create it after existing subsections
+
+### Pattern 4: Subagent Spawning (Planner then Executor)
+**What:** Sequential spawning of planner then executor(s)
+**When to use:** After directory created
+
+```markdown
+# Planner spawn
+Task(
+  prompt="
+<planning_context>
+**Mode:** quick
+**Phase Directory:** .planning/quick/{NNN}-{slug}/
+**Description:** {description}
+
+**Project State:**
+@.planning/STATE.md
+</planning_context>
+
+<output>
+Write PLAN.md to: .planning/quick/{NNN}-{slug}/PLAN.md
+Return: ## PLANNING COMPLETE
+</output>
+",
+  subagent_type="gsd-planner",
+  description="Quick plan: {description}"
+)
+```
+
+### Anti-Patterns to Avoid
+- **Updating ROADMAP.md:** Quick tasks are interruptions, not planned work. Keep ROADMAP clean for phases only.
+- **Using decimal phases:** The CONTEXT.md explicitly chose `.planning/quick/` to separate quick tasks from planned phases.
+- **Inline args:** The CONTEXT.md chose interactive prompt instead of `/gsd:quick "description"` style.
+- **Adding flags:** No flags (--plan-only, --after N). Keep it minimal per CONTEXT.md.
+
+## Don't Hand-Roll
+
+Problems that look simple but have existing solutions:
+
+| Problem | Don't Build | Use Instead | Why |
+|---------|-------------|-------------|-----|
+| Plan creation | Custom quick-plan logic | gsd-planner (quick mode) | Already documented in QUICK-MODE-DESIGN.md |
+| Task execution | Custom execution | gsd-executor | Unchanged, handles checkpoints/commits |
+| Commit format | Custom commit messages | git-integration.md patterns | Consistent with full GSD |
+| Wave execution | Custom parallel logic | execute-phase.md patterns | Proven wave-based parallelization |
+| Slug generation | Custom slugify | Bash tr/sed pattern | Used throughout GSD commands |
+
+**Key insight:** Quick mode is the same system with a shorter path. Reuse existing agents and patterns.
+
+## Common Pitfalls
+
+### Pitfall 1: Trying to Track Quick Tasks in ROADMAP.md
+**What goes wrong:** Pollutes the roadmap with ad-hoc work, loses the clean "planned phases" narrative
+**Why it happens:** Natural assumption that all work should be in the roadmap
+**How to avoid:** STATE.md "Quick Tasks Completed" table is the tracking mechanism
+**Warning signs:** Impulse to add decimal phases or "QUICK" markers to ROADMAP.md
+
+### Pitfall 2: Not Checking for .planning/ROADMAP.md
+**What goes wrong:** Command runs without a project context, creates orphan artifacts
+**Why it happens:** Forgetting pre-flight validation
+**How to avoid:** First step must be `ls .planning/ROADMAP.md` check
+**Warning signs:** Quick task directories appearing in non-project codebases
+
+### Pitfall 3: Complex Argument Parsing
+**What goes wrong:** Adds complexity that CONTEXT.md explicitly rejected
+**Why it happens:** QUICK-MODE-DESIGN.md has `--plan-only` and `--after N` flags
+**How to avoid:** CONTEXT.md overrides: "No flags - keep it minimal"
+**Warning signs:** Building arg parser for flags that won't be used
+
+### Pitfall 4: Forgetting the Failure Case (No Resume)
+**What goes wrong:** Users expect to resume failed quick tasks
+**Why it happens:** Full GSD has resume capability
+**How to avoid:** CONTEXT.md: "On failure: no resume tracking - user re-runs from scratch"
+**Warning signs:** Building checkpoint/resume infrastructure for quick mode
+
+### Pitfall 5: Not Creating .planning/quick/ Directory
+**What goes wrong:** First quick task fails because parent directory doesn't exist
+**Why it happens:** Assuming directory exists
+**How to avoid:** `mkdir -p .planning/quick/` before creating task directory
+**Warning signs:** "No such file or directory" errors on first quick task
+
+## Code Examples
+
+Verified patterns from existing GSD codebase:
+
+### Pre-flight Validation
+```bash
+# Source: commands/gsd/quick.md (to be created)
+# Check .planning exists with ROADMAP.md
+if [ ! -f .planning/ROADMAP.md ]; then
+  echo "Quick mode requires an active project with ROADMAP.md."
+  echo "Run /gsd:new-project first."
+  exit 1
+fi
+```
+
+### Next Quick Task Number Calculation
+```bash
+# Source: new pattern for quick task numbering
+# Find highest existing number and increment
+last=$(ls -1d .planning/quick/[0-9][0-9][0-9]-* 2>/dev/null | sort -r | head -1 | xargs -I{} basename {} | grep -oE '^[0-9]+')
+
+if [ -z "$last" ]; then
+  next_num="001"
+else
+  next_num=$(printf "%03d" $((10#$last + 1)))
+fi
+```
+
+### Slug Generation
+```bash
+# Source: commands/gsd/new-project.md, commands/gsd/quick.md patterns
+slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//' | cut -c1-40)
+```
+
+### Directory Creation
+```bash
+# Ensure .planning/quick/ exists then create task directory
+mkdir -p ".planning/quick/${next_num}-${slug}"
+```
+
+### Planner Spawn (Quick Mode)
+```markdown
+# Source: QUICK-MODE-DESIGN.md, adapted for .planning/quick/ structure
+Task(
+  prompt="
+<planning_context>
+
+**Mode:** quick
+**Directory:** .planning/quick/{NNN}-{slug}/
+**Description:** {description}
+
+**Project State:**
+@.planning/STATE.md
+
+</planning_context>
+
+<output>
+Write PLAN.md to: .planning/quick/{NNN}-{slug}/PLAN.md
+Return: ## PLANNING COMPLETE
+</output>
+",
+  subagent_type="gsd-planner",
+  description="Quick plan: {description}"
+)
+```
+
+### Executor Spawn
+```markdown
+# Source: commands/gsd/execute-phase.md, adapted for quick tasks
+Task(
+  prompt="
+Execute quick task {NNN}.
+
+Plan: @.planning/quick/{NNN}-{slug}/PLAN.md
+Project state: @.planning/STATE.md
+",
+  subagent_type="gsd-executor",
+  description="Execute: {description}"
+)
+```
+
+### STATE.md Table Update (Conceptual)
+```markdown
+# Use Edit tool to append row to Quick Tasks Completed table
+# Anchor: "### Quick Tasks Completed" section
+# If section doesn't exist, create after "### Blockers/Concerns"
+
+| {NNN} | {description} | {date} | {commit_hash} | [{NNN}-{slug}](./quick/{NNN}-{slug}/) |
+```
+
+### Commit Pattern
+```bash
+# Source: get-shit-done/references/git-integration.md
+# Stage specific files only (never git add .)
+git add .planning/quick/${next_num}-${slug}/
+git add .planning/STATE.md
+git commit -m "$(cat <<'EOF'
+docs(quick-{NNN}): {description}
+
+Quick task completed.
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+EOF
+)"
+```
+
+## State of the Art
+
+| Old Approach (QUICK-MODE-DESIGN.md) | Current Approach (CONTEXT.md) | Why Changed | Impact |
+|-------------------------------------|------------------------------|-------------|--------|
+| `/gsd:quick "description"` inline args | Interactive prompt | Simpler UX, no quoting issues | Command parsing simplified |
+| Decimal phases (3.1, 3.2) | `.planning/quick/NNN-slug/` | Cleaner separation from planned work | Directory logic completely different |
+| Update ROADMAP.md | Do NOT update ROADMAP.md | Roadmap is plan, not execution log | Skip ROADMAP editing entirely |
+| `--plan-only`, `--after N` flags | No flags | Keep it minimal | No argument parsing needed |
+| STATE.md brief mention | Full "Quick Tasks Completed" table | Proper tracking mechanism | Need table creation/update logic |
+
+**Key context:** CONTEXT.md from `/gsd:discuss-phase` represents user decisions that override the earlier QUICK-MODE-DESIGN.md. The research must follow CONTEXT.md.
+
+## Open Questions
+
+Things that couldn't be fully resolved:
+
+1. **Table Creation Timing**
+   - What we know: STATE.md needs "Quick Tasks Completed" table
+   - What's unclear: Should table be created on first quick task, or pre-created in STATE.md template?
+   - Recommendation: Create on first quick task (check if exists, create if not)
+
+2. **Multi-Plan Wave Execution**
+   - What we know: Quick tasks can produce multiple plans (per QUICK-MODE-DESIGN.md)
+   - What's unclear: CONTEXT.md mentions "execute each plan" but doesn't specify wave logic
+   - Recommendation: Reuse execute-phase wave pattern for consistency
+
+3. **PLAN.md Naming in Quick Directory**
+   - What we know: Directory is `NNN-slug/`, contains PLAN.md and SUMMARY.md
+   - What's unclear: Should PLAN.md be named `PLAN.md` or `{NNN}-PLAN.md`?
+   - Recommendation: Simple `PLAN.md` since it's inside a numbered directory already
+
+## Sources
+
+### Primary (HIGH confidence)
+- `.planning/phases/01-core-command/01-CONTEXT.md` - User decisions that override original requirements
+- `commands/gsd/execute-phase.md` - Wave execution patterns
+- `get-shit-done/workflows/execute-plan.md` - Executor workflow details
+- `get-shit-done/workflows/execute-phase.md` - Subagent spawning patterns
+- `get-shit-done/references/git-integration.md` - Commit format and patterns
+- `get-shit-done/templates/state.md` - STATE.md structure
+
+### Secondary (MEDIUM confidence)
+- `docs/QUICK-MODE-DESIGN.md` - Original design (partially superseded by CONTEXT.md)
+- `docs/QUICK-MODE-MVP.md` - MVP approach (partially superseded by CONTEXT.md)
+
+### Changes from Design Docs
+The CONTEXT.md decisions override several aspects of QUICK-MODE-DESIGN.md:
+- No inline args (interactive prompt instead)
+- No decimal phases (`.planning/quick/` instead)
+- No ROADMAP.md updates
+- No flags
+- "Quick Tasks Completed" table for tracking
+
+## Metadata
+
+**Confidence breakdown:**
+- Standard stack: HIGH - Using existing GSD agents unchanged
+- Architecture: HIGH - Patterns well-documented in existing commands
+- Pitfalls: HIGH - CONTEXT.md explicitly addresses common misunderstandings
+
+**Research date:** 2025-01-19
+**Valid until:** Stable - patterns from existing GSD codebase

CHANGELOG.md

@@ -6,6 +6,27 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-01-19
+
+### Added
+- **Quick Mode** (`/gsd:quick`) — Execute small, ad-hoc tasks with GSD guarantees but skip optional agents (researcher, checker, verifier). Quick tasks live in `.planning/quick/` with their own tracking in STATE.md.
+
+### Changed
+- Improved progress bar calculation to clamp values within 0-100 range
+- Updated documentation with comprehensive Quick Mode sections in help.md, README.md, and GSD-STYLE.md
+
+### Fixed
+- Console window flash on Windows when running hooks
+- Empty `--config-dir` value validation
+- Consistent `allowed-tools` YAML format across agents
+- Corrected agent name in research-phase heading
+- Removed hardcoded 2025 year from search query examples
+- Removed dead gsd-researcher agent references
+- Integrated unused reference files into documentation
+
+### Housekeeping
+- Added homepage and bugs fields to package.json
+
 ## [1.6.4] - 2026-01-17
 
 ### Fixed
@@ -925,7 +946,8 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - YOLO mode for autonomous execution
 - Interactive mode with checkpoints
 
-[Unreleased]: https://github.com/glittercowboy/get-shit-done/compare/v1.6.4...HEAD
+[Unreleased]: https://github.com/glittercowboy/get-shit-done/compare/v1.7.0...HEAD
+[1.7.0]: https://github.com/glittercowboy/get-shit-done/releases/tag/v1.7.0
 [1.6.4]: https://github.com/glittercowboy/get-shit-done/releases/tag/v1.6.4
 [1.6.3]: https://github.com/glittercowboy/get-shit-done/releases/tag/v1.6.3
 [1.6.2]: https://github.com/glittercowboy/get-shit-done/releases/tag/v1.6.2

GSD-STYLE.md

@@ -376,6 +376,74 @@ Depth setting controls compression tolerance:
 
 ---
 
+## Quick Mode Patterns
+
+Quick mode provides GSD guarantees for ad-hoc tasks without full planning overhead.
+
+### When to Use Quick Mode
+
+**Quick mode:**
+- Task is small and self-contained
+- You know exactly what to do (no research needed)
+- Task doesn't warrant full phase planning
+- Mid-project fixes or small additions
+
+**Full planning:**
+- Task involves multiple subsystems
+- You need to investigate approach first
+- Task is part of a larger phase
+- Task might have hidden complexity
+
+### Quick Task Structure
+
+```
+.planning/quick/
+├── 001-add-dark-mode/
+│   ├── PLAN.md
+│   └── SUMMARY.md
+├── 002-fix-login-bug/
+│   ├── PLAN.md
+│   └── SUMMARY.md
+```
+
+Numbering: 3-digit sequential (001, 002, 003...)
+Slug: kebab-case from description, max 40 chars
+
+### Quick Mode Tracking
+
+Quick tasks update STATE.md, NOT ROADMAP.md:
+
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Directory |
+|---|-------------|------|--------|-----------|
+| 001 | Add dark mode toggle | 2026-01-19 | abc123f | [001-add-dark-mode](./quick/001-add-dark-mode/) |
+```
+
+### Quick Mode Orchestration
+
+Unlike full phases, quick mode orchestration is inline in the command file — no separate workflow. The simplified flow:
+
+1. Validate ROADMAP.md exists (project active)
+2. Get task description
+3. Spawn planner (quick constraints)
+4. Spawn executor
+5. Update STATE.md
+6. Commit artifacts
+
+### Commit Convention
+
+```
+docs(quick-NNN): description
+
+Quick task completed.
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+```
+
+---
+
 ## TDD Plans
 
 ### Detection Heuristic

README.md

@@ -297,6 +297,31 @@ Then `/gsd:new-milestone` starts the next version — same flow as `new-project`
 
 ---
 
+### Quick Mode
+
+```
+/gsd:quick
+```
+
+**For ad-hoc tasks that don't need full planning.**
+
+Quick mode gives you GSD guarantees (atomic commits, state tracking) with a faster path:
+
+- **Same agents** — Planner + executor, same quality
+- **Skips optional steps** — No research, no plan checker, no verifier
+- **Separate tracking** — Lives in `.planning/quick/`, not phases
+
+Use for: bug fixes, small features, config changes, one-off tasks.
+
+```
+/gsd:quick
+> What do you want to do? "Add dark mode toggle to settings"
+```
+
+**Creates:** `.planning/quick/001-add-dark-mode-toggle/PLAN.md`, `SUMMARY.md`
+
+---
+
 ## Why It Works
 
 ### Context Engineering
@@ -429,6 +454,7 @@ You're never locked in. The system adapts.
 | `/gsd:add-todo [desc]` | Capture idea for later |
 | `/gsd:check-todos` | List pending todos |
 | `/gsd:debug [desc]` | Systematic debugging with persistent state |
+| `/gsd:quick` | Execute ad-hoc task with GSD guarantees |
 
 <sup>¹ Contributed by reddit user OracleGreyBeard</sup>
 

agents/gsd-meta.md

@@ -1,32 +0,0 @@
-# gsd-meta
-
-Instant GSD expert for discussing architecture, diagnosing issues, planning improvements, and reasoning about the GSD codebase. Use when working on GSD development or asking meta questions about how GSD works.
-
-## Tools Available
-
-- Glob, Grep, Read, WebFetch, WebSearch
-
-## Key Behaviors
-
-1. **Complete GSD comprehension** - Architecture, patterns, execution flows, design principles
-2. **Diagnosis capability** - Trace through systems to identify root causes
-3. **Improvement planning** - Identify which files need changes and impact assessment
-4. **Tradeoff analysis** - Explain design decisions using loaded principles
-
-## When Spawned
-
-- User asks meta questions about GSD while working on GSD
-- Debugging GSD-specific issues
-- Planning improvements to GSD system
-- Understanding how GSD components interact
-
-## Output Format
-
-Direct answers using loaded knowledge. Load specific files only when implementation details needed.
-
-## Critical Rules
-
-- Use loaded knowledge from skill directly (don't re-analyze codebase)
-- Reference specific files/lines when discussing implementation
-- Trace through execution flows to explain behavior
-- Apply GSD's own principles when suggesting improvements

commands/gsd/help.md

@@ -129,6 +129,21 @@ Execute all plans in a phase.
 
 Usage: `/gsd:execute-phase 5`
 
+### Quick Mode
+
+**`/gsd:quick`**
+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)
+- 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.
+
+Usage: `/gsd:quick`
+Result: Creates `.planning/quick/NNN-slug/PLAN.md`, `.planning/quick/NNN-slug/SUMMARY.md`
+
 ### Roadmap Management
 
 **`/gsd:add-phase <description>`**

commands/gsd/quick.md

@@ -0,0 +1,286 @@
+---
+name: gsd:quick
+description: Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Execute small, ad-hoc tasks with GSD guarantees (atomic commits, STATE.md tracking) while skipping optional agents (research, plan-checker, verifier).
+
+Quick mode is the same system with a shorter path:
+- Spawns gsd-planner (quick mode) + gsd-executor(s)
+- Skips gsd-phase-researcher, gsd-plan-checker, gsd-verifier
+- Quick tasks live in `.planning/quick/` separate from planned phases
+- Updates STATE.md "Quick Tasks Completed" table (NOT ROADMAP.md)
+
+Use when: You know exactly what to do and the task is small enough to not need research or verification.
+</objective>
+
+<execution_context>
+Orchestration is inline - no separate workflow file. Quick mode is deliberately simpler than full GSD.
+</execution_context>
+
+<context>
+@.planning/STATE.md
+</context>
+
+<process>
+**Step 1: Pre-flight validation**
+
+Check that an active GSD project exists:
+
+```bash
+if [ ! -f .planning/ROADMAP.md ]; then
+  echo "Quick mode requires an active project with ROADMAP.md."
+  echo "Run /gsd:new-project first."
+  exit 1
+fi
+```
+
+If validation fails, stop immediately with the error message.
+
+Quick tasks can run mid-phase - validation only checks ROADMAP.md exists, not phase status.
+
+---
+
+**Step 2: Get task description**
+
+Prompt user interactively for the task description:
+
+```
+AskUserQuestion(
+  header: "Quick Task",
+  question: "What do you want to do?",
+  followUp: null
+)
+```
+
+Store response as `$DESCRIPTION`.
+
+If empty, re-prompt: "Please provide a task description."
+
+Generate slug from description:
+```bash
+slug=$(echo "$DESCRIPTION" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//' | cut -c1-40)
+```
+
+---
+
+**Step 3: Calculate next quick task number**
+
+Ensure `.planning/quick/` directory exists and find the next sequential number:
+
+```bash
+# Ensure .planning/quick/ exists
+mkdir -p .planning/quick
+
+# Find highest existing number and increment
+last=$(ls -1d .planning/quick/[0-9][0-9][0-9]-* 2>/dev/null | sort -r | head -1 | xargs -I{} basename {} | grep -oE '^[0-9]+')
+
+if [ -z "$last" ]; then
+  next_num="001"
+else
+  next_num=$(printf "%03d" $((10#$last + 1)))
+fi
+```
+
+---
+
+**Step 4: Create quick task directory**
+
+Create the directory for this quick task:
+
+```bash
+QUICK_DIR=".planning/quick/${next_num}-${slug}"
+mkdir -p "$QUICK_DIR"
+```
+
+Report to user:
+```
+Creating quick task ${next_num}: ${DESCRIPTION}
+Directory: ${QUICK_DIR}
+```
+
+Store `$QUICK_DIR` for use in orchestration.
+
+---
+
+**Step 5: Spawn planner (quick mode)**
+
+Spawn gsd-planner with quick mode context:
+
+```
+Task(
+  prompt="
+<planning_context>
+
+**Mode:** quick
+**Directory:** ${QUICK_DIR}
+**Description:** ${DESCRIPTION}
+
+**Project State:**
+@.planning/STATE.md
+
+</planning_context>
+
+<constraints>
+- Create a SINGLE plan with 1-3 focused tasks
+- Quick tasks should be atomic and self-contained
+- No research phase, no checker phase
+- Target ~30% context usage (simple, focused)
+</constraints>
+
+<output>
+Write PLAN.md to: ${QUICK_DIR}/PLAN.md
+Return: ## PLANNING COMPLETE with plan path
+</output>
+",
+  subagent_type="gsd-planner",
+  description="Quick plan: ${DESCRIPTION}"
+)
+```
+
+After planner returns:
+1. Verify PLAN.md exists at `${QUICK_DIR}/PLAN.md`
+2. Extract plan count (typically 1 for quick tasks)
+3. Report: "Plan created: ${QUICK_DIR}/PLAN.md"
+
+If PLAN.md not found, error: "Planner failed to create PLAN.md"
+
+---
+
+**Step 6: Spawn executor**
+
+Spawn gsd-executor with plan reference:
+
+```
+Task(
+  prompt="
+Execute quick task ${next_num}.
+
+Plan: @${QUICK_DIR}/PLAN.md
+Project state: @.planning/STATE.md
+
+<constraints>
+- Execute all tasks in the plan
+- Commit each task atomically
+- Create SUMMARY.md in the quick task directory
+- Do NOT update ROADMAP.md (quick tasks are separate from planned phases)
+</constraints>
+",
+  subagent_type="gsd-executor",
+  description="Execute: ${DESCRIPTION}"
+)
+```
+
+After executor returns:
+1. Verify SUMMARY.md exists at `${QUICK_DIR}/SUMMARY.md`
+2. Extract commit hash from executor output
+3. Report completion status
+
+If SUMMARY.md not found, error: "Executor failed to create SUMMARY.md"
+
+Note: For quick tasks producing multiple plans (rare), spawn executors in parallel waves per execute-phase patterns.
+
+---
+
+**Step 7: Update STATE.md**
+
+Update STATE.md with quick task completion record.
+
+**7a. Check if "Quick Tasks Completed" section exists:**
+
+Read STATE.md and check for `### Quick Tasks Completed` section.
+
+**7b. If section doesn't exist, create it:**
+
+Insert after `### Blockers/Concerns` section:
+
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Directory |
+|---|-------------|------|--------|-----------|
+```
+
+**7c. Append new row to table:**
+
+```markdown
+| ${next_num} | ${DESCRIPTION} | $(date +%Y-%m-%d) | ${commit_hash} | [${next_num}-${slug}](./quick/${next_num}-${slug}/) |
+```
+
+**7d. Update "Last activity" line:**
+
+Find and update the line:
+```
+Last activity: $(date +%Y-%m-%d) - Completed quick task ${next_num}: ${DESCRIPTION}
+```
+
+Use Edit tool to make these changes atomically
+
+---
+
+**Step 8: Final commit and completion**
+
+Stage and commit quick task artifacts:
+
+```bash
+# Stage quick task artifacts
+git add ${QUICK_DIR}/PLAN.md
+git add ${QUICK_DIR}/SUMMARY.md
+git add .planning/STATE.md
+
+# Commit with quick task format
+git commit -m "$(cat <<'EOF'
+docs(quick-${next_num}): ${DESCRIPTION}
+
+Quick task completed.
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+EOF
+)"
+```
+
+Get final commit hash:
+```bash
+commit_hash=$(git rev-parse --short HEAD)
+```
+
+Display completion output:
+```
+---
+
+GSD > QUICK TASK COMPLETE
+
+Quick Task ${next_num}: ${DESCRIPTION}
+
+Summary: ${QUICK_DIR}/SUMMARY.md
+Commit: ${commit_hash}
+
+---
+
+Ready for next task: /gsd:quick
+```
+
+</process>
+
+<success_criteria>
+- [ ] ROADMAP.md validation passes
+- [ ] User provides task description
+- [ ] Slug generated (lowercase, hyphens, max 40 chars)
+- [ ] Next number calculated (001, 002, 003...)
+- [ ] Directory created at `.planning/quick/NNN-slug/`
+- [ ] PLAN.md created by planner
+- [ ] SUMMARY.md created by executor
+- [ ] STATE.md updated with quick task row
+- [ ] Artifacts committed
+</success_criteria>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.6.4",
+  "version": "1.7.0",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "get-shit-done-cc": "bin/install.js"