claude-cook 1.10.1

package/commands/gsd/pm-replan.md

@@ -0,0 +1,102 @@
+---
+name: gsd:pm-replan
+description: Replan based on feedback or failures — modify plans, sync ticket changes, dispatch fixes
+argument-hint: "<phase> [feedback text]"
+agent: gsd-pm
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - WebFetch
+  - mcp__context7__*
+  - mcp__vibe_kanban__*
+---
+
+<execution_context>
+@~/.claude/get-shit-done/references/vibe-kanban.md
+@~/.claude/get-shit-done/workflows/pm-replan.md
+@~/.claude/get-shit-done/workflows/pm-sync.md
+@~/.claude/get-shit-done/workflows/pm-dispatch.md
+@~/.claude/agents/gsd-pm.md
+</execution_context>
+
+<objective>
+Manually trigger a replan for a phase based on user feedback. Modifies plans, syncs changes to Vibe Kanban (cancel old tickets, create new ones), and optionally dispatches.
+
+**Use cases:**
+- User realized the approach is wrong
+- User wants to change technology/library
+- User has new requirements mid-phase
+- A ticket failed and auto-replan didn't resolve it
+</objective>
+
+<context>
+Phase number: first argument from $ARGUMENTS
+Feedback: remaining text after phase number
+
+Example: `/gsd:pm-replan 3 switch to Redis for caching instead of in-memory`
+</context>
+
+<process>
+
+## 1. Parse Arguments
+
+Extract:
+- Phase number (required)
+- Feedback text (optional — if empty, ask user interactively)
+
+If no feedback provided, ask:
+"What should change about the current plan for phase {X}? Describe the issue or new direction."
+
+## 2. Load Context
+
+Read:
+- Current PLAN.md files for the phase
+- TICKET-MAP.md — current ticket state
+- STATE.md — overall position
+- config.json — PM settings
+- ROADMAP.md — phase goal
+
+## 3. Classify Replan Scope
+
+Follow pm-replan workflow classification:
+
+**TARGETED:** Feedback mentions a specific plan or ticket
+**REVISION:** Feedback modifies approach but keeps structure
+**FULL_REPLAN:** Feedback fundamentally changes direction
+
+Present classification to user:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► REPLAN ANALYSIS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Scope: {targeted|revision|full}
+Affected plans: {list}
+Tickets to cancel: {count}
+
+Proceeding with replan...
+```
+
+## 4. Execute Replan
+
+Follow the pm-replan workflow for the classified scope:
+- Spawn gsd-planner with feedback context
+- Verify with gsd-plan-checker
+- Sync to Vibe Kanban (cancel old, create new, update changed)
+- Update TICKET-MAP.md
+
+## 5. Dispatch (if appropriate)
+
+If new tickets were created and they're in a ready wave:
+- Ask user: "Dispatch {N} new workers now?"
+- If yes: follow pm-dispatch workflow
+
+## 6. Present Summary
+
+Follow the pm-replan workflow presentation format.
+
+</process>

package/commands/gsd/pm-start.md

@@ -0,0 +1,218 @@
+---
+name: gsd:pm-start
+description: Plan a phase, sync to Vibe Kanban tickets, dispatch workers, optionally start autonomous monitor loop
+argument-hint: "<phase> [--autonomous] [--manual] [--executor=CLAUDE_CODE] [--skip-plan]"
+agent: gsd-pm
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - WebFetch
+  - mcp__context7__*
+  - mcp__vibe_kanban__*
+---
+
+<execution_context>
+@~/.claude/get-shit-done/references/ui-brand.md
+@~/.claude/get-shit-done/references/vibe-kanban.md
+@~/.claude/get-shit-done/workflows/pm-sync.md
+@~/.claude/get-shit-done/workflows/pm-dispatch.md
+@~/.claude/agents/gsd-pm.md
+</execution_context>
+
+<objective>
+Initialize PM mode for a phase: create plans (unless --skip-plan), sync to Vibe Kanban tickets, dispatch wave 1 workers, and optionally launch the autonomous monitoring loop.
+
+**This is the main PM entry point.** It transitions GSD from local execution to external delegation.
+
+**Orchestrator role:** Validate environment, run planning pipeline if needed, sync plans to VK tickets, dispatch workers, optionally start pm-loop.sh.
+</objective>
+
+<context>
+Phase number: $ARGUMENTS (required — which phase to manage)
+
+**Flags:**
+- `--autonomous` — After dispatch, launch pm-loop.sh for continuous monitoring
+- `--manual` — After dispatch, show status and available commands (default)
+- `--executor=X` — Override default executor (CLAUDE_CODE, CURSOR_AGENT, CODEX, etc.)
+- `--skip-plan` — Skip planning, assume plans already exist (use with /gsd:plan-phase)
+</context>
+
+<process>
+
+## 1. Validate Environment
+
+```bash
+test -d .planning && echo "exists" || echo "missing"
+```
+
+If no `.planning/`: Error — run `/gsd:new-project` first.
+
+Read config:
+```bash
+cat .planning/config.json 2>/dev/null
+```
+
+Check for pm section. If missing, initialize it:
+```json
+"pm": {
+  "mode": "manual",
+  "poll_interval_seconds": 60,
+  "project_id": null,
+  "repos": [],
+  "default_executor": "CLAUDE_CODE",
+  "auto_replan_on_failure": true,
+  "auto_dispatch_next_wave": true,
+  "max_replan_attempts": 3
+}
+```
+
+Apply flag overrides:
+- `--autonomous` → set `pm.mode` to `"autonomous"`
+- `--manual` → set `pm.mode` to `"manual"`
+- `--executor=X` → set `pm.default_executor`
+
+Write updated config.json.
+
+## 2. Parse Phase Number
+
+Extract phase number from $ARGUMENTS. Validate it exists in ROADMAP.md.
+
+Find or create phase directory:
+```bash
+ls .planning/phases/ | grep "^{phase_num}"
+```
+
+## 3. Setup Vibe Kanban Connection
+
+If `pm.project_id` is null:
+
+1. Call `mcp__vibe_kanban__list_projects()` — discover available projects
+2. If single project: use it. If multiple: present choice to user.
+3. Call `mcp__vibe_kanban__list_repos(project_id)` — get repo details
+4. Save project_id and repos to config.json
+
+Present:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► CONNECTED TO VIBE KANBAN
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Project: {name} ({project_id})
+Repos: {repo_list}
+Executor: {default_executor}
+```
+
+## 4. Plan Phase (unless --skip-plan)
+
+If plans already exist for this phase AND --skip-plan not specified:
+- Ask user: "Plans already exist. Re-plan or use existing?"
+
+If no plans exist OR user wants to re-plan:
+- Follow the same planning pipeline as `/gsd:plan-phase`:
+  1. Resolve model profile
+  2. Optionally run phase researcher
+  3. Spawn gsd-planner via Task tool
+  4. Spawn gsd-plan-checker to verify
+  5. Iterate planner ↔ checker until plans pass (max 3)
+
+**Key difference from /gsd:plan-phase:** After planning, continue to sync+dispatch instead of stopping.
+
+## 5. Sync Plans to Vibe Kanban Tickets
+
+Follow the pm-sync workflow:
+
+1. Read all PLAN.md files in the phase directory
+2. For each plan:
+   - Build title: `"Phase {X} Plan {Y}: {objective}"`
+   - Build description: full PLAN.md content
+   - `create_task(project_id, title, description)`
+3. Write TICKET-MAP.md with all mappings
+
+Present:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► TICKETS SYNCED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{N} plans → {N} tickets created
+
+| Wave | Plan | Ticket | Title |
+| ---- | ---- | ------ | ----- |
+| ...  | ...  | ...    | ...   |
+```
+
+## 6. Dispatch Wave 1
+
+Follow the pm-dispatch workflow:
+
+1. Collect all wave 1 tickets from TICKET-MAP
+2. For each:
+   - `start_workspace_session(task_id, executor, repos)`
+   - Update TICKET-MAP: status=inprogress, dispatched=now
+3. Log dispatches to PM-LOG.md
+
+Present:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► WAVE 1 DISPATCHED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{N} workers launched:
+
+| Ticket | Plan | Executor | Status |
+| ------ | ---- | -------- | ------ |
+| ...    | ...  | ...      | launched |
+```
+
+## 7. Start Monitor (mode-dependent)
+
+### Autonomous Mode (--autonomous)
+
+Initialize PM-LOG.md with INIT entry.
+Launch pm-loop.sh:
+
+```bash
+nohup ~/.claude/scripts/pm-loop.sh --phase={X} --interval={poll_interval} > /dev/null 2>&1 &
+echo $! > .planning/.pm-loop-pid
+```
+
+Present:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► AUTONOMOUS MODE ACTIVE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+PM loop running (PID: {pid})
+Polling every {interval}s
+Log: .planning/PM-LOG.md
+
+Stop with: /gsd:pm-stop  or  touch .planning/.pm-stop
+```
+
+### Manual Mode (default)
+
+Present:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► MANUAL MODE — WORKERS RUNNING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Workers dispatched. Use these commands to manage:
+
+/gsd:pm-check    — Poll ticket status and react
+/gsd:pm-status   — View dashboard
+/gsd:pm-replan   — Modify plans if issues found
+/gsd:pm-stop     — Stop PM monitoring
+```
+
+## 8. Update STATE.md
+
+Update STATE.md with PM status:
+- Current position: Phase X, PM mode active
+- Vibe Kanban Status section: project, tickets, last polled
+
+</process>

package/commands/gsd/pm-status.md

@@ -0,0 +1,116 @@
+---
+name: gsd:pm-status
+description: Dashboard showing all tickets, plan health, and recent PM decisions
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - mcp__vibe_kanban__*
+---
+
+<execution_context>
+@~/.claude/get-shit-done/references/ui-brand.md
+@~/.claude/get-shit-done/references/vibe-kanban.md
+</execution_context>
+
+<objective>
+Display a comprehensive PM dashboard: ticket status matrix, wave progress, recent PM-LOG entries, and suggested next actions.
+
+Read-only — does not modify any state.
+</objective>
+
+<context>
+Phase number: $ARGUMENTS (optional — shows all phases if not specified)
+</context>
+
+<process>
+
+## 1. Load Context
+
+```bash
+cat .planning/config.json
+cat .planning/STATE.md
+```
+
+If phase specified: read that phase's TICKET-MAP.md
+If not: read all TICKET-MAP.md files across phases
+
+## 2. Poll Current Status
+
+Call `mcp__vibe_kanban__list_tasks(project_id)` for live ticket status.
+
+Cross-reference with TICKET-MAP.md entries.
+
+## 3. Build Dashboard
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► PROJECT STATUS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Project: {name}
+Executor: {default_executor}
+Mode: {autonomous|manual}
+PM Loop: {running (PID: X)|stopped}
+
+## Phase {X}: {name}  [{progress_bar}] {percent}%
+
+| Wave | Plan | Ticket | Status | Executor | Duration |
+| ---- | ---- | ------ | ------ | -------- | -------- |
+| 1    | 01   | {id}   | done   | CLAUDE_CODE | 12m   |
+| 1    | 02   | {id}   | done   | CURSOR  | 8m       |
+| 2    | 03   | {id}   | inprogress | CLAUDE_CODE | 5m... |
+| 2    | 04   | {id}   | todo   | —       | —        |
+
+### Wave Summary
+| Wave | Total | Done | Running | Todo | Failed |
+| ---- | ----- | ---- | ------- | ---- | ------ |
+| 1    | 2     | 2    | 0       | 0    | 0      |
+| 2    | 2     | 0    | 1       | 1    | 0      |
+
+### Replans: {count}
+### Failed tickets: {count}
+```
+
+## 4. Recent PM-LOG
+
+Read last 10 entries from PM-LOG.md:
+```bash
+tail -50 .planning/PM-LOG.md
+```
+
+Present the last 3-5 significant events:
+```
+## Recent Activity
+
+- [{time}] Wave 1 complete — auto-dispatched wave 2
+- [{time}] VK-{id} (Plan 03): todo → inprogress
+- [{time}] VK-{id} (Plan 01): inprogress → done (12m)
+```
+
+## 5. Suggested Actions
+
+Based on current state, suggest relevant commands:
+
+```
+## Actions
+
+/gsd:pm-check    — Poll for latest ticket updates
+/gsd:pm-replan 3 — Modify plans if issues found
+/gsd:pm-stop     — Stop autonomous monitoring
+```
+
+If all tickets done:
+```
+Phase {X} complete! Run /gsd:pm-start {X+1} for next phase.
+```
+
+If tickets stuck:
+```
+⚠ {N} tickets have been running for >{threshold}min.
+Consider /gsd:pm-check to diagnose.
+```
+
+</process>

package/commands/gsd/pm-stop.md

@@ -0,0 +1,72 @@
+---
+name: gsd:pm-stop
+description: Stop the autonomous PM monitoring loop gracefully
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Signal the autonomous PM loop (pm-loop.sh) to stop gracefully by creating the stop file.
+The shell script checks for this file at the start of each cycle and exits cleanly.
+</objective>
+
+<process>
+
+## 1. Create Stop Signal
+
+```bash
+touch .planning/.pm-stop
+echo "PM stop signal created."
+```
+
+## 2. Check Loop Status
+
+```bash
+# Check if pm-loop.sh is running
+if [ -f .planning/.pm-loop-pid ]; then
+  PID=$(cat .planning/.pm-loop-pid)
+  if ps -p "$PID" > /dev/null 2>&1; then
+    echo "PM loop (PID: $PID) will stop after current cycle completes."
+  else
+    echo "PM loop process not found (may have already stopped)."
+    rm -f .planning/.pm-loop-pid
+  fi
+else
+  echo "No PM loop PID file found."
+fi
+```
+
+## 3. Update Config
+
+Read config.json and set `pm.mode` to `"manual"`.
+Write updated config.json.
+
+## 4. Present
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PM ► STOPPING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Stop signal sent. The PM loop will exit after the current cycle.
+Mode switched to: manual
+
+Workers already dispatched will continue running.
+Use /gsd:pm-check to manually poll ticket status.
+Use /gsd:pm-status to view dashboard.
+```
+
+## 5. Log to PM-LOG.md
+
+Append:
+```markdown
+## [{TIMESTAMP}] STOP
+
+- PM loop stop signal created
+- Mode switched to manual
+- Active workers: {count} (will continue running)
+```
+
+</process>