maestro-flow 0.2.0 → 0.2.2

package/.claude/skills/team-lifecycle-v4/roles/analyst/role.md

@@ -0,0 +1,78 @@
+---
+role: analyst
+prefix: RESEARCH
+inner_loop: false
+discuss_rounds: [DISCUSS-001]
+message_types:
+  success: research_ready
+  error: error
+---
+
+# Analyst
+
+Research and codebase exploration for context gathering.
+
+## Identity
+- Tag: [analyst] | Prefix: RESEARCH-*
+- Responsibility: Gather structured context from topic and codebase
+
+## Boundaries
+### MUST
+- Extract structured seed information from task topic
+- Explore codebase if project detected
+- Package context for downstream roles
+### MUST NOT
+- Implement code or modify files
+- Make architectural decisions
+- Skip codebase exploration when project files exist
+
+## Phase 2: Seed Analysis
+
+1. Read upstream artifacts via team_msg(operation="get_state")
+2. Extract session folder from task description
+3. Parse topic from task description
+4. If topic references file (@path or .md/.txt) → read it
+5. CLI seed analysis:
+   ```
+   Bash({ command: `maestro cli -p "PURPOSE: Analyze topic, extract structured seed info.
+   TASK: • Extract problem statement • Identify target users • Determine domain
+   • List constraints • Identify 3-5 exploration dimensions
+   TOPIC: <topic-content>
+   MODE: analysis
+   EXPECTED: JSON with: problem_statement, target_users[], domain, constraints[], exploration_dimensions[]" --tool gemini --mode analysis`, run_in_background: false })
+   ```
+6. Parse result JSON
+
+## Phase 3: Codebase Exploration
+
+| Condition | Action |
+|-----------|--------|
+| package.json / Cargo.toml / pyproject.toml / go.mod exists | Explore |
+| No project files | Skip (codebase_context = null) |
+
+When project detected:
+```
+Bash({ command: `maestro cli -p "PURPOSE: Explore codebase for context
+TASK: • Identify tech stack • Map architecture patterns • Document conventions • List integration points
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: JSON with: tech_stack[], architecture_patterns[], conventions[], integration_points[]" --tool gemini --mode analysis`, run_in_background: false })
+```
+
+## Phase 4: Context Packaging
+
+1. Write spec-config.json → <session>/spec/
+2. Write discovery-context.json → <session>/spec/
+3. Inline Discuss (DISCUSS-001):
+   - Artifact: <session>/spec/discovery-context.json
+   - Perspectives: product, risk, coverage
+4. Handle verdict per consensus protocol
+5. Report: complexity, codebase presence, dimensions, discuss verdict, output paths
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| CLI failure | Fallback to direct analysis |
+| No project detected | Continue as new project |
+| Topic too vague | Report with clarification questions |

package/.claude/skills/team-lifecycle-v4/roles/coordinator/commands/analyze.md

@@ -0,0 +1,56 @@
+# Analyze Task
+
+Parse user task -> detect capabilities -> build dependency graph -> design roles.
+
+**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
+
+## Signal Detection
+
+| Keywords | Capability | Prefix |
+|----------|------------|--------|
+| investigate, explore, research | analyst | RESEARCH |
+| write, draft, document | writer | DRAFT |
+| implement, build, code, fix | executor | IMPL |
+| design, architect, plan | planner | PLAN |
+| test, verify, validate | tester | TEST |
+| analyze, review, audit | reviewer | REVIEW |
+
+## Dependency Graph
+
+Natural ordering tiers:
+- Tier 0: analyst, planner (knowledge gathering)
+- Tier 1: writer (creation requires context)
+- Tier 2: executor (implementation requires plan/design)
+- Tier 3: tester, reviewer (validation requires artifacts)
+
+## Complexity Scoring
+
+| Factor | Points |
+|--------|--------|
+| Per capability | +1 |
+| Cross-domain | +2 |
+| Parallel tracks | +1 per track |
+| Serial depth > 3 | +1 |
+
+Results: 1-3 Low, 4-6 Medium, 7+ High
+
+## Role Minimization
+
+- Cap at 5 roles
+- Merge overlapping capabilities
+- Absorb trivial single-step roles
+
+## Output
+
+Write <session>/task-analysis.json:
+```json
+{
+  "task_description": "<original>",
+  "pipeline_type": "<spec-only|impl-only|full-lifecycle|...>",
+  "capabilities": [{ "name": "<cap>", "prefix": "<PREFIX>", "keywords": ["..."] }],
+  "dependency_graph": { "<TASK-ID>": { "role": "<role>", "blockedBy": ["..."], "priority": "P0|P1|P2" } },
+  "roles": [{ "name": "<role>", "prefix": "<PREFIX>", "inner_loop": false }],
+  "complexity": { "score": 0, "level": "Low|Medium|High" },
+  "needs_research": true
+}
+```

package/.claude/skills/team-lifecycle-v4/roles/coordinator/commands/dispatch.md

@@ -0,0 +1,56 @@
+# Dispatch Tasks
+
+Create task chains from dependency graph with proper blockedBy relationships.
+
+## Workflow
+
+1. Read task-analysis.json -> extract dependency_graph
+2. Read specs/pipelines.md -> get task registry for selected pipeline
+3. Topological sort tasks (respect blockedBy)
+4. Validate all owners exist in role registry (SKILL.md)
+5. For each task (in order):
+   - TaskCreate with structured description (see template below)
+   - TaskUpdate with blockedBy + owner assignment
+6. Update team-session.json with pipeline.tasks_total
+7. Validate chain (no orphans, no cycles, all refs valid)
+
+## Task Description Template
+
+```
+PURPOSE: <goal> | Success: <criteria>
+TASK:
+  - <step 1>
+  - <step 2>
+CONTEXT:
+  - Session: <session-folder>
+  - Upstream artifacts: <list>
+  - Key files: <list>
+EXPECTED: <artifact path> + <quality criteria>
+CONSTRAINTS: <scope limits>
+---
+InnerLoop: <true|false>
+RoleSpec: ~  or <project>/.claude/skills/team-lifecycle-v4/roles/<role>/role.md
+```
+
+## InnerLoop Flag Rules
+
+- true: Role has 2+ serial same-prefix tasks (writer: DRAFT-001->004)
+- false: Role has 1 task, or tasks are parallel
+
+## CHECKPOINT Task Rules
+
+CHECKPOINT tasks are dispatched like regular tasks but handled differently at spawn time:
+
+- Created via TaskCreate with proper blockedBy (upstream tasks that must complete first)
+- Owner: supervisor
+- **NOT spawned as team-worker** — coordinator wakes the resident supervisor via SendMessage
+- If `supervision: false` in team-session.json, skip creating CHECKPOINT tasks entirely
+- RoleSpec in description: `~  or <project>/.claude/skills/team-lifecycle-v4/roles/supervisor/role.md`
+
+## Dependency Validation
+
+- No orphan tasks (all tasks have valid owner)
+- No circular dependencies
+- All blockedBy references exist
+- Session reference in every task description
+- RoleSpec reference in every task description

package/.claude/skills/team-lifecycle-v4/roles/coordinator/commands/monitor.md

@@ -0,0 +1,157 @@
+# Monitor Pipeline
+
+Event-driven pipeline coordination. Beat model: coordinator wake -> process -> spawn -> STOP.
+
+## Constants
+
+- SPAWN_MODE: background
+- ONE_STEP_PER_INVOCATION: true
+- FAST_ADVANCE_AWARE: true
+- WORKER_AGENT: team-worker
+- SUPERVISOR_AGENT: team-supervisor (resident, woken via SendMessage)
+
+## Handler Router
+
+| Source | Handler |
+|--------|---------|
+| Message contains [role-name] | handleCallback |
+| "capability_gap" | handleAdapt |
+| "check" or "status" | handleCheck |
+| "resume" or "continue" | handleResume |
+| All tasks completed | handleComplete |
+| Default | handleSpawnNext |
+
+## handleCallback
+
+Worker completed. Process and advance.
+
+1. Find matching worker by role in message
+2. Check if progress update (inner loop) or final completion
+3. Progress -> update session state, STOP
+4. Completion -> mark task done
+   - Resident agent (supervisor) -> keep in active_workers (stays alive for future checkpoints)
+   - Standard worker -> remove from active_workers
+5. Check for checkpoints:
+   - CHECKPOINT-* with verdict "block" -> AskUserQuestion: Override / Revise upstream / Abort
+   - CHECKPOINT-* with verdict "warn" -> log risks to wisdom, proceed normally
+   - CHECKPOINT-* with verdict "pass" -> proceed normally
+   - QUALITY-001 -> display quality gate, pause for user commands
+   - PLAN-001 -> read plan.json complexity, create dynamic IMPL tasks per specs/pipelines.md routing
+6. -> handleSpawnNext
+
+## handleCheck
+
+Read-only status report, then STOP.
+
+**Worker Progress** (from message bus):
+
+Before generating status output, read worker milestones:
+
+```javascript
+const progressMsgs = mcp__ccw-tools__team_msg({
+  operation: "list", session_id: sessionId, type: "progress", last: 50
+})
+const blockerMsgs = mcp__ccw-tools__team_msg({
+  operation: "list", session_id: sessionId, type: "blocker", last: 10
+})
+
+// Aggregate latest milestone per task
+const taskProgress = {}
+for (const msg of (progressMsgs.result?.messages || [])) {
+  const tid = msg.data?.task_id
+  if (tid && (!taskProgress[tid] || msg.ts > taskProgress[tid].ts)) {
+    taskProgress[tid] = { phase: msg.data.phase, pct: msg.data.progress_pct, ts: msg.ts }
+  }
+}
+```
+
+Include in status output:
+- Per-worker latest milestone (phase + progress_pct) next to task status
+- Active blockers section (if any blockerMsgs found)
+
+Output:
+```
+[coordinator] Pipeline Status
+[coordinator] Progress: <done>/<total> (<pct>%)
+[coordinator] Active: <workers with elapsed time>
+[coordinator] Ready: <pending tasks with resolved deps>
+[coordinator] Commands: 'resume' to advance | 'check' to refresh
+```
+
+## handleResume
+
+1. No active workers -> handleSpawnNext
+2. Has active -> check each status
+   - completed -> mark done
+   - in_progress -> still running
+   - Resident agent (supervisor) with `resident: true` + no CHECKPOINT in_progress + pending CHECKPOINT exists
+     -> supervisor may have crashed. Respawn with `recovery: true`
+3. Some completed -> handleSpawnNext
+4. All running -> report status, STOP
+
+## handleSpawnNext
+
+Find ready tasks, spawn workers, STOP.
+
+1. Collect: completedSubjects, inProgressSubjects, readySubjects
+2. No ready + work in progress -> report waiting, STOP
+3. No ready + nothing in progress -> handleComplete
+4. Has ready -> for each:
+   a. Check if inner loop role with active worker -> skip (worker picks up)
+   b. **CHECKPOINT-* task** -> wake resident supervisor (see below)
+   c. Other tasks -> standard spawn:
+      - TaskUpdate -> in_progress
+      - team_msg log -> task_unblocked
+      - Spawn team-worker (see SKILL.md Worker Spawn Template)
+      - Add to active_workers
+5. Update session, output summary, STOP
+
+### Wake Supervisor for CHECKPOINT
+
+When a ready task has prefix `CHECKPOINT-*`:
+
+1. Verify supervisor is in active_workers with `resident: true`
+   - Not found -> spawn supervisor using SKILL.md Supervisor Spawn Template, wait for ready callback, then wake
+2. Determine scope: list task IDs that this checkpoint depends on (its blockedBy tasks)
+3. SendMessage to supervisor (see SKILL.md Supervisor Wake Template):
+   ```
+   SendMessage({
+     type: "message",
+     recipient: "supervisor",
+     content: "## Checkpoint Request\ntask_id: <CHECKPOINT-NNN>\nscope: [<upstream-task-ids>]\npipeline_progress: <done>/<total> tasks completed",
+     summary: "Checkpoint request: <CHECKPOINT-NNN>"
+   })
+   ```
+4. Do NOT TaskUpdate in_progress — supervisor claims the task itself
+5. Do NOT add duplicate entry to active_workers (supervisor already tracked)
+
+## handleComplete
+
+Pipeline done. Generate report and completion action.
+
+1. Shutdown resident supervisor (if active):
+   ```
+   SendMessage({ to: "supervisor", message: { type: "shutdown_request", reason: "Pipeline complete" } })
+   ```
+2. Generate summary (deliverables, stats, discussions)
+3. Read session.completion_action:
+   - interactive -> AskUserQuestion (Archive/Keep/Export)
+   - auto_archive -> Archive & Clean (status=completed, TeamDelete)
+   - auto_keep -> Keep Active (status=paused)
+
+## handleAdapt
+
+Capability gap reported mid-pipeline.
+
+1. Parse gap description
+2. Check if existing role covers it -> redirect
+3. Role count < 5 -> generate dynamic role-spec in <session>/role-specs/
+4. Create new task, spawn worker
+5. Role count >= 5 -> merge or pause
+
+## Fast-Advance Reconciliation
+
+On every coordinator wake:
+1. Read team_msg entries with type="fast_advance"
+2. Sync active_workers with spawned successors
+3. No duplicate spawns

package/.claude/skills/team-lifecycle-v4/roles/coordinator/role.md

@@ -0,0 +1,130 @@
+# Coordinator Role
+
+Orchestrate team-lifecycle-v4: analyze -> dispatch -> spawn -> monitor -> report.
+
+## Identity
+- Name: coordinator | Tag: [coordinator]
+- Responsibility: Analyze task -> Create team -> Dispatch tasks -> Monitor progress -> Report results
+
+## Boundaries
+
+### MUST
+- Parse task description (text-level only, no codebase reading)
+- Create team and spawn team-worker agents in background
+- Dispatch tasks with proper dependency chains
+- Monitor progress via callbacks and route messages
+- Maintain session state (team-session.json)
+- Handle capability_gap reports
+- Execute completion action when pipeline finishes
+
+### MUST NOT
+- Read source code or explore codebase (delegate to workers)
+- Execute task work directly
+- Modify task output artifacts
+- Spawn workers with general-purpose agent (MUST use team-worker)
+- Generate more than 5 worker roles
+
+## Command Execution Protocol
+When coordinator needs to execute a specific phase:
+1. Read `commands/<command>.md`
+2. Follow the workflow defined in the command
+3. Commands are inline execution guides, NOT separate agents
+4. Execute synchronously, complete before proceeding
+
+## Entry Router
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| Worker callback | Message contains [role-name] | -> handleCallback (monitor.md) |
+| Status check | Args contain "check" or "status" | -> handleCheck (monitor.md) |
+| Manual resume | Args contain "resume" or "continue" | -> handleResume (monitor.md) |
+| Capability gap | Message contains "capability_gap" | -> handleAdapt (monitor.md) |
+| Pipeline complete | All tasks completed | -> handleComplete (monitor.md) |
+| Interrupted session | Active session in .workflow/.team/TLV4-* | -> Phase 0 |
+| New session | None of above | -> Phase 1 |
+
+For callback/check/resume/adapt/complete: load @commands/monitor.md, execute handler, STOP.
+
+## Phase 0: Session Resume Check
+
+1. Scan .workflow/.team/TLV4-*/team-session.json for active/paused sessions
+2. No sessions -> Phase 1
+3. Single session -> reconcile:
+   a. Audit TaskList, reset in_progress->pending
+   b. Rebuild team workers
+   c. If pipeline has CHECKPOINT tasks AND `supervision !== false`:
+      - Respawn supervisor with `recovery: true` (see SKILL.md Supervisor Spawn Template)
+      - Supervisor auto-rebuilds context from existing CHECKPOINT-*-report.md files
+   d. Kick first ready task
+4. Multiple -> AskUserQuestion for selection
+
+## Phase 1: Requirement Clarification
+
+TEXT-LEVEL ONLY. No source code reading.
+
+1. Parse task description
+2. Clarify if ambiguous (AskUserQuestion: scope, deliverables, constraints)
+3. Delegate to @commands/analyze.md
+4. Output: task-analysis.json
+5. CRITICAL: Always proceed to Phase 2, never skip team workflow
+
+## Phase 2: Create Team + Initialize Session
+
+1. Resolve workspace paths (MUST do first):
+   - `project_root` = result of `Bash({ command: "pwd" })`
+   - `skill_root` = `<project_root>/.claude/skills/team-lifecycle-v4`
+2. Generate session ID: TLV4-<slug>-<date>
+3. Create session folder structure
+4. TeamCreate with team name
+5. Read specs/pipelines.md -> select pipeline
+6. Register roles in team-session.json
+7. Initialize shared infrastructure (wisdom/*.md, explorations/cache-index.json)
+8. Initialize pipeline via team_msg state_update:
+   ```
+   mcp__ccw-tools__team_msg({
+     operation: "log", session_id: "<id>", from: "coordinator",
+     type: "state_update", summary: "Session initialized",
+     data: { pipeline_mode: "<mode>", pipeline_stages: [...], team_name: "<name>" }
+   })
+   ```
+9. Write team-session.json
+10. Spawn resident supervisor (if pipeline has CHECKPOINT tasks AND `supervision !== false`):
+   - Use SKILL.md Supervisor Spawn Template (subagent_type: "team-supervisor")
+   - Wait for "[supervisor] Ready" callback before proceeding to Phase 3
+   - Record supervisor in active_workers with `resident: true` flag
+
+## Phase 3: Create Task Chain
+
+Delegate to @commands/dispatch.md:
+1. Read dependency graph from task-analysis.json
+2. Read specs/pipelines.md for selected pipeline's task registry
+3. Topological sort tasks
+4. Create tasks via TaskCreate with blockedBy
+5. Update team-session.json
+
+## Phase 4: Spawn-and-Stop
+
+Delegate to @commands/monitor.md#handleSpawnNext:
+1. Find ready tasks (pending + blockedBy resolved)
+2. Spawn team-worker agents (see SKILL.md Spawn Template)
+3. Output status summary
+4. STOP
+
+## Phase 5: Report + Completion Action
+
+1. Generate summary (deliverables, pipeline stats, discussions)
+2. Execute completion action per session.completion_action:
+   - interactive -> AskUserQuestion (Archive/Keep/Export)
+   - auto_archive -> Archive & Clean
+   - auto_keep -> Keep Active
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Task too vague | AskUserQuestion for clarification |
+| Session corruption | Attempt recovery, fallback to manual |
+| Worker crash | Reset task to pending, respawn |
+| Supervisor crash | Respawn with `recovery: true` in prompt, supervisor rebuilds context from existing reports |
+| Dependency cycle | Detect in analysis, halt |
+| Role limit exceeded | Merge overlapping roles |

package/.claude/skills/team-lifecycle-v4/roles/executor/commands/fix.md

@@ -0,0 +1,35 @@
+# Fix
+
+Revision workflow for bug fixes and feedback-driven changes.
+
+## Workflow
+
+1. Read original task + feedback/revision notes from task description
+2. Load original implementation context (files modified, approach taken)
+3. Analyze feedback to identify specific changes needed
+4. Apply fixes:
+   - Agent mode: Edit tool for targeted changes
+   - CLI mode: Resume previous session with fix prompt
+5. Re-validate convergence criteria
+6. Report: original task, changes applied, validation result
+
+## Fix Prompt Template (CLI mode)
+
+```
+PURPOSE: Fix issues in <task.title> based on feedback
+TASK:
+  - Review original implementation
+  - Apply feedback: <feedback text>
+  - Verify fixes address all feedback points
+MODE: write
+CONTEXT: @<modified files>
+EXPECTED: All feedback points addressed, convergence criteria met
+CONSTRAINTS: Minimal changes | No scope creep
+```
+
+## Quality Rules
+
+- Fix ONLY what feedback requests
+- No refactoring beyond fix scope
+- Verify original convergence criteria still pass
+- Report partial_completion if some feedback unclear

package/.claude/skills/team-lifecycle-v4/roles/executor/commands/implement.md

@@ -0,0 +1,62 @@
+# Implement
+
+Execute implementation from task JSON via agent or CLI delegation.
+
+## Agent Mode
+
+Direct implementation using Edit/Write/Bash tools:
+
+1. Read task.files[] as target files
+2. Read task.implementation[] as step-by-step instructions
+3. For each step:
+   - Substitute [variable] placeholders with pre_analysis results
+   - New file → Write tool; Modify file → Edit tool
+   - Follow task.reference patterns
+4. Apply task.rationale.chosen_approach
+5. Mitigate task.risks[] during implementation
+
+Quality rules:
+- Verify module existence before referencing
+- Incremental progress — small working changes
+- Follow existing patterns from task.reference
+- ASCII-only, no premature abstractions
+
+## CLI Delegation Mode
+
+Build prompt from task JSON, delegate to CLI:
+
+Prompt structure:
+```
+PURPOSE: <task.title>
+<task.description>
+
+TARGET FILES:
+<task.files[] with paths and changes>
+
+IMPLEMENTATION STEPS:
+<task.implementation[] numbered>
+
+PRE-ANALYSIS CONTEXT:
+<pre_analysis results>
+
+REFERENCE:
+<task.reference pattern and files>
+
+DONE WHEN:
+<task.convergence.criteria[]>
+
+MODE: write
+CONSTRAINTS: Only modify listed files | Follow existing patterns
+```
+
+CLI call:
+```
+Bash({ command: `maestro cli -p "<prompt>" --tool <tool> --mode write --rule development-implement-feature`,
+  run_in_background: false, timeout: 3600000 })
+```
+
+Resume strategy:
+| Strategy | Command |
+|----------|---------|
+| new | --id <session>-<task_id> |
+| resume | --resume <parent_id> |

package/.claude/skills/team-lifecycle-v4/roles/executor/role.md

@@ -0,0 +1,67 @@
+---
+role: executor
+prefix: IMPL
+inner_loop: true
+message_types:
+  success: impl_complete
+  progress: impl_progress
+  error: error
+---
+
+# Executor
+
+Code implementation worker with dual execution modes.
+
+## Identity
+- Tag: [executor] | Prefix: IMPL-*
+- Responsibility: Implement code from plan tasks via agent or CLI delegation
+
+## Boundaries
+### MUST
+- Parse task JSON before implementation
+- Execute pre_analysis steps if defined
+- Follow existing code patterns (task.reference)
+- Run convergence check after implementation
+### MUST NOT
+- Skip convergence validation
+- Implement without reading task JSON
+- Introduce breaking changes not in plan
+
+## Phase 2: Parse Task + Resolve Mode
+
+1. Extract from task description: task_file path, session folder, execution mode
+2. Read task JSON (id, title, files[], implementation[], convergence.criteria[])
+3. Resolve execution mode:
+   | Priority | Source |
+   |----------|--------|
+   | 1 | Task description Executor: field |
+   | 2 | task.meta.execution_config.method |
+   | 3 | plan.json recommended_execution |
+   | 4 | Auto: Low → agent, Medium/High → codex |
+4. Execute pre_analysis[] if exists (Read, Bash, Grep, Glob tools)
+
+## Phase 3: Execute Implementation
+
+Route by mode → read commands/<command>.md:
+- agent / gemini / codex / qwen → commands/implement.md
+- Revision task → commands/fix.md
+
+## Phase 4: Self-Validation
+
+| Step | Method | Pass Criteria |
+|------|--------|--------------|
+| Convergence check | Match criteria vs output | All criteria addressed |
+| Syntax check | tsc --noEmit or equivalent | Exit code 0 |
+| Test detection | Find test files for modified files | Tests identified |
+
+Report: task ID, status, mode used, files modified, convergence results.
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Agent mode syntax errors | Retry with error context (max 3) |
+| CLI mode failure | Retry or resume with --resume |
+| pre_analysis failure | Follow on_error (fail/continue/skip) |
+| CLI tool unavailable | Fallback: gemini → qwen → codex |
+| Max retries exceeded | Report failure to coordinator |