agentic-qe 3.3.2 → 3.3.4

package/.claude/agents/v3/README.md

@@ -0,0 +1,100 @@
+# AQE V3 Agents Index
+
+This directory contains V3 QE agents installed by `aqe init`.
+
+> **Note**: This directory only contains AQE-specific agents (v3-qe-*).
+> Claude-flow core agents (adr-architect, memory-specialist, etc.) are part of
+> the claude-flow system and are available separately.
+
+## Summary
+
+- **Total Agents**: 1
+- **V3 QE Domain Agents**: 1
+- **V3 Subagents**: 0
+
+## V2 → V3 Migration Guide
+
+| V2 Agent | V3 Agent | Domain | Key Changes |
+|----------|----------|--------|-------------|
+| `qe-a11y-ally` | `qe-accessibility-auditor` | visual-accessibility | **MANDATORY video pipeline** |
+| `qe-test-generator` | `qe-test-architect` | test-generation | ReasoningBank learning |
+| `qe-coverage-analyzer` | `qe-coverage-specialist` | coverage-analysis | O(log n) sublinear |
+| `qe-coordinator` | `qe-learning-coordinator` | learning-optimization | Cross-domain patterns |
+| `qe-flaky-investigator` | `qe-flaky-hunter` | defect-intelligence | ML-powered detection |
+
+## Critical: qe-accessibility-auditor
+
+The V3 accessibility auditor has a **MANDATORY video accessibility pipeline**.
+
+### V2 Behavior (qe-a11y-ally)
+
+Generated these files when videos detected:
+- `*-captions.vtt` - For deaf/hard-of-hearing users
+- `*-audiodesc.vtt` - For blind/low-vision users
+- Implementation instructions
+
+### V3 Behavior (qe-accessibility-auditor)
+
+**MUST** execute the same pipeline:
+
+1. **Detect** - Find `<video>`, `<iframe>` elements
+2. **Download** - `curl -L -o video.mp4 URL`
+3. **Extract** - `ffmpeg -vf "fps=1/3" -frames:v 10`
+4. **Analyze** - Read each .jpg with Claude Vision
+5. **Generate** - Create .vtt from actual descriptions
+6. **Save** - Output to `docs/accessibility/captions/{page-slug}/`
+
+### Expected Output Structure
+
+```
+docs/accessibility/captions/{page-slug}/
+├── video-001-captions.vtt     # Captions
+├── video-001-audiodesc.vtt    # Audio descriptions
+├── implementation.md          # HTML integration
+└── audit-report.md            # WCAG report
+```
+
+### Invocation
+
+Use the skill for guaranteed video pipeline execution:
+
+```
+/qe-a11y-ally https://example.com/page
+```
+
+Or via Task with explicit video pipeline requirement:
+
+```javascript
+Task({
+  prompt: "Audit accessibility including MANDATORY video pipeline for URL",
+  subagent_type: "qe-accessibility-auditor"
+})
+```
+
+## Usage
+
+Spawn agents using Claude Code's Task tool:
+
+```javascript
+Task("Generate tests for UserService", "...", "qe-test-architect")
+Task("Analyze coverage gaps", "...", "qe-coverage-specialist")
+Task("Audit accessibility with video captions", "...", "qe-accessibility-auditor")
+```
+
+## V3 QE Domain Agents (1)
+
+Quality Engineering agents mapped to the 12 DDD bounded contexts.
+
+| Agent | Domain | File |
+|-------|--------|------|
+| `qe-accessibility-auditor` | visual-accessibility | `qe-accessibility-auditor.md` |
+
+## V3 Subagents (0)
+
+Specialized sub-task agents for TDD and code review.
+
+*None installed*
+
+---
+
+*Updated 2026-01-26 - Added V2→V3 migration guide and video pipeline documentation*

package/.claude/agents/v3/qe-accessibility-auditor.md

@@ -53,17 +53,118 @@ Proceed with testing without confirmation when standards are clear.
 Apply multi-tool testing by default for comprehensive coverage.
 Generate remediation guidance with code examples automatically.
 
-**Video Accessibility Pipeline (MANDATORY for pages with videos):**
-1. Extract video URLs using Playwright/network interception
-2. Download videos locally with curl/ffmpeg
-3. Extract frames: `ffmpeg -i video.mp4 -vf "fps=1/3" -frames:v 10 frame_%02d.jpg`
-4. Analyze each frame with Claude Vision (Read tool on .jpg files)
-5. Generate WebVTT captions from ACTUAL frame descriptions
-6. Generate audio descriptions for blind users
-7. Save files to `docs/accessibility/captions/` ready to deploy
-
-**NEVER skip video analysis when videos are detected.**
-**NEVER generate generic/template captions - use actual frame descriptions.**
+## CRITICAL: VIDEO ACCESSIBILITY PIPELINE
+
+**This pipeline is MANDATORY when ANY video is detected on the page.**
+**Failure to execute this pipeline is a CRITICAL ERROR.**
+
+### Detection Phase
+Look for these video indicators in fetched HTML:
+- `<video>` elements with `src` or `<source>` children
+- `<iframe>` with YouTube/Vimeo/Wistia URLs
+- `video-container`, `video-player` class elements
+- JavaScript video players (Video.js, Plyr, etc.)
+
+### Execution Phase (FOR EACH VIDEO)
+
+**Step 1: Download Video**
+```bash
+# Create working directory
+mkdir -p /tmp/a11y-video-work
+
+# For direct MP4/WebM URLs
+curl -L -o /tmp/a11y-video-work/video-001.mp4 "VIDEO_URL"
+
+# For YouTube (if yt-dlp available)
+yt-dlp -f "best[height<=720]" -o /tmp/a11y-video-work/video-001.mp4 "YOUTUBE_URL" 2>/dev/null || echo "yt-dlp not available"
+```
+
+**Step 2: Extract Frames**
+```bash
+mkdir -p /tmp/a11y-video-work/frames-001
+ffmpeg -i /tmp/a11y-video-work/video-001.mp4 \
+  -vf "fps=1/3" \
+  -frames:v 10 \
+  /tmp/a11y-video-work/frames-001/frame_%02d.jpg \
+  2>/dev/null
+```
+
+**Step 3: Analyze Each Frame with Claude Vision**
+Use the Read tool on EACH extracted .jpg file:
+```
+Read /tmp/a11y-video-work/frames-001/frame_01.jpg
+Read /tmp/a11y-video-work/frames-001/frame_02.jpg
+Read /tmp/a11y-video-work/frames-001/frame_03.jpg
+... (continue for all 10 frames)
+```
+
+For each frame, document:
+- Scene: Setting, environment, lighting conditions
+- People: Who is present, what they're doing, expressions
+- Objects: Products, props, vehicles, equipment
+- Text: Any visible text, logos, signs, labels
+- Action: What's happening, movement, transitions
+- Colors: Dominant colors, contrasts, accessibility-relevant
+
+**Step 4: Generate WebVTT Captions**
+```vtt
+WEBVTT
+Kind: captions
+
+00:00:00.000 --> 00:00:03.000
+[Description from frame_01.jpg analysis]
+
+00:00:03.000 --> 00:00:06.000
+[Description from frame_02.jpg analysis]
+
+00:00:06.000 --> 00:00:09.000
+[Description from frame_03.jpg analysis]
+```
+
+**Step 5: Generate Audio Descriptions**
+```vtt
+WEBVTT
+Kind: descriptions
+
+00:00:00.000 --> 00:00:03.000
+SCENE: [Detailed scene description for blind users]
+VISUAL: [What's on screen]
+TEXT: [Any readable text]
+ACTION: [What's happening]
+```
+
+**Step 6: Save Output Files**
+```bash
+# Create output directory
+mkdir -p docs/accessibility/captions/{page-slug}
+
+# Save generated files
+# - video-001-captions.vtt
+# - video-001-audiodesc.vtt
+# - implementation.md (HTML code examples)
+```
+
+### Enforcement Rules
+
+1. **NEVER** complete an accessibility audit without checking for videos
+2. **NEVER** skip the video pipeline if videos are detected
+3. **NEVER** generate placeholder/template captions - use ACTUAL frame analysis
+4. **ALWAYS** use the Read tool on actual .jpg frame files for Vision analysis
+5. **ALWAYS** save output to `docs/accessibility/captions/{page-slug}/`
+6. **ALWAYS** include implementation instructions in the output
+
+### Validation Checklist (Self-Check Before Completing)
+
+- [ ] Did I check for `<video>` and `<iframe>` elements?
+- [ ] Did I download each detected video?
+- [ ] Did I extract frames with ffmpeg?
+- [ ] Did I use Read tool on each .jpg frame file?
+- [ ] Did I generate captions.vtt from ACTUAL frame descriptions?
+- [ ] Did I generate audiodesc.vtt with detailed scene info?
+- [ ] Did I save files to docs/accessibility/captions/?
+- [ ] Did I include implementation instructions?
+
+**If ANY checkbox is NO and videos were detected, the task is INCOMPLETE.**
 </default_to_action>
 
 <parallel_execution>

package/.claude/agents/v3/qe-bdd-generator.md

@@ -257,6 +257,46 @@ Use via CLI: `aqe skills show test-design-techniques`
 Use via Claude Code: `Skill("exploratory-testing-advanced")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Quality-Criteria Loop (Development → Ideation)
+**Role**: CONSUMER - Receives untestable patterns to avoid in BDD scenarios
+
+### On Startup, Query Quality-Criteria Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "quality-criteria",
+  maxAge: "60d"
+});
+
+// Learn from historical untestable patterns
+for (const signal of result.signals) {
+  if (signal.untestablePatterns) {
+    for (const pattern of signal.untestablePatterns) {
+      // Never generate scenarios using untestable patterns
+      avoidPattern(pattern.acPattern);
+      // Use better patterns in scenario generation
+      preferPattern(pattern.betterPattern);
+    }
+  }
+  if (signal.recommendations?.acTemplates) {
+    // Use proven AC templates for scenario generation
+    addScenarioTemplates(signal.recommendations.acTemplates);
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Pattern Avoidance**: Don't use patterns from `untestablePatterns[].acPattern`
+2. **Better Patterns**: Prefer `untestablePatterns[].betterPattern` structures
+3. **Templates**: Use `acTemplates` for proven scenario structures
+4. **Coverage Gaps**: Generate scenarios that would fill `coverageGaps[].codeArea`
+
+### Signal Flow:
+- **Consumes**: Untestable patterns and templates from qe-coverage-specialist, qe-gap-detector
+- **Namespace**: `aqe/cross-phase/quality-criteria/ac-quality`
+- **Expected Signals**: AC templates and patterns to avoid
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the requirements-validation bounded context (ADR-006).
 

package/.claude/agents/v3/qe-coverage-specialist.md

@@ -206,6 +206,45 @@ Use via CLI: `aqe skills show risk-based-testing`
 Use via Claude Code: `Skill("mutation-testing")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Quality-Criteria Loop (Development → Ideation)
+**Role**: PRODUCER - Stores untestable patterns from coverage analysis
+
+### On Coverage Gap Detection, Store Quality-Criteria Signal:
+```typescript
+mcp__agentic_qe__cross_phase_store({
+  loop: "quality-criteria",
+  data: {
+    untestablePatterns: [
+      {
+        acPattern: "<acceptance-criteria-pattern>",
+        problem: "<why-its-untestable>",
+        frequency: <0.0-1.0>,
+        betterPattern: "<improved-pattern>"
+      }
+    ],
+    coverageGaps: [
+      {
+        codeArea: "<file-or-module>",
+        coveragePercentage: <percentage>,
+        rootCause: "<why-gap-exists>",
+        acImprovement: "<how-better-AC-would-help>"
+      }
+    ],
+    recommendations: {
+      forRequirementsValidator: ["<AC improvement recommendations>"],
+      acTemplates: { "<feature>": "<template>" }
+    }
+  }
+})
+```
+
+### Signal Flow:
+- **Produces**: Untestable patterns, coverage gaps → consumed by qe-requirements-validator, qe-bdd-generator
+- **Namespace**: `aqe/cross-phase/quality-criteria/ac-quality`
+- **TTL**: 60 days (AC quality insights inform story writing)
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the coverage-analysis bounded context (ADR-003).
 

package/.claude/agents/v3/qe-defect-predictor.md

@@ -230,6 +230,42 @@ Use via CLI: `aqe skills show risk-based-testing`
 Use via Claude Code: `Skill("mutation-testing")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Strategic Loop (Production → Ideation)
+**Role**: PRODUCER - Stores risk weights from production defect analysis
+
+### On Completion, Store Strategic Signal:
+```typescript
+mcp__agentic_qe__cross_phase_store({
+  loop: "strategic",
+  data: {
+    riskWeights: [
+      {
+        category: "<defect-prone-area>",
+        weight: <0.0-1.0>,
+        confidence: <0.0-1.0>,
+        evidence: {
+          defectCount: <count>,
+          percentageOfTotal: <percentage>,
+          severityDistribution: { critical: <n>, high: <n>, medium: <n> },
+          timeRange: { start: "<date>", end: "<date>" }
+        }
+      }
+    ],
+    recommendations: {
+      forRiskAssessor: ["<recommendations for risk assessment>"],
+      forQualityCriteria: ["<recommendations for acceptance criteria>"]
+    }
+  }
+})
+```
+
+### Signal Flow:
+- **Produces**: Production risk weights → consumed by qe-risk-assessor, qe-quality-criteria-recommender
+- **Namespace**: `aqe/cross-phase/strategic/production-risk`
+- **TTL**: 90 days (strategic insights have long-term value)
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the defect-intelligence bounded context (ADR-006).
 

package/.claude/agents/v3/qe-gap-detector.md

@@ -238,6 +238,45 @@ Use via CLI: `aqe skills show risk-based-testing`
 Use via Claude Code: `Skill("test-design-techniques")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Quality-Criteria Loop (Development → Ideation)
+**Role**: PRODUCER - Stores coverage gap patterns for AC improvement
+
+### On Gap Detection, Store Quality-Criteria Signal:
+```typescript
+mcp__agentic_qe__cross_phase_store({
+  loop: "quality-criteria",
+  data: {
+    untestablePatterns: [
+      {
+        acPattern: "<vague-ac-pattern>",
+        problem: "Not testable - missing specific assertions",
+        frequency: <0.0-1.0>,
+        betterPattern: "Given/When/Then with specific values"
+      }
+    ],
+    coverageGaps: [
+      {
+        codeArea: "<path/to/file>",
+        coveragePercentage: <percentage>,
+        rootCause: "No acceptance criteria for this path",
+        acImprovement: "Add explicit AC for edge cases"
+      }
+    ],
+    recommendations: {
+      forRequirementsValidator: ["<recommendations for AC validation>"],
+      acTemplates: {}
+    }
+  }
+})
+```
+
+### Signal Flow:
+- **Produces**: Coverage gaps mapped to AC problems → consumed by qe-requirements-validator, qe-bdd-generator
+- **Namespace**: `aqe/cross-phase/quality-criteria/ac-quality`
+- **TTL**: 60 days
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the coverage-analysis bounded context (ADR-003).
 

package/.claude/agents/v3/qe-pattern-learner.md

@@ -250,6 +250,37 @@ Use via CLI: `aqe skills show agentdb-learning`
 Use via Claude Code: `Skill("reasoningbank-intelligence")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Tactical Loop (Grooming → Ideation)
+**Role**: PRODUCER - Stores SFDIPOT factor weights from pattern analysis
+
+### On Pattern Discovery, Store Tactical Signal:
+```typescript
+mcp__agentic_qe__cross_phase_store({
+  loop: "tactical",
+  data: {
+    factorWeights: [
+      {
+        factor: "<Structure|Function|Data|Interfaces|Platform|Operations|Time>",
+        weight: <0.0-1.0>,
+        defectPercentage: <percentage>,
+        commonPatterns: ["<pattern-1>", "<pattern-2>"]
+      }
+    ],
+    featureContext: "<feature-being-analyzed>",
+    recommendations: {
+      forProductFactorsAssessor: ["<factor-based recommendations>"]
+    }
+  }
+})
+```
+
+### Signal Flow:
+- **Produces**: SFDIPOT factor weights → consumed by qe-product-factors-assessor
+- **Namespace**: `aqe/cross-phase/tactical/sfdipot-weights`
+- **TTL**: 90 days (tactical insights inform future feature grooming)
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the learning-optimization bounded context (ADR-012).
 

package/.claude/agents/v3/qe-product-factors-assessor.md

@@ -306,6 +306,40 @@ Use via CLI: `aqe skills show brutal-honesty-review`
 Use via Claude Code: `Skill("context-driven-testing")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Tactical Loop (Grooming → Ideation)
+**Role**: CONSUMER - Receives SFDIPOT factor weights from production analysis
+
+### On Startup, Query Tactical Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "tactical",
+  maxAge: "90d",
+  featureContext: "<current-feature>"  // Optional: filter by feature
+});
+
+// Apply learned factor weights to SFDIPOT analysis
+for (const signal of result.signals) {
+  if (signal.factorWeights) {
+    for (const factor of signal.factorWeights) {
+      // Prioritize factors with higher production defect correlation
+      adjustFactorWeight(factor.factor, factor.weight);
+    }
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Factor Prioritization**: Use `signal.factorWeights` to prioritize SFDIPOT factors
+2. **Common Patterns**: Reference `factor.commonPatterns` when documenting risks
+3. **Recommendations**: Apply `signal.recommendations.forProductFactorsAssessor`
+
+### Signal Flow:
+- **Consumes**: SFDIPOT factor weights from qe-pattern-learner
+- **Namespace**: `aqe/cross-phase/tactical/sfdipot-weights`
+- **Expected Signals**: Factor weights with defect percentages and patterns
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the requirements-validation bounded context (ADR-004).
 

package/.claude/agents/v3/qe-quality-criteria-recommender.md

@@ -300,6 +300,38 @@ Use via CLI: `aqe skills show brutal-honesty-review`
 Use via Claude Code: `Skill("brutal-honesty-review")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Strategic Loop (Production → Ideation)
+**Role**: CONSUMER - Receives production insights to recommend better quality criteria
+
+### On Startup, Query Strategic Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "strategic",
+  maxAge: "90d"
+});
+
+// Apply production learnings to quality criteria recommendations
+for (const signal of result.signals) {
+  if (signal.recommendations?.forQualityCriteria) {
+    for (const rec of signal.recommendations.forQualityCriteria) {
+      addQualityCriteriaRecommendation(rec);
+    }
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Defect-Prone Areas**: Prioritize quality criteria for areas with high defect weights
+2. **Recommendations**: Apply `signal.recommendations.forQualityCriteria` directly
+3. **Evidence**: Reference defect evidence when explaining recommendations
+
+### Signal Flow:
+- **Consumes**: Production risk weights from qe-defect-predictor
+- **Namespace**: `aqe/cross-phase/strategic/production-risk`
+- **Expected Signals**: Recommendations for quality criteria improvements
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the requirements-validation bounded context (ADR-004).
 

package/.claude/agents/v3/qe-quality-gate.md

@@ -197,6 +197,45 @@ Use via CLI: `aqe skills show quality-metrics`
 Use via Claude Code: `Skill("compliance-testing")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Operational Loop (CI/CD → Development)
+**Role**: PRODUCER - Stores flaky test patterns and gate failures
+
+### On Gate Failure or Flaky Detection, Store Operational Signal:
+```typescript
+mcp__agentic_qe__cross_phase_store({
+  loop: "operational",
+  data: {
+    flakyPatterns: [
+      {
+        pattern: "<flaky test pattern>",
+        frequency: <0.0-1.0>,
+        affectedTests: ["<test-file-1>", "<test-file-2>"],
+        rootCause: "<identified root cause>",
+        fix: "<recommended fix>"
+      }
+    ],
+    gateFailures: [
+      {
+        reason: "<failure reason>",
+        percentage: <metric-value>,
+        trend: "<increasing|stable|decreasing>"
+      }
+    ],
+    recommendations: {
+      forTestArchitect: ["<test architecture recommendations>"],
+      antiPatterns: ["<anti-patterns to avoid>"]
+    }
+  }
+})
+```
+
+### Signal Flow:
+- **Produces**: Flaky patterns, gate failures → consumed by qe-test-architect, qe-tdd-specialist
+- **Namespace**: `aqe/cross-phase/operational/test-health`
+- **TTL**: 30 days (operational insights are time-sensitive)
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the quality-assessment bounded context (ADR-004).
 

package/.claude/agents/v3/qe-requirements-validator.md

@@ -381,6 +381,43 @@ Use via CLI: `aqe skills show context-driven-testing`
 Use via Claude Code: `Skill("bdd-scenario-tester")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Quality-Criteria Loop (Development → Ideation)
+**Role**: CONSUMER - Receives untestable patterns to flag during validation
+
+### On Startup, Query Quality-Criteria Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "quality-criteria",
+  maxAge: "60d"
+});
+
+// Learn from historical untestable patterns
+for (const signal of result.signals) {
+  if (signal.untestablePatterns) {
+    for (const pattern of signal.untestablePatterns) {
+      // Flag these patterns during AC validation
+      addKnownUntestablePattern(pattern.acPattern, pattern.betterPattern);
+    }
+  }
+  if (signal.recommendations?.forRequirementsValidator) {
+    applyValidationRecommendations(signal.recommendations.forRequirementsValidator);
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Pattern Detection**: Flag AC matching `untestablePatterns[].acPattern`
+2. **Improvement Suggestions**: Suggest `untestablePatterns[].betterPattern`
+3. **AC Templates**: Use `signal.recommendations.acTemplates` for guidance
+4. **Root Causes**: Reference `coverageGaps[].rootCause` in validation feedback
+
+### Signal Flow:
+- **Consumes**: Untestable patterns from qe-coverage-specialist, qe-gap-detector
+- **Namespace**: `aqe/cross-phase/quality-criteria/ac-quality`
+- **Expected Signals**: AC patterns with testability problems and improvements
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the requirements-validation bounded context (ADR-006).
 

package/.claude/agents/v3/qe-risk-assessor.md

@@ -251,6 +251,39 @@ Use via CLI: `aqe skills show risk-based-testing`
 Use via Claude Code: `Skill("quality-metrics")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Strategic Loop (Production → Ideation)
+**Role**: CONSUMER - Receives production risk weights to inform risk assessment
+
+### On Startup, Query Strategic Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "strategic",
+  maxAge: "90d"
+});
+
+// Apply risk weights to current assessment
+for (const signal of result.signals) {
+  if (signal.riskWeights) {
+    for (const weight of signal.riskWeights) {
+      // Boost risk scores for categories with production defects
+      applyHistoricalRiskWeight(weight.category, weight.weight, weight.confidence);
+    }
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Risk Category Weights**: Use `signal.riskWeights` to prioritize assessment categories
+2. **Confidence Levels**: Trust weights with high confidence (>0.8) more heavily
+3. **Recommendations**: Apply `signal.recommendations.forRiskAssessor` directly
+
+### Signal Flow:
+- **Consumes**: Production risk weights from qe-defect-predictor
+- **Namespace**: `aqe/cross-phase/strategic/production-risk`
+- **Expected Signals**: Risk weights by category with evidence
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the quality-assessment bounded context (ADR-004).