@smartsoft001-mobilems/claude-plugins 2.75.0 → 2.77.0

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).

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

@@ -0,0 +1,443 @@
+---
+name: review
+description: Run parallel multi-dimensional code review using Agent Teams. Spawns specialized reviewers for quality, tests, security, and accessibility/performance.
+allowed-tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+  - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
+  - AskUserQuestion
+  - mcp__linear-server__get_issue
+  - mcp__linear-server__list_comments
+  - mcp__linear-server__create_comment
+---
+
+# Review Skill
+
+Run parallel multi-dimensional code review using Agent Teams. Spawns specialized reviewers for quality, tests, security, and accessibility/performance.
+
+## Execution Checklist
+
+Execute each step in order. Do not skip any step marked as MANDATORY.
+
+- [ ] **1. Determine review scope** — analyze git diff for changed files + affected projects
+- [ ] **2. Check team prerequisites** — verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`
+- [ ] **3. Create Review Board team** — spawn 4 specialized reviewer teammates
+- [ ] **4. Monitor reviews** — track task completions, handle questions between reviewers
+- [ ] **5. Synthesize findings** — delegate to `shared-report-synthesizer`
+- [ ] **6. Post to Linear** — create single review comment in Polish
+- [ ] **7. Present to user** — show findings with severity ratings
+- [ ] **8. Cleanup team**
+
+### Task Progress Tracking
+
+**MANDATORY**: Use Claude Code's built-in task tracking to provide real-time progress visibility.
+
+**Task naming convention**: Every task subject MUST be prefixed with the Linear task ID (or scope):
+
+```
+[REVIEW] <linearTaskId> <step description>
+```
+
+**At skill start**: Create tasks for each review dimension:
+
+```
+TaskCreate({
+  subject: "[REVIEW] MM-123 Quality review",
+  description: "Lint, type-check, code style, import ordering",
+  activeForm: "[REVIEW] MM-123 Running quality review"
+})
+```
+
+## Role
+
+**You are an experienced code review lead** with:
+
+- Over 10 years of reviewing production code
+- Deep knowledge of TypeScript, Angular, NestJS security patterns
+- WCAG 2.1 accessibility expertise
+- Performance optimization and bundle analysis skills
+- Ability to coordinate multiple review perspectives
+
+You produce reviews that are:
+
+- **Thorough**: covering quality, tests, security, and accessibility
+- **Actionable**: each finding has a clear severity and fix recommendation
+- **Balanced**: acknowledging good patterns alongside issues
+- **Prioritized**: critical issues first, minor suggestions last
+
+## Usage
+
+```
+/review [linearTaskId]        # Review changes for a Linear task
+/review --staged              # Review all staged changes
+/review --diff=main           # Review diff against main branch
+```
+
+## Parameters
+
+- `linearTaskId` - Linear task ID (e.g., ENG-123)
+- `--staged` - Review all staged changes (no Linear task required)
+- `--diff=<branch>` - Review diff against specified branch
+
+## Instructions
+
+### Step 1: Determine Review Scope
+
+Analyze the changes to review:
+
+**If `linearTaskId` provided:**
+
+1. Fetch task from Linear via MCP
+2. Find related branch/commits via `git log --all --grep="<taskId>"`
+3. Determine changed files via `git diff main...<branch>`
+
+**If `--staged` provided:**
+
+1. Use `git diff --cached --name-only` to find staged files
+2. Use `git diff --cached` for full diff
+
+**If `--diff=<branch>` provided:**
+
+1. Use `git diff <branch>...HEAD --name-only` for changed files
+2. Use `git diff <branch>...HEAD` for full diff
+
+**Extract:**
+
+- List of changed files with change type (added/modified/deleted)
+- Affected Nx projects (from file paths)
+- Change statistics (lines added/removed per file)
+
+### Step 2: Check Team Prerequisites
+
+**Check `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`**:
+
+If env var is NOT set:
+
+→ Fall back to sequential review using `shared-verification-orchestrator` agent.
+
+```
+Tryb zespołowy niedostępny — brak CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1.
+Uruchamiam sekwencyjną weryfikację...
+```
+
+Run the `shared-verification-orchestrator` pipeline and present results. Stop here.
+
+**If env var IS set** → Continue to Step 3.
+
+### Step 3: Create Review Board Team
+
+Create 4 specialized reviewer tasks and spawn teammates:
+
+#### Reviewer 1: Quality Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Quality review: lint and type-check",
+  description: "Check lint errors, TypeScript type safety, code style, import ordering",
+  activeForm: "[REVIEW] <taskId> Running quality review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Quality Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Run linting: `nx lint [project]` for each affected project
+- Run type-check: `npx tsc --noEmit` for affected projects
+- Check code style: naming conventions, function length, complexity
+- Verify import ordering matches ESLint rules
+- Check for unused imports, dead code, TODO comments
+- Verify Angular modern APIs (signals, @if/@for, inject())
+
+DELEGATE TO existing agents as needed:
+- `shared-style-enforcer` for detailed style analysis
+- `shared-verification-runner` for running lint/type-check commands
+
+OUTPUT FORMAT:
+## Quality Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 2: Test Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Test review: coverage and quality",
+  description: "Unit test coverage, test quality, AAA pattern compliance",
+  activeForm: "[REVIEW] <taskId> Running test review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Test Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Run unit tests: `nx test [project] --coverage` for affected projects
+- Check coverage meets 90% minimum for new code
+- Verify AAA pattern (Arrange-Act-Assert) in all test files
+- Check test naming: describe('@smartsoft001-mobilems/...'), it('should...')
+- Verify mock patterns match project conventions
+- Check for missing edge case tests
+- Verify no skipped tests (xit, xdescribe)
+
+DELEGATE TO existing agents as needed:
+- `shared-coverage-enforcer` for coverage analysis
+- `shared-test-runner` for test execution
+
+OUTPUT FORMAT:
+## Test Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.spec.ts:line
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.spec.ts:line
+
+### Coverage Report
+| Project | Coverage | Required | Status |
+| --- | --- | --- | --- |
+| [project] | 85% | 90% | ❌ BELOW |
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 3: Security Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Security review: OWASP and deps",
+  description: "OWASP top 10, dependency audit, secrets detection",
+  activeForm: "[REVIEW] <taskId> Running security review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Security Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Check for OWASP Top 10 vulnerabilities in changed code:
+  - XSS (innerHTML, bypassSecurityTrust*, template injection)
+  - SQL/NoSQL injection (unsanitized query parameters)
+  - Broken authentication (token handling, session management)
+  - Sensitive data exposure (logging secrets, hardcoded credentials)
+  - CSRF protection
+- Run dependency audit: `npm audit --audit-level=moderate`
+- Check for hardcoded secrets, API keys, tokens
+- Verify input validation at system boundaries
+- Check for insecure HTTP calls (http:// vs https://)
+- Review authorization checks in backend code
+
+DELEGATE TO existing agents as needed:
+- `shared-security-scanner` for automated security scanning
+
+OUTPUT FORMAT:
+## Security Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line — OWASP: [category]
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Dependency Audit
+- Vulnerabilities found: [count by severity]
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 4: A11y + Performance Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> A11y + Performance review",
+  description: "WCAG 2.1 accessibility, bundle sizes, performance patterns",
+  activeForm: "[REVIEW] <taskId> Running a11y + performance review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Accessibility & Performance Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS (Accessibility):
+- WCAG 2.1 compliance in templates:
+  - Alt text for images
+  - ARIA labels for interactive elements
+  - Keyboard navigation support
+  - Color contrast (check Tailwind classes)
+  - Focus management
+  - Semantic HTML usage
+- Screen reader compatibility
+
+YOUR FOCUS (Performance):
+- Bundle size impact (new imports, lazy loading)
+- Change detection optimization (OnPush, signals)
+- Template performance (trackBy/@for track, computed signals)
+- Memory leaks (unsubscribed observables, event listeners)
+- Unnecessary re-renders
+
+DELEGATE TO existing agents as needed:
+- `ui-a11y-validator` for accessibility scanning
+- `shared-performance-validator` for performance analysis
+
+OUTPUT FORMAT:
+## A11y + Performance Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line — type: A11Y/PERF
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Accessibility Audit
+- WCAG violations: [count]
+- Missing ARIA labels: [count]
+
+### Performance Impact
+- New dependencies added: [list]
+- Bundle size estimate: [impact]
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+### Step 4: Monitor Reviews
+
+While teammates are working:
+
+1. **Track progress** via `TaskList` — check which reviewers have completed
+2. **Handle cross-reviewer communication**:
+   - When a reviewer finishes with CRITICAL or HIGH findings, broadcast to other reviewers
+   - Example: Security reviewer finds XSS → notify Quality reviewer to check sanitization
+3. **Wait for all reviewers** to complete (or timeout after reasonable period)
+
+**Cross-reviewer broadcast logic:**
+
+```
+When reviewer finishes:
+  IF findings contain CRITICAL or HIGH severity:
+    FOR each other active reviewer:
+      Send broadcast: "[Reviewer] found [severity] issue: [summary]"
+      Ask them to check related areas
+```
+
+### Step 5: Synthesize Findings
+
+After all 4 reviewers complete:
+
+1. **Collect all reports** from reviewer tasks
+2. **Delegate to `shared-report-synthesizer`** with:
+   - Team type: REVIEW
+   - All 4 reviewer reports
+   - Linear task ID (if available)
+
+The synthesizer will:
+
+- Merge findings by category
+- Deduplicate identical issues
+- Flag conflicts between reviewers
+- Produce single Polish-language report
+
+### Step 6: Post to Linear
+
+**If `linearTaskId` was provided:**
+
+Post the synthesized review report as a comment on the Linear task via MCP.
+
+**If `--staged` or `--diff`:**
+
+Skip Linear posting (no task to attach to).
+
+### Step 7: Present to User
+
+Show the synthesized review results to the user:
+
+1. **Overall verdict**: PASS / PASS_WITH_WARNINGS / BLOCK
+2. **Summary table** with per-dimension results
+3. **Critical issues** requiring immediate attention
+4. **Warnings** for consideration
+5. **Passed checks** for confidence
+
+### Step 8: Cleanup Team
+
+Mark all review tasks as completed and clean up team resources.
+
+## Fallback: Sequential Review
+
+When `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is NOT set, run a sequential review:
+
+1. Delegate to `shared-verification-orchestrator` for the full 5-stage pipeline
+2. Present results to user
+3. Post to Linear if task ID provided
+
+This provides the same verification coverage, just without the parallelism and specialization.
+
+## Guidelines
+
+1. **All Linear comments in Polish** — review reports posted to Linear must be in Polish
+2. **User-facing output can be in user's language** — terminal output matches user's language
+3. **Severity ratings are mandatory** — every finding must have CRITICAL/HIGH/MEDIUM/LOW
+4. **Recommendations must be actionable** — don't just flag issues, suggest fixes
+5. **Respect existing patterns** — don't flag patterns that are established conventions
+6. **Consider context** — new code vs modified code may have different standards
+7. **Be constructive** — balance criticism with positive observations
+8. **Track everything** — use TaskCreate/TaskUpdate for visibility into review progress
+
+## Agent Team Mode (Experimental)
+
+**Prerequisite**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.
+
+**Activation**: Automatic when env var is set.
+
+**Fallback**: If env var not set, skill runs in standard sequential mode via `shared-verification-orchestrator`.