claude-code-workflow 6.3.54 → 7.0.0

package/.claude/skills/team-coordinate-v2/roles/coordinator/commands/monitor.md

@@ -0,0 +1,301 @@
+# Command: monitor
+
+## Purpose
+
+Event-driven pipeline coordination with Spawn-and-Stop pattern. Role names are read from `team-session.json#roles`. Workers are spawned as `team-worker` agents with role-spec paths. Includes `handleComplete` for pipeline completion action and `handleAdapt` for mid-pipeline capability gap handling.
+
+## Constants
+
+| Constant | Value | Description |
+|----------|-------|-------------|
+| SPAWN_MODE | background | All workers spawned via `Task(run_in_background: true)` |
+| ONE_STEP_PER_INVOCATION | true | Coordinator does one operation then STOPS |
+| FAST_ADVANCE_AWARE | true | Workers may skip coordinator for simple linear successors |
+| WORKER_AGENT | team-worker | All workers spawned as team-worker agents |
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Session file | `<session-folder>/team-session.json` | Yes |
+| Task list | `TaskList()` | Yes |
+| Active workers | session.active_workers[] | Yes |
+| Role registry | session.roles[] | Yes |
+
+**Dynamic role resolution**: Known worker roles are loaded from `session.roles[].name`. Role-spec paths are in `session.roles[].role_spec`.
+
+## Phase 3: Handler Routing
+
+### Wake-up Source Detection
+
+Parse `$ARGUMENTS` to determine handler:
+
+| Priority | Condition | Handler |
+|----------|-----------|---------|
+| 1 | Message contains `[<role-name>]` from session roles | handleCallback |
+| 2 | Contains "capability_gap" | handleAdapt |
+| 3 | Contains "check" or "status" | handleCheck |
+| 4 | Contains "resume", "continue", or "next" | handleResume |
+| 5 | Pipeline detected as complete | handleComplete |
+| 6 | None of the above (initial spawn after dispatch) | handleSpawnNext |
+
+---
+
+### Handler: handleCallback
+
+Worker completed a task. Verify completion, update state, auto-advance.
+
+```
+Receive callback from [<role>]
+  +- Find matching active worker by role (from session.roles)
+  +- Is this a progress update (not final)? (Inner Loop intermediate task completion)
+  |   +- YES -> Update session state, do NOT remove from active_workers -> STOP
+  +- Task status = completed?
+  |   +- YES -> remove from active_workers -> update session
+  |   |   +- -> handleSpawnNext
+  |   +- NO -> progress message, do not advance -> STOP
+  +- No matching worker found
+      +- Scan all active workers for completed tasks
+      +- Found completed -> process each -> handleSpawnNext
+      +- None completed -> STOP
+```
+
+**Fast-advance note**: A worker may have already spawned its successor via fast-advance. When processing a callback:
+1. Check if the expected next task is already `in_progress` (fast-advanced)
+2. If yes -> skip spawning that task, update active_workers to include the fast-advanced worker
+3. If no -> normal handleSpawnNext
+
+---
+
+### Handler: handleCheck
+
+Read-only status report. No pipeline advancement.
+
+**Output format**:
+
+```
+[coordinator] Pipeline Status
+[coordinator] Progress: <completed>/<total> (<percent>%)
+
+[coordinator] Execution Graph:
+  <visual representation of dependency graph with status icons>
+
+  done=completed  >>>=running  o=pending  .=not created
+
+[coordinator] Active Workers:
+  > <subject> (<role>) - running <elapsed> [inner-loop: N/M tasks done]
+
+[coordinator] Ready to spawn: <subjects>
+[coordinator] Commands: 'resume' to advance | 'check' to refresh
+```
+
+Then STOP.
+
+---
+
+### Handler: handleResume
+
+Check active worker completion, process results, advance pipeline.
+
+```
+Load active_workers from session
+  +- No active workers -> handleSpawnNext
+  +- Has active workers -> check each:
+      +- status = completed -> mark done, log
+      +- status = in_progress -> still running, log
+      +- other status -> worker failure -> reset to pending
+      After processing:
+        +- Some completed -> handleSpawnNext
+        +- All still running -> report status -> STOP
+        +- All failed -> handleSpawnNext (retry)
+```
+
+---
+
+### Handler: handleSpawnNext
+
+Find all ready tasks, spawn team-worker agents in background, update session, STOP.
+
+```
+Collect task states from TaskList()
+  +- completedSubjects: status = completed
+  +- inProgressSubjects: status = in_progress
+  +- readySubjects: pending + all blockedBy in completedSubjects
+
+Ready tasks found?
+  +- NONE + work in progress -> report waiting -> STOP
+  +- NONE + nothing in progress -> PIPELINE_COMPLETE -> handleComplete
+  +- HAS ready tasks -> for each:
+      +- Is task owner an Inner Loop role AND that role already has an active_worker?
+      |   +- YES -> SKIP spawn (existing worker will pick it up via inner loop)
+      |   +- NO -> normal spawn below
+      +- TaskUpdate -> in_progress
+      +- team_msg log -> task_unblocked (team=<session-id>, NOT team name)
+      +- Spawn team-worker (see spawn tool call below)
+      +- Add to session.active_workers
+      Update session file -> output summary -> STOP
+```
+
+**Spawn worker tool call** (one per ready task):
+
+```
+Task({
+  subagent_type: "team-worker",
+  description: "Spawn <role> worker for <subject>",
+  team_name: <team-name>,
+  name: "<role>",
+  run_in_background: true,
+  prompt: `## Role Assignment
+role: <role>
+role_spec: <session-folder>/role-specs/<role>.md
+session: <session-folder>
+session_id: <session-id>
+team_name: <team-name>
+requirement: <task-description>
+inner_loop: <true|false>
+
+Read role_spec file to load Phase 2-4 domain instructions.`
+})
+```
+
+---
+
+### Handler: handleComplete
+
+Pipeline complete. Execute completion action based on session configuration.
+
+```
+All tasks completed (no pending, no in_progress)
+  +- Generate pipeline summary:
+  |   - Deliverables list with paths
+  |   - Pipeline stats (tasks completed, duration)
+  |   - Discussion verdicts (if any)
+  |
+  +- Read session.completion_action:
+      |
+      +- "interactive":
+      |   AskUserQuestion({
+      |     questions: [{
+      |       question: "Team pipeline complete. What would you like to do?",
+      |       header: "Completion",
+      |       multiSelect: false,
+      |       options: [
+      |         { label: "Archive & Clean (Recommended)", description: "Archive session, clean up team" },
+      |         { label: "Keep Active", description: "Keep session for follow-up work" },
+      |         { label: "Export Results", description: "Export deliverables to target directory" }
+      |       ]
+      |     }]
+      |   })
+      |   +- "Archive & Clean":
+      |   |   Update session status="completed"
+      |   |   TeamDelete(<team-name>)
+      |   |   Output final summary with artifact paths
+      |   +- "Keep Active":
+      |   |   Update session status="paused"
+      |   |   Output: "Resume with: Skill(skill='team-coordinate-v2', args='resume')"
+      |   +- "Export Results":
+      |       AskUserQuestion for target directory
+      |       Copy deliverables to target
+      |       Execute Archive & Clean flow
+      |
+      +- "auto_archive":
+      |   Execute Archive & Clean without prompt
+      |
+      +- "auto_keep":
+          Execute Keep Active without prompt
+```
+
+**Fallback**: If completion action fails, default to Keep Active (session status="paused"), log warning.
+
+---
+
+### Handler: handleAdapt
+
+Handle mid-pipeline capability gap discovery. A worker reports `capability_gap` when it encounters work outside its scope.
+
+**CONSTRAINT**: Maximum 5 worker roles per session. handleAdapt MUST enforce this limit.
+
+```
+Parse capability_gap message:
+  +- Extract: gap_description, requesting_role, suggested_capability
+  +- Validate gap is genuine:
+      +- Check existing roles in session.roles -> does any role cover this?
+      |   +- YES -> redirect: SendMessage to that role's owner -> STOP
+      |   +- NO -> genuine gap, proceed to role-spec generation
+  +- CHECK ROLE COUNT LIMIT (MAX 5 ROLES):
+      +- Count current roles in session.roles
+      +- If count >= 5:
+          +- Attempt to merge new capability into existing role
+          +- If merge NOT possible -> PAUSE, report to user
+  +- Generate new role-spec:
+      1. Read specs/role-spec-template.md
+      2. Fill template with: frontmatter (role, prefix, inner_loop, message_types) + Phase 2-4 content
+      3. Write to <session-folder>/role-specs/<new-role>.md
+      4. Add to session.roles[]
+  +- Create new task(s) via TaskCreate
+  +- Update team-session.json
+  +- Spawn new team-worker -> STOP
+```
+
+---
+
+### Worker Failure Handling
+
+When a worker has unexpected status (not completed, not in_progress):
+
+1. Reset task -> pending via TaskUpdate
+2. Log via team_msg (type: error)
+3. Report to user: task reset, will retry on next resume
+
+### Fast-Advance Failure Recovery
+
+When coordinator detects a fast-advanced task has failed:
+
+```
+handleCallback / handleResume detects:
+  +- Task is in_progress (was fast-advanced by predecessor)
+  +- No active_worker entry for this task
+  +- Resolution:
+      1. TaskUpdate -> reset task to pending
+      2. Remove stale active_worker entry (if any)
+      3. Log via team_msg (type: error)
+      4. -> handleSpawnNext (will re-spawn the task normally)
+```
+
+### Consensus-Blocked Handling
+
+```
+handleCallback receives message with consensus_blocked flag
+  +- Route by severity:
+      +- severity = HIGH
+      |   +- Create REVISION task (same role, incremented suffix)
+      |   +- Max 1 revision per task. If already revised -> PAUSE, escalate to user
+      +- severity = MEDIUM
+      |   +- Proceed with warning, log to wisdom/issues.md
+      |   +- Normal handleSpawnNext
+      +- severity = LOW
+          +- Proceed normally, treat as consensus_reached with notes
+```
+
+## Phase 4: Validation
+
+| Check | Criteria |
+|-------|----------|
+| Session state consistent | active_workers matches TaskList in_progress tasks |
+| No orphaned tasks | Every in_progress task has an active_worker entry |
+| Dynamic roles valid | All task owners exist in session.roles |
+| Completion detection | readySubjects=0 + inProgressSubjects=0 -> PIPELINE_COMPLETE |
+| Fast-advance tracking | Detect tasks already in_progress via fast-advance, sync to active_workers |
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Session file not found | Error, suggest re-initialization |
+| Worker callback from unknown role | Log info, scan for other completions |
+| All workers still running on resume | Report status, suggest check later |
+| Pipeline stall (no ready, no running) | Check for missing tasks, report to user |
+| Fast-advance conflict | Coordinator reconciles, no duplicate spawns |
+| Dynamic role-spec file not found | Error, coordinator must regenerate from task-analysis |
+| capability_gap when role limit (5) reached | Attempt merge, else pause for user |
+| Completion action fails | Default to Keep Active, log warning |

package/.claude/skills/team-coordinate-v2/roles/coordinator/role.md

@@ -0,0 +1,297 @@
+# Coordinator Role
+
+Orchestrate the team-coordinate workflow: task analysis, dynamic role-spec generation, task dispatching, progress monitoring, session state, and completion action. The sole built-in role -- all worker roles are generated at runtime as role-specs and spawned via team-worker agent.
+
+## Identity
+
+- **Name**: `coordinator` | **Tag**: `[coordinator]`
+- **Responsibility**: Analyze task -> Generate role-specs -> Create team -> Dispatch tasks -> Monitor progress -> Completion action -> Report results
+
+## Boundaries
+
+### MUST
+- Parse task description (text-level: keyword scanning, capability inference, dependency design)
+- Dynamically generate worker role-specs from specs/role-spec-template.md
+- Create team and spawn team-worker agents in background
+- Dispatch tasks with proper dependency chains from task-analysis.json
+- Monitor progress via worker callbacks and route messages
+- Maintain session state persistence (team-session.json)
+- Handle capability_gap reports (generate new role-specs mid-pipeline)
+- Handle consensus_blocked HIGH verdicts (create revision tasks or pause)
+- Detect fast-advance orphans on resume/check and reset to pending
+- Execute completion action when pipeline finishes
+
+### MUST NOT
+- **Read source code or perform codebase exploration** (delegate to worker roles)
+- Execute task work directly (delegate to workers)
+- Modify task output artifacts (workers own their deliverables)
+- Call implementation subagents (code-developer, etc.) directly
+- Skip dependency validation when creating task chains
+- Generate more than 5 worker roles (merge if exceeded)
+- Override consensus_blocked HIGH without user confirmation
+- Spawn workers with `general-purpose` agent (MUST use `team-worker`)
+
+---
+
+## Command Execution Protocol
+
+When coordinator needs to execute a command (analyze-task, dispatch, monitor):
+
+1. **Read the command file**: `roles/coordinator/commands/<command-name>.md`
+2. **Follow the workflow** defined in the command file (Phase 2-4 structure)
+3. **Commands are inline execution guides** - NOT separate agents or subprocesses
+4. **Execute synchronously** - complete the command workflow before proceeding
+
+Example:
+```
+Phase 1 needs task analysis
+  -> Read roles/coordinator/commands/analyze-task.md
+  -> Execute Phase 2 (Context Loading)
+  -> Execute Phase 3 (Task Analysis)
+  -> Execute Phase 4 (Output)
+  -> Continue to Phase 2
+```
+
+---
+
+## Entry Router
+
+When coordinator is invoked, first detect the invocation type:
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| Worker callback | Message contains `[role-name]` from session roles | -> handleCallback |
+| Status check | Arguments contain "check" or "status" | -> handleCheck |
+| Manual resume | Arguments contain "resume" or "continue" | -> handleResume |
+| Capability gap | Message contains "capability_gap" | -> handleAdapt |
+| Pipeline complete | All tasks completed, no pending/in_progress | -> handleComplete |
+| Interrupted session | Active/paused session exists in `.workflow/.team/TC-*` | -> Phase 0 (Resume Check) |
+| New session | None of above | -> Phase 1 (Task Analysis) |
+
+For callback/check/resume/adapt/complete: load `commands/monitor.md` and execute the appropriate handler, then STOP.
+
+### Router Implementation
+
+1. **Load session context** (if exists):
+   - Scan `.workflow/.team/TC-*/team-session.json` for active/paused sessions
+   - If found, extract `session.roles[].name` for callback detection
+
+2. **Parse $ARGUMENTS** for detection keywords
+
+3. **Route to handler**:
+   - For monitor handlers: Read `commands/monitor.md`, execute matched handler section, STOP
+   - For Phase 0: Execute Session Resume Check below
+   - For Phase 1: Execute Task Analysis below
+
+---
+
+## Phase 0: Session Resume Check
+
+**Objective**: Detect and resume interrupted sessions before creating new ones.
+
+**Workflow**:
+1. Scan `.workflow/.team/TC-*/team-session.json` for sessions with status "active" or "paused"
+2. No sessions found -> proceed to Phase 1
+3. Single session found -> resume it (-> Session Reconciliation)
+4. Multiple sessions -> AskUserQuestion for user selection
+
+**Session Reconciliation**:
+1. Audit TaskList -> get real status of all tasks
+2. Reconcile: session.completed_tasks <-> TaskList status (bidirectional sync)
+3. Reset any in_progress tasks -> pending (they were interrupted)
+4. Detect fast-advance orphans (in_progress without recent activity) -> reset to pending
+5. Determine remaining pipeline from reconciled state
+6. Rebuild team if disbanded (TeamCreate + spawn needed workers only)
+7. Create missing tasks with correct blockedBy dependencies
+8. Verify dependency chain integrity
+9. Update session file with reconciled state
+10. Kick first executable task's worker -> Phase 4
+
+---
+
+## Phase 1: Task Analysis
+
+**Objective**: Parse user task, detect capabilities, build dependency graph, design roles.
+
+**Constraint**: This is TEXT-LEVEL analysis only. No source code reading, no codebase exploration.
+
+**Workflow**:
+
+1. **Parse user task description**
+
+2. **Clarify if ambiguous** via AskUserQuestion:
+   - What is the scope? (specific files, module, project-wide)
+   - What deliverables are expected? (documents, code, analysis reports)
+   - Any constraints? (timeline, technology, style)
+
+3. **Delegate to `commands/analyze-task.md`**:
+   - Signal detection: scan keywords -> infer capabilities
+   - Artifact inference: each capability -> default output type (.md)
+   - Dependency graph: build DAG of work streams
+   - Complexity scoring: count capabilities, cross-domain factor, parallel tracks
+   - Role minimization: merge overlapping, absorb trivial, cap at 5
+   - **Role-spec metadata**: Generate frontmatter fields (prefix, inner_loop, subagents, message_types)
+
+4. **Output**: Write `<session>/task-analysis.json`
+
+5. **If `needs_research: true`**: Phase 2 will spawn researcher worker first
+
+**Success**: Task analyzed, capabilities detected, dependency graph built, roles designed with role-spec metadata.
+
+**CRITICAL - Team Workflow Enforcement**:
+
+Regardless of complexity score or role count, coordinator MUST:
+- ✅ **Always proceed to Phase 2** (generate role-specs)
+- ✅ **Always create team** and spawn workers via team-worker agent
+- ❌ **NEVER execute task work directly**, even for single-role low-complexity tasks
+- ❌ **NEVER skip team workflow** based on complexity assessment
+
+**Single-role execution is still team-based** - just with one worker. The team architecture provides:
+- Consistent message bus communication
+- Session state management
+- Artifact tracking
+- Fast-advance capability
+- Resume/recovery mechanisms
+
+---
+
+## Phase 2: Generate Role-Specs + Initialize Session
+
+**Objective**: Create session, generate dynamic role-spec files, initialize shared infrastructure.
+
+**Workflow**:
+
+1. **Check `needs_research` flag** from task-analysis.json:
+   - If `true`: **Spawn researcher worker first** to gather codebase context
+     - Wait for researcher callback
+     - Merge research findings into task context
+     - Update task-analysis.json with enriched context
+
+2. **Generate session ID**: `TC-<slug>-<date>` (slug from first 3 meaningful words of task)
+
+3. **Create session folder structure**:
+   ```
+   .workflow/.team/<session-id>/
+   +-- role-specs/
+   +-- artifacts/
+   +-- wisdom/
+   +-- explorations/
+   +-- discussions/
+   +-- .msg/
+   ```
+
+4. **Call TeamCreate** with team name derived from session ID
+
+5. **Read `specs/role-spec-template.md`** + task-analysis.json
+
+6. **For each role in task-analysis.json#roles**:
+   - Fill role-spec template with:
+     - YAML frontmatter: role, prefix, inner_loop, subagents, message_types
+     - Phase 2-4 content from responsibility type reference sections in template
+     - Task-specific instructions from task description
+   - Write generated role-spec to `<session>/role-specs/<role-name>.md`
+
+7. **Register roles** in team-session.json#roles (with `role_spec` path instead of `role_file`)
+
+8. **Initialize shared infrastructure**:
+   - `wisdom/learnings.md`, `wisdom/decisions.md`, `wisdom/issues.md` (empty with headers)
+   - `explorations/cache-index.json` (`{ "entries": [] }`)
+   - `shared-memory.json` (`{}`)
+   - `discussions/` (empty directory)
+
+9. **Write team-session.json** with: session_id, task_description, status="active", roles, pipeline (empty), active_workers=[], completion_action="interactive", created_at
+
+**Success**: Session created, role-spec files generated, shared infrastructure initialized.
+
+---
+
+## Phase 3: Create Task Chain
+
+**Objective**: Dispatch tasks based on dependency graph with proper dependencies.
+
+Delegate to `commands/dispatch.md` which creates the full task chain:
+1. Reads dependency_graph from task-analysis.json
+2. Topological sorts tasks
+3. Creates tasks via TaskCreate with correct blockedBy
+4. Assigns owner based on role mapping from task-analysis.json
+5. Includes `Session: <session-folder>` in every task description
+6. Sets InnerLoop flag for multi-task roles
+7. Updates team-session.json with pipeline and tasks_total
+
+**Success**: All tasks created with correct dependency chains, session updated.
+
+---
+
+## Phase 4: Spawn-and-Stop
+
+**Objective**: Spawn first batch of ready workers in background, then STOP.
+
+**Design**: Spawn-and-Stop + Callback pattern, with worker fast-advance.
+
+**Workflow**:
+1. Load `commands/monitor.md`
+2. Find tasks with: status=pending, blockedBy all resolved, owner assigned
+3. For each ready task -> spawn team-worker (see SKILL.md Coordinator Spawn Template)
+4. Output status summary with execution graph
+5. STOP
+
+**Pipeline advancement** driven by three wake sources:
+- Worker callback (automatic) -> Entry Router -> handleCallback
+- User "check" -> handleCheck (status only)
+- User "resume" -> handleResume (advance)
+
+---
+
+## Phase 5: Report + Completion Action
+
+**Objective**: Completion report, interactive completion choice, and follow-up options.
+
+**Workflow**:
+1. Load session state -> count completed tasks, duration
+2. List all deliverables with output paths in `<session>/artifacts/`
+3. Include discussion summaries (if inline discuss was used)
+4. Summarize wisdom accumulated during execution
+5. Output report:
+
+```
+[coordinator] ============================================
+[coordinator] TASK COMPLETE
+[coordinator]
+[coordinator] Deliverables:
+[coordinator]   - <artifact-1.md> (<producer role>)
+[coordinator]   - <artifact-2.md> (<producer role>)
+[coordinator]
+[coordinator] Pipeline: <completed>/<total> tasks
+[coordinator] Roles: <role-list>
+[coordinator] Duration: <elapsed>
+[coordinator]
+[coordinator] Session: <session-folder>
+[coordinator] ============================================
+```
+
+6. **Execute Completion Action** (based on session.completion_action):
+
+| Mode | Behavior |
+|------|----------|
+| `interactive` | AskUserQuestion with Archive/Keep/Export options |
+| `auto_archive` | Execute Archive & Clean without prompt |
+| `auto_keep` | Execute Keep Active without prompt |
+
+**Interactive handler**: See SKILL.md Completion Action section.
+
+---
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Task timeout | Log, mark failed, ask user to retry or skip |
+| Worker crash | Respawn worker, reassign task |
+| Dependency cycle | Detect in task analysis, report to user, halt |
+| Task description too vague | AskUserQuestion for clarification |
+| Session corruption | Attempt recovery, fallback to manual reconciliation |
+| Role-spec generation fails | Fall back to single general-purpose role |
+| capability_gap reported | handleAdapt: generate new role-spec, create tasks, spawn |
+| All capabilities merge to one | Valid: single-role execution, reduced overhead |
+| No capabilities detected | Default to single general role with TASK prefix |
+| Completion action fails | Default to Keep Active, log warning |