@dzhechkov/keysarium 1.3.0 → 1.5.0

package/templates/.claude/skills/feature-adr/references/agentic-qe/qcsd-ideation-swarm.md

@@ -0,0 +1,126 @@
+---
+name: qcsd-ideation-swarm
+description: "QCSD Ideation phase swarm for Quality Criteria sessions using HTSM v6.3, Risk Storming, and Testability analysis before development begins."
+source: https://github.com/proffesor-for-testing/agentic-qe/tree/main/assets/skills/qcsd-ideation-swarm
+version: 7.5.1
+trust_tier: 3
+agents:
+  core: [qe-quality-criteria-recommender, qe-risk-assessor, qe-requirements-validator]
+  conditional: [qe-accessibility-auditor, qe-security-auditor, qe-qx-partner]
+---
+
+# QCSD Ideation Swarm (Adapted for Feature-ADR)
+
+Shift-left quality engineering swarm applied to feature ADR and requirements analysis.
+
+---
+
+## Phase 1: Flag Detection
+
+Scan feature requirements/ADR and SET these flags:
+
+```
+□ HAS_UI = FALSE
+  Set TRUE if feature contains: UI, frontend, visual, component, screen, page, form, button,
+  modal, dialog, dashboard, widget, interface, display, view, layout, CSS, styling
+
+□ HAS_SECURITY = FALSE
+  Set TRUE if feature contains: auth, security, credential, token, encrypt, PII, compliance,
+  password, login, session, OAuth, JWT, permission, role, access control, RBAC, sensitive
+
+□ HAS_UX = FALSE
+  Set TRUE if feature contains: user experience, UX, journey, usability, user flow, persona,
+  friction, delight, onboarding, retention, engagement
+```
+
+## Phase 2: Spawn Core Agents (3 parallel)
+
+ALL THREE core agents MUST be spawned in a single message:
+
+### Agent 1: Quality Criteria Recommender (HTSM v6.3)
+Analyze ALL 10 HTSM categories with weight and testability score:
+1. Capability — does it do what's required?
+2. Reliability — under stress, load, edge cases
+3. Usability — learnability, accessibility, efficiency
+4. Charisma — visual design, responsiveness
+5. Security — authentication, authorization, data protection
+6. Scalability — growth handling, resource limits
+7. Compatibility — browsers, devices, APIs, integrations
+8. Performance — speed, throughput, resource usage
+9. Installability — deployment, configuration, migration
+10. Development — testability, maintainability, portability
+
+### Agent 2: Risk Assessor (SFDIPOT)
+Apply SFDIPOT framework:
+- **S**tructure: Code architecture, component dependencies
+- **F**unction: Business logic, calculations, workflows
+- **D**ata: Data integrity, migrations, edge values
+- **I**nterfaces: API contracts, integration points, UI interactions
+- **P**latform: OS, browser, infrastructure dependencies
+- **O**perations: Deployment, monitoring, maintenance
+- **T**ime: Scheduling, concurrency, timeouts, caching
+
+Identify minimum 10 risks with probability (1-5), impact (1-5), and risk score.
+
+### Agent 3: Requirements Validator (Testability)
+Apply 10 Principles of Testability, score each 0-100:
+1. Observability — can we see what the system does?
+2. Controllability — can we put it in the state we need?
+3. Decomposability — can we test parts independently?
+4. Simplicity — is it only as complex as needed?
+5. Stability — does it change predictably?
+6. Information — do we have what we need to test?
+7. Communication — do we know what to test?
+8. Relation to prior work — can we leverage past tests?
+9. Time — do we have enough time to test?
+10. Accountability — who owns quality?
+
+## Phase 3: Conditional Agents (based on flags)
+
+| Flag | Agent | Analysis |
+|------|-------|----------|
+| HAS_UI | qe-accessibility-auditor | WCAG 2.2 AA compliance assessment |
+| HAS_SECURITY | qe-security-auditor | STRIDE threat modeling |
+| HAS_UX | qe-qx-partner | User journey and experience quality analysis |
+
+## Phase 4: GO/NO-GO Decision
+
+| Metric | NO-GO | CONDITIONAL | GO |
+|--------|-------|-------------|-----|
+| Testability Score | < 40 | 40-79 | ≥ 80 |
+| HTSM Coverage | < 6/10 | 6-7/10 | ≥ 8/10 |
+| AC Completeness | < 50% | 50-89% | ≥ 90% |
+| Critical Risks | > 2 | 1-2 | 0 |
+
+**NO-GO**: Stop. Requirements need rework before development.
+**CONDITIONAL**: Proceed with advisory warnings. Include findings in judge context.
+**GO**: Full confidence. Proceed to implementation planning.
+
+## Phase 5: Synthesis Report
+
+Generate consolidated report with:
+1. Executive summary (GO/CONDITIONAL/NO-GO verdict)
+2. Quality criteria scores (10 HTSM categories)
+3. Risk matrix (top 10 risks by score)
+4. Testability assessment (10 principles)
+5. Test ideas (categorized by type: unit/integration/E2E)
+6. Recommendations (prioritized by risk × impact)
+
+## Integration with Feature-ADR
+
+This swarm runs as Step 3.5 in the feature-adr pipeline:
+- **Input**: Refined ADR from Step 3 + Requirements from Step 1
+- **Output**: Quality assessment report in `features/<slug>/03.5_ideation_report.md`
+- **Gate**: NO-GO blocks progression to Step 6 (Implementation Plan)
+- **CONDITIONAL**: Warnings are passed to Steps 6-8 as context
+
+## Enforcement Rules
+
+| Rule | Requirement |
+|------|------------|
+| E1 | ALL THREE core agents must be spawned. No exceptions. |
+| E2 | All parallel agents in a SINGLE message. |
+| E3 | STOP and WAIT after each batch. No proceeding early. |
+| E4 | Conditional agents MUST be spawned if flags are TRUE. |
+| E5 | GO/CONDITIONAL/NO-GO logic applied exactly as specified. |
+| E6 | Full report structure generated. No abbreviated versions. |

package/templates/.claude/skills/feature-adr/references/agentic-qe/qcsd-production-swarm.md

@@ -0,0 +1,108 @@
+# QCSD Production Swarm (Condensed for Feature ADR)
+
+> Source: agentic-qe `qcsd-production-swarm` skill (Tier 3)
+> Condensed from 2781 lines — SAP/middleware-specific agents removed, universal patterns retained.
+
+## Purpose
+
+Post-release production health assessment and QCSD feedback loop closure.
+The only QCSD phase with dual responsibility: assessing current health AND
+closing the feedback loop back to earlier phases.
+
+## QCSD Phase Positioning
+
+| Phase | Swarm | Question | Decision |
+|-------|-------|----------|----------|
+| Ideation | qcsd-ideation-swarm | Should we build this? | GO / CONDITIONAL / NO-GO |
+| Refinement | qcsd-refinement-swarm | How should we test this? | READY / CONDITIONAL / NOT-READY |
+| Development | qcsd-development-swarm | Is code quality sufficient? | SHIP / CONDITIONAL / HOLD |
+| Verification | qcsd-cicd-swarm | Is this change safe to release? | RELEASE / REMEDIATE / BLOCK |
+| **Production** | **qcsd-production-swarm** | **Is release healthy?** | **HEALTHY / DEGRADED / CRITICAL** |
+
+## Core Agents (always run)
+
+| Agent | Domain | Role |
+|-------|--------|------|
+| qe-metrics-optimizer | learning-optimization | DORA metrics + SLA compliance |
+| qe-defect-predictor | defect-intelligence | Defect trend + density prediction |
+| qe-root-cause-analyzer | defect-intelligence | Incident RCA + severity assessment |
+
+## Conditional Agents (flag-based)
+
+| Flag | Agent | When to activate |
+|------|-------|------------------|
+| HAS_INFRASTRUCTURE_CHANGE | qe-chaos-engineer | Infra changes in release |
+| HAS_PERFORMANCE_SLA | qe-performance-tester | Performance SLAs defined |
+| HAS_REGRESSION_RISK | qe-regression-analyzer | Known regression risk areas |
+| HAS_RECURRING_INCIDENTS | qe-pattern-learner | Repeated incident patterns |
+
+## Feedback Agents (always run, SEQUENTIAL)
+
+| Order | Agent | Role |
+|-------|-------|------|
+| 1st | qe-learning-coordinator | Synthesize production findings |
+| 2nd | qe-transfer-specialist | Transfer learnings to Ideation + Refinement |
+
+## Decision Logic
+
+```
+CRITICAL (any condition):
+  - Active P0/P1 incidents
+  - DORA score < 0.4
+  - SLA compliance < 95%
+  - Accelerating defect trend (increasing + density > 5.0/KLOC)
+
+HEALTHY (all conditions):
+  - DORA score >= 0.7
+  - SLA compliance >= 99%
+  - No P0/P1/P2 incidents
+  - RCA completeness >= 80%
+  - Defect trend declining or stable
+  - Defect density <= 2.0/KLOC
+
+DEGRADED:
+  - Everything else (default)
+```
+
+## Execution Pattern (3 batches)
+
+```
+Batch 1 (parallel):  Core agents [3]
+  → WAIT for all to complete
+Batch 2 (parallel):  Conditional agents [0-4, based on flags]
+  → WAIT for all to complete
+Batch 3 (sequential): Feedback agents [2, strictly ordered]
+  → Learning coordinator THEN transfer specialist
+```
+
+## Enforcement Rules
+
+1. ALL THREE core agents MUST be spawned — no exceptions
+2. All parallel agents in a SINGLE message
+3. STOP and WAIT after each batch
+4. Conditional agents MUST spawn if flags are TRUE
+5. Decision logic applied EXACTLY as specified
+6. Both feedback agents MUST run SEQUENTIALLY
+7. Learning persistence MUST happen BEFORE feedback agents
+
+## Feedback Loop Closure
+
+Production swarm closes the QCSD loop by feeding findings back:
+
+```
+Production findings
+  → qe-learning-coordinator (synthesize)
+    → qe-transfer-specialist (distribute)
+      → Ideation phase (future GO/NO-GO informed by production data)
+      → Refinement phase (test strategy informed by production failures)
+```
+
+This is the key differentiator: no other QCSD phase feeds back to earlier phases.
+
+## Integration with Feature ADR
+
+When used in Direct Mode (full agentic-qe installed):
+- After Step 9 Fleet QE detects issues, production swarm feedback patterns
+  inform future `/feature-adr` runs via memory system
+- Historical production health data feeds Step 3.5 QCSD Ideation quality risks
+- Defect patterns from production inform Step 2 Research phase

package/templates/.claude/skills/feature-adr/references/agentic-qe/qe-coverage-analysis.md

@@ -0,0 +1,193 @@
+---
+name: "QE Coverage Analysis"
+description: "O(log n) sublinear coverage gap detection with risk-weighted analysis and intelligent test prioritization."
+trust_tier: 3
+validation:
+  schema_path: schemas/output.json
+  validator_path: scripts/validate-config.json
+  eval_path: evals/qe-coverage-analysis.yaml
+
+---
+
+# QE Coverage Analysis
+
+## Purpose
+
+Guide the use of v3's advanced coverage analysis capabilities including sublinear gap detection algorithms, risk-weighted coverage scoring, and intelligent test prioritization based on code criticality.
+
+## Activation
+
+- When analyzing test coverage
+- When identifying coverage gaps
+- When prioritizing testing effort
+- When setting coverage targets
+- When assessing code risk
+
+## Quick Start
+
+```bash
+# Analyze coverage with gap detection
+aqe coverage analyze --source src/ --tests tests/
+
+# Find high-risk uncovered code
+aqe coverage gaps --risk-weighted --threshold 80
+
+# Generate coverage report
+aqe coverage report --format html --output coverage-report/
+
+# Compare coverage between branches
+aqe coverage diff --base main --head feature-branch
+```
+
+## Agent Workflow
+
+```typescript
+// Comprehensive coverage analysis
+Task("Analyze coverage gaps", `
+  Perform O(log n) coverage analysis on src/:
+  - Calculate statement, branch, function coverage
+  - Identify uncovered critical paths
+  - Risk-weight gaps by code complexity and change frequency
+  - Recommend tests to write for maximum coverage impact
+`, "qe-coverage-specialist")
+
+// Risk-based prioritization
+Task("Prioritize coverage effort", `
+  Analyze coverage gaps and prioritize by:
+  - Business criticality (payment, auth, data)
+  - Code complexity (cyclomatic > 10)
+  - Recent bug history
+  - Change frequency
+  Output prioritized list of files needing tests.
+`, "qe-coverage-analyzer")
+```
+
+## Analysis Strategies
+
+### 1. Sublinear Gap Detection
+
+```typescript
+await coverageAnalyzer.detectGaps({
+  algorithm: 'sublinear',  // O(log n) complexity
+  source: 'src/**/*.ts',
+  metrics: ['statement', 'branch', 'function'],
+  sampling: {
+    enabled: true,
+    confidence: 0.95,
+    maxSamples: 1000
+  }
+});
+```
+
+### 2. Risk-Weighted Coverage
+
+```typescript
+await coverageAnalyzer.riskWeightedAnalysis({
+  coverage: coverageReport,
+  riskFactors: {
+    complexity: { weight: 0.3, threshold: 10 },
+    changeFrequency: { weight: 0.25, window: '90d' },
+    bugHistory: { weight: 0.25, window: '180d' },
+    criticality: { weight: 0.2, tags: ['payment', 'auth'] }
+  },
+  output: {
+    riskScore: true,
+    prioritizedGaps: true
+  }
+});
+```
+
+### 3. Differential Coverage
+
+```typescript
+await coverageAnalyzer.diffCoverage({
+  base: 'main',
+  head: 'feature-branch',
+  requirements: {
+    newCode: 80,           // New code must have 80% coverage
+    modifiedCode: 'maintain',  // Don't decrease existing
+    deletedCode: 'ignore'
+  }
+});
+```
+
+## Coverage Thresholds
+
+```yaml
+thresholds:
+  global:
+    statements: 80
+    branches: 75
+    functions: 85
+    lines: 80
+
+  per_file:
+    min_statements: 70
+    critical_paths: 90
+
+  new_code:
+    statements: 85
+    branches: 80
+
+  exceptions:
+    - path: "src/migrations/**"
+      reason: "Database migrations"
+    - path: "src/generated/**"
+      reason: "Auto-generated code"
+```
+
+## Coverage Report
+
+```typescript
+interface CoverageAnalysis {
+  summary: {
+    statements: { covered: number; total: number; percentage: number };
+    branches: { covered: number; total: number; percentage: number };
+    functions: { covered: number; total: number; percentage: number };
+  };
+  gaps: {
+    file: string;
+    uncoveredLines: number[];
+    uncoveredBranches: BranchInfo[];
+    riskScore: number;
+    suggestedTests: string[];
+  }[];
+  trends: {
+    period: string;
+    coverageChange: number;
+    newGaps: number;
+    closedGaps: number;
+  };
+  recommendations: {
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    file: string;
+    action: string;
+    expectedImpact: number;
+  }[];
+}
+```
+
+## Quality Gates
+
+```yaml
+quality_gates:
+  coverage:
+    block_merge:
+      - new_code_coverage < 80
+      - coverage_regression > 5
+      - critical_path_uncovered
+
+    warn:
+      - overall_coverage < 75
+      - branch_coverage < 70
+
+    metrics:
+      - track_trends: true
+      - alert_on_decline: 3  # consecutive PRs
+```
+
+## Coordination
+
+**Primary Agents**: qe-coverage-specialist, qe-coverage-analyzer, qe-gap-detector
+**Coordinator**: qe-coverage-coordinator
+**Related Skills**: qe-test-generation, qe-quality-assessment

package/templates/.claude/skills/feature-adr/references/agentic-qe/qe-requirements-validation.md

@@ -0,0 +1,254 @@
+---
+name: "QE Requirements Validation"
+description: "Requirements traceability, acceptance criteria validation, and BDD scenario management for complete requirements coverage."
+trust_tier: 3
+validation:
+  schema_path: schemas/output.json
+  validator_path: scripts/validate-config.json
+  eval_path: evals/qe-requirements-validation.yaml
+
+---
+
+# QE Requirements Validation
+
+## Purpose
+
+Guide the use of v3's requirements validation capabilities including acceptance criteria parsing, requirements traceability, BDD scenario generation, and coverage gap identification.
+
+## Activation
+
+- When validating requirements
+- When tracing requirements to tests
+- When generating BDD scenarios
+- When assessing requirements coverage
+- When reviewing acceptance criteria
+
+## Quick Start
+
+```bash
+# Parse acceptance criteria
+aqe requirements parse --source jira --project MYAPP
+
+# Build traceability matrix
+aqe requirements trace --requirements reqs/ --tests tests/
+
+# Generate BDD scenarios
+aqe requirements bdd --story US-123 --output features/
+
+# Check requirements coverage
+aqe requirements coverage --sprint current
+```
+
+## Agent Workflow
+
+```typescript
+// Requirements validation
+Task("Validate acceptance criteria", `
+  Review acceptance criteria for sprint stories:
+  - Check SMART criteria (Specific, Measurable, Achievable, Relevant, Testable)
+  - Identify ambiguous requirements
+  - Flag missing edge cases
+  - Suggest improvements
+`, "qe-acceptance-criteria")
+
+// Traceability matrix
+Task("Build traceability", `
+  Create requirements traceability matrix:
+  - Map user stories to test cases
+  - Identify untested requirements
+  - Find orphan tests (no linked requirement)
+  - Calculate coverage metrics
+`, "qe-traceability-builder")
+```
+
+## Requirements Operations
+
+### 1. Acceptance Criteria Validation
+
+```typescript
+await acceptanceCriteria.validate({
+  source: {
+    type: 'jira',
+    project: 'MYAPP',
+    stories: 'sprint=current'
+  },
+  validation: {
+    specific: true,
+    measurable: true,
+    achievable: true,
+    relevant: true,
+    testable: true
+  },
+  output: {
+    score: true,
+    issues: true,
+    suggestions: true
+  }
+});
+```
+
+### 2. Traceability Matrix
+
+```typescript
+await traceabilityBuilder.build({
+  requirements: {
+    source: 'jira',
+    types: ['story', 'task', 'bug']
+  },
+  artifacts: {
+    tests: 'tests/**/*.test.ts',
+    code: 'src/**/*.ts',
+    documentation: 'docs/**/*.md'
+  },
+  output: {
+    matrix: true,
+    coverage: true,
+    gaps: true,
+    orphans: true
+  }
+});
+```
+
+### 3. BDD Scenario Generation
+
+```typescript
+await bddGenerator.generate({
+  requirements: userStory,
+  format: 'gherkin',
+  scenarios: {
+    happyPath: true,
+    edgeCases: true,
+    errorCases: true,
+    dataVariations: true
+  },
+  output: {
+    featureFile: true,
+    stepDefinitions: 'skeleton'
+  }
+});
+```
+
+### 4. Coverage Analysis
+
+```typescript
+await requirementsCoverage.analyze({
+  scope: 'sprint-23',
+  metrics: {
+    requirementsCovered: true,
+    testCasesCoverage: true,
+    automationCoverage: true,
+    riskAssessment: true
+  },
+  report: {
+    summary: true,
+    details: true,
+    recommendations: true
+  }
+});
+```
+
+## Traceability Matrix
+
+```typescript
+interface TraceabilityMatrix {
+  requirements: {
+    id: string;
+    title: string;
+    type: string;
+    priority: string;
+    status: string;
+    linkedTests: string[];
+    linkedCode: string[];
+    coverage: 'full' | 'partial' | 'none';
+  }[];
+  tests: {
+    id: string;
+    name: string;
+    type: 'unit' | 'integration' | 'e2e';
+    linkedRequirements: string[];
+    automated: boolean;
+  }[];
+  coverage: {
+    requirementsCovered: number;
+    requirementsPartial: number;
+    requirementsUncovered: number;
+    orphanTests: number;
+  };
+  gaps: {
+    requirement: string;
+    missingCoverage: string[];
+    risk: 'high' | 'medium' | 'low';
+  }[];
+}
+```
+
+## BDD Integration
+
+```gherkin
+# Generated feature file
+Feature: User Registration
+  As a new user
+  I want to create an account
+  So that I can access the platform
+
+  @happy-path
+  Scenario: Successful registration with valid details
+    Given I am on the registration page
+    When I enter valid email "user@example.com"
+    And I enter valid password "SecurePass123!"
+    And I click the register button
+    Then I should see a success message
+    And I should receive a confirmation email
+
+  @edge-case
+  Scenario: Registration with existing email
+    Given a user exists with email "existing@example.com"
+    When I try to register with email "existing@example.com"
+    Then I should see an error "Email already registered"
+```
+
+## Requirements Quality
+
+```yaml
+quality_checks:
+  acceptance_criteria:
+    has_given_when_then: preferred
+    is_testable: required
+    is_measurable: required
+    no_ambiguity: required
+
+  user_story:
+    follows_template: "As a <role>, I want <feature>, so that <benefit>"
+    has_acceptance_criteria: required
+    estimated: preferred
+
+  completeness:
+    edge_cases_identified: required
+    error_scenarios_covered: required
+    non_functional_considered: preferred
+```
+
+## Sprint Integration
+
+```typescript
+await requirementsValidator.sprintReview({
+  sprint: 'current',
+  checks: {
+    storiesComplete: true,
+    criteriaValidated: true,
+    testsLinked: true,
+    coverageAdequate: true
+  },
+  gates: {
+    minCoverage: 80,
+    maxUntested: 2,
+    requireDemo: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: qe-acceptance-criteria, qe-traceability-builder, qe-bdd-specialist
+**Coordinator**: qe-requirements-coordinator
+**Related Skills**: qe-test-generation, qe-quality-assessment