@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/assets/skills/consultancy-practices/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: consultancy-practices
+description: "Apply effective software quality consultancy practices. Use when consulting, advising clients, or establishing consultancy workflows."
+category: professional-practice
+priority: medium
+tokenEstimate: 950
+agents: [qe-quality-analyzer, qe-regression-risk-analyzer, qe-quality-gate]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-03
+dependencies: []
+quick_reference_card: true
+tags: [consulting, advisory, client-engagement, quality-assessment, transformation]
+---
+
+# Consultancy Practices
+
+<default_to_action>
+When consulting on quality:
+1. LISTEN FIRST: Understand their context before prescribing solutions
+2. DISCOVER: What's the pain? What have they tried? What are constraints?
+3. PRIORITIZE: Impact/effort matrix - high impact, low effort first
+4. TRANSFER KNOWLEDGE: Leave them better, not dependent on you
+5. MEASURE: Define success metrics upfront, track weekly
+
+**Engagement Types:**
+- **Assessment (1-4 weeks)**: Discover, analyze, recommend
+- **Transformation (3-12 months)**: Implement new practices
+- **Advisory (ongoing)**: Strategic guidance, course-correct
+- **Crisis (1-4 weeks)**: Fix critical issues blocking production
+
+**Key Questions:**
+- "Walk me through your last deployment"
+- "Tell me about a recent bug that escaped to production"
+- "If you could fix one thing, what would it be?"
+</default_to_action>
+
+## Quick Reference Card
+
+### The Consulting Process
+
+| Phase | Duration | Goal | Deliverable |
+|-------|----------|------|-------------|
+| **Discovery** | Week 1-2 | Understand context | Interview notes, observations |
+| **Analysis** | Week 2-3 | Identify root causes | Impact/effort matrix |
+| **Recommendations** | Week 3-4 | Present findings | Report with roadmap |
+| **Implementation** | Month 2-6+ | Execute changes | Working system, trained team |
+| **Transition** | Final month | Ensure self-sufficiency | Handover docs |
+
+### Impact/Effort Matrix
+
+| Priority | What | Action |
+|----------|------|--------|
+| High Impact, Low Effort | Quick wins | Do first |
+| High Impact, High Effort | Major initiatives | Plan carefully |
+| Low Impact, Low Effort | Nice-to-haves | If time permits |
+| Low Impact, High Effort | Distractions | Skip |
+
+---
+
+## Common Patterns
+
+### "We Need Test Automation"
+
+**What they say:** "We need test automation"
+**What they mean:** "Manual testing is too slow/expensive"
+
+**Discovery:** How long is regression? What's deployment frequency?
+
+**Typical Finding:** They need faster feedback, not "automation"
+
+**Recommendation:**
+1. Unit tests for new code (TDD)
+2. Smoke tests for critical paths
+3. Keep exploratory for discovery
+4. Build automation incrementally
+
+### "Fix Our Quality Problem"
+
+**What they say:** "We have too many bugs"
+**What they mean:** "Something is broken but we don't know what"
+
+**Discovery:** Where found? What types? When introduced?
+
+**Typical Finding:** No test strategy, testing too late, poor feedback loops
+
+**Recommendation:**
+1. Shift testing left
+2. Improve coverage on critical paths
+3. Speed up CI/CD feedback
+4. Better requirements/acceptance criteria
+
+### "We Want to Scale Quality"
+
+**What they say:** "Growing fast, quality can't keep up"
+**What they mean:** "Can't hire enough QA fast enough"
+
+**Discovery:** Current QA:Dev ratio? Where's QA spending time?
+
+**Typical Finding:** QA is bottleneck - manual regression, gatekeeping
+
+**Recommendation:**
+1. Make QA strategic, not tactical
+2. Developers own test automation
+3. QA focuses on exploratory, risk analysis
+4. Use agentic approaches for scale
+
+---
+
+## Anti-Patterns
+
+| Anti-Pattern | Problem | Better |
+|--------------|---------|--------|
+| **Cookie-Cutter** | Same solution everywhere | Context-specific recommendations |
+| **Tool Pusher** | Recommend expensive tools | Tools that solve actual problems |
+| **Process Nazi** | Impose rigid process | Lightweight, fits their culture |
+| **Permanent Fixture** | Never leave, create dependency | Work toward them not needing you |
+| **Blame Game** | Point fingers at people | Fix systems, not blame people |
+
+---
+
+## Difficult Situations
+
+**"We already tried that"**
+→ "Tell me what you tried and what didn't work" (learn from their experience)
+
+**"Our context is special"**
+→ "Help me understand what makes yours special" (they might be right, or making excuses)
+
+**"We don't have budget/time"**
+→ "What's the cost of not fixing this? Let's start small" (show ROI)
+
+**"That won't work here"**
+→ "What specific constraints? Let's adapt" (find what WILL work)
+
+---
+
+## Agent Integration
+
+```typescript
+// Automated codebase assessment
+const assessment = await Task("Assess Codebase", {
+  scope: 'client-project/',
+  depth: 'comprehensive',
+  reportFormat: 'executive-summary'
+}, "qe-quality-analyzer");
+
+// Returns: { qualityScore, testCoverage, technicalDebt, recommendations }
+
+// ROI analysis for quality initiatives
+const roi = await Task("Calculate ROI", {
+  currentState: { defectEscapeRate: 0.15, mttr: 48 },
+  proposedImprovements: ['test-automation', 'ci-cd-pipeline'],
+  timeframe: '6-months'
+}, "qe-quality-analyzer");
+
+// Returns: { estimatedCost, estimatedSavings, paybackPeriod }
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/consultancy/
+├── assessments/*      - Client assessments
+├── recommendations/*  - Prioritized recommendations
+├── roi-analysis/*     - ROI calculations
+└── progress/*         - Implementation tracking
+```
+
+### Fleet Coordination
+```typescript
+const consultingFleet = await FleetManager.coordinate({
+  strategy: 'client-engagement',
+  agents: [
+    'qe-quality-analyzer',          // Assess current state
+    'qe-regression-risk-analyzer',  // Risk assessment
+    'qe-quality-gate',              // Define quality gates
+    'qe-deployment-readiness'       // Deployment maturity
+  ],
+  topology: 'hierarchical'
+});
+```
+
+---
+
+## Related Skills
+- [quality-metrics](../quality-metrics/) - Metrics for client reporting
+- [risk-based-testing](../risk-based-testing/) - Client risk assessment
+- [holistic-testing-pact](../holistic-testing-pact/) - Comprehensive strategy
+
+---
+
+## Remember
+
+**Good consulting is about empowering teams, not creating dependency.** Your success is measured by them not needing you anymore - while still wanting to work with you again.
+
+**Best compliment:** "We've got this now, but when we tackle X next year, we're calling you."
+
+Be honest. Be helpful. Be context-driven. Leave them better.

package/assets/skills/context-driven-testing/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: context-driven-testing
+description: "Apply context-driven testing principles where practices are chosen based on project context, not universal 'best practices'. Use when making testing decisions, questioning dogma, or adapting approaches to specific project needs."
+category: testing-methodologies
+priority: high
+tokenEstimate: 1100
+agents: [qe-fleet-commander, qe-regression-risk-analyzer, qe-requirements-validator, qe-quality-analyzer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [context-driven, rst, exploratory, heuristics, oracles, skilled-testing]
+---
+
+# Context-Driven Testing
+
+<default_to_action>
+When making testing decisions or adapting approaches:
+1. ANALYZE context: project goals, constraints, risks, team skills
+2. QUESTION practices: "Why this? What risk does it address? What's the cost?"
+3. INVESTIGATE not just check: Does software solve the problem, or create new ones?
+4. ADAPT approach based on context, not "best practices"
+5. DOCUMENT discoveries, not pre-written plans
+
+**Quick Context Analysis:**
+- Mission: "Find important problems fast enough to matter" (not "execute test cases")
+- Risk: Safety-critical = high rigor; internal tool = lighter touch
+- Constraints: Startup with tight timeline ≠ enterprise with compliance
+- Skills: Novice needs structure; expert adapts intuitively
+
+**Critical Success Factors:**
+- No "best practices" work everywhere - only good practices in context
+- Testing is investigation, not script execution
+- Context changes; your approach should too
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Making testing decisions for new project
+- Questioning "that's how it's done" dogma
+- Adapting approach to specific constraints
+- Exploratory testing sessions
+
+### Seven Context-Driven Principles
+1. Value of any practice depends on its context
+2. Good practices in context, no universal best practices
+3. People working together are most important
+4. Projects unfold in unpredictable ways
+5. Product is a solution - if problem not solved, product fails
+6. Good testing is challenging intellectual work
+7. Judgment and skill determine right things at right times
+
+### Context Factors
+| Factor | Questions |
+|--------|-----------|
+| **Project** | Business goal? User needs? Failure impact? |
+| **Constraints** | Timeline? Budget? Team skills? Legacy? |
+| **Risk** | Safety-critical? Regulated? High volume? |
+| **Technical** | Stack quirks? Integrations? Observability? |
+
+### RST Heuristics
+| Heuristic | Application |
+|-----------|-------------|
+| **SFDIPOT** | Structure, Function, Data, Interfaces, Platform, Operations, Time |
+| **Oracles** | Consistency with history, similar products, expectations, docs |
+| **Tours** | Business District, Historical, Bad Neighborhood, Tourist, Museum |
+
+---
+
+## Context-Driven Decisions
+
+### Example: Test Automation Level
+
+**Startup Context:**
+- Small team, rapid changes, unclear product-market fit
+- **Decision:** Light automation on critical paths, heavy exploratory
+- **Rationale:** Requirements change too fast for extensive automation
+
+**Enterprise Context:**
+- Stable features, regulatory requirements, large team
+- **Decision:** Comprehensive automated regression suite
+- **Rationale:** Stability allows automation investment to pay off
+
+### Example: Documentation
+
+**Regulated (FDA/medical):**
+- **Decision:** Detailed test protocols, traceability matrices
+- **Rationale:** Regulatory compliance isn't optional
+
+**Fast-paced startup:**
+- **Decision:** Lightweight session notes, risk logs
+- **Rationale:** Bureaucracy slows more than it helps
+
+---
+
+## Investigation vs. Checking
+
+| Checking | Testing (Investigation) |
+|----------|------------------------|
+| Did API return 200? | Does API meet user needs? |
+| Does button work? | What happens under load? |
+| Match the spec? | Does it solve the problem? |
+
+---
+
+## Red Flags: Not Context-Driven
+
+- Follow process "because that's how it's done"
+- Can't explain *why* you're doing something
+- Measure test cases executed, not problems found
+- Test plan could apply to any project
+- Stop thinking once you have a script
+
+---
+
+## Agent-Assisted Context-Driven Testing
+
+```typescript
+// Agent analyzes context and recommends approach
+const context = await Task("Analyze Context", {
+  project: 'e-commerce-platform',
+  stage: 'startup',
+  constraints: ['timeline: tight', 'budget: limited'],
+  risks: ['payment-security', 'high-volume']
+}, "qe-fleet-commander");
+
+// Context-aware agent selection
+// - qe-security-scanner (critical risk)
+// - qe-performance-tester (high volume)
+// - Skip: qe-visual-tester (low priority in startup context)
+
+// Adaptive testing strategy
+await Task("Generate Tests", {
+  context: 'startup',
+  focus: 'critical-paths-only',
+  depth: 'smoke-tests',
+  automation: 'minimal'
+}, "qe-test-generator");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/context-driven/
+├── context-analysis/*    - Project context snapshots
+├── decisions/*           - Testing decisions with rationale
+├── discoveries/*         - What was learned during testing
+└── adaptations/*         - How approach changed over time
+```
+
+### Fleet Coordination
+```typescript
+const contextFleet = await FleetManager.coordinate({
+  strategy: 'context-driven',
+  context: {
+    type: 'greenfield-saas',
+    stage: 'growth',
+    compliance: 'gdpr-only'
+  },
+  agents: ['qe-test-generator', 'qe-security-scanner', 'qe-performance-tester'],
+  exclude: ['qe-visual-tester', 'qe-requirements-validator']  // Not priority
+});
+```
+
+---
+
+## Practical Tips
+
+1. **Start with risk assessment** - List features, ask: How likely to fail? How bad? How hard to test?
+2. **Time-box exploration** - 2 hours checkout, 30 min error handling, 15 min per browser
+3. **Document discoveries** - Not "Enter invalid email, verify error" but "Payment API returns 500 instead of 400, no user-visible error. Bug filed."
+4. **Talk to humans** - Developers, users, support, product
+5. **Pair with others** - Different perspectives = different bugs
+
+---
+
+## Related Skills
+- [agentic-quality-engineering](../agentic-quality-engineering/) - Context-aware agent selection
+- [holistic-testing-pact](../holistic-testing-pact/) - Adapt holistic model to context
+- [risk-based-testing](../risk-based-testing/) - Context affects risk assessment
+- [exploratory-testing-advanced](../exploratory-testing-advanced/) - RST techniques
+
+---
+
+## Remember
+
+**Context drives decisions.** No universal best practices. Skilled testers make informed decisions based on specific goals, constraints, and risks.
+
+You're not a test script executor. You're a skilled investigator helping teams build better products.
+
+**With Agents:** Agents analyze context, adapt strategies, and learn what works in your situation. Use agents to scale context-driven thinking while maintaining human judgment for critical decisions.

package/assets/skills/contract-testing/SKILL.md

@@ -0,0 +1,222 @@
+---
+name: contract-testing
+description: "Consumer-driven contract testing for microservices using Pact, schema validation, API versioning, and backward compatibility testing. Use when testing API contracts or coordinating distributed teams."
+category: testing-methodologies
+priority: high
+tokenEstimate: 900
+agents: [qe-api-contract-validator, qe-test-generator, qe-security-scanner]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [contract, pact, consumer-driven, api, microservices, schema-validation]
+---
+
+# Contract Testing
+
+<default_to_action>
+When testing API contracts or microservices:
+1. DEFINE consumer expectations (what consumers actually need)
+2. VERIFY provider fulfills contracts (Pact verification)
+3. DETECT breaking changes before deployment (CI/CD integration)
+4. VERSION APIs semantically (breaking = major bump)
+5. MAINTAIN backward compatibility for supported versions
+
+**Quick Contract Testing Steps:**
+- Consumer: Define expected request/response pairs
+- Provider: Verify against all consumer contracts
+- CI/CD: Block deploys that break contracts
+- Versioning: Document supported versions and deprecation
+
+**Critical Success Factors:**
+- Consumers own the contract (they define what they need)
+- Provider must pass all consumer contracts before deploy
+- Breaking changes require coordination, not surprise
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Microservices communication
+- Third-party API integrations
+- Distributed team coordination
+- Preventing breaking changes
+
+### Consumer-Driven Contract Flow
+```
+Consumer → Defines Expectations → Contract
+                    ↓
+Provider → Verifies Contract → Pass/Fail
+                    ↓
+CI/CD → Blocks Breaking Changes
+```
+
+### Breaking vs Non-Breaking Changes
+| Change Type | Breaking? | Semver |
+|-------------|-----------|--------|
+| Remove field | ✅ Yes | Major |
+| Rename field | ✅ Yes | Major |
+| Change type | ✅ Yes | Major |
+| Add optional field | ❌ No | Minor |
+| Add new endpoint | ❌ No | Minor |
+| Bug fix | ❌ No | Patch |
+
+### Tools
+| Tool | Best For |
+|------|----------|
+| **Pact** | Consumer-driven contracts |
+| **OpenAPI/Swagger** | API-first design |
+| **JSON Schema** | Schema validation |
+| **GraphQL** | Schema-first contracts |
+
+---
+
+## Consumer Contract (Pact)
+
+```javascript
+// Consumer defines what it needs
+const { Pact } = require('@pact-foundation/pact');
+
+describe('Order API Consumer', () => {
+  const provider = new Pact({
+    consumer: 'CheckoutUI',
+    provider: 'OrderService'
+  });
+
+  beforeAll(() => provider.setup());
+  afterAll(() => provider.finalize());
+
+  it('creates an order', async () => {
+    await provider.addInteraction({
+      state: 'products exist',
+      uponReceiving: 'a create order request',
+      withRequest: {
+        method: 'POST',
+        path: '/orders',
+        body: { productId: 'abc', quantity: 2 }
+      },
+      willRespondWith: {
+        status: 201,
+        body: {
+          orderId: like('order-123'),  // Any string matching pattern
+          total: like(19.99)           // Any number
+        }
+      }
+    });
+
+    const response = await orderClient.create({ productId: 'abc', quantity: 2 });
+    expect(response.orderId).toBeDefined();
+  });
+});
+```
+
+---
+
+## Provider Verification
+
+```javascript
+// Provider verifies it fulfills all consumer contracts
+const { Verifier } = require('@pact-foundation/pact');
+
+describe('Order Service Provider', () => {
+  it('fulfills all consumer contracts', async () => {
+    await new Verifier({
+      provider: 'OrderService',
+      providerBaseUrl: 'http://localhost:3000',
+      pactUrls: ['./pacts/checkoutui-orderservice.json'],
+      stateHandlers: {
+        'products exist': async () => {
+          await db.products.create({ id: 'abc', price: 9.99 });
+        }
+      }
+    }).verifyProvider();
+  });
+});
+```
+
+---
+
+## Breaking Change Detection
+
+```typescript
+// Agent detects breaking changes
+await Task("Contract Validation", {
+  currentContract: 'openapi-v2.yaml',
+  previousContract: 'openapi-v1.yaml',
+  detectBreaking: true,
+  calculateSemver: true,
+  generateMigrationGuide: true
+}, "qe-api-contract-validator");
+
+// Output:
+// Breaking changes found: 2
+// - Removed field: order.discount
+// - Type change: order.total (number → string)
+// Recommended version: 3.0.0 (major bump)
+```
+
+---
+
+## CI/CD Integration
+
+```yaml
+name: Contract Tests
+on: [push]
+
+jobs:
+  consumer-tests:
+    steps:
+      - run: npm run test:contract
+      - name: Publish Pacts
+        run: npx pact-broker publish ./pacts --broker-base-url $PACT_BROKER
+
+  provider-verification:
+    needs: consumer-tests
+    steps:
+      - name: Verify Provider
+        run: npm run verify:contracts
+      - name: Can I Deploy?
+        run: npx pact-broker can-i-deploy --pacticipant OrderService --version $VERSION
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/contract-testing/
+├── contracts/*           - Current contracts
+├── breaking-changes/*    - Detected breaking changes
+├── versioning/*          - Version compatibility matrix
+└── verification-results/* - Provider verification history
+```
+
+### Fleet Coordination
+```typescript
+const contractFleet = await FleetManager.coordinate({
+  strategy: 'contract-testing',
+  agents: [
+    'qe-api-contract-validator',  // Validation, breaking detection
+    'qe-test-generator',          // Generate contract tests
+    'qe-security-scanner'         // API security
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [api-testing-patterns](../api-testing-patterns/) - API testing strategies
+- [shift-left-testing](../shift-left-testing/) - Early contract validation
+- [cicd-pipeline-qe-orchestrator](../cicd-pipeline-qe-orchestrator/) - Pipeline integration
+
+---
+
+## Remember
+
+**Consumers own the contract.** They define what they need; providers must fulfill it. Breaking changes require major version bumps and coordination. CI/CD blocks deploys that break contracts. Use Pact for consumer-driven, OpenAPI for API-first.
+
+**With Agents:** Agents validate contracts, detect breaking changes with semver recommendations, and generate migration guides. Use agents to maintain contract compliance at scale.