agentic-qe 3.6.3 → 3.6.4

package/v3/dist/learning/qe-reasoning-bank.js

@@ -152,6 +152,13 @@ export class QEReasoningBank {
         // Load any pre-trained patterns
         await this.loadPretrainedPatterns();
         this.initialized = true;
+        // Run cross-domain transfer after initialization to enrich related domains
+        try {
+            await this.seedCrossDomainPatterns();
+        }
+        catch (error) {
+            console.warn('[QEReasoningBank] Cross-domain seeding failed (non-fatal):', error);
+        }
         console.log('[QEReasoningBank] Initialized');
     }
     /**
@@ -279,6 +286,602 @@ Check for:
                     tags: ['flaky', 'timing', 'async', 'stability'],
                 },
             },
+            // ================================================================
+            // quality-assessment domain seeds
+            // ================================================================
+            {
+                patternType: 'assertion-pattern',
+                qeDomain: 'quality-assessment',
+                name: 'Quality Gate Checklist',
+                description: 'Evaluate deployment readiness against quality gate criteria',
+                template: {
+                    type: 'prompt',
+                    content: `Quality gate evaluation for {{targetModule}}:
+
+1. Test coverage >= {{coverageThreshold}}%
+2. No critical/high severity bugs open
+3. All P1 tests passing
+4. Performance benchmarks within SLA (p95 < {{latencyThresholdMs}}ms)
+5. Security scan clean (no critical CVEs)
+6. Code review approved
+
+Fail the gate if ANY criterion is unmet. Report which criteria passed/failed.`,
+                    variables: [
+                        { name: 'targetModule', type: 'string', required: true, description: 'Module or service to evaluate' },
+                        { name: 'coverageThreshold', type: 'number', required: false, defaultValue: 80, description: 'Minimum coverage %' },
+                        { name: 'latencyThresholdMs', type: 'number', required: false, defaultValue: 500, description: 'P95 latency limit in ms' },
+                    ],
+                },
+                context: {
+                    tags: ['quality-gate', 'deployment', 'readiness', 'sla'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'assertion-pattern',
+                qeDomain: 'quality-assessment',
+                name: 'Metric Threshold Validator',
+                description: 'Validate quality metrics against configurable thresholds',
+                template: {
+                    type: 'code',
+                    content: `function validateMetrics(metrics: Record<string, number>, thresholds: Record<string, { min?: number; max?: number }>) {
+  const violations: string[] = [];
+  for (const [metric, value] of Object.entries(metrics)) {
+    const threshold = thresholds[metric];
+    if (!threshold) continue;
+    if (threshold.min !== undefined && value < threshold.min) {
+      violations.push(\`\${metric}: \${value} < min \${threshold.min}\`);
+    }
+    if (threshold.max !== undefined && value > threshold.max) {
+      violations.push(\`\${metric}: \${value} > max \${threshold.max}\`);
+    }
+  }
+  return { pass: violations.length === 0, violations };
+}`,
+                    variables: [],
+                },
+                context: {
+                    tags: ['metrics', 'threshold', 'validation', 'scoring'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // defect-intelligence domain seeds
+            // ================================================================
+            {
+                patternType: 'error-handling',
+                qeDomain: 'defect-intelligence',
+                name: 'Root Cause Analysis Workflow',
+                description: 'Systematic root cause analysis for test failures and production incidents',
+                template: {
+                    type: 'prompt',
+                    content: `Root cause analysis for: {{incidentDescription}}
+
+1. **Reproduce**: Confirm the failure is deterministic
+2. **Isolate**: Narrow down to the smallest failing component
+3. **Timeline**: When did it last pass? What changed since?
+4. **Categorize**: Is it a code bug, config issue, data issue, or environment?
+5. **Five Whys**: Ask why at least 5 times to reach the root cause
+6. **Fix**: Propose fix with test to prevent regression
+7. **Verify**: Run the fix and confirm the original failure is resolved`,
+                    variables: [
+                        { name: 'incidentDescription', type: 'string', required: true, description: 'Description of the failure or incident' },
+                    ],
+                },
+                context: {
+                    tags: ['root-cause', 'rca', 'debugging', 'incident'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'error-handling',
+                qeDomain: 'defect-intelligence',
+                name: 'Regression Risk Scorer',
+                description: 'Score change risk for regression based on code complexity and history',
+                template: {
+                    type: 'prompt',
+                    content: `Regression risk assessment for {{changePath}}:
+
+Risk factors (score each 0-3):
+- Lines changed: {{linesChanged}} → complexity risk
+- Files affected: {{filesAffected}} → blast radius
+- Previous bugs in area: historical defect density
+- Test coverage of changed code: gap risk
+- Dependency depth: cascade risk
+
+Total risk = sum / 15 → Low (<0.3), Medium (0.3-0.6), High (>0.6)`,
+                    variables: [
+                        { name: 'changePath', type: 'string', required: true, description: 'File or module changed' },
+                        { name: 'linesChanged', type: 'number', required: true, description: 'Number of lines changed' },
+                        { name: 'filesAffected', type: 'number', required: true, description: 'Number of files affected' },
+                    ],
+                },
+                context: {
+                    tags: ['regression', 'risk', 'prediction', 'change-analysis'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // requirements-validation domain seeds
+            // ================================================================
+            {
+                patternType: 'test-template',
+                qeDomain: 'requirements-validation',
+                name: 'Gherkin BDD Scenario',
+                description: 'Behavior-driven development scenario in Given/When/Then format',
+                template: {
+                    type: 'code',
+                    content: `Feature: {{featureName}}
+
+  Scenario: {{scenarioDescription}}
+    Given {{precondition}}
+    When {{action}}
+    Then {{expectedOutcome}}
+
+  Scenario: {{scenarioDescription}} - error case
+    Given {{precondition}}
+    When {{errorAction}}
+    Then {{errorOutcome}}`,
+                    variables: [
+                        { name: 'featureName', type: 'string', required: true, description: 'Feature under test' },
+                        { name: 'scenarioDescription', type: 'string', required: true, description: 'What the scenario validates' },
+                        { name: 'precondition', type: 'string', required: true, description: 'Given precondition' },
+                        { name: 'action', type: 'string', required: true, description: 'When action' },
+                        { name: 'expectedOutcome', type: 'string', required: true, description: 'Then expected result' },
+                        { name: 'errorAction', type: 'string', required: true, description: 'When error action' },
+                        { name: 'errorOutcome', type: 'string', required: true, description: 'Then error result' },
+                    ],
+                },
+                context: {
+                    tags: ['bdd', 'gherkin', 'requirements', 'acceptance'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'test-template',
+                qeDomain: 'requirements-validation',
+                name: 'Acceptance Criteria Testability Check',
+                description: 'Evaluate whether acceptance criteria are testable and complete',
+                template: {
+                    type: 'prompt',
+                    content: `Testability assessment for: {{requirementId}} - {{requirementTitle}}
+
+Acceptance criteria:
+{{acceptanceCriteria}}
+
+Evaluate each criterion:
+1. **Observable**: Can we verify the outcome without internal knowledge?
+2. **Measurable**: Is there a quantifiable threshold or clear pass/fail?
+3. **Atomic**: Does each criterion test exactly one thing?
+4. **Achievable**: Can this be tested with available tools?
+5. **Complete**: Are edge cases and error paths covered?
+
+Flag any untestable or ambiguous criteria with suggested rewrites.`,
+                    variables: [
+                        { name: 'requirementId', type: 'string', required: true, description: 'Requirement identifier' },
+                        { name: 'requirementTitle', type: 'string', required: true, description: 'Requirement title' },
+                        { name: 'acceptanceCriteria', type: 'string', required: true, description: 'The acceptance criteria text' },
+                    ],
+                },
+                context: {
+                    tags: ['requirements', 'testability', 'acceptance-criteria', 'validation'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // code-intelligence domain seeds
+            // ================================================================
+            {
+                patternType: 'refactor-safe',
+                name: 'Safe Refactoring Checklist',
+                description: 'Ensure refactoring preserves behavior with systematic safety checks',
+                template: {
+                    type: 'prompt',
+                    content: `Safe refactoring checklist for {{targetPath}}:
+
+Before refactoring:
+1. Run existing tests — capture baseline results
+2. Check coverage of code being refactored
+3. Identify all callers and dependents via references
+
+During refactoring:
+4. Make one semantic change at a time
+5. Keep public API signatures stable (or update all callers)
+6. Preserve error handling contracts
+
+After refactoring:
+7. Run full test suite — compare to baseline
+8. Check for any new uncovered paths
+9. Verify no unused imports or dead code introduced`,
+                    variables: [
+                        { name: 'targetPath', type: 'string', required: true, description: 'Path to refactor' },
+                    ],
+                },
+                context: {
+                    tags: ['refactor', 'safety', 'code-change', 'impact'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'refactor-safe',
+                name: 'Dependency Impact Analysis',
+                description: 'Analyze the blast radius of a code change through the dependency graph',
+                template: {
+                    type: 'prompt',
+                    content: `Impact analysis for changes in {{changedFile}}:
+
+1. Direct dependents: files that import/require {{changedFile}}
+2. Transitive dependents: files that depend on direct dependents
+3. Test coverage: which tests exercise the changed code?
+4. Integration points: does this affect API contracts or events?
+5. Risk tier: Critical (auth/payments) > High (business logic) > Medium (utils)
+
+Output: sorted list of affected files with risk scores.`,
+                    variables: [
+                        { name: 'changedFile', type: 'string', required: true, description: 'File being changed' },
+                    ],
+                },
+                context: {
+                    tags: ['impact', 'dependency', 'blast-radius', 'analysis'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // security-compliance domain seeds
+            // ================================================================
+            {
+                patternType: 'assertion-pattern',
+                qeDomain: 'security-compliance',
+                name: 'OWASP Top 10 Security Audit',
+                description: 'Check code against OWASP Top 10 vulnerability categories',
+                template: {
+                    type: 'prompt',
+                    content: `Security audit for {{targetPath}} against OWASP Top 10:
+
+1. **A01 Broken Access Control**: Check authorization on every endpoint
+2. **A02 Cryptographic Failures**: No plaintext secrets, proper hashing
+3. **A03 Injection**: Parameterized queries, input sanitization
+4. **A04 Insecure Design**: Threat modeling, least privilege
+5. **A05 Security Misconfiguration**: Default creds, verbose errors
+6. **A06 Vulnerable Components**: Check dependencies for CVEs
+7. **A07 Auth Failures**: Brute force protection, session management
+8. **A08 Data Integrity Failures**: Verify signatures, safe deserialization
+9. **A09 Logging Failures**: Audit trail, no sensitive data in logs
+10. **A10 SSRF**: Validate/allowlist outbound URLs
+
+Flag findings as Critical/High/Medium/Low with remediation guidance.`,
+                    variables: [
+                        { name: 'targetPath', type: 'string', required: true, description: 'Code path to audit' },
+                    ],
+                },
+                context: {
+                    tags: ['owasp', 'security', 'audit', 'vulnerability'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'assertion-pattern',
+                qeDomain: 'security-compliance',
+                name: 'Input Sanitization Pattern',
+                description: 'Validate and sanitize inputs at system boundaries to prevent injection',
+                template: {
+                    type: 'code',
+                    content: `// Input validation at system boundary
+function validateInput(input: unknown, schema: {
+  type: 'string' | 'number' | 'boolean';
+  maxLength?: number;
+  pattern?: RegExp;
+  allowedValues?: unknown[];
+}): { valid: boolean; sanitized: unknown; errors: string[] } {
+  const errors: string[] = [];
+  if (typeof input !== schema.type) {
+    errors.push(\`Expected \${schema.type}, got \${typeof input}\`);
+    return { valid: false, sanitized: null, errors };
+  }
+  if (schema.type === 'string') {
+    let str = input as string;
+    if (schema.maxLength && str.length > schema.maxLength) {
+      str = str.slice(0, schema.maxLength);
+      errors.push('Input truncated to max length');
+    }
+    if (schema.pattern && !schema.pattern.test(str)) {
+      errors.push('Input does not match expected pattern');
+      return { valid: false, sanitized: null, errors };
+    }
+    return { valid: errors.length === 0, sanitized: str, errors };
+  }
+  return { valid: true, sanitized: input, errors };
+}`,
+                    variables: [],
+                },
+                context: {
+                    tags: ['security', 'validation', 'sanitization', 'injection-prevention'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // contract-testing domain seeds
+            // ================================================================
+            {
+                patternType: 'api-contract',
+                name: 'OpenAPI Contract Validator',
+                description: 'Validate API responses against OpenAPI/Swagger schema',
+                template: {
+                    type: 'code',
+                    content: `describe('{{apiEndpoint}} contract', () => {
+  it('should match the OpenAPI schema for {{operationId}}', async () => {
+    const response = await request(app).{{httpMethod}}('{{apiEndpoint}}');
+    expect(response.status).toBe({{expectedStatus}});
+    expect(response.body).toMatchSchema(openApiSpec.paths['{{apiEndpoint}}'].{{httpMethod}}.responses['{{expectedStatus}}'].content['application/json'].schema);
+  });
+
+  it('should return proper error for invalid input', async () => {
+    const response = await request(app).{{httpMethod}}('{{apiEndpoint}}').send({{invalidPayload}});
+    expect(response.status).toBe(400);
+    expect(response.body).toHaveProperty('errors');
+  });
+});`,
+                    variables: [
+                        { name: 'apiEndpoint', type: 'string', required: true, description: 'API endpoint path' },
+                        { name: 'operationId', type: 'string', required: true, description: 'OpenAPI operation ID' },
+                        { name: 'httpMethod', type: 'string', required: true, description: 'HTTP method (get/post/put/delete)' },
+                        { name: 'expectedStatus', type: 'number', required: true, description: 'Expected HTTP status code' },
+                        { name: 'invalidPayload', type: 'object', required: true, description: 'Invalid request body for error case' },
+                    ],
+                },
+                context: {
+                    tags: ['api', 'contract', 'openapi', 'schema-validation'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'api-contract',
+                name: 'Consumer-Driven Contract Test',
+                description: 'Pact-style consumer-driven contract testing between services',
+                template: {
+                    type: 'code',
+                    content: `// Consumer side contract
+const pact = new Pact({
+  consumer: '{{consumerName}}',
+  provider: '{{providerName}}',
+});
+
+describe('{{consumerName}} -> {{providerName}} contract', () => {
+  beforeAll(() => pact.setup());
+  afterAll(() => pact.finalize());
+
+  it('should receive {{expectedResource}}', async () => {
+    await pact.addInteraction({
+      state: '{{providerState}}',
+      uponReceiving: '{{interactionDescription}}',
+      withRequest: { method: '{{httpMethod}}', path: '{{requestPath}}' },
+      willRespondWith: {
+        status: 200,
+        body: like({{expectedShape}}),
+      },
+    });
+
+    const result = await client.{{clientMethod}}();
+    expect(result).toBeDefined();
+  });
+});`,
+                    variables: [
+                        { name: 'consumerName', type: 'string', required: true, description: 'Consumer service name' },
+                        { name: 'providerName', type: 'string', required: true, description: 'Provider service name' },
+                        { name: 'expectedResource', type: 'string', required: true, description: 'Resource being consumed' },
+                        { name: 'providerState', type: 'string', required: true, description: 'Provider state precondition' },
+                        { name: 'interactionDescription', type: 'string', required: true, description: 'Interaction description' },
+                        { name: 'httpMethod', type: 'string', required: true, description: 'HTTP method' },
+                        { name: 'requestPath', type: 'string', required: true, description: 'Request path' },
+                        { name: 'expectedShape', type: 'object', required: true, description: 'Expected response shape' },
+                        { name: 'clientMethod', type: 'string', required: true, description: 'Client method to call' },
+                    ],
+                },
+                context: {
+                    tags: ['contract', 'pact', 'consumer-driven', 'microservice'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // visual-accessibility domain seeds
+            // ================================================================
+            {
+                patternType: 'a11y-check',
+                name: 'WCAG Contrast and ARIA Check',
+                description: 'Validate WCAG 2.2 color contrast ratios and ARIA attribute correctness',
+                template: {
+                    type: 'prompt',
+                    content: `Accessibility audit for {{componentName}}:
+
+WCAG 2.2 AA Compliance:
+1. **Color Contrast**: Text contrast ratio >= 4.5:1 (normal), >= 3:1 (large)
+2. **ARIA Roles**: All interactive elements have correct role attributes
+3. **ARIA Labels**: Forms and buttons have aria-label or aria-labelledby
+4. **Focus Management**: Tab order is logical, focus visible on all interactive elements
+5. **Screen Reader**: Content is meaningful when linearized
+6. **Keyboard**: All functionality accessible via keyboard alone
+
+Test with: axe-core, pa11y, or lighthouse --accessibility`,
+                    variables: [
+                        { name: 'componentName', type: 'string', required: true, description: 'UI component to audit' },
+                    ],
+                },
+                context: {
+                    tags: ['wcag', 'accessibility', 'aria', 'contrast', 'a11y'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'visual-baseline',
+                name: 'Visual Regression Baseline',
+                description: 'Capture and compare screenshots for visual regression detection',
+                template: {
+                    type: 'code',
+                    content: `describe('{{pageName}} visual regression', () => {
+  it('should match baseline screenshot', async () => {
+    await page.goto('{{pageUrl}}');
+    await page.waitForLoadState('networkidle');
+
+    const screenshot = await page.screenshot({ fullPage: {{fullPage}} });
+    expect(screenshot).toMatchSnapshot('{{pageName}}-baseline.png', {
+      maxDiffPixelRatio: {{maxDiffRatio}},
+    });
+  });
+
+  it('should match baseline at mobile viewport', async () => {
+    await page.setViewportSize({ width: 375, height: 812 });
+    await page.goto('{{pageUrl}}');
+    const screenshot = await page.screenshot({ fullPage: {{fullPage}} });
+    expect(screenshot).toMatchSnapshot('{{pageName}}-mobile-baseline.png', {
+      maxDiffPixelRatio: {{maxDiffRatio}},
+    });
+  });
+});`,
+                    variables: [
+                        { name: 'pageName', type: 'string', required: true, description: 'Page name for snapshot naming' },
+                        { name: 'pageUrl', type: 'string', required: true, description: 'Page URL to capture' },
+                        { name: 'fullPage', type: 'boolean', required: false, defaultValue: true, description: 'Capture full page' },
+                        { name: 'maxDiffRatio', type: 'number', required: false, defaultValue: 0.01, description: 'Max pixel diff ratio' },
+                    ],
+                },
+                context: {
+                    tags: ['visual', 'screenshot', 'regression', 'baseline', 'playwright'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // chaos-resilience domain seeds
+            // ================================================================
+            {
+                patternType: 'perf-benchmark',
+                name: 'Load Test Scenario',
+                description: 'k6-style load test with ramp-up stages and SLA assertions',
+                template: {
+                    type: 'code',
+                    content: `import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export const options = {
+  stages: [
+    { duration: '{{rampUpDuration}}', target: {{peakUsers}} },
+    { duration: '{{steadyDuration}}', target: {{peakUsers}} },
+    { duration: '{{rampDownDuration}}', target: 0 },
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<{{p95ThresholdMs}}'],
+    http_req_failed: ['rate<{{errorRateThreshold}}'],
+  },
+};
+
+export default function () {
+  const res = http.get('{{targetUrl}}');
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+    'response time < {{p95ThresholdMs}}ms': (r) => r.timings.duration < {{p95ThresholdMs}},
+  });
+  sleep(1);
+}`,
+                    variables: [
+                        { name: 'targetUrl', type: 'string', required: true, description: 'Target URL to load test' },
+                        { name: 'peakUsers', type: 'number', required: true, description: 'Peak concurrent users' },
+                        { name: 'rampUpDuration', type: 'string', required: false, defaultValue: '2m', description: 'Ramp-up duration' },
+                        { name: 'steadyDuration', type: 'string', required: false, defaultValue: '5m', description: 'Steady state duration' },
+                        { name: 'rampDownDuration', type: 'string', required: false, defaultValue: '1m', description: 'Ramp-down duration' },
+                        { name: 'p95ThresholdMs', type: 'number', required: false, defaultValue: 500, description: 'P95 latency threshold in ms' },
+                        { name: 'errorRateThreshold', type: 'number', required: false, defaultValue: 0.01, description: 'Max error rate (0-1)' },
+                    ],
+                },
+                context: {
+                    tags: ['load-test', 'k6', 'performance', 'sla'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'perf-benchmark',
+                name: 'Circuit Breaker Resilience Test',
+                description: 'Test circuit breaker behavior under fault injection',
+                template: {
+                    type: 'prompt',
+                    content: `Resilience test for {{serviceName}} circuit breaker:
+
+1. **Closed state**: Verify normal requests pass through
+2. **Fault injection**: Inject {{faultType}} faults at {{faultRate}}% rate
+3. **Trip threshold**: Verify breaker opens after {{failureThreshold}} consecutive failures
+4. **Open state**: Verify requests fail fast (no upstream calls)
+5. **Half-open probe**: After {{cooldownMs}}ms, verify single probe request
+6. **Recovery**: On probe success, verify breaker closes and traffic resumes
+7. **Metrics**: Verify circuit state changes are logged and observable`,
+                    variables: [
+                        { name: 'serviceName', type: 'string', required: true, description: 'Service with circuit breaker' },
+                        { name: 'faultType', type: 'string', required: false, defaultValue: 'latency', description: 'Type of fault (latency/error/timeout)' },
+                        { name: 'faultRate', type: 'number', required: false, defaultValue: 50, description: 'Fault injection rate %' },
+                        { name: 'failureThreshold', type: 'number', required: false, defaultValue: 5, description: 'Failures to trip breaker' },
+                        { name: 'cooldownMs', type: 'number', required: false, defaultValue: 30000, description: 'Cooldown before half-open' },
+                    ],
+                },
+                context: {
+                    tags: ['chaos', 'circuit-breaker', 'resilience', 'fault-injection'],
+                },
+                confidence: 0.6,
+            },
+            // ================================================================
+            // learning-optimization domain seeds
+            // ================================================================
+            {
+                patternType: 'coverage-strategy',
+                qeDomain: 'learning-optimization',
+                name: 'Cross-Domain Pattern Transfer',
+                description: 'Strategy for transferring useful patterns from one QE domain to related domains',
+                template: {
+                    type: 'prompt',
+                    content: `Pattern transfer from {{sourceDomain}} to {{targetDomain}}:
+
+1. Identify generalizable patterns in source domain (success rate > 70%)
+2. Check domain compatibility (related domains get 80% relevance, unrelated 50%)
+3. Adapt pattern context: replace domain-specific terms with target equivalents
+4. Set transferred pattern confidence to source * compatibility factor
+5. Store in target domain with provenance metadata
+6. Track transfer outcomes to learn which transfers are valuable`,
+                    variables: [
+                        { name: 'sourceDomain', type: 'string', required: true, description: 'Source QE domain' },
+                        { name: 'targetDomain', type: 'string', required: true, description: 'Target QE domain' },
+                    ],
+                },
+                context: {
+                    tags: ['transfer', 'cross-domain', 'learning', 'pattern-reuse'],
+                },
+                confidence: 0.6,
+            },
+            {
+                patternType: 'coverage-strategy',
+                qeDomain: 'learning-optimization',
+                name: 'Pattern Quality Promotion Pipeline',
+                description: 'Pipeline for promoting short-term patterns to long-term based on success evidence',
+                template: {
+                    type: 'prompt',
+                    content: `Pattern promotion evaluation for {{patternName}}:
+
+Criteria (all must pass):
+1. Usage count >= 3 successful applications
+2. Success rate >= 70%
+3. Confidence score >= 0.6
+4. Coherence check: no contradiction with existing long-term patterns
+5. Age: pattern has existed for at least 24 hours (not rushed)
+
+On promotion:
+- Move from short-term to long-term tier
+- Boost confidence by 10%
+- Enable for cross-domain transfer to related domains
+- Mark as reusable for token savings optimization`,
+                    variables: [
+                        { name: 'patternName', type: 'string', required: true, description: 'Pattern to evaluate for promotion' },
+                    ],
+                },
+                context: {
+                    tags: ['promotion', 'learning', 'quality', 'pipeline'],
+                },
+                confidence: 0.6,
+            },
         ];
         for (const options of foundationalPatterns) {
             try {
@@ -290,6 +893,100 @@ Check for:
         }
         console.log(`[QEReasoningBank] Loaded ${foundationalPatterns.length} foundational patterns`);
     }
+    /**
+     * Seed cross-domain patterns by transferring generalizable patterns
+     * from populated domains to their related domains.
+     *
+     * Uses the domain compatibility matrix to determine which domains
+     * are related and applies a relevance decay to transferred patterns.
+     */
+    async seedCrossDomainPatterns() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        const stats = await this.patternStore.getStats();
+        let transferred = 0;
+        let skipped = 0;
+        // Domain compatibility matrix (same as TransferSpecialistService)
+        const relatedDomains = {
+            'test-generation': ['test-execution', 'coverage-analysis', 'requirements-validation'],
+            'test-execution': ['test-generation', 'coverage-analysis', 'quality-assessment'],
+            'coverage-analysis': ['test-generation', 'test-execution', 'quality-assessment'],
+            'quality-assessment': ['test-execution', 'coverage-analysis', 'defect-intelligence'],
+            'defect-intelligence': ['quality-assessment', 'code-intelligence'],
+            'requirements-validation': ['test-generation', 'quality-assessment'],
+            'code-intelligence': ['defect-intelligence', 'security-compliance'],
+            'security-compliance': ['code-intelligence', 'quality-assessment'],
+            'contract-testing': ['test-generation', 'test-execution'],
+            'visual-accessibility': ['quality-assessment'],
+            'chaos-resilience': ['test-execution', 'quality-assessment'],
+            'learning-optimization': ['test-generation', 'test-execution', 'coverage-analysis', 'quality-assessment', 'defect-intelligence'],
+        };
+        // For each domain that has patterns, transfer to related domains
+        for (const [sourceDomainStr, targetDomains] of Object.entries(relatedDomains)) {
+            const sourceDomain = sourceDomainStr;
+            const sourceCount = stats.byDomain[sourceDomain] || 0;
+            if (sourceCount === 0)
+                continue;
+            // Get source domain patterns
+            const sourceResult = await this.searchPatterns('', {
+                domain: sourceDomain,
+                limit: 50,
+            });
+            if (!sourceResult.success)
+                continue;
+            for (const targetDomain of targetDomains) {
+                // Only transfer to domains that have few patterns (less than source)
+                const targetCount = stats.byDomain[targetDomain] || 0;
+                if (targetCount >= sourceCount) {
+                    skipped++;
+                    continue;
+                }
+                // Transfer each source pattern to the target domain
+                for (const { pattern: sourcePattern } of sourceResult.value) {
+                    // Check if a similar pattern already exists in target domain
+                    const existingCheck = await this.searchPatterns(sourcePattern.name, {
+                        domain: targetDomain,
+                        limit: 1,
+                    });
+                    if (existingCheck.success && existingCheck.value.length > 0) {
+                        const bestMatch = existingCheck.value[0];
+                        if (bestMatch.score > 0.8) {
+                            skipped++;
+                            continue; // Similar pattern already exists
+                        }
+                    }
+                    // Create transferred pattern with reduced confidence
+                    const transferredConfidence = Math.max(0.3, (sourcePattern.confidence || 0.5) * 0.8);
+                    const transferResult = await this.storePattern({
+                        patternType: sourcePattern.patternType,
+                        qeDomain: targetDomain,
+                        name: `${sourcePattern.name} (from ${sourceDomain})`,
+                        description: `${sourcePattern.description} [Transferred from ${sourceDomain} domain]`,
+                        template: sourcePattern.template,
+                        context: {
+                            ...sourcePattern.context,
+                            relatedDomains: [sourceDomain, targetDomain],
+                            tags: [
+                                ...sourcePattern.context.tags,
+                                'cross-domain-transfer',
+                                `source:${sourceDomain}`,
+                            ],
+                        },
+                        confidence: transferredConfidence,
+                    });
+                    if (transferResult.success) {
+                        transferred++;
+                    }
+                    else {
+                        skipped++;
+                    }
+                }
+            }
+        }
+        console.log(`[QEReasoningBank] Cross-domain transfer complete: ${transferred} transferred, ${skipped} skipped`);
+        return { transferred, skipped };
+    }
     /**
      * Store a new pattern
      */
@@ -357,6 +1054,18 @@ Check for:
             return ok(undefined);
         }
         const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success);
+        // Write to qe_pattern_usage table for analytics/feedback loop
+        try {
+            const { getUnifiedMemory } = await import('../kernel/unified-memory.js');
+            const db = getUnifiedMemory().getDatabase();
+            db.prepare(`
+        INSERT INTO qe_pattern_usage (pattern_id, success, metrics_json, feedback)
+        VALUES (?, ?, ?, ?)
+      `).run(outcome.patternId, outcome.success ? 1 : 0, outcome.metrics ? JSON.stringify(outcome.metrics) : null, outcome.feedback || null);
+        }
+        catch {
+            // Non-critical — don't fail if analytics insert fails
+        }
         if (result.success) {
             this.stats.learningOutcomes++;
             if (outcome.success) {