claude-cook 1.10.1

package/get-shit-done/workflows/pm-dispatch.md

@@ -0,0 +1,104 @@
+# PM Dispatch Workflow — Wave-Aware Worker Launch
+
+<purpose>
+Launch external coding agents on Vibe Kanban tickets, respecting wave ordering.
+Only dispatches tickets whose wave dependencies are satisfied.
+
+Called by:
+- `/gsd:pm-start` after sync (dispatch wave 1)
+- `/gsd:pm-check` when WAVE_COMPLETE detected (dispatch next wave)
+- `/gsd:pm-dispatch` manual command
+</purpose>
+
+<process>
+
+<step name="load_context" priority="first">
+
+## 1. Load Dispatch Context
+
+Read config for executor and repo settings:
+```bash
+cat .planning/config.json   # pm.default_executor, pm.repos
+```
+
+Read TICKET-MAP.md for the target phase:
+```bash
+cat .planning/phases/{phase_dir}/TICKET-MAP.md
+```
+
+Determine target wave:
+- If wave specified (e.g., `--wave=2`): use that wave
+- If not specified: find the lowest wave number with `todo` tickets where all prior waves are complete
+
+</step>
+
+<step name="validate_wave">
+
+## 2. Validate Wave Dependencies
+
+For the target wave N:
+
+1. Check all wave N-1 tickets are `done` (if wave > 1)
+2. If any wave N-1 tickets are NOT done:
+   - If `inprogress`: "Wave {N-1} still running. Wait for completion."
+   - If `todo`: "Wave {N-1} has undispatched tickets. Dispatch those first."
+   - If `cancelled`/`failed`: "Wave {N-1} has failed tickets. Replan needed."
+   - **Do NOT dispatch wave N.** Exit with status.
+
+3. Collect all wave N tickets with status `todo`
+4. If none: "All wave {N} tickets already dispatched." Exit.
+
+</step>
+
+<step name="dispatch">
+
+## 3. Dispatch Workers
+
+For each `todo` ticket in the target wave:
+
+1. Read executor from config (or per-ticket override if specified in TICKET-MAP notes)
+2. Read repos from config
+3. Call:
+   ```
+   mcp__vibe_kanban__start_workspace_session(
+     task_id: ticket_uuid,
+     executor: default_executor,
+     repos: [{repo_id, base_branch}]
+   )
+   ```
+4. Update TICKET-MAP.md for this ticket:
+   - status: inprogress
+   - executor: {executor_name}
+   - dispatched: {timestamp}
+5. Log dispatch to PM-LOG.md
+
+**Error handling:**
+- If `start_workspace_session` fails: log error, skip ticket, continue with others
+- Report failed dispatches at the end
+
+</step>
+
+<step name="report">
+
+## 4. Report Dispatch Summary
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► DISPATCHING WAVE {N}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Dispatched {X} workers for phase {P}, wave {N}:
+
+| Ticket | Plan | Executor | Status |
+| ------ | ---- | -------- | ------ |
+| {id}   | 01   | CLAUDE_CODE | launched |
+| {id}   | 02   | CLAUDE_CODE | launched |
+
+Next: Workers are running. Check progress with /gsd:pm-check
+```
+
+Update STATE.md Vibe Kanban Status section.
+
+</step>
+
+</process>

package/get-shit-done/workflows/pm-replan.md

@@ -0,0 +1,203 @@
+# PM Replan Workflow — Dynamic Plan Modification
+
+<purpose>
+Modify plans and sync changes to Vibe Kanban when things go wrong or requirements change.
+Handles three scopes: targeted fix, revision, and full replan.
+
+Triggered by:
+- `/gsd:pm-check` detecting ticket failure (auto-replan)
+- `/gsd:pm-replan` manual command with user feedback
+- `/gsd:pm-check` detecting cascading issues
+</purpose>
+
+<process>
+
+<step name="gather_context" priority="first">
+
+## 1. Gather Replan Context
+
+Read current state:
+```bash
+cat .planning/config.json
+cat .planning/STATE.md
+cat .planning/phases/{phase_dir}/TICKET-MAP.md
+```
+
+Read all current plans:
+```bash
+ls .planning/phases/{phase_dir}/*-PLAN.md
+```
+
+Read any relevant summaries or verification reports:
+```bash
+ls .planning/phases/{phase_dir}/*-SUMMARY.md 2>/dev/null
+ls .planning/phases/{phase_dir}/*-VERIFICATION.md 2>/dev/null
+```
+
+Gather trigger-specific context:
+- **Failure trigger:** failed ticket details from `get_task(task_id)`
+- **Feedback trigger:** user feedback text from command arguments
+- **Cascade trigger:** completed ticket output that changes assumptions
+
+</step>
+
+<step name="classify">
+
+## 2. Classify Replan Scope
+
+### TARGETED (single ticket failed)
+Conditions:
+- One specific ticket failed/cancelled
+- Other tickets in the wave are unaffected
+- The failure is isolated (not a systemic issue)
+
+Action: Create a fix plan for just the failed task.
+
+### REVISION (feedback changes approach)
+Conditions:
+- User provided feedback that modifies existing plans
+- Plans exist but need updates
+- Core approach is still valid
+
+Action: Revise existing plans with new constraints.
+
+### FULL_REPLAN (fundamental change)
+Conditions:
+- User wants to change the overall approach
+- Multiple cascading failures suggest wrong direction
+- New information invalidates the current plan set
+
+Action: Cancel all undone tickets, re-plan from phase goal.
+
+</step>
+
+<step name="targeted_replan">
+
+## 3a. Targeted Fix
+
+1. Read the failed ticket's original PLAN.md content
+2. Read the failure details from ticket description/notes
+3. Spawn gsd-planner via Task tool:
+   - Mode: gap-closure (`--gaps`)
+   - Context: failed plan + error details + phase goal
+   - Output: one fix PLAN.md
+
+4. Spawn gsd-plan-checker to verify the fix plan
+5. If checker rejects: revise (max 3 iterations)
+
+6. Sync to Vibe Kanban:
+   - `update_task(failed_ticket_id, status="cancelled")`
+   - `create_task(project_id, fix_title, fix_plan_content)` → new ticket
+   - Record in TICKET-MAP.md
+
+7. Dispatch fix ticket if autonomous mode
+
+</step>
+
+<step name="revision_replan">
+
+## 3b. Revision
+
+1. Identify which plans are affected by the feedback
+2. Spawn gsd-planner via Task tool:
+   - Mode: revision
+   - Context: existing plans + user feedback
+   - Output: updated PLAN.md files
+
+3. Spawn gsd-plan-checker to verify revised plans
+4. If checker rejects: revise (max 3 iterations)
+
+5. Sync to Vibe Kanban (via pm-sync workflow):
+   - Updated plans → update ticket descriptions
+   - New plans → create new tickets
+   - Removed plans → cancel tickets
+   - Update TICKET-MAP.md
+
+6. Dispatch new/updated tickets if appropriate
+
+</step>
+
+<step name="full_replan">
+
+## 3c. Full Replan
+
+1. Cancel all undone tickets:
+   ```
+   For each ticket with status in [todo, inprogress]:
+     update_task(ticket_id, status="cancelled")
+   ```
+   Note: tickets already `done` are kept — that work is preserved.
+
+2. Spawn gsd-planner via Task tool:
+   - Mode: standard (fresh planning)
+   - Context: phase goal + new requirements/feedback + what's already done
+   - Output: new set of PLAN.md files
+
+3. Spawn gsd-plan-checker to verify
+4. If checker rejects: revise (max 3 iterations)
+
+5. Sync all new plans to Vibe Kanban (via pm-sync workflow)
+6. Dispatch wave 1 of new plan set
+
+</step>
+
+<step name="record">
+
+## 4. Record Replan
+
+### In TICKET-MAP.md Replan History:
+```markdown
+### Replan #{N} — {TIMESTAMP}
+
+- Trigger: {failure|feedback|cascade}
+- Scope: {targeted|revision|full}
+- Cancelled tickets: {list}
+- New tickets: {list}
+- Reason: {description}
+```
+
+### In PM-LOG.md:
+```markdown
+## [{TIMESTAMP}] REPLAN
+
+- Scope: {targeted|revision|full}
+- Trigger: {description}
+- Plans affected: {list}
+- Old tickets cancelled: {count}
+- New tickets created: {count}
+- Dispatched: {yes/no}
+```
+
+### In STATE.md:
+Update the Vibe Kanban Status section with new ticket counts.
+
+</step>
+
+<step name="present">
+
+## 5. Present Replan Summary
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► REPLANNED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Scope: {targeted|revision|full}
+Reason: {description}
+
+Changes:
+- Cancelled: {N} tickets
+- Created: {N} new tickets
+- Updated: {N} ticket descriptions
+- Dispatched: {N} workers
+
+## Current Ticket State
+{Updated table from TICKET-MAP}
+
+## Next
+{Suggested action based on current state}
+```
+
+</step>
+
+</process>

package/get-shit-done/workflows/pm-sync.md

@@ -0,0 +1,130 @@
+# PM Sync Workflow — Plan-to-Ticket Synchronization
+
+<purpose>
+Synchronize PLAN.md files with Vibe Kanban tickets. Creates tickets for new plans, updates tickets for modified plans, cancels tickets for removed plans. Maintains TICKET-MAP.md as the authoritative mapping.
+
+Called by:
+- `/gsd:pm-start` after planning completes
+- `/gsd:pm-replan` after plans are revised
+</purpose>
+
+<process>
+
+<step name="load_vk_context" priority="first">
+
+## 1. Load Vibe Kanban Context
+
+Read `.planning/config.json` for pm section.
+
+**If `pm.project_id` is null (first run):**
+1. Call `mcp__vibe_kanban__list_projects()` to discover projects
+2. If single project: use it. If multiple: present choice to user.
+3. Call `mcp__vibe_kanban__list_repos(project_id)` for repo details
+4. Save to config.json:
+   ```json
+   "pm": {
+     "project_id": "{discovered_uuid}",
+     "repos": [{"repo_id": "{uuid}", "base_branch": "main"}]
+   }
+   ```
+
+**If already configured:** Use stored values.
+
+</step>
+
+<step name="discover_plans">
+
+## 2. Discover Plans and Build Diff
+
+List all PLAN.md files in the phase directory:
+```bash
+ls .planning/phases/{phase_dir}/*-PLAN.md 2>/dev/null
+```
+
+Read existing TICKET-MAP.md if it exists:
+```bash
+cat .planning/phases/{phase_dir}/TICKET-MAP.md 2>/dev/null
+```
+
+Build three lists:
+
+**New plans:** PLAN.md exists but no corresponding ticket in TICKET-MAP
+**Modified plans:** PLAN.md exists, ticket exists, but plan content has changed
+**Removed plans:** Ticket exists in TICKET-MAP but PLAN.md no longer exists
+
+</step>
+
+<step name="sync_new">
+
+## 3. Create Tickets for New Plans
+
+For each new plan:
+
+1. Read the full PLAN.md content
+2. Extract from frontmatter: `wave`, `depends_on`, `phase`, `plan`
+3. Extract objective from the `<objective>` section (first line)
+4. Build ticket:
+   - **title:** `"Phase {phase} Plan {plan}: {objective_first_line}"`
+   - **description:** Full PLAN.md content as-is (this is the worker's prompt)
+5. Call `mcp__vibe_kanban__create_task(project_id, title, description)`
+6. Record in TICKET-MAP.md:
+   ```
+   | {plan} | {task_summary} | {ticket_uuid} | todo | — | {wave} | — | — | new |
+   ```
+
+</step>
+
+<step name="sync_modified">
+
+## 4. Update Tickets for Modified Plans
+
+For each modified plan:
+
+1. Find ticket_id from TICKET-MAP.md
+2. Check current ticket status:
+   - If `todo`: safe to update → `update_task(task_id, description=new_content)`
+   - If `inprogress`: **WARNING** — worker is running. Log warning, do NOT update.
+   - If `done`/`cancelled`: skip (no point updating)
+3. Update TICKET-MAP.md with notes
+
+</step>
+
+<step name="sync_removed">
+
+## 5. Cancel Tickets for Removed Plans
+
+For each plan that no longer exists:
+
+1. Find ticket_id from TICKET-MAP.md
+2. Check current ticket status:
+   - If `todo`: cancel → `update_task(task_id, status="cancelled")`
+   - If `inprogress`: **WARNING** — worker running. Log but don't cancel yet.
+   - If already `done`/`cancelled`: skip
+3. Mark as cancelled in TICKET-MAP.md
+
+</step>
+
+<step name="finalize">
+
+## 6. Write TICKET-MAP.md
+
+If TICKET-MAP.md doesn't exist yet, create it from template with all ticket entries.
+
+If it exists, update the existing entries and add new ones.
+
+Update the Wave Summary table:
+
+```markdown
+## Wave Summary
+
+| Wave | Total | Done | In Progress | Todo | Failed |
+| ---- | ----- | ---- | ----------- | ---- | ------ |
+| 1    | 3     | 0    | 0           | 3    | 0      |
+| 2    | 2     | 0    | 0           | 2    | 0      |
+```
+
+Update `last_polled` timestamp.
+
+</step>
+
+</process>