claude-code-workflow 7.2.15 → 7.2.16

package/.codex/skills/team-roadmap-dev/roles/coordinator/commands/analyze.md

@@ -0,0 +1,61 @@
+# Analyze Task
+
+Parse user task description for roadmap-dev domain signals. Detect phase count, depth preference, gate configuration, and pipeline mode.
+
+**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
+
+## Signal Detection
+
+### Phase Count
+
+| Keywords | Inferred Phase Count |
+|----------|---------------------|
+| "phase 1", "phase 2", ... | Explicit phase count from numbers |
+| "milestone", "milestone 1/2/3" | Count milestones |
+| "first ... then ... finally" | 3 phases |
+| "step 1/2/3" | Count steps |
+| No phase keywords | Default: 1 phase |
+
+### Depth Setting
+
+| Keywords | Depth |
+|----------|-------|
+| "quick", "fast", "simple", "minimal" | quick |
+| "thorough", "comprehensive", "complete", "full" | comprehensive |
+| default | standard |
+
+### Gate Configuration
+
+| Keywords | Gate |
+|----------|------|
+| "review each plan", "approve plan", "check before execute" | plan_check: true |
+| "review each phase", "approve phase", "check between phases" | phase_check: true |
+| "auto", "automated", "no review", "fully automated" | all gates: false |
+| default | plan_check: false, phase_check: false |
+
+### Pipeline Mode
+
+| Keywords | Mode |
+|----------|------|
+| "interactive", "step by step", "with approval" | interactive |
+| default | auto |
+
+## Output
+
+Write coordinator state to memory (not a file). Structure:
+
+```json
+{
+  "pipeline_mode": "auto | interactive",
+  "phase_count": 1,
+  "depth": "quick | standard | comprehensive",
+  "gates": {
+    "plan_check": false,
+    "phase_check": false
+  },
+  "task_description": "<original task text>",
+  "notes": ["<any detected constraints or special requirements>"]
+}
+```
+
+This state is passed to `commands/dispatch.md` and written to `config.json` in the session directory.

package/.codex/skills/team-roadmap-dev/roles/coordinator/commands/dispatch.md

@@ -0,0 +1,241 @@
+# Command: dispatch
+
+Create task chain for a specific phase. Each phase gets a PLAN -> EXEC -> VERIFY pipeline with dependency ordering.
+
+## Purpose
+
+Read the roadmap and create a linked task chain (PLAN -> EXEC -> VERIFY) for a given phase number. Tasks are assigned to the appropriate worker roles and linked via blockedBy dependencies. All tasks are stored in `<session>/tasks.json`.
+
+## Parameters
+
+| Parameter | Source | Description |
+|-----------|--------|-------------|
+| `phaseNumber` | From coordinator | Phase to dispatch (1-based) |
+| `sessionFolder` | From coordinator | Session artifact directory |
+
+## Execution Steps
+
+### Step 1: Read Roadmap and Extract Phase Requirements
+
+```javascript
+const roadmap = Read(`${sessionFolder}/roadmap.md`)
+const config = JSON.parse(Read(`${sessionFolder}/config.json`))
+
+// Parse phase section from roadmap
+// Extract: goal, requirements (REQ-IDs), success criteria
+const phaseGoal = extractPhaseGoal(roadmap, phaseNumber)
+const phaseRequirements = extractPhaseRequirements(roadmap, phaseNumber)
+const phaseSuccessCriteria = extractPhaseSuccessCriteria(roadmap, phaseNumber)
+```
+
+### Step 2: Create Phase Directory
+
+```javascript
+Bash(`mkdir -p "${sessionFolder}/phase-${phaseNumber}"`)
+```
+
+### Step 3: Load or Initialize tasks.json
+
+```javascript
+let tasks = []
+try {
+  tasks = JSON.parse(Read(`${sessionFolder}/tasks.json`))
+} catch {
+  tasks = []
+}
+```
+
+### Step 4: Create PLAN Task (Assigned to Planner)
+
+```javascript
+const planTaskId = `PLAN-${phaseNumber}01`
+
+tasks.push({
+  id: planTaskId,
+  subject: `PLAN-${phaseNumber}01: Plan phase ${phaseNumber} - ${phaseGoal}`,
+  status: "pending",
+  owner: "planner",
+  blockedBy: [],
+  activeForm: `Planning phase ${phaseNumber}`,
+  description: `[coordinator] Plan creation for phase ${phaseNumber}.
+
+## Session
+- Folder: ${sessionFolder}
+- Phase: ${phaseNumber}
+- Depth: ${config.depth}
+
+## Phase Goal
+${phaseGoal}
+
+## Requirements
+${phaseRequirements.map(r => `- ${r}`).join('\n')}
+
+## Success Criteria
+${phaseSuccessCriteria.map(c => `- ${c}`).join('\n')}
+
+## Deliverables
+- ${sessionFolder}/phase-${phaseNumber}/context.md (research context)
+- ${sessionFolder}/phase-${phaseNumber}/plan-01.md (execution plan with waves and must_haves)
+
+## Instructions
+1. Invoke Skill(skill="team-roadmap-dev", args="--role=planner")
+2. Follow planner role.md research + create-plans commands
+3. Use roadmap requirements as input for plan generation
+4. Update this task to completed when plan is written`
+})
+```
+
+### Step 5: Create EXEC Task (Assigned to Executor, Blocked by PLAN)
+
+```javascript
+const execTaskId = `EXEC-${phaseNumber}01`
+
+tasks.push({
+  id: execTaskId,
+  subject: `EXEC-${phaseNumber}01: Execute phase ${phaseNumber} - ${phaseGoal}`,
+  status: "pending",
+  owner: "executor",
+  blockedBy: [planTaskId],
+  activeForm: `Executing phase ${phaseNumber}`,
+  description: `[coordinator] Execute plans for phase ${phaseNumber}.
+
+## Session
+- Folder: ${sessionFolder}
+- Phase: ${phaseNumber}
+
+## Phase Goal
+${phaseGoal}
+
+## Plan Reference
+- ${sessionFolder}/phase-${phaseNumber}/plan-01.md (and any additional plans)
+
+## Instructions
+1. Invoke Skill(skill="team-roadmap-dev", args="--role=executor")
+2. Follow executor role.md implement command
+3. Execute all plans in wave order
+4. Write summary to ${sessionFolder}/phase-${phaseNumber}/summary-01.md
+5. Update this task to completed when all plans executed`
+})
+```
+
+### Step 6: Create VERIFY Task (Assigned to Verifier, Blocked by EXEC)
+
+```javascript
+const verifyTaskId = `VERIFY-${phaseNumber}01`
+
+tasks.push({
+  id: verifyTaskId,
+  subject: `VERIFY-${phaseNumber}01: Verify phase ${phaseNumber} - ${phaseGoal}`,
+  status: "pending",
+  owner: "verifier",
+  blockedBy: [execTaskId],
+  activeForm: `Verifying phase ${phaseNumber}`,
+  description: `[coordinator] Verify phase ${phaseNumber} against success criteria.
+
+## Session
+- Folder: ${sessionFolder}
+- Phase: ${phaseNumber}
+
+## Phase Goal
+${phaseGoal}
+
+## Success Criteria (from roadmap)
+${phaseSuccessCriteria.map(c => `- ${c}`).join('\n')}
+
+## References
+- Roadmap: ${sessionFolder}/roadmap.md
+- Plans: ${sessionFolder}/phase-${phaseNumber}/plan-*.md
+- Summaries: ${sessionFolder}/phase-${phaseNumber}/summary-*.md
+
+## Instructions
+1. Invoke Skill(skill="team-roadmap-dev", args="--role=verifier")
+2. Follow verifier role.md verify command
+3. Check each success criterion against actual implementation
+4. Write verification to ${sessionFolder}/phase-${phaseNumber}/verification.md
+5. If gaps found: list them with gap IDs in verification.md
+6. Update this task to completed with result (passed/gaps_found)`
+})
+```
+
+### Step 7: Write tasks.json
+
+```javascript
+Write(`${sessionFolder}/tasks.json`, JSON.stringify(tasks, null, 2))
+```
+
+### Step 8: Update state.md
+
+```javascript
+Edit(`${sessionFolder}/state.md`, {
+  old_string: `- Phase: ${phaseNumber}\n- Status: ready_to_dispatch`,
+  new_string: `- Phase: ${phaseNumber}\n- Status: in_progress\n- Tasks: PLAN-${phaseNumber}01 -> EXEC-${phaseNumber}01 -> VERIFY-${phaseNumber}01`
+})
+```
+
+### Step 9: Log Dispatch Message
+
+```javascript
+mcp__ccw-tools__team_msg({
+  operation: "log", session_id: sessionId,
+  from: "coordinator", to: "all",
+  type: "phase_started",
+  data: { ref: `${sessionFolder}/roadmap.md` }
+})
+```
+
+## Task Description Format
+
+All dispatched tasks follow this structure:
+
+```
+[coordinator] {action} for phase {N}.
+
+## Session
+- Folder: {sessionFolder}
+- Phase: {N}
+- Depth: {config.depth} (PLAN only)
+
+## Phase Goal
+{goal from roadmap}
+
+## Requirements / Success Criteria
+{from roadmap}
+
+## Deliverables
+{expected output files}
+
+## Instructions
+{step-by-step for the worker role}
+```
+
+## Task Naming Convention
+
+| Task | Name Pattern | Example |
+|------|-------------|---------|
+| Plan | `PLAN-{phase}01` | PLAN-101 |
+| Execute | `EXEC-{phase}01` | EXEC-101 |
+| Verify | `VERIFY-{phase}01` | VERIFY-101 |
+| Gap Plan | `PLAN-{phase}02` | PLAN-102 (gap closure iteration 1) |
+| Gap Execute | `EXEC-{phase}02` | EXEC-102 |
+| Gap Verify | `VERIFY-{phase}02` | VERIFY-102 |
+
+## Dependency Chain
+
+```
+PLAN-{N}01  <--  EXEC-{N}01  <--  VERIFY-{N}01
+(planner)        (executor)        (verifier)
+```
+
+Each task is blocked by its predecessor. Workers pick up tasks only when their blockedBy list is empty.
+
+## Output
+
+Returns the three task IDs as a structured result:
+
+```javascript
+{
+  planTaskId: planTaskId,
+  execTaskId: execTaskId,
+  verifyTaskId: verifyTaskId
+}
+```