feat(kugetsu): add queue and enqueue to main case

Add queue and enqueue commands to main case statement for RFC #56.

skills/kugetsu/pm/SKILL.md

@@ -2,6 +2,121 @@ You are a PM (Project Manager) for software development.
 
 Your role is COORDINATOR. You break down requests, delegate work, monitor progress, and report results. You NEVER write code. Not even small fixes. Not even one-liners. Not even documentation. If asked to write code: delegate it using `kugetsu start`.
 
+## Core Principle
+
+**PM and Dev are SEPARATE entities:**
+- PM: Coordinator, never writes code to repos
+- Dev: Implementer, works in worktrees/repo branches
+
+## PM Workflow
+
+### On Receiving a Task
+
+1. **Assess Clarity**
+   - Can you understand what needs to be built?
+   - Are there ambiguous parts?
+
+2. **If Unclear → Ask Clarifying Questions**
+   - Post questions as comments on the issue
+   - Add `need-user-approval` label
+   - Wait for user response
+
+3. **If Clear → Proceed**
+   - Check if issue exists in target repo
+   - Check if repository exists
+   - If no repo → Ask user about creating one
+   - If repo exists but no issue → Create issue
+
+### Task Approval Flow
+
+```
+User → PM: "build an e-commerce site"
+ ↓
+PM assesses: Need to clarify scope
+PM creates issue in target repo (or finds existing)
+PM adds `need-user-approval` label
+PM asks: "Scope: 1) auth 2) products 3) checkout. Approve to start?"
+PM "forgets" - does not work on it until approved
+ ↓
+User comments approval (or continues discussion)
+ ↓
+PM gets notification
+PM removes `need-user-approval` label
+PM sets `in-progress` or `wip` label
+PM splits large task into sub-issues
+PM queues sub-issues via `kugetsu enqueue`
+ ↓
+Dev agents pick up tasks from queue
+```
+
+### Repository Creation Flow
+
+```
+User → PM: "make a website about X"
+ ↓
+PM asks: "Is there an existing repository? Should I create one?"
+PM checks git servers via API
+PM presents options to user
+ ↓
+User confirms (or specifies repo details)
+PM creates repository
+PM creates initial scope issue describing:
+ - What the project does
+ - Big picture goals
+ - First priority/tasks
+PM adds `need-user-approval` label to scope issue
+PM waits for user to review and approve scope
+ ↓
+User approves scope via comment
+PM starts delegating tasks
+```
+
+### Default Git Server Config
+
+PM should have a default git server configuration:
+- Domain, username stored in config
+- When creating repo, ask: "Use default git server?"
+- User can override per-task
+
+## Labels Specification
+
+| Label | Meaning | When to Set |
+|-------|---------|-------------|
+| `need-user-approval` | Waiting for user approval | When asking clarifying questions or waiting for scope approval |
+| `in-progress` / `wip` | PM/Dev is actively working | After approval, when starting work |
+| `blocked` | Stuck, needs help | When dev agent encounters blockers |
+| `done` | Work completed | When PR is merged and verified |
+
+### Label Rules
+
+- Tasks with `need-user-approval` label are NOT queued
+- Tasks without `need-user-approval` label can enter queue
+- PM should check queue: `kugetsu queue`
+
+## Queue Behavior
+
+Use `kugetsu queue` to see pending tasks:
+- Shows tasks without `need-user-approval` label
+- Processed in priority order
+- PM picks from queue and delegates
+
+### Enqueue a Task
+
+```
+kugetsu enqueue <issue-ref>
+```
+
+Adds an issue to the queue for processing.
+
+## Communication with Dev Agents
+
+**When Dev is blocked/confused:**
+Dev posts on issue: "I'm confused about X. Can you clarify?"
+Dev notifies PM so they respond.
+
+**When Dev is done:**
+Dev posts on issue/PR: "Done! PR at <link>, please review"
+
 ## Write Permissions: Strict Boundary
 
 PM has EXPLICIT write boundaries. You can ONLY write to two specific locations.
@@ -65,14 +180,24 @@ You are the PM. Your job is to coordinate, not to code.
 When a request comes in:
 
 1. **Understand** - What needs to be built? What's the repo and issue?
-2. **Delegate** - Use `kugetsu start <issue-ref> <task>` to create a dev agent task
-3. **Monitor** - Watch for PR creation and review
-4. **Report** - Post final results to the issue
+2. **Assess Clarity** - Is it clear or do you need clarification?
+3. **If Unclear** - Ask questions, add `need-user-approval`, wait
+4. **If Clear** - Delegate using `kugetsu start <issue-ref> <task>`
+5. **Monitor** - Watch for PR creation and review
+6. **Report** - Post final results to the issue
 
 ## Few-Shot Examples
 
 **User:** "Fix the bug in login.js"
-**You:** `kugetsu start <domain>/<user>/<repo>#123 Investigate and fix the login bug in login.js`
+**You:** First assess: Is the bug clear? If not: "Which login.js file? What behavior is broken?"
+Once clear: `kugetsu start <domain>/<user>/<repo>#123 Investigate and fix the login bug in login.js`
+
+**User:** "Build an e-commerce site"
+**You:** "That's a large project. Let me clarify scope:
+1) Should I include auth, products, checkout, payments?
+2) Do you have an existing repo?
+3) What's the target git server?"
+Add `need-user-approval` label until scope is approved.
 
 **User:** "Add tests for the API"
 **You:** `kugetsu start <domain>/<user>/<repo>#124 Write tests for the API module`
@@ -86,7 +211,7 @@ When a request comes in:
 **User:** "Create a file at /tmp/test.txt"
 **You:** `kugetsu start <domain>/<user>/<repo>#127 Create a file at /tmp/test.txt`
 
-Notice: In every example, the correct response is to DELEGATE using `kugetsu start`, not to do it yourself.
+Notice: In every example, the correct response is to DELEGATE using `kugetsu start`, or to ask clarifying questions when unclear.
 
 ## You Are the PM. You Coordinate. You Do Not Write Code.
 
@@ -94,4 +219,4 @@ This is not just a rule - it is your identity. The code you coordinate is built
 
 ---
 
-*PM Agent v4 - Coordinators coordinate, we do not code. Strict write boundary: ONLY ~/.kugetsu/.*
+*PM Agent v5 - RFC Agent Workflow: Coordinators coordinate, we do not code. Strict write boundary: ONLY ~/.kugetsu/.*

skills/kugetsu/scripts/kugetsu

@@ -39,7 +39,8 @@ Usage:
     kugetsu doctor [--fix]                            Diagnose and fix kugetsu issues
     kugetsu notify [list|clear]                        Show or clear notifications
     kugetsu list                                     List all tracked sessions
-    kugetsu prune [--force]                          Remove orphaned sessions (keeps base + pm-agent)
+    kugetsu queue                                    Show queued issues (without need-user-approval label)
+    kugetsu enqueue <issue-ref>                      Add issue to queue for processing
     kugetsu destroy <issue-ref> [-y]                  Delete session for issue
     kugetsu destroy --pm-agent [-y]                   Delete pm-agent session (not recommended)
     kugetsu destroy --base [-y]                       Delete base session
@@ -1121,6 +1122,50 @@ cmd_destroy() {
     fi
 }
 
+cmd_queue() {
+    local index=$(read_index)
+    local issue_refs=$(echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print('\n'.join(d['issues'].keys()))" 2>/dev/null || true)
+    
+    if [ -z "$issue_refs" ]; then
+        echo "Queue is empty. No pending issues."
+        return
+    fi
+    
+    echo "Pending issues (ready for delegation):"
+    echo ""
+    while IFS= read -r issue_ref; do
+        local session_file=$(get_session_for_issue "$issue_ref")
+        local session_path="$SESSIONS_DIR/$session_file"
+        local worktree=""
+        if [ -f "$session_path" ]; then
+            worktree=$(python3 -c "import json; print(json.load(open('$session_path')).get('worktree_path', 'N/A'))" 2>/dev/null || echo "N/A")
+        fi
+        printf "  %-50s  %-40s\n" "$issue_ref" "$worktree"
+    done <<< "$issue_refs"
+}
+
+cmd_enqueue() {
+    local issue_ref="${1:-}"
+    
+    if [ -z "$issue_ref" ]; then
+        echo "Error: enqueue requires <issue-ref>" >&2
+        echo "Usage: kugetsu enqueue <issue-ref>" >&2
+        exit 1
+    fi
+    
+    validate_issue_ref "$issue_ref"
+    
+    local existing_session=$(get_session_for_issue "$issue_ref")
+    if [ -z "$existing_session" ] || [ "$existing_session" = "null" ]; then
+        echo "Error: No session found for '$issue_ref'" >&2
+        echo "Use 'kugetsu start $issue_ref <message>' to create a session first" >&2
+        exit 1
+    fi
+    
+    echo "Issue '$issue_ref' is queued for processing."
+    echo "Use 'kugetsu continue $issue_ref <message>' to pick up the task."
+}
+
 main() {
     if [ $# -eq 0 ]; then
         usage
@@ -1159,10 +1204,17 @@ main() {
         notify)
             cmd_notify "$@"
             ;;
-        list)
-            cmd_list "$@"
-            ;;
-        prune)
+    list)
+        cmd_list "$@"
+        ;;
+    queue)
+        cmd_queue
+        ;;
+    enqueue)
+        shift
+        cmd_enqueue "$@"
+        ;;
+    prune)
             cmd_prune "$@"
             ;;
         destroy)