agileflow 2.94.1 → 2.95.1

package/src/core/commands/research/analyze.md

@@ -5,12 +5,12 @@ compact_context:
   priority: high
   preserve_rules:
     - "ACTIVE COMMAND: /agileflow:research:analyze - Analyze saved research for project implementation"
-    - "MUST use EnterPlanMode to gather project context before analyzing"
+    - "MUST use EnterPlanMode and deploy 3-5 domain experts IN PARALLEL for multi-perspective analysis"
     - "MUST be project-specific: reference actual files and patterns from user's codebase"
-    - "MUST show benefits FIRST before asking for implementation commitment"
-    - "MUST intelligently recommend artifact type (ADR/Epic/Stories/Practice) based on scope"
-    - "DO NOT assume a one-size-fits-all artifact type"
-    - "Research type + analysis determines artifact: Architecture decision→ADR, Large feature→Epic+Stories, Focused improvement→Story"
+    - "MUST synthesize expert results with confidence scoring (HIGH = 2+ experts agree)"
+    - "MUST present Implementation Ideation Report with expert consensus before artifact creation"
+    - "DO NOT use single-perspective analysis (shallow, misses domain considerations)"
+    - "Research type + expert consensus determines artifact: Architecture decision→ADR, Large feature→Epic+Stories, Focused improvement→Story"
     - "For large research files (50k+ chars) or HIGH complexity: Use RLM approach with document-repl.js"
     - "Assess file with --info before reading; use targeted extraction for large docs"
   state_fields:
@@ -20,6 +20,9 @@ compact_context:
     - research_chars
     - plan_mode_active
     - implementation_analysis
+    - experts_deployed
+    - expert_results
+    - consensus_level
 ---
 
 # /agileflow:research:analyze
@@ -58,23 +61,28 @@ node .agileflow/scripts/obtain-context.js research:analyze
 
 ---
 
-### 🚨 RULE #1: ALWAYS ENTER PLAN MODE FIRST
+### 🚨 RULE #1: IMPLEMENTATION IDEATION = PLAN MODE + MULTI-EXPERT ANALYSIS
 
-**Before analyzing research, ALWAYS call `EnterPlanMode`.** This gathers project context:
+**Before analyzing research, ALWAYS:**
 
+1. **Enter plan mode**:
 ```xml
 <invoke name="EnterPlanMode"/>
 ```
 
-Then immediately:
+2. **Gather project context**:
 ```bash
 node .agileflow/scripts/obtain-context.js babysit
 ```
 
-**Why**: Generic analysis is worthless. You need to know their specific codebase, patterns, files, tech stack.
+3. **Deploy 3-5 domain experts IN PARALLEL** (see RULE #6 for expert selection)
 
-**❌ WRONG**: Show generic benefits without project context
-**✅ RIGHT**: Reference actual files, patterns, and architecture from their codebase
+4. **Synthesize results** with confidence scoring
+
+**Why**: Single-perspective analysis misses domain-specific considerations. Multi-expert analysis provides security, performance, testing, and architecture perspectives for comprehensive implementation guidance.
+
+**❌ WRONG**: Single-perspective analysis without expert consultation
+**✅ RIGHT**: Deploy domain experts in parallel, synthesize with confidence scoring
 
 ---
 
@@ -186,23 +194,53 @@ node packages/cli/scripts/document-repl.js --load="FILE" --section="Key Findings
 
 ---
 
+### 🚨 RULE #6: IMPLEMENTATION IDEATION (Multi-Expert Analysis)
+
+When user requests "Yes - Implementation ideation with multi-expert analysis":
+
+1. **Enter Plan Mode** and auto-detect research type to select experts
+2. **Deploy 3-5 experts IN PARALLEL** (like /ideate pattern)
+3. **Each expert analyzes from their domain perspective**:
+   - Implementation fit for codebase
+   - Domain-specific considerations
+   - Recommended approach with specific files
+   - Risks and gotchas
+4. **Synthesize with confidence scoring**:
+   - HIGH CONFIDENCE: 2+ experts agree on approach/files
+   - MEDIUM CONFIDENCE: 1 expert with specific evidence
+5. **Present unified Implementation Ideation Report** with expert consensus
+
+**Expert Selection by Research Type:**
+
+| Research Type | Detection Keywords | Experts |
+|--------------|-------------------|---------|
+| **Security/Compliance** | auth, oauth, jwt, encryption, vulnerability, compliance, csrf, xss | security, api, testing, compliance |
+| **Performance** | cache, optimize, latency, throughput, benchmark, profiling | performance, database, api, monitoring |
+| **Architecture/Framework** | migrate, upgrade, framework, refactor, redesign, architecture | api, database, performance, security |
+| **UI/Frontend** | component, styling, accessibility, ux, design system, responsive | ui, api, testing, accessibility |
+| **Database** | schema, migration, query, index, model, postgres, mongo | database, api, performance, datamigration |
+| **Full-Stack (default)** | multiple domains or unclear | api, ui, database, testing, security |
+
+---
+
 ### ANTI-PATTERNS (DON'T DO THESE)
 
 ❌ Skip plan mode and analyze without project context
-❌ Show generic benefits ("better performance") instead of specific gains
+❌ Single-perspective analysis (shallow, misses domain considerations)
+❌ Deploy experts one at a time (MUST be parallel)
 ❌ Reference files that don't exist in their codebase
 ❌ Assume one artifact type for all research (Epic for everything)
 ❌ Create artifacts without user asking first
-❌ Finish without asking "Should we implement this?"
 ❌ Load full large research files (50k+) - use RLM approach
 
 ### DO THESE INSTEAD
 
 ✅ ALWAYS enter plan mode first
-✅ Get project context (obtain-context.js)
+✅ Deploy 3-5 domain experts IN PARALLEL for multi-perspective analysis
+✅ Synthesize expert results with confidence scoring
+✅ Present Implementation Ideation Report with expert consensus
 ✅ Reference actual files and patterns from their codebase
-✅ Show specific, quantifiable benefits
-✅ Recommend artifact type based on research scope
+✅ Recommend artifact type based on expert agreement
 ✅ Confirm user wants to implement before creating anything
 ✅ Assess research file size/complexity before reading
 ✅ Use document-repl.js for large or complex research files
@@ -214,28 +252,29 @@ node packages/cli/scripts/document-repl.js --load="FILE" --section="Key Findings
 **Phase 1: Select Research**
 1. List research files if FILE not provided
 2. User selects which research to analyze
-3. Read and display the research summary
+3. Assess file size/complexity
+4. Read and display the research summary
 
-**Phase 2: Gather Context**
-4. Enter plan mode
-5. Run obtain-context.js to understand project
-6. Read relevant source files
-7. Understand current patterns and architecture
+**Phase 2: Offer Implementation Ideation**
+5. Ask if user wants multi-expert analysis
+6. If "No": Display full research, exit
+7. If "Yes": Continue to Phase 3
 
-**Phase 3: Analyze & Present**
-8. Write detailed implementation analysis
-9. Show benefits first, then complexity
-10. Include project-specific file references
+**Phase 3: Implementation Ideation**
+8. Enter plan mode + select 3-5 domain experts
+9. Deploy experts IN PARALLEL (Task tool with run_in_background)
+10. Collect results (TaskOutput) + synthesize with confidence scoring
+11. Present Implementation Ideation Report
 
 **Phase 4: Decide on Artifacts**
-11. Ask if user wants to proceed
-12. Recommend artifact type (ADR/Epic/Story/Practice/Tech debt)
-13. Create artifact if user confirms
+12. Confirm interest in proceeding
+13. Recommend artifact type based on expert consensus
+14. Create artifact if user confirms
 
 **Phase 5: Finish**
-14. Exit plan mode
-15. Confirm artifact created
-16. Research is now tracked and ready to implement
+15. Exit plan mode
+16. Confirm artifact created with expert validation
+17. Research is now tracked and ready to implement
 
 ---
 
@@ -275,10 +314,11 @@ node packages/cli/scripts/document-repl.js --load="FILE" --section="Key Findings
 ### REMEMBER AFTER COMPACTION
 
 - `/agileflow:research:analyze` IS ACTIVE - you're analyzing research for implementation
-- ALWAYS enter plan mode and gather context first
+- ALWAYS enter plan mode + deploy 3-5 domain experts IN PARALLEL
+- Synthesize expert results with confidence scoring (HIGH = 2+ agree)
+- Present unified Implementation Ideation Report
 - ALWAYS make analysis project-specific (reference actual files)
-- Show benefits FIRST, then implementation complexity
-- Recommend artifact type based on research scope (not always Epic)
+- Recommend artifact type based on expert consensus (not always Epic)
 - Confirm user wants to implement before creating artifacts
 
 <!-- COMPACT_SUMMARY_END -->
@@ -303,10 +343,12 @@ Upon invocation, execute these steps:
 <invoke name="TodoWrite">
 <parameter name="todos">[
   {"content": "Select research note", "status": "in_progress", "activeForm": "Selecting research"},
-  {"content": "Display research summary", "status": "pending", "activeForm": "Showing summary"},
-  {"content": "Enter plan mode and gather context", "status": "pending", "activeForm": "Gathering context"},
-  {"content": "Analyze implementation approach", "status": "pending", "activeForm": "Analyzing approach"},
-  {"content": "Present benefits and changes", "status": "pending", "activeForm": "Presenting analysis"},
+  {"content": "Assess file and display research summary", "status": "pending", "activeForm": "Showing summary"},
+  {"content": "Offer implementation ideation", "status": "pending", "activeForm": "Offering ideation"},
+  {"content": "Enter plan mode and select domain experts", "status": "pending", "activeForm": "Selecting experts"},
+  {"content": "Deploy 3-5 experts in parallel", "status": "pending", "activeForm": "Deploying experts"},
+  {"content": "Synthesize expert results with confidence scoring", "status": "pending", "activeForm": "Synthesizing results"},
+  {"content": "Present Implementation Ideation Report", "status": "pending", "activeForm": "Presenting report"},
   {"content": "Confirm interest in implementing", "status": "pending", "activeForm": "Confirming interest"},
   {"content": "Suggest and create artifact", "status": "pending", "activeForm": "Creating artifact"}
 ]</parameter>
@@ -396,7 +438,7 @@ Display a brief summary:
   "header": "Analyze",
   "multiSelect": false,
   "options": [
-    {"label": "Yes - Enter plan mode and explore (Recommended)", "description": "I'll analyze your codebase and show benefits, implementation steps, and what would change"},
+    {"label": "Yes - Implementation ideation with multi-expert analysis (Recommended)", "description": "Deploy 3-5 domain experts to analyze from security, performance, testing, and architecture perspectives"},
     {"label": "Just view the full research", "description": "Display without analysis"},
     {"label": "Cancel", "description": "Exit"}
   ]
@@ -408,116 +450,234 @@ Display a brief summary:
 **If "Cancel"**: Exit.
 **If "Yes"**: Continue to Step 5.
 
-### Step 5: Enter Plan Mode and Gather Context
+### Step 5: Enter Plan Mode and Select Experts
 
 ```xml
 <invoke name="EnterPlanMode"/>
 ```
 
-Gather project context:
+Then immediately gather project context:
 
 ```bash
 node .agileflow/scripts/obtain-context.js babysit
 ```
 
-Also read key files to understand the project:
-- `CLAUDE.md` or `README.md` for project overview
-- Relevant source files based on research topic
-- Existing architecture/pattern files
+**Auto-detect research type and select experts:**
+
+Analyze the research TOPIC and CONTENT to determine research type, then select 3-5 experts:
 
-**Goal**: Understand:
-- Current project structure
-- Existing patterns that apply
-- Files that would be affected
-- Current tech stack
-- How research findings apply to THIS specific project
+| Research Type | Detection Keywords | Experts |
+|--------------|-------------------|---------|
+| **Security/Compliance** | auth, oauth, jwt, encryption, vulnerability, compliance, csrf, xss | security, api, testing, compliance |
+| **Performance** | cache, optimize, latency, throughput, benchmark, profiling | performance, database, api, monitoring |
+| **Architecture/Framework** | migrate, upgrade, framework, refactor, redesign, architecture | api, database, performance, security |
+| **UI/Frontend** | component, styling, accessibility, ux, design system, responsive | ui, api, testing, accessibility |
+| **Database** | schema, migration, query, index, model, postgres, mongo | database, api, performance, datamigration |
+| **Full-Stack (default)** | multiple domains or unclear | api, ui, database, testing, security |
 
-### Step 6: Analyze and Present Implementation Plan
+---
 
-Based on the research content AND project context, prepare a detailed analysis:
+### Step 6: Deploy Experts in Parallel
 
-```markdown
-## Implementation Analysis for "[Research Topic]"
+**CRITICAL**: Deploy ALL selected experts in a SINGLE message using the Task tool.
+
+Each expert receives this prompt template:
+
+```
+EXPERTISE FIRST: Read your expertise.yaml file if it exists at .agileflow/expertise/{domain}.yaml
+
+RESEARCH TOPIC: {TOPIC}
+RESEARCH SUMMARY: {2-3 paragraph summary from research file}
+PROJECT CONTEXT: {from obtain-context.js output}
+
+TASK: Analyze this research from your {DOMAIN} perspective:
+
+1. **Implementation Fit**: How well does this fit the current codebase?
+   - What patterns/files would need to change?
+   - Any conflicts with existing architecture?
+
+2. **Domain-Specific Considerations**: From your expertise:
+   - For SECURITY: What security implications? Risks? Compliance needs?
+   - For PERFORMANCE: What performance impacts? Bottlenecks? Optimization opportunities?
+   - For TESTING: What test coverage needed? Edge cases? Regression risks?
+   - For API: What API changes? Breaking changes? Versioning needs?
+   - For UI: What UX considerations? Accessibility? Design patterns?
+   - For DATABASE: What schema changes? Migration strategy? Query impact?
+
+3. **Implementation Approach**: Your recommended approach:
+   - Key files to modify (specific paths from codebase)
+   - Effort estimate (hours/days/weeks)
+   - Dependencies or prerequisites
+
+4. **Risks & Gotchas**: What could go wrong?
+   - Technical risks
+   - Migration complexity
+   - Team adoption concerns
+
+FORMAT as structured markdown with specific file paths and evidence from codebase.
+```
+
+**Deploy using Task tool (ALL in one message):**
+
+```xml
+<invoke name="Task">
+<parameter name="description">Security analysis of {TOPIC}</parameter>
+<parameter name="prompt">{prompt with DOMAIN=security}</parameter>
+<parameter name="subagent_type">agileflow-security</parameter>
+<parameter name="run_in_background">true</parameter>
+</invoke>
+
+<invoke name="Task">
+<parameter name="description">API analysis of {TOPIC}</parameter>
+<parameter name="prompt">{prompt with DOMAIN=api}</parameter>
+<parameter name="subagent_type">agileflow-api</parameter>
+<parameter name="run_in_background">true</parameter>
+</invoke>
+
+<invoke name="Task">
+<parameter name="description">Testing analysis of {TOPIC}</parameter>
+<parameter name="prompt">{prompt with DOMAIN=testing}</parameter>
+<parameter name="subagent_type">agileflow-testing</parameter>
+<parameter name="run_in_background">true</parameter>
+</invoke>
+
+<!-- Continue for all selected experts -->
+```
 
-### 🎯 Benefits of Implementing This Research
+---
+
+### Step 7: Collect Results and Synthesize
+
+Collect all expert outputs:
+
+```xml
+<invoke name="TaskOutput">
+<parameter name="task_id">{security_task_id}</parameter>
+<parameter name="block">true</parameter>
+<parameter name="timeout">60000</parameter>
+</invoke>
+
+<!-- Repeat for each expert -->
+```
 
-**What you would gain:**
-- [Benefit 1 - specific to this project]
-- [Benefit 2 - quantifiable if possible]
-- [Benefit 3 - addresses current gaps/pain points]
+**Synthesis Process:**
 
-**Problems this solves:**
-- [Current issue 1 this addresses]
-- [Current issue 2 this addresses]
+1. **Find Consensus**: Group similar recommendations across experts
+   - **HIGH CONFIDENCE**: 2+ experts recommend same approach/files
+   - **MEDIUM CONFIDENCE**: 1 expert with specific evidence
 
-**Why now?**
-- [Reason this is relevant to current project state]
+2. **Aggregate Effort Estimates**: Average across experts, note range
+
+3. **Collect All Risks**: Union of risks from all experts, prioritize by frequency
+
+4. **Validate Artifact Recommendation** via expert consensus:
+   - If experts mention "decision", "tradeoffs", "alternatives" → **ADR**
+   - If experts identify 5+ files across multiple domains → **Epic + Stories**
+   - If experts agree on single focus area, 1-3 files → **Story**
+   - If experts focus on guidelines, patterns → **Practice doc**
 
 ---
 
-### 🔧 How It Would Be Implemented
+### Step 8: Present Implementation Ideation Report
 
-**Files to modify:**
-| File | Change | Effort |
-|------|--------|--------|
-| `path/to/file1.ts` | [What changes] | Low |
-| `path/to/file2.ts` | [What changes] | Medium |
+Present the synthesized analysis:
 
-**New files to create:**
-- `path/to/new/file.ts` - [Purpose]
+```markdown
+## 🧠 Implementation Ideation Report
 
-**Implementation steps:**
-1. [Step 1 - specific action]
-2. [Step 2 - specific action]
-3. [Step 3 - specific action]
+**Research**: {TOPIC}
+**Experts Consulted**: {list of 3-5 experts with badges}
+**Consensus Level**: {High/Medium/Low based on agreement}
 
 ---
 
-### 🔄 What Would Change
+### 🎯 High-Confidence Implementation Steps
+*Agreed by 2+ experts*
+
+1. **{Step title}**
+   - Experts: 🔒 security, 🧪 testing
+   - Files: `path/to/file1.ts`, `path/to/file2.ts`
+   - Effort: {averaged estimate}
+   - Approach: {consensus approach}
+
+2. **{Step title}**
+   - Experts: ⚡ api, 🗄️ database
+   - Files: `path/to/file3.ts`
+   - Effort: {averaged estimate}
+   - Approach: {consensus approach}
+
+---
 
-**Behavior changes:**
-- [User-facing change 1]
-- [Developer experience change]
+### 💡 Domain-Specific Considerations
 
-**Architecture impact:**
-- [How this affects current architecture]
-- [New patterns introduced]
+**🔒 Security** (security expert):
+- {key consideration 1}
+- {risk flagged}
+- Mitigation: {recommended approach}
 
-**Dependencies:**
-- [New packages needed, if any]
-- [Internal dependencies affected]
+**⚡ Performance** (performance expert):
+- {optimization opportunity}
+- {bottleneck identified}
+
+**🧪 Testing** (testing expert):
+- {coverage requirements}
+- {edge cases to handle}
+- {regression risk assessment}
+
+**🔧 API** (api expert):
+- {API changes needed}
+- {versioning considerations}
 
 ---
 
-### ⚠️ Risks & Considerations
+### ⚠️ Risks & Gotchas
+*Flagged by experts*
 
-- [Risk 1 - migration complexity, breaking changes, etc.]
-- [Risk 2 - learning curve, team adoption]
-- [Mitigation strategy for each]
+| Risk | Expert(s) | Severity | Mitigation |
+|------|-----------|----------|------------|
+| {risk 1} | 🔒 security | High | {mitigation} |
+| {risk 2} | ⚡ performance | Medium | {mitigation} |
+| {risk 3} | 🧪 testing | Low | {mitigation} |
 
 ---
 
-### ⏱️ Effort Estimate
+### 📊 Effort Estimate Summary
+
+| Expert | Estimate | Notes |
+|--------|----------|-------|
+| security | {estimate} | {notes} |
+| api | {estimate} | {notes} |
+| testing | {estimate} | {notes} |
+| **Consensus** | **{averaged}** | {range: min-max} |
+
+---
+
+### 📋 Recommended Artifact
+
+Based on expert consensus: **{ADR/Epic/Story/Practice}**
 
-**Scope**: [Small/Medium/Large]
-**Suggested approach**: [Epic with stories / Single story / Quick fix]
-**Estimated effort**: [Low/Medium/High]
+**Reason**: {why this artifact type based on scope and expert recommendations}
+
+**Evidence**:
+- {expert 1} recommended: {artifact type}
+- {expert 2} recommended: {artifact type}
+- Scope assessment: {small/medium/large}
 ```
 
-Present this analysis to the user.
+---
 
-### Step 7: Confirm Interest in Implementing
+### Step 9: Confirm Interest in Implementing
 
 ```xml
 <invoke name="AskUserQuestion">
 <parameter name="questions">[{
-  "question": "Based on this analysis, would you like to proceed with implementation?",
+  "question": "Based on this multi-expert analysis, would you like to proceed with implementation?",
   "header": "Proceed?",
   "multiSelect": false,
   "options": [
-    {"label": "Yes - Create implementation artifacts", "description": "I'll suggest the best artifact type based on scope"},
+    {"label": "Yes - Create implementation artifacts", "description": "I'll create the recommended artifact based on expert consensus"},
     {"label": "Modify approach first", "description": "Let's adjust the plan before creating artifacts"},
-    {"label": "Save analysis to research file", "description": "Append this analysis to the research note for later"},
+    {"label": "Save analysis to research file", "description": "Append Implementation Ideation Report to the research note for later"},
     {"label": "Cancel", "description": "Exit plan mode, no changes"}
   ]
 }]</parameter>
@@ -525,32 +685,24 @@ Present this analysis to the user.
 ```
 
 **If "Modify approach"**: Discuss changes, update analysis, re-ask.
-**If "Save analysis"**: Append the analysis section to the research file, exit plan mode.
+**If "Save analysis"**: Append the Implementation Ideation Report to the research file, exit plan mode.
 **If "Cancel"**: Exit plan mode, done.
-**If "Yes"**: Continue to Step 8.
+**If "Yes"**: Continue to Step 10.
 
-### Step 8: Intelligently Suggest Artifact Type
-
-Based on the research content and analysis, determine the BEST artifact to create:
+---
 
-| Research Type | Suggested Artifact | Indicators |
-|---------------|-------------------|------------|
-| Architecture/technology decision | **ADR** | "Should we use X or Y?", trade-offs, alternatives |
-| Large feature with multiple parts | **Epic + Stories** | 5+ implementation steps, multiple domains |
-| Single focused improvement | **Story** | Clear scope, 1-3 files, can be done in one session |
-| Best practices/patterns | **Practice doc** | "How to do X", guidelines, not feature work |
-| Code quality improvement | **Tech debt item** | Refactoring, cleanup, no user-facing change |
+### Step 10: Intelligently Suggest Artifact Type
 
-Present the recommendation:
+Based on expert consensus, present the recommendation:
 
 ```xml
 <invoke name="AskUserQuestion">
 <parameter name="questions">[{
-  "question": "Based on the scope, I recommend creating: [ARTIFACT TYPE]. What would you like to do?",
+  "question": "Based on expert consensus, I recommend creating: [ARTIFACT TYPE]. What would you like to do?",
   "header": "Create",
   "multiSelect": false,
   "options": [
-    {"label": "[Recommended artifact] (Recommended)", "description": "[Why this is the right choice]"},
+    {"label": "[Recommended artifact] (Recommended)", "description": "[Why experts agreed on this choice]"},
     {"label": "Create ADR instead", "description": "Document this as an architecture decision"},
     {"label": "Create Epic + Stories instead", "description": "Break down into trackable work items"},
     {"label": "Create single Story instead", "description": "Track as a single work item"},
@@ -560,36 +712,48 @@ Present the recommendation:
 </invoke>
 ```
 
-### Step 9: Create Selected Artifact
+---
+
+### Step 11: Create Selected Artifact
 
 **If ADR selected**:
 - Use `/agileflow:adr` command format
 - Reference the research file
-- Include key decisions from analysis
+- Include key decisions from expert analysis
+- Document trade-offs identified by experts
 
 **If Epic + Stories selected**:
 - Create epic in status.json
-- Generate stories based on implementation steps
+- Generate stories based on high-confidence implementation steps
+- Include expert-identified risks as acceptance criteria
 - Reference research in epic
 
 **If Story selected**:
 - Create single story with ACs from implementation steps
+- Include testing requirements from testing expert
 - Reference research
 
 **If Practice doc selected**:
 - Create doc in `docs/02-practices/`
 - Format as guidelines/best practices
+- Include expert-recommended patterns
 
 After creation, exit plan mode and confirm:
 
 ```
 ✅ Created [ARTIFACT] from research "[TOPIC]"
 
+**Multi-Expert Analysis Summary:**
+- Experts consulted: {list}
+- Consensus level: {High/Medium/Low}
+- Key insights preserved: {count}
+
+**Artifacts:**
 - Research: docs/10-research/[filename]
-- Analysis: [appended to research file / separate]
+- Implementation Ideation Report: [appended to research file]
 - [Artifact]: [path or ID]
 
-The implementation plan is now tracked and ready to execute.
+The implementation plan is now tracked and ready to execute with expert-validated guidance.
 ```
 
 ---