pi-gsd 1.0.3

package/skills/gsd-manager/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: gsd-manager
+description: Interactive command center for managing multiple phases from one terminal
+---
+
+<objective>
+Single-terminal command center for managing a milestone. Shows a dashboard of all phases with visual status indicators, recommends optimal next actions, and dispatches work - discuss runs inline, plan/execute run as background agents.
+
+Designed for power users who want to parallelize work across phases from one terminal: discuss a phase while another plans or executes in the background.
+
+**Creates/Updates:**
+
+- No files created directly - dispatches to existing GSD commands via Skill() and background Task agents.
+- Reads `.planning/STATE.md`, `.planning/ROADMAP.md`, phase directories for status.
+
+**After:** User exits when done managing, or all phases complete and milestone lifecycle is suggested.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/manager.md
+@.agent/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+No arguments required. Requires an active milestone with ROADMAP.md and STATE.md.
+
+Project context, phase list, dependencies, and recommendations are resolved inside the workflow using `gsd-tools.cjs init manager`. No upfront context loading needed.
+</context>
+
+<process>
+Execute the manager workflow from @.agent/get-shit-done/workflows/manager.md end-to-end.
+Maintain the dashboard refresh loop until the user exits or all phases complete.
+</process>

package/skills/gsd-map-codebase/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: gsd-map-codebase
+description: Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
+---
+
+
+<objective>
+Analyze existing codebase using parallel gsd-codebase-mapper agents to produce structured codebase documents.
+
+Each mapper agent explores a focus area and **writes documents directly** to `.planning/codebase/`. The orchestrator only receives confirmations, keeping context usage minimal.
+
+Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/map-codebase.md
+</execution_context>
+
+<context>
+Focus area: $ARGUMENTS (optional - if provided, tells agents to focus on specific subsystem)
+
+**Load project state if exists:**
+Check for .planning/STATE.md - loads context if project already initialized
+
+**This command can run:**
+- Before /gsd-new-project (brownfield codebases) - creates codebase map first
+- After /gsd-new-project (greenfield codebases) - updates codebase map as code evolves
+- Anytime to refresh codebase understanding
+</context>
+
+<when_to_use>
+**Use map-codebase for:**
+- Brownfield projects before initialization (understand existing code first)
+- Refreshing codebase map after significant changes
+- Onboarding to an unfamiliar codebase
+- Before major refactoring (understand current state)
+- When STATE.md references outdated codebase info
+
+**Skip map-codebase for:**
+- Greenfield projects with no code yet (nothing to map)
+- Trivial codebases (<5 files)
+</when_to_use>
+
+<process>
+1. Check if .planning/codebase/ already exists (offer to refresh or skip)
+2. Create .planning/codebase/ directory structure
+3. Spawn 4 parallel gsd-codebase-mapper agents:
+   - Agent 1: tech focus → writes STACK.md, INTEGRATIONS.md
+   - Agent 2: arch focus → writes ARCHITECTURE.md, STRUCTURE.md
+   - Agent 3: quality focus → writes CONVENTIONS.md, TESTING.md
+   - Agent 4: concerns focus → writes CONCERNS.md
+4. Wait for agents to complete, collect confirmations (NOT document contents)
+5. Verify all 7 documents exist with line counts
+6. Commit codebase map
+7. Offer next steps (typically: /gsd-new-project or /gsd-plan-phase)
+</process>
+
+<success_criteria>
+- [ ] .planning/codebase/ directory created
+- [ ] All 7 codebase documents written by mapper agents
+- [ ] Documents follow template structure
+- [ ] Parallel agents completed without errors
+- [ ] User knows next steps
+</success_criteria>

package/skills/gsd-milestone-summary/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: gsd-milestone-summary
+description: Generate a comprehensive project summary from milestone artifacts for team onboarding and review
+---
+
+<objective>
+Generate a structured milestone summary for team onboarding and project review. Reads completed milestone artifacts (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION files) and produces a human-friendly overview of what was built, how, and why.
+
+Purpose: Enable new team members to understand a completed project by reading one document and asking follow-up questions.
+Output: MILESTONE_SUMMARY written to `.planning/reports/`, presented inline, optional interactive Q&A.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/milestone-summary.md
+</execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/PROJECT.md`
+- `.planning/STATE.md`
+- `.planning/RETROSPECTIVE.md`
+- `.planning/milestones/v{version}-ROADMAP.md` (if archived)
+- `.planning/milestones/v{version}-REQUIREMENTS.md` (if archived)
+- `.planning/phases/*-*/` (SUMMARY.md, VERIFICATION.md, CONTEXT.md, RESEARCH.md)
+
+**User input:**
+
+- Version: $ARGUMENTS (optional - defaults to current/latest milestone)
+  </context>
+
+<process>
+Read and execute the milestone-summary workflow from @.agent/get-shit-done/workflows/milestone-summary.md end-to-end.
+</process>
+
+<success_criteria>
+
+- Milestone version resolved (from args, STATE.md, or archive scan)
+- All available artifacts read (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION, RESEARCH, RETROSPECTIVE)
+- Summary document written to `.planning/reports/MILESTONE_SUMMARY-v{version}.md`
+- All 7 sections generated (Overview, Architecture, Phases, Decisions, Requirements, Tech Debt, Getting Started)
+- Summary presented inline to user
+- Interactive Q&A offered
+- STATE.md updated
+  </success_criteria>

package/skills/gsd-new-milestone/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: gsd-new-milestone
+description: Start a new milestone cycle - update PROJECT.md and route to requirements
+---
+
+<objective>
+Start a new milestone: questioning → research (optional) → requirements → roadmap.
+
+Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
+
+**Creates/Updates:**
+
+- `.planning/PROJECT.md` - updated with new milestone goals
+- `.planning/research/` - domain research (optional, NEW features only)
+- `.planning/REQUIREMENTS.md` - scoped requirements for this milestone
+- `.planning/ROADMAP.md` - phase structure (continues numbering)
+- `.planning/STATE.md` - reset for new milestone
+
+**After:** `/gsd-plan-phase [N]` to start execution.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/new-milestone.md
+@.agent/get-shit-done/references/questioning.md
+@.agent/get-shit-done/references/ui-brand.md
+@.agent/get-shit-done/templates/project.md
+@.agent/get-shit-done/templates/requirements.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+Project and milestone context files are resolved inside the workflow (`init new-milestone`) and delegated via `<files_to_read>` blocks where subagents are used.
+</context>
+
+<process>
+Execute the new-milestone workflow from @.agent/get-shit-done/workflows/new-milestone.md end-to-end.
+Preserve all workflow gates (validation, questioning, research, requirements, roadmap approval, commits).
+</process>

package/skills/gsd-new-project/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: gsd-new-project
+description: Initialize a new project with deep context gathering and PROJECT.md
+---
+
+<context>
+**Flags:**
+- `--auto` - Automatic mode. After config questions, runs research → requirements → roadmap without further interaction. Expects idea document via @ reference.
+</context>
+
+<objective>
+Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.
+
+**Creates:**
+
+- `.planning/PROJECT.md` - project context
+- `.planning/config.json` - workflow preferences
+- `.planning/research/` - domain research (optional)
+- `.planning/REQUIREMENTS.md` - scoped requirements
+- `.planning/ROADMAP.md` - phase structure
+- `.planning/STATE.md` - project memory
+
+**After this command:** Run `/gsd-plan-phase 1` to start execution.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/new-project.md
+@.agent/get-shit-done/references/questioning.md
+@.agent/get-shit-done/references/ui-brand.md
+@.agent/get-shit-done/templates/project.md
+@.agent/get-shit-done/templates/requirements.md
+</execution_context>
+
+<process>
+Execute the new-project workflow from @.agent/get-shit-done/workflows/new-project.md end-to-end.
+Preserve all workflow gates (validation, approvals, commits, routing).
+</process>

package/skills/gsd-new-workspace/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: gsd-new-workspace
+description: Create an isolated workspace with repo copies and independent .planning/
+---
+
+<context>
+**Flags:**
+- `--name` (required) - Workspace name
+- `--repos` - Comma-separated repo paths or names. If omitted, interactive selection from child git repos in cwd
+- `--path` - Target directory. Defaults to `~/gsd-workspaces/<name>`
+- `--strategy` - `worktree` (default, lightweight) or `clone` (fully independent)
+- `--branch` - Branch to checkout. Defaults to `workspace/<name>`
+- `--auto` - Skip interactive questions, use defaults
+</context>
+
+<objective>
+Create a physical workspace directory containing copies of specified git repos (as worktrees or clones) with an independent `.planning/` directory for isolated GSD sessions.
+
+**Use cases:**
+
+- Multi-repo orchestration: work on a subset of repos in parallel with isolated GSD state
+- Feature branch isolation: create a worktree of the current repo with its own `.planning/`
+
+**Creates:**
+
+- `<path>/WORKSPACE.md` - workspace manifest
+- `<path>/.planning/` - independent planning directory
+- `<path>/<repo>/` - git worktree or clone for each specified repo
+
+**After this command:** `cd` into the workspace and run `/gsd-new-project` to initialize GSD.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/new-workspace.md
+@.agent/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<process>
+Execute the new-workspace workflow from @.agent/get-shit-done/workflows/new-workspace.md end-to-end.
+Preserve all workflow gates (validation, approvals, commits, routing).
+</process>

package/skills/gsd-next/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: gsd-next
+description: Automatically advance to the next logical step in the GSD workflow
+---
+
+<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>
+@.agent/get-shit-done/workflows/next.md
+</execution_context>
+
+<process>
+Execute the next workflow from @.agent/get-shit-done/workflows/next.md end-to-end.
+</process>

package/skills/gsd-note/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: gsd-note
+description: Zero-friction idea capture. Append, list, or promote notes to todos.
+---
+
+<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 AskUserQuestion, no Bash.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/note.md
+@.agent/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the note workflow from @.agent/get-shit-done/workflows/note.md end-to-end.
+Capture the note, list notes, or promote to todo - depending on arguments.
+</process>

package/skills/gsd-pause-work/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: gsd-pause-work
+description: Create context handoff when pausing work mid-phase
+---
+
+
+<objective>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions.
+
+Routes to the pause-work workflow which handles:
+- Current phase detection from recent files
+- Complete state gathering (position, completed work, remaining work, decisions, blockers)
+- Handoff file creation with all context sections
+- Git commit as WIP
+- Resume instructions
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/pause-work.md
+</execution_context>
+
+<context>
+State and phase progress are gathered in-workflow with targeted reads.
+</context>
+
+<process>
+**Follow the pause-work workflow** from `@.agent/get-shit-done/workflows/pause-work.md`.
+
+The workflow handles all logic including:
+1. Phase directory detection
+2. State gathering with user clarifications
+3. Handoff file writing with timestamp
+4. Git commit
+5. Confirmation with resume instructions
+</process>

package/skills/gsd-plan-milestone-gaps/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: gsd-plan-milestone-gaps
+description: Create phases to close all gaps identified by milestone audit
+---
+
+<objective>
+Create all phases necessary to close gaps identified by `/gsd-audit-milestone`.
+
+Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase.
+
+One command creates all fix phases - no manual `/gsd-add-phase` per gap.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/plan-milestone-gaps.md
+</execution_context>
+
+<context>
+**Audit results:**
+Glob: .planning/v*-MILESTONE-AUDIT.md (use most recent)
+
+Original intent and current planning state are loaded on demand inside the workflow.
+</context>
+
+<process>
+Execute the plan-milestone-gaps workflow from @.agent/get-shit-done/workflows/plan-milestone-gaps.md end-to-end.
+Preserve all workflow gates (audit loading, prioritization, phase grouping, user confirmation, roadmap updates).
+</process>

package/skills/gsd-plan-phase/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gsd-plan-phase
+description: Create detailed phase plan (PLAN.md) with verification loop
+---
+
+<objective>
+Create executable phase prompts (PLAN.md files) for a roadmap phase with integrated research and verification.
+
+**Default flow:** Research (if needed) → Plan → Verify → Done
+
+**Orchestrator role:** Parse arguments, validate phase, research domain (unless skipped), spawn gsd-planner, verify with gsd-plan-checker, iterate until pass or max iterations, present results.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/plan-phase.md
+@.agent/get-shit-done/references/ui-brand.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if omitted)
+
+**Flags:**
+
+- `--research` - Force re-research even if RESEARCH.md exists
+- `--skip-research` - Skip research, go straight to planning
+- `--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>
+
+<process>
+Execute the plan-phase workflow from @.agent/get-shit-done/workflows/plan-phase.md end-to-end.
+Preserve all workflow gates (validation, research, planning, verification loop, routing).
+</process>

package/skills/gsd-plant-seed/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: gsd-plant-seed
+description: Capture a forward-looking idea with trigger conditions - surfaces automatically at the right milestone
+---
+
+<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>
+@.agent/get-shit-done/workflows/plant-seed.md
+</execution_context>
+
+<process>
+Execute the plant-seed workflow from @.agent/get-shit-done/workflows/plant-seed.md end-to-end.
+</process>

package/skills/gsd-pr-branch/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: gsd-pr-branch
+description: Create a clean PR branch by filtering out .planning/ commits - ready for code review
+---
+
+<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>
+@.agent/get-shit-done/workflows/pr-branch.md
+</execution_context>
+
+<process>
+Execute the pr-branch workflow from @.agent/get-shit-done/workflows/pr-branch.md end-to-end.
+</process>

package/skills/gsd-profile-user/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gsd-profile-user
+description: Generate developer behavioral profile and create Claude-discoverable artifacts
+---
+
+
+<objective>
+Generate a developer behavioral profile from session analysis (or questionnaire) and produce artifacts (USER-PROFILE.md, /gsd-dev-preferences, GEMINI.md section) that personalize the agent'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>
+@.agent/get-shit-done/workflows/profile-user.md
+@.agent/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, GEMINI.md sections)
+9. Sequential artifact generation
+10. Summary with refresh diff (if applicable)
+</process>

package/skills/gsd-progress/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: gsd-progress
+description: Check project progress, show context, and route to next action (execute or plan)
+---
+
+<objective>
+Check project progress, summarize recent work and what's ahead, then intelligently route to the next action - either executing an existing plan or creating the next one.
+
+Provides situational awareness before continuing work.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/progress.md
+</execution_context>
+
+<process>
+Execute the progress workflow from @.agent/get-shit-done/workflows/progress.md end-to-end.
+Preserve all routing logic (Routes A through F) and edge case handling.
+</process>

package/skills/gsd-quick/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gsd-quick
+description: Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
+---
+
+<objective>
+Execute small, ad-hoc tasks with GSD guarantees (atomic commits, STATE.md tracking).
+
+Quick mode is the same system with a shorter path:
+- Spawns gsd-planner (quick mode) + gsd-executor(s)
+- Quick tasks live in `.planning/quick/` separate from planned phases
+- Updates STATE.md "Quick Tasks Completed" table (NOT ROADMAP.md)
+
+**Default:** Skips research, discussion, plan-checker, verifier. Use when you know exactly what to do.
+
+**`--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.
+
+**`--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.
+
+Flags are composable: `--discuss --research --full` gives discussion + research + plan-checking + verification.
+</objective>
+
+<execution_context>
+@.agent/get-shit-done/workflows/quick.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Context files are resolved inside the workflow (`init quick`) and delegated via `<files_to_read>` blocks.
+</context>
+
+<process>
+Execute the quick workflow from @.agent/get-shit-done/workflows/quick.md end-to-end.
+Preserve all workflow gates (validation, task description, planning, execution, state updates, commits).
+</process>