@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/research/automation/rd-agent-guide/SKILL.md

@@ -0,0 +1,246 @@
+---
+name: rd-agent-guide
+description: "Microsoft AI-driven R&D agent for automated data and model development"
+metadata:
+  openclaw:
+    emoji: "🤖"
+    category: "research"
+    subcategory: "automation"
+    keywords: ["r-and-d", "microsoft", "automation", "model-development", "data-science", "experiment-automation"]
+    source: "https://github.com/microsoft/RD-Agent"
+---
+
+# RD-Agent Guide
+
+## Overview
+
+RD-Agent is an open-source AI-powered research and development automation framework developed by Microsoft Research, with over 12,000 stars on GitHub. It automates key steps in the R&D lifecycle -- including hypothesis generation, experiment design, code implementation, and result analysis -- enabling researchers and data scientists to accelerate their development cycles significantly.
+
+The framework implements a closed-loop R&D automation pipeline where an AI agent iteratively proposes hypotheses, implements experiments, evaluates results, and refines its approach based on feedback. This mirrors the scientific method but operates at machine speed, allowing researchers to explore a much larger space of ideas and configurations than would be feasible manually.
+
+RD-Agent is particularly valuable for researchers working in quantitative finance, data science, and machine learning, where the development process involves iterating on feature engineering, model architectures, and hyperparameter configurations. The framework has demonstrated the ability to autonomously develop competitive machine learning models and trading strategies, achieving results comparable to experienced human practitioners.
+
+## Installation and Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/microsoft/RD-Agent.git
+cd RD-Agent
+
+# Install dependencies
+pip install -e .
+
+# Or install from PyPI
+pip install rdagent
+```
+
+### Environment Configuration
+
+```bash
+# LLM configuration (required)
+export OPENAI_API_KEY=$OPENAI_API_KEY
+export CHAT_MODEL=gpt-4o
+
+# Or use Azure OpenAI
+export AZURE_OPENAI_API_KEY=$AZURE_OPENAI_API_KEY
+export AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT
+export AZURE_OPENAI_DEPLOYMENT=$AZURE_OPENAI_DEPLOYMENT
+
+# Docker is required for sandboxed code execution
+# Ensure Docker is installed and running
+docker --version
+```
+
+RD-Agent uses Docker containers to execute generated code safely, ensuring that automatically generated experiments cannot affect the host system. This sandboxed execution is critical for an autonomous agent that writes and runs arbitrary code.
+
+## Core Concepts
+
+### The R&D Loop
+
+RD-Agent implements a continuous improvement loop with four phases:
+
+1. **Proposal**: The agent analyzes the current state and proposes new hypotheses or improvements
+2. **Implementation**: Hypotheses are translated into executable code (feature engineering, model changes, etc.)
+3. **Evaluation**: The implemented changes are executed in a sandbox and results are measured against defined metrics
+4. **Feedback**: Results are analyzed and used to inform the next round of proposals
+
+```python
+from rdagent.core.runner import RDRunner
+from rdagent.scenarios.data_science import DataScienceScenario
+
+# Define the research scenario
+scenario = DataScienceScenario(
+    task="tabular_classification",
+    dataset_path="path/to/dataset.csv",
+    target_column="label",
+    metric="auc",
+)
+
+# Create and run the R&D agent
+runner = RDRunner(
+    scenario=scenario,
+    max_iterations=50,
+    llm_model="gpt-4o",
+)
+
+# Start the autonomous R&D loop
+results = runner.run()
+
+# Review the best solution found
+print(f"Best metric: {results.best_score}")
+print(f"Iterations: {results.total_iterations}")
+print(f"Solutions explored: {results.num_solutions}")
+```
+
+### Scenario Types
+
+RD-Agent supports multiple R&D scenarios out of the box:
+
+#### Data Science / Kaggle Competitions
+
+Automatically engineer features, select models, and tune hyperparameters for tabular data tasks:
+
+```python
+from rdagent.scenarios.data_science import DataScienceScenario
+
+scenario = DataScienceScenario(
+    task="tabular_regression",
+    dataset_path="data/housing.csv",
+    target_column="price",
+    metric="rmse",
+    time_budget_hours=4,
+)
+```
+
+#### Quantitative Finance
+
+Develop and backtest trading factors and strategies:
+
+```python
+from rdagent.scenarios.qlib import QlibScenario
+
+scenario = QlibScenario(
+    market="csi300",
+    task="alpha_factor_mining",
+    backtest_start="2020-01-01",
+    backtest_end="2024-12-31",
+    metric="information_coefficient",
+)
+```
+
+#### Model Development
+
+Iterate on model architectures and training procedures:
+
+```python
+from rdagent.scenarios.model_dev import ModelDevScenario
+
+scenario = ModelDevScenario(
+    task="image_classification",
+    base_model="resnet50",
+    dataset="cifar100",
+    optimization_target="accuracy",
+)
+```
+
+## Advanced Features
+
+### Experiment Tracking and Analysis
+
+RD-Agent maintains detailed logs of all experiments, enabling post-hoc analysis of the R&D process:
+
+```python
+# Access experiment history
+for experiment in results.history:
+    print(f"Iteration {experiment.iteration}:")
+    print(f"  Hypothesis: {experiment.hypothesis}")
+    print(f"  Changes: {experiment.code_changes}")
+    print(f"  Metric: {experiment.score}")
+    print(f"  Analysis: {experiment.feedback}")
+```
+
+### Custom Evaluation Functions
+
+Define custom evaluation metrics for domain-specific research:
+
+```python
+from rdagent.core.evaluation import EvaluationFunction
+
+class CustomMetric(EvaluationFunction):
+    def evaluate(self, predictions, ground_truth, **kwargs):
+        # Your custom metric computation
+        score = compute_domain_specific_metric(predictions, ground_truth)
+        return {
+            "primary_metric": score,
+            "secondary_metrics": {
+                "precision": compute_precision(predictions, ground_truth),
+                "recall": compute_recall(predictions, ground_truth),
+            }
+        }
+
+scenario = DataScienceScenario(
+    evaluation_function=CustomMetric(),
+    # ... other config
+)
+```
+
+### Human-in-the-Loop Mode
+
+Guide the agent with human feedback at key decision points:
+
+```python
+runner = RDRunner(
+    scenario=scenario,
+    human_in_the_loop=True,
+    review_frequency=5,  # Review every 5 iterations
+)
+
+# The agent will pause for human review at specified intervals
+# You can approve, reject, or modify proposed experiments
+```
+
+## Research Applications
+
+### Ablation Studies at Scale
+
+Use RD-Agent to systematically explore which components contribute most to model performance:
+
+```python
+# Define ablation study
+ablation_config = {
+    "base_model": "your_full_model",
+    "components_to_ablate": [
+        "attention_mechanism",
+        "residual_connections",
+        "layer_normalization",
+        "data_augmentation",
+    ],
+    "metric": "accuracy",
+    "num_seeds": 5,  # Run each configuration with 5 seeds
+}
+```
+
+### Automated Feature Engineering
+
+Let the agent discover and implement novel features for your dataset:
+
+```python
+scenario = DataScienceScenario(
+    task="feature_engineering",
+    dataset_path="data/research_data.csv",
+    existing_features=["feature_a", "feature_b", "feature_c"],
+    target="outcome",
+    max_new_features=20,
+)
+```
+
+### Reproducibility
+
+Every experiment run by RD-Agent is fully reproducible. The framework saves the complete experiment specification including code, data transformations, random seeds, and environment details, enabling other researchers to reproduce and build upon the results.
+
+## References
+
+- Repository: https://github.com/microsoft/RD-Agent
+- Microsoft Research blog post: https://www.microsoft.com/en-us/research/project/rd-agent/
+- Qlib quantitative platform: https://github.com/microsoft/qlib
+- Documentation: https://microsoft.github.io/RD-Agent/

package/skills/research/automation/research-paper-orchestrator/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: research-paper-orchestrator
+description: "Master orchestrator coordinating 10 specialized subagents for papers"
+metadata:
+  openclaw:
+    emoji: "🎼"
+    category: "research"
+    subcategory: "automation"
+    keywords: ["research orchestration", "multi-agent", "automated research", "paper production", "workflow automation", "agent coordination"]
+    source: "https://github.com/AcademicSkills/research-paper-orchestrator"
+---
+
+# Research Paper Orchestrator
+
+A master orchestrator skill that coordinates up to 10 specialized subagents to produce comprehensive research outputs. Each subagent handles a distinct phase of the research pipeline -- from literature search through data analysis to manuscript drafting -- while the orchestrator manages sequencing, data flow, quality gates, and synthesis across all components.
+
+## Overview
+
+Producing a research paper involves many distinct tasks: searching literature, reading and summarizing papers, analyzing data, generating figures, writing sections, formatting citations, and checking consistency. Each task requires different expertise and tools. The Research Paper Orchestrator decomposes the full research workflow into specialized roles, assigns each to a dedicated subagent, and coordinates their execution through a defined pipeline with quality checkpoints.
+
+This approach mirrors how research teams operate in practice: a PI sets the direction and checks quality, a literature specialist handles the review, a statistician runs the analysis, a writer drafts the prose, and reviewers provide feedback. The orchestrator plays the PI role, ensuring all components align and meet quality standards before advancing to the next phase.
+
+## Orchestrator Architecture
+
+### The 10 Subagent Roles
+
+```yaml
+subagents:
+  1_planner:
+    role: "Research Planner"
+    responsibility: "Define research question, scope, methodology, and timeline"
+    inputs: ["user topic", "constraints"]
+    outputs: ["research_plan.yaml"]
+
+  2_literature_scout:
+    role: "Literature Scout"
+    responsibility: "Search databases, identify relevant papers, build bibliography"
+    inputs: ["research_plan", "search_queries"]
+    outputs: ["candidate_papers.json", "search_log.md"]
+
+  3_paper_reader:
+    role: "Paper Reader"
+    responsibility: "Read and extract structured summaries from selected papers"
+    inputs: ["candidate_papers"]
+    outputs: ["paper_summaries.json", "evidence_matrix.csv"]
+
+  4_gap_analyzer:
+    role: "Gap Analyzer"
+    responsibility: "Identify research gaps, contradictions, and opportunities"
+    inputs: ["paper_summaries", "evidence_matrix"]
+    outputs: ["gap_analysis.md", "positioning_statement.md"]
+
+  5_data_analyst:
+    role: "Data Analyst"
+    responsibility: "Clean, analyze, and model the research data"
+    inputs: ["research_data", "analysis_plan"]
+    outputs: ["results.json", "statistical_tests.md"]
+
+  6_figure_generator:
+    role: "Figure Generator"
+    responsibility: "Create publication-quality figures and tables"
+    inputs: ["results", "figure_specifications"]
+    outputs: ["figures/", "tables/"]
+
+  7_section_writer:
+    role: "Section Writer"
+    responsibility: "Draft each manuscript section following academic conventions"
+    inputs: ["research_plan", "paper_summaries", "results", "figures"]
+    outputs: ["draft_sections/"]
+
+  8_citation_manager:
+    role: "Citation Manager"
+    responsibility: "Format citations, build bibliography, check reference consistency"
+    inputs: ["draft_sections", "paper_summaries"]
+    outputs: ["references.bib", "citation_report.md"]
+
+  9_consistency_checker:
+    role: "Consistency Checker"
+    responsibility: "Verify internal consistency across sections, figures, and claims"
+    inputs: ["full_draft"]
+    outputs: ["consistency_report.md", "issues.json"]
+
+  10_quality_reviewer:
+    role: "Quality Reviewer"
+    responsibility: "Final quality assessment against journal standards"
+    inputs: ["full_draft", "consistency_report"]
+    outputs: ["review_comments.md", "quality_score"]
+```
+
+### Pipeline Execution Flow
+
+```
+Phase 1: PLANNING
+  [1_planner] → research_plan
+  Quality Gate: Is the plan specific, feasible, and novel?
+
+Phase 2: LITERATURE
+  [2_literature_scout] → candidate_papers
+  [3_paper_reader] → paper_summaries, evidence_matrix
+  [4_gap_analyzer] → gap_analysis, positioning
+  Quality Gate: Is the literature coverage sufficient? Is the gap real?
+
+Phase 3: ANALYSIS
+  [5_data_analyst] → results
+  [6_figure_generator] → figures, tables
+  Quality Gate: Are results statistically sound? Do figures accurately represent data?
+
+Phase 4: WRITING
+  [7_section_writer] → draft_sections
+  [8_citation_manager] → formatted_references
+  Quality Gate: Does each section follow conventions? Are all claims cited?
+
+Phase 5: REVIEW
+  [9_consistency_checker] → consistency_report
+  [10_quality_reviewer] → review_comments
+  Quality Gate: Overall quality score >= threshold?
+
+If any quality gate fails → loop back to the relevant phase.
+```
+
+## Quality Gates
+
+### Gate Definitions
+
+```python
+QUALITY_GATES = {
+    'planning': {
+        'checks': [
+            'Research question is specific and testable',
+            'Scope is achievable within stated constraints',
+            'Methodology matches the research question',
+            'Timeline is realistic'
+        ],
+        'threshold': 4,  # All checks must pass
+        'fallback': 'Return to planner with feedback'
+    },
+    'literature': {
+        'checks': [
+            'Minimum 20 relevant papers identified',
+            'Coverage spans last 5 years',
+            'Multiple databases searched',
+            'Gap analysis identifies a clear contribution',
+            'No critical papers obviously missing'
+        ],
+        'threshold': 4,  # At least 4 of 5 must pass
+        'fallback': 'Expand search with additional queries'
+    },
+    'analysis': {
+        'checks': [
+            'Statistical assumptions verified',
+            'Results are reproducible (seed set)',
+            'Effect sizes reported alongside p-values',
+            'Figures match reported statistics',
+            'Sensitivity analysis performed'
+        ],
+        'threshold': 5,  # All must pass
+        'fallback': 'Data analyst revises analysis'
+    },
+    'writing': {
+        'checks': [
+            'All sections present and complete',
+            'Every factual claim has a citation',
+            'No plagiarized passages',
+            'Consistent terminology throughout',
+            'Abstract accurately reflects content'
+        ],
+        'threshold': 5,
+        'fallback': 'Section writer revises with specific feedback'
+    },
+    'review': {
+        'checks': [
+            'No internal contradictions found',
+            'Figures referenced correctly in text',
+            'References complete and formatted',
+            'Meets target journal formatting requirements',
+            'Overall quality score >= 7/10'
+        ],
+        'threshold': 5,
+        'fallback': 'Loop back to relevant earlier phase'
+    }
+}
+```
+
+## Coordination Protocol
+
+### Inter-Agent Communication
+
+```python
+class OrchestratorMessage:
+    """
+    Standard message format for communication between orchestrator and subagents.
+    """
+    def __init__(self, sender: str, receiver: str, msg_type: str, payload: dict):
+        self.sender = sender       # e.g., "orchestrator", "data_analyst"
+        self.receiver = receiver   # e.g., "figure_generator"
+        self.msg_type = msg_type   # "task", "result", "feedback", "query"
+        self.payload = payload     # task-specific data
+        self.timestamp = None
+        self.status = "pending"    # pending, in_progress, completed, failed
+
+# Example: Orchestrator assigns task to data analyst
+msg = OrchestratorMessage(
+    sender="orchestrator",
+    receiver="data_analyst",
+    msg_type="task",
+    payload={
+        "action": "run_analysis",
+        "data_path": "data/experiment_results.csv",
+        "analysis_plan": "analysis_plan.yaml",
+        "output_format": "json",
+        "deadline": "phase_3_end"
+    }
+)
+```
+
+### Progress Tracking Dashboard
+
+| Phase | Subagent | Status | Output | Quality Gate |
+|-------|----------|--------|--------|-------------|
+| Planning | Planner | Completed | research_plan.yaml | PASSED |
+| Literature | Scout | Completed | 45 papers found | - |
+| Literature | Reader | Completed | 28 papers summarized | - |
+| Literature | Gap Analyzer | Completed | gap_analysis.md | PASSED |
+| Analysis | Data Analyst | In Progress | 60% complete | - |
+| Analysis | Figure Gen | Pending | waiting for results | - |
+| Writing | Section Writer | Pending | - | - |
+| Writing | Citation Mgr | Pending | - | - |
+| Review | Consistency | Pending | - | - |
+| Review | Quality Rev | Pending | - | - |
+
+## Error Handling and Recovery
+
+When a subagent fails or a quality gate is not met:
+
+1. **Isolate the failure**: Determine which specific check failed and why.
+2. **Provide targeted feedback**: Send the subagent specific, actionable instructions for revision.
+3. **Limit retries**: Maximum 3 attempts per subagent before escalating to user.
+4. **Preserve progress**: Never discard completed upstream work when re-running a downstream phase.
+5. **Log everything**: Record all attempts, feedback, and revisions for debugging and improvement.
+
+## Best Practices
+
+- Run the pipeline end-to-end on a small scope first (e.g., 5 papers, 1 analysis) before scaling up.
+- Human-in-the-loop at quality gates produces much better results than fully automated runs.
+- The planner subagent is the most critical; invest extra time in the research plan.
+- Allow the consistency checker to flag issues even if the quality reviewer has not yet run.
+- Save intermediate outputs at each phase for debugging and incremental refinement.
+- The orchestrator should not perform research tasks itself; its role is coordination and quality control.
+
+## References
+
+- Gu, J., et al. (2024). Agent Workflow Memory for Multi-Agent Systems. *arXiv:2409.07429*.
+- Wu, Q., et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. *arXiv:2308.08155*.
+- Hong, S., et al. (2023). MetaGPT: Meta Programming for Multi-Agent Collaborative Framework. *ICLR 2024*.

package/skills/research/deep-research/academic-deep-research/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: academic-deep-research
+description: "Multi-cycle exhaustive investigation framework for academic topics"
+metadata:
+  openclaw:
+    emoji: "🔬"
+    category: "research"
+    subcategory: "deep-research"
+    keywords: ["deep research", "exhaustive search", "multi-cycle investigation", "literature synthesis", "comprehensive review"]
+    source: "https://github.com/AcademicSkills/academic-deep-research"
+---
+
+# Academic Deep Research
+
+A structured multi-cycle investigation framework designed for exhaustive academic research. Unlike single-pass literature searches, this skill implements iterative deepening: each cycle expands the search scope, refines the query based on discovered themes, and synthesizes findings into an increasingly comprehensive knowledge map.
+
+## Overview
+
+Traditional literature searches follow a linear process: define keywords, search databases, screen results, extract data, synthesize. This approach works well for scoping reviews but often misses important connections across subfields, fails to surface grey literature, and stops too early when the obvious sources have been found. Academic Deep Research addresses these limitations through a multi-cycle approach where each cycle builds on the findings of the previous one, progressively expanding the search frontier.
+
+The framework is inspired by systematic review methodology but optimized for speed and breadth rather than exhaustive recall within a single database. It is particularly useful for interdisciplinary research questions, emerging fields where terminology is not yet standardized, and complex topics where important insights may be scattered across diverse literatures.
+
+## The Multi-Cycle Framework
+
+### Cycle Architecture
+
+```
+Cycle 1: BREADTH (Survey Phase)
+  Purpose: Map the landscape, identify major themes and key authors
+  Sources: Google Scholar, Semantic Scholar, review articles
+  Output: Theme taxonomy, key author list, terminology inventory
+  Duration: 2-4 hours
+
+Cycle 2: DEPTH (Focused Phase)
+  Purpose: Deep-dive into each identified theme
+  Sources: Discipline-specific databases (PubMed, IEEE, SSRN, etc.)
+  Output: Annotated bibliography, evidence matrix, gap identification
+  Duration: 4-8 hours
+
+Cycle 3: CONNECTIONS (Synthesis Phase)
+  Purpose: Find cross-theme relationships, contradictions, and gaps
+  Sources: Citation networks, author collaboration networks
+  Output: Conceptual framework, research gap map, contradiction log
+  Duration: 2-4 hours
+
+Cycle 4: FRONTIERS (Currency Phase)
+  Purpose: Capture the latest work and preprints
+  Sources: arXiv, bioRxiv, conference proceedings, working papers
+  Output: Trend analysis, emerging methods, future directions
+  Duration: 1-2 hours
+```
+
+### Cycle Execution Protocol
+
+```python
+class ResearchCycle:
+    """
+    Execute a single cycle of the deep research framework.
+    """
+    def __init__(self, cycle_number: int, focus: str, prior_findings: dict = None):
+        self.cycle = cycle_number
+        self.focus = focus  # 'breadth', 'depth', 'connections', 'frontiers'
+        self.prior = prior_findings or {}
+        self.findings = []
+        self.new_queries = []
+        self.gaps = []
+
+    def generate_queries(self, base_topic: str) -> list:
+        """
+        Generate search queries adapted to the cycle's focus.
+        """
+        if self.focus == 'breadth':
+            return [
+                f'"{base_topic}" review',
+                f'"{base_topic}" survey',
+                f'"{base_topic}" systematic review',
+                f'"{base_topic}" meta-analysis',
+                f'"{base_topic}" overview OR tutorial',
+            ]
+        elif self.focus == 'depth':
+            # Use themes discovered in Cycle 1
+            themes = self.prior.get('themes', [])
+            return [f'"{base_topic}" AND "{theme}"' for theme in themes]
+        elif self.focus == 'connections':
+            # Cross-theme queries
+            themes = self.prior.get('themes', [])
+            queries = []
+            for i, t1 in enumerate(themes):
+                for t2 in themes[i+1:]:
+                    queries.append(f'"{t1}" AND "{t2}"')
+            return queries
+        elif self.focus == 'frontiers':
+            return [
+                f'"{base_topic}" 2025 OR 2026',
+                f'"{base_topic}" preprint',
+                f'"{base_topic}" forthcoming OR "in press"',
+            ]
+        return []
+
+    def evaluate_saturation(self) -> bool:
+        """
+        Determine if additional searching is likely to yield new information.
+        Saturation is reached when >80% of new results are already in the corpus.
+        """
+        if not self.findings:
+            return False
+        new_unique = sum(1 for f in self.findings if not f.get('seen_before'))
+        total = len(self.findings)
+        novelty_rate = new_unique / total if total > 0 else 1.0
+        return novelty_rate < 0.20  # Saturated when <20% new
+```
+
+## Evidence Matrix Construction
+
+### Structuring Findings Across Studies
+
+| Study | Method | Sample | Key Finding | Effect Size | Relevance |
+|-------|--------|--------|-------------|-------------|-----------|
+| Author (Year) | RCT | n=200 | Treatment improved X by 15% | d=0.45 | High |
+| Author (Year) | Survey | n=1500 | Factor Y predicts Z (beta=0.3) | R2=0.12 | Medium |
+| Author (Year) | Qualitative | n=30 | Three themes emerged | N/A | High |
+
+### Tracking Contradictions
+
+```
+Contradiction Log:
+1. Study A (2023) finds positive effect of X on Y (d=0.4, n=200)
+   Study B (2024) finds null effect (d=0.02, n=500)
+   Possible explanations:
+     - Different populations (students vs. professionals)
+     - Different operationalization of X
+     - Study A may have publication bias
+   Resolution needed: moderator analysis or direct replication
+```
+
+## Knowledge Map Generation
+
+### From Findings to Conceptual Framework
+
+After completing all cycles, synthesize findings into a knowledge map:
+
+1. **Core concepts**: The fundamental constructs in the field.
+2. **Established relationships**: Well-replicated findings supported by multiple studies.
+3. **Contested relationships**: Findings with conflicting evidence.
+4. **Unexplored areas**: Logical research questions that no study has addressed.
+5. **Methodological gaps**: Approaches not yet applied to the topic.
+
+```
+Knowledge Map: [Topic]
+
+  Established:
+    A → B (strong evidence, 12 studies, meta-analytic d=0.5)
+    C moderates A → B (4 studies)
+
+  Contested:
+    D → E (3 positive, 2 null, 1 negative; likely moderator)
+
+  Unexplored:
+    F → B (theoretically plausible, no empirical studies)
+    A → B in context G (only studied in context H)
+
+  Methodological Gaps:
+    No longitudinal studies of A → B
+    No experimental manipulation of C
+```
+
+## Output Deliverables
+
+Each deep research session produces:
+
+1. **Executive summary** (500 words): Key findings, gaps, and recommended next steps.
+2. **Annotated bibliography** (20-100 entries): Each source with a 2-3 sentence summary and relevance rating.
+3. **Evidence matrix**: Tabular comparison of studies on key dimensions.
+4. **Knowledge map**: Visual or structured representation of the field's state.
+5. **Research gap inventory**: Prioritized list of unanswered questions.
+6. **Search audit trail**: All queries, databases, dates, and result counts for reproducibility.
+
+## Best Practices
+
+- Start with Cycle 1 even if you think you know the field well. Survey-level searching often reveals adjacent literatures you did not know existed.
+- Keep a running terminology inventory. The same concept may be called different things across subfields.
+- Do not skip the contradiction log. Contested findings often point to the most productive research opportunities.
+- Set a time budget for each cycle. Diminishing returns set in; use the saturation check to know when to move on.
+- Save all search results with timestamps for PRISMA-style reporting if needed later.
+
+## References
+
+- Arksey, H. & O'Malley, L. (2005). Scoping Studies: Towards a Methodological Framework. *International Journal of Social Research Methodology*, 8(1), 19-32.
+- Greenhalgh, T. & Peacock, R. (2005). Effectiveness and Efficiency of Search Methods in Systematic Reviews. *BMJ*, 331(7524), 1064-1065.
+- Wohlin, C. (2014). Guidelines for Snowballing in Systematic Literature Studies. *EASE 2014*.