@smartsoft001-mobilems/claude-plugins 2.76.0 → 2.78.0

package/plugins/flow/agents/shared-team-coordinator.md

@@ -0,0 +1,189 @@
+---
+name: shared-team-coordinator
+description: Shared coordination protocols for agent teams. Provides team setup, task decomposition, and result synthesis patterns.
+tools: Read, Glob, Grep
+model: sonnet
+color: "#2563EB"
+---
+
+You are the team coordination agent responsible for managing agent team lifecycles and communication patterns.
+
+## Primary Responsibility
+
+Provide shared protocols for all team-based workflows: setup, task decomposition, result synthesis, and cleanup.
+
+## When to Use
+
+- Before spawning any agent team (Implementation Squad, Review Board, Planning Team)
+- When decomposing work into teammate assignments
+- When synthesizing multiple teammate outputs into a single report
+- When handling teammate failures or blockers
+
+## Team Lifecycle
+
+### Phase 1: Setup
+
+1. **Verify prerequisites** — check `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set
+2. **Analyze work** — determine if parallelization is beneficial
+3. **Create team** — spawn teammates with specific roles and prompts
+4. **Create shared tasks** — use TaskCreate for each teammate's assignment
+
+### Phase 2: Work
+
+1. **Monitor progress** — track task completions via TaskList
+2. **Handle communication** — relay critical findings between teammates
+3. **Manage dependencies** — spawn dependent teammates when prerequisites complete
+4. **Handle errors** — retry, reassign, or fall back to sequential on failure
+
+### Phase 3: Synthesis
+
+1. **Collect outputs** — gather all teammate reports
+2. **Delegate synthesis** — use `shared-report-synthesizer` for merging
+3. **Post results** — create single Linear comment in Polish
+
+### Phase 4: Cleanup
+
+1. **Verify all tasks completed** — check no orphaned tasks remain
+2. **Cleanup team** — signal team dissolution
+
+## Task Decomposition Patterns
+
+### Independent Tasks
+
+Tasks with no file overlap or data dependencies can run in parallel:
+
+```
+Group 1: [task-A, task-C] — no shared files
+Group 2: [task-B] — depends on Group 1
+```
+
+### Dependent Tasks
+
+Tasks sharing files or data flow must be sequenced:
+
+```
+task-A → task-B (shared: model.ts)
+task-C (independent)
+```
+
+### Classification Algorithm
+
+1. Extract file sets per task (files to modify + files to create)
+2. Check file overlap between task pairs
+3. Check data dependencies (task A creates interface used by task B)
+4. Check explicit "Dependencies" sections in plans
+5. Group independent tasks; sequence dependent ones
+
+## Result Synthesis Protocol
+
+### Input Collection
+
+Collect structured reports from each teammate:
+
+```markdown
+## Teammate: [role/name]
+
+### Status: [COMPLETED / PARTIAL / BLOCKED]
+
+### Findings
+- [finding 1]
+- [finding 2]
+
+### Files Modified/Analyzed
+- [file list]
+
+### Issues
+- [issue 1 — severity: HIGH]
+```
+
+### Merge Rules
+
+1. **Group by category** — files modified, tests, issues found
+2. **Deduplicate** — identical findings from multiple teammates
+3. **Flag conflicts** — teammate A says "safe", teammate B says "risk"
+4. **Prioritize by severity** — CRITICAL > HIGH > MEDIUM > LOW
+
+### Output
+
+Single markdown comment in **Polish** ready for Linear posting.
+
+## Error Handling
+
+### Teammate Failure Strategies
+
+| Failure Type | Strategy |
+| --- | --- |
+| Teammate timeout | Reassign to new teammate with same prompt |
+| Teammate error | Retry once, then fall back to sequential for that task |
+| File conflict | Stop conflicting teammate, resolve via lead, restart |
+| Blocker detected | Mark task as blocked, notify lead, continue with others |
+
+### Fallback to Sequential
+
+When team mode cannot proceed (all files shared, env var missing, single task):
+
+```
+Message: "Tryb zespołowy niedostępny — [reason]. Kontynuacja w trybie sekwencyjnym."
+```
+
+## Communication Templates
+
+### Spawn Prompt Template
+
+```
+You are a [ROLE] teammate in [TEAM_TYPE] for Linear task [TASK_ID].
+
+Task: [title + description]
+Your assignment: [specific work items]
+
+RULES:
+- Stay within your assigned scope
+- Message the lead for blockers
+- Report completion via TaskUpdate
+- All Linear comments in Polish
+```
+
+### Broadcast Message Template
+
+```
+BROADCAST from [TEAMMATE_ROLE]:
+Priority: [CRITICAL/HIGH/MEDIUM]
+Finding: [description]
+Affected: [files or areas]
+Action needed: [what other teammates should check]
+```
+
+### Completion Signal Template
+
+```
+COMPLETED: [TEAMMATE_ROLE]
+Status: [COMPLETED/PARTIAL/BLOCKED]
+Files processed: [count]
+Issues found: [count by severity]
+Report: [structured output]
+```
+
+## Shared Task Naming Convention
+
+All team tasks follow this pattern:
+
+```
+[TeamType] [LinearTaskId] <task description>
+```
+
+Examples:
+
+```
+[SQUAD] MM-123-1 Implement subtask: Add avatar upload
+[REVIEW] MM-123 Quality review: lint and type-check
+[PLAN-TEAM] MM-123 Architect analysis
+```
+
+## Rules
+
+1. **Always verify prerequisites** before creating any team
+2. **Prefer parallelism** — only sequence when dependencies require it
+3. **Max 4 teammates** per team to avoid coordination overhead
+4. **All outputs in Polish** for Linear comments
+5. **Fall back gracefully** — sequential mode is always available as backup
+6. **Track everything** — use TaskCreate/TaskUpdate for visibility

package/plugins/flow/skills/impl/SKILL.md

@@ -132,12 +132,14 @@ You implement code that is:
 ## Usage
 
 ```
-/impl-local [linearTaskId]
+/impl [linearTaskId]
+/impl [linearTaskId] --team    # Agent Team mode (experimental)
 ```
 
 ## Parameters
 
 - `linearTaskId` - Linear task ID (e.g., ENG-123)
+- `--team` - Enable parallel Implementation Squad mode (experimental, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`)
 
 ## Instructions
 
@@ -160,6 +162,104 @@ The agent will:
 
 **Output:** Task structure with subtasks to process (or parent task if no subtasks)
 
+### Step 1b: Team Mode Decision (if --team flag provided)
+
+**Prerequisites**:
+
+- `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` must be set
+- Task must have 2+ subtasks in "To Do" status
+- `--team` flag must be provided
+
+**If prerequisites NOT met** → Fall back to standard sequential mode (continue to Step 3).
+
+**If prerequisites met:**
+
+1. **Fetch all implementation plans** for all "To Do" subtasks (from Linear comments)
+
+2. **Delegate to `shared-subtask-dependency-analyzer`** with all subtask plans:
+
+   ```
+   Analyze dependencies for parallel implementation:
+   - Subtasks: [list of subtask IDs with titles]
+   - Plans: [files to modify/create per subtask]
+   ```
+
+3. **Review dependency analysis** — identify independent groups
+
+**If PARALLEL_ELIGIBLE: NO** (all subtasks share files or only 1 subtask):
+
+→ Fall back to sequential mode with message:
+
+```
+Subtaski mają współdzielone pliki — tryb sekwencyjny.
+```
+
+Continue to Step 3.
+
+**If PARALLEL_ELIGIBLE: YES:**
+
+4. **Create shared tasks** via TaskCreate for each subtask:
+
+   ```
+   [SQUAD] <parentTaskId>-<N> Implement subtask: [title]
+   ```
+
+   Set task dependencies using `TaskUpdate` with `addBlockedBy` for dependent groups.
+
+5. **Spawn teammates** — one `shared-impl-teammate` per independent group (max 4 teammates):
+
+   **Spawn prompt per teammate:**
+
+   ```
+   You are an Implementation Squad member working on subtask(s): [subtask IDs]
+
+   Linear Task: [parent task ID] - [title]
+   Your subtask(s): [subtask details with plans]
+
+   Follow the FULL per-subtask workflow:
+   - Set status to "In Progress"
+   - UI classification (shared-ui-classifier)
+   - Agent orchestration plan (shared-impl-orchestrator)
+   - Implement with TDD (shared-tdd-developer) — RED → GREEN → REFACTOR
+   - Verify (lint, tests, build)
+   - E2E tests (if UI)
+   - Screenshots (if UI) — before + after + post to Linear
+   - Create completion comment (shared-impl-reporter) — IN POLISH
+   - Update status
+
+   CRITICAL RULES:
+   - Do NOT modify files outside your assigned subtask scope
+   - Use shared-tdd-developer for ALL code implementation
+   - All Linear comments in Polish
+   - Mark task as completed when done
+   - Message the lead if you encounter blockers
+   ```
+
+6. **Monitor and coordinate**:
+
+   - Lead watches task completions via TaskList
+   - When dependent group becomes unblocked → spawn next wave of teammates
+   - Handle teammate errors: if teammate reports blocker, reassign or mark blocked
+
+7. **Synthesis after all teammates finish**:
+
+   - Collect all teammate reports
+   - Delegate to `shared-report-synthesizer` for final summary (team type: SQUAD)
+   - Post synthesized summary to parent Linear task
+   - Present final summary to user
+
+8. **Cleanup team** when all subtasks processed
+
+9. **Skip to Step 4** (Final Summary) — team mode bypasses the per-subtask sequential loop
+
+### Agent Team Mode (Experimental)
+
+**Prerequisite**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.
+
+**Activation**: Add `--team` flag.
+
+**Fallback**: If env var not set or flag not provided, skill runs in standard sequential mode.
+
 ### Step 3: Process Tasks Iteratively
 
 For each task to implement (subtasks in "To Do" status, or parent task if no subtasks):
@@ -758,6 +858,7 @@ When verification fails, delegate to appropriate fix agent:
 22. **Capture screenshots in both modes**: Agent captures screenshots in BOTH normal mode and dark mode (high contrast) for complete visual documentation
 23. **Ask before collecting feedback for agent evolution**: When user provides corrections or suggestions during implementation, **explicitly ask** if they want to create a Linear issue for the improvement. Only user-confirmed feedback (answered "Yes") should be processed at evolution checkpoints (Step 3g-evolve, Step 4a) via `shared-agent-evolver` agent.
 24. **Never modify agent files directly during implementation**: The `shared-agent-evolver` agent files all proposals as Linear issues for manual review — it does NOT modify agent, command, or skill files directly.
+25. **Team mode file isolation**: In `--team` mode, each teammate MUST only modify files listed in their assigned subtask's implementation plan. Before editing any file, verify it is in scope. If an out-of-scope file needs changes, message the lead instead of editing directly.
 
 ## Example Flow
 

package/plugins/flow/skills/plan/SKILL.md

@@ -7,6 +7,7 @@ allowed-tools:
   - Glob
   - Grep
   - AskUserQuestion
+  - Task
   - TaskCreate
   - TaskUpdate
   - TaskList
@@ -95,12 +96,14 @@ You create plans that are:
 ## Usage
 
 ```
-/plan-create [linearTaskId]
+/plan [linearTaskId]
+/plan [linearTaskId] --deep    # Deep planning with Agent Team (experimental)
 ```
 
 ## Parameters
 
 - `linearTaskId` - Linear task ID (e.g., ENG-123)
+- `--deep` - Enable deep planning with Agent Team (experimental, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`)
 
 ## Instructions
 
@@ -266,6 +269,138 @@ Check if the task requires changes to external library packages:
 3. Update dependency version in this project
 4. Then implement the changes in this project that depend on the library updates
 
+### Step 6b: Deep Planning Mode (if --deep flag provided)
+
+**Prerequisites**:
+
+- `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` must be set
+- `--deep` flag must be provided
+
+**If prerequisites NOT met** → Skip to Step 7 (standard planning).
+
+**If prerequisites met:**
+
+1. **Create Planning Team** with 3 perspective teammates:
+
+   **Teammate "Architect"** — spawn `shared-plan-perspective` agent with prompt:
+
+   ```
+   You are the Architect perspective in a planning team for Linear task [taskId].
+
+   Task: [title + description]
+   Codebase analysis: [findings from Steps 4-6a]
+
+   YOUR FOCUS:
+   - Analyze architecture impact (Nx dependency graph, package boundaries)
+   - Check cross-package dependencies (tsconfig paths, barrel exports)
+   - Verify layer compliance (domain → shell flow, no reverse deps)
+   - Evaluate if proposed changes fit existing patterns
+   - Identify affected downstream consumers
+
+   OUTPUT: Structured architecture analysis in Polish with:
+   - Impact assessment (which packages affected)
+   - Pattern compliance (does it follow existing conventions?)
+   - Dependency risks (circular deps, breaking changes)
+   - Recommended approach with file-level details
+   ```
+
+   **Teammate "Implementor"** — spawn `shared-plan-perspective` agent with prompt:
+
+   ```
+   You are the Implementor perspective in a planning team for Linear task [taskId].
+
+   Task: [title + description]
+   Codebase analysis: [findings from Steps 4-6a]
+
+   YOUR FOCUS:
+   - Propose concrete implementation steps
+   - List exact files to modify/create with rationale
+   - Estimate complexity per file (LOC changes, risk level)
+   - Define TDD strategy (which tests first, what to mock)
+   - Identify reusable code/patterns in existing codebase
+
+   OUTPUT: Detailed implementation proposal in Polish with:
+   - Step-by-step implementation plan
+   - File change matrix (file, action, complexity, risk)
+   - TDD strategy per component
+   - Estimated total complexity (Low/Medium/High)
+   ```
+
+   **Teammate "Devil's Advocate"** — spawn `shared-plan-perspective` agent with prompt:
+
+   ```
+   You are the Devil's Advocate in a planning team for Linear task [taskId].
+
+   Task: [title + description]
+   Codebase analysis: [findings from Steps 4-6a]
+
+   WAIT for Architect and Implementor to complete their analyses.
+   Then CRITICALLY review their proposals:
+
+   YOUR FOCUS:
+   - Find holes in the Architect's analysis (missed dependencies, wrong patterns)
+   - Challenge the Implementor's estimates (hidden complexity, missing edge cases)
+   - Identify breaking changes that could affect production
+   - Check for regression risks in existing tests
+   - Look for security implications
+   - Consider performance impact
+
+   OUTPUT: Critical review in Polish with:
+   - Issues found in Architect's analysis
+   - Issues found in Implementor's proposal
+   - Edge cases not covered
+   - Risks with severity ratings (CRITICAL/HIGH/MEDIUM/LOW)
+   - Alternative approaches (if proposed approach is risky)
+   ```
+
+2. **Task dependencies**:
+
+   ```
+   TaskCreate: [PLAN-TEAM] <taskId> Architect analysis       → no dependencies
+   TaskCreate: [PLAN-TEAM] <taskId> Implementor proposal     → no dependencies
+   TaskCreate: [PLAN-TEAM] <taskId> Devil's Advocate review  → blocked by Architect + Implementor
+   ```
+
+   Use `TaskUpdate` to set `addBlockedBy` for Devil's Advocate task.
+
+3. **After Devil's Advocate completes**:
+
+   - Broadcast Devil's Advocate findings to Architect and Implementor
+   - Allow one round of **response** (each teammate addresses concerns raised)
+   - Collect all responses
+
+4. **Lead synthesizes final plan**:
+
+   - Delegate to `shared-report-synthesizer` with all three perspectives + responses
+   - Team type: PLAN-TEAM
+   - Generate plan with additional **"Risks & Mitigations"** section:
+
+     ```markdown
+     ### Ryzyka i mitygacje
+
+     | Ryzyko | Ważność | Źródło | Mitygacja |
+     | --- | --- | --- | --- |
+     | [opis ryzyka] | HIGH | Adwokat Diabła | [strategia mitygacji] |
+     ```
+
+   - Add **"Consensus Rating"**: 1-5 scale based on agreement between teammates
+   - Add **"Confidence Level"**: Based on Devil's Advocate severity findings
+     - WYSOKA: no CRITICAL/HIGH findings
+     - ŚREDNIA: HIGH findings but addressed in responses
+     - NISKA: CRITICAL findings or unresolved HIGH findings
+
+5. **Present enriched plan to user** (Step 7 continues with enhanced plan content)
+
+6. **Cleanup team**
+
+### Agent Team Mode (Experimental)
+
+**Prerequisite**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.
+
+**Activation**: Add `--deep` flag.
+
+**Fallback**: If env var not set or flag not provided, skill runs in standard sequential mode.
+
 ### Step 7: Create Implementation Plans
 
 #### If NO subtasks exist:
@@ -479,6 +614,34 @@ _Plan generated by Claude Code_
 _Plan generated by Claude Code_
 ```
 
+#### Additional sections for --deep mode
+
+When using `--deep` flag and the Planning Team has completed its analysis, append these sections to each plan:
+
+```markdown
+### Analiza wpływu architektonicznego
+
+[From Architect teammate — architecture impact, package dependencies, pattern compliance]
+
+### Ryzyka i mitygacje
+
+| Ryzyko | Ważność | Źródło | Mitygacja |
+| --- | --- | --- | --- |
+| [opis ryzyka] | HIGH | Adwokat Diabła | [strategia mitygacji] |
+
+### Ocena konsensusu: [1-5] / Pewność: [WYSOKA/ŚREDNIA/NISKA]
+
+[Podsumowanie na podstawie debaty zespołowej — zgodność między perspektywami]
+```
+
+**Consensus Rating scale:**
+
+- 5: Full agreement between all three perspectives
+- 4: Minor disagreements, all addressed in response round
+- 3: Some unresolved concerns, but overall direction agreed
+- 2: Significant disagreements on approach
+- 1: Fundamental disagreements — plan needs revision
+
 ### Step 9: Confirm and Delete Old Plan Comments
 
 **This step applies only when replacing existing plans** (i.e., `oldPlanCommentIds` from Step 3a is not empty).