Use this workflow when: - Starting a new session on an existing project - User says "continue", "what's next", "where were we", "resume" - Any planning operation when .planning/ already exists - User returns after time away from project Instantly restore full project context and present clear status. Enables seamless session continuity for fully autonomous workflows. "Where were we?" should have an immediate, complete answer. Check if this is an existing project: ```bash ls .planning/STATE.md 2>/dev/null && echo "Project exists" ls .planning/ROADMAP.md 2>/dev/null && echo "Roadmap exists" ls .planning/PROJECT.md 2>/dev/null && echo "Project file exists" ``` **If STATE.md exists:** Proceed to load_state **If only ROADMAP.md/PROJECT.md exist:** Offer to reconstruct STATE.md **If .planning/ doesn't exist:** This is a new project - route to /prompts:gsd-new-project Read and parse STATE.md: ```bash cat .planning/STATE.md ``` Extract: - **Brief Summary**: What we're building (immutable reminder) - **Current Position**: Phase X of Y, Plan A of B, Status - **Progress**: Visual progress bar - **Decisions Made**: Key decisions that constrain future work - **Deferred Issues**: Open items awaiting attention - **Blockers/Concerns**: Issues carried forward - **Brief Alignment**: Are we on track? - **Session Continuity**: Where we left off, any resume files Look for incomplete work that needs attention: ```bash # Check for continue-here files (mid-plan resumption) ls .planning/phases/*/.continue-here*.md 2>/dev/null # Check for plans without summaries (incomplete execution) for plan in .planning/phases/*/*-PLAN.md; do summary="${plan/PLAN/SUMMARY}" [ ! -f "$summary" ] && echo "Incomplete: $plan" done 2>/dev/null ``` **If .continue-here file exists:** - This is a mid-plan resumption point - Read the file for specific resumption context - Flag: "Found mid-plan checkpoint" **If PLAN without SUMMARY exists:** - Execution was started but not completed - Flag: "Found incomplete plan execution" Present complete project status to user: ``` ╔══════════════════════════════════════════════════════════════╗ ║ PROJECT STATUS ║ ╠══════════════════════════════════════════════════════════════╣ ║ Building: [one-liner from Brief Summary] ║ ║ ║ ║ Phase: [X] of [Y] - [Phase name] ║ ║ Plan: [A] of [B] - [Status] ║ ║ Progress: [██████░░░░] XX% ║ ║ ║ ║ Last activity: [date] - [what happened] ║ ╚══════════════════════════════════════════════════════════════╝ [If incomplete work found:] ⚠️ Incomplete work detected: - [.continue-here file or incomplete plan] [If deferred issues exist:] 📋 [N] deferred issues awaiting attention [If blockers exist:] ⚠️ Carried concerns: - [blocker 1] - [blocker 2] [If alignment is not ✓:] ⚠️ Brief alignment: [status] - [assessment] ``` Based on project state, determine the most logical next action: **If .continue-here file exists:** → Primary: Resume from checkpoint → Option: Start fresh on current plan **If incomplete plan (PLAN without SUMMARY):** → Primary: Complete the incomplete plan → Option: Abandon and move on **If phase in progress, all plans complete:** → Primary: Transition to next phase → Option: Review completed work **If phase ready to plan:** → Check if CONTEXT.md exists for this phase: - If CONTEXT.md missing: → Primary: Discuss phase vision (how user imagines it working) → Secondary: Plan directly (skip context gathering) - If CONTEXT.md exists: → Primary: Plan the phase → Option: Review roadmap **If phase ready to execute:** → Primary: Execute next plan → Option: Review the plan first Present contextual options based on project state: ``` What would you like to do? [Primary action based on state - e.g.:] 1. Resume from checkpoint (/prompts:gsd-execute-plan .planning/phases/XX-name/.continue-here-02-01.md) OR 1. Execute next plan (/prompts:gsd-execute-plan .planning/phases/XX-name/02-02-PLAN.md) OR 1. Discuss Phase 3 context (/prompts:gsd-discuss-phase 3) [if CONTEXT.md missing] OR 1. Plan Phase 3 (/prompts:gsd-plan-phase 3) [if CONTEXT.md exists or discuss option declined] [Secondary options:] 2. Review current phase status 3. Check deferred issues ([N] open) 4. Review brief alignment 5. Something else ``` **Note:** When offering phase planning, check for CONTEXT.md existence first: ```bash ls .planning/phases/XX-name/CONTEXT.md 2>/dev/null ``` If missing, suggest discuss-phase before plan. If exists, offer plan directly. Wait for user selection. Based on user selection, route to appropriate workflow: - **Execute plan** → Show command for user to run after clearing: ``` --- ## ▶ Next Up **{phase}-{plan}: [Plan Name]** — [objective from PLAN.md] `/prompts:gsd-execute-plan [path]` <sub>`/clear` first → fresh context window</sub> --- ``` - **Plan phase** → Show command for user to run after clearing: ``` --- ## ▶ Next Up **Phase [N]: [Name]** — [Goal from ROADMAP.md] `/prompts:gsd-plan-phase [phase-number]` <sub>`/clear` first → fresh context window</sub> --- **Also available:** - `/prompts:gsd-discuss-phase [N]` — gather context first - `/prompts:gsd-research-phase [N]` — investigate unknowns --- ``` - **Transition** → ./transition.md - **Review issues** → Read ISSUES.md, present summary - **Review alignment** → Read PROJECT.md, compare to current state - **Something else** → Ask what they need Before proceeding to routed workflow, update session continuity: Update STATE.md: ```markdown ## Session Continuity Last session: [now] Stopped at: Session resumed, proceeding to [action] Resume file: [updated if applicable] ``` This ensures if session ends unexpectedly, next resume knows the state. If STATE.md is missing but other artifacts exist: "STATE.md missing. Reconstructing from artifacts..." 1. Read PROJECT.md → Extract Brief Summary 2. Read ROADMAP.md → Determine phases, find current position 3. Scan \*-SUMMARY.md files → Extract decisions, issues, concerns 4. Read ISSUES.md → Count deferred issues 5. Check for .continue-here files → Session continuity Reconstruct and write STATE.md, then proceed normally. This handles cases where: - Project predates STATE.md introduction - File was accidentally deleted - Cloning repo without full .planning/ state For users who want minimal friction: If user says just "continue" or "go": - Load state silently - Determine primary action - Execute immediately without presenting options "Continuing from [state]... [action]" This enables fully autonomous "just keep going" workflow. Resume is complete when: - [ ] STATE.md loaded (or reconstructed) - [ ] Incomplete work detected and flagged - [ ] Clear status presented to user - [ ] Contextual next actions offered - [ ] User knows exactly where project stands - [ ] Session continuity updated