/execute-plan

<objective> Execute a PLAN.md file with per-task atomic commits, create SUMMARY.md, update project state.

Commit strategy:

• Each task → 1 commit immediately after completion (feat/fix/test/refactor)
• Plan completion → 1 metadata commit (docs: SUMMARY + STATE + ROADMAP)

Uses intelligent segmentation:

• Plans without checkpoints → spawn subagent for full autonomous execution
• Plans with verify checkpoints → segment execution, pause at checkpoints
• Plans with decision checkpoints → execute in main context </objective>

<execution_context> @/.claude/get-your-work-done/workflows/execute-phase.md @/.claude/get-your-work-done/templates/summary.md @/.claude/get-your-work-done/references/checkpoints.md @/.claude/get-your-work-done/references/tdd.md </execution_context>

<context> Plan path and options: $ARGUMENTS

Argument parsing:

• Path: First argument (required) - path to PLAN.md
• --tasks: Optional task filter
  • Range format: --tasks 1-3 (tasks 1, 2, 3)
  • List format: --tasks 2,4,5 (specific tasks)
  • Single: --tasks 3 (just task 3)

Examples:

• /gywd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md
• /gywd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md --tasks 1-3
• /gywd:execute-plan --tasks 4,5 (uses current plan from STATE.md)

Load project state first: @.planning/STATE.md

Load workflow config: @.planning/config.json </context>

<process> 1. Parse arguments: - Extract plan path (or auto-detect from STATE.md) - Parse --tasks flag if present: - `--tasks 1-3` → [1, 2, 3] - `--tasks 2,4,5` → [2, 4, 5] - `--tasks 3` → [3] - If no --tasks flag: execute all tasks

2. Check .planning/ directory exists (error if not - user should run /gywd:new-project)

3. Verify plan exists

4. If --tasks specified (partial execution):

   • Show: "Partial execution: Tasks {list}"
   • Skip tasks not in the list
   • Mark partial completion in STATE.md
   • Create partial SUMMARY.md with note about which tasks were executed
   • DO NOT mark plan as complete unless all tasks done

5. If no --tasks (full execution):

   • Check if SUMMARY.md already exists (plan already executed?)

6. Load workflow config for mode (interactive/yolo)

7. Follow execute-phase.md workflow:

   • Parse plan and determine execution strategy (A/B/C)
   • Execute tasks (via subagent or main context as appropriate)
   • Handle checkpoints and deviations
   • Create SUMMARY.md
   • Update STATE.md
   • Commit changes </process>

<execution_strategies> Strategy A: Fully Autonomous (no checkpoints)

• Spawn subagent to execute entire plan
• Subagent creates SUMMARY.md and commits
• Main context: orchestration only (~5% usage)

Strategy B: Segmented (has verify-only checkpoints)

• Execute in segments between checkpoints
• Subagent for autonomous segments
• Main context for checkpoints
• Aggregate results → SUMMARY → commit

Strategy C: Decision-Dependent (has decision checkpoints)

• Execute in main context
• Decision outcomes affect subsequent tasks
• Quality maintained through small scope (2-3 tasks per plan) </execution_strategies>

<deviation_rules> During execution, handle discoveries automatically:

1. Auto-fix bugs - Fix immediately, document in Summary
2. Auto-add critical - Security/correctness gaps, add and document
3. Auto-fix blockers - Can't proceed without fix, do it and document
4. Ask about architectural - Major structural changes, stop and ask user
5. Log enhancements - Nice-to-haves, log to ISSUES.md, continue

Only rule 4 requires user intervention. </deviation_rules>

<commit_rules> Per-Task Commits:

After each task completes:

1. Stage only files modified by that task
2. Commit with format: {type}({phase}-{plan}): {task-name}
3. Types: feat, fix, test, refactor, perf, chore
4. Record commit hash for SUMMARY.md

Plan Metadata Commit:

After all tasks complete:

1. Stage planning artifacts only: PLAN.md, SUMMARY.md, STATE.md, ROADMAP.md
2. Commit with format: docs({phase}-{plan}): complete [plan-name] plan
3. NO code files (already committed per-task)

NEVER use:

• git add .
• git add -A
• git add src/ or any broad directory

Always stage files individually.

See ~/.claude/get-your-work-done/references/git-integration.md for full commit strategy. </commit_rules>

<success_criteria>

• All tasks executed
• Each task committed individually (feat/fix/test/refactor)
• SUMMARY.md created with substantive content and commit hashes
• STATE.md updated (position, decisions, issues, session)
• ROADMAP updated (plan count, phase status)
• Metadata committed with docs({phase}-{plan}): complete [plan-name] plan
• User informed of next steps </success_criteria>