@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/research/deep-research/auto-deep-research-guide/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: auto-deep-research-guide
+description: "Automated deep research tool for thorough topic investigation"
+version: 1.0.0
+author: wentor-community
+source: https://github.com/Auto-Deep-Research/Auto-Deep-Research
+metadata:
+  openclaw:
+    category: "research"
+    subcategory: "deep-research"
+    keywords:
+      - deep-research
+      - automated-investigation
+      - topic-exploration
+      - research-synthesis
+      - iterative-search
+      - knowledge-mapping
+---
+
+# Auto Deep Research Guide
+
+A skill for conducting automated, in-depth research investigations that go beyond surface-level searches to produce comprehensive, well-sourced reports on any academic topic. Based on Auto-Deep-Research (1K stars), this skill implements iterative search-analyze-refine cycles that progressively deepen understanding of a research topic.
+
+## Overview
+
+Deep research differs from simple literature search in its depth and synthesis. Rather than returning a list of papers, deep research produces a structured understanding of a topic: its history, current state, key debates, methodological approaches, open questions, and future directions. This skill automates the iterative process that expert researchers perform manually, cycling through search, reading, analysis, and question refinement until a satisfactory depth of understanding is achieved.
+
+The approach is particularly valuable for researchers entering a new field, preparing comprehensive literature reviews, writing grant proposals that require thorough background knowledge, or advising students on topics adjacent to their own expertise.
+
+## Deep Research Methodology
+
+The automated deep research process follows a structured methodology:
+
+**Phase 1: Topic Decomposition**
+- Parse the initial research question into its core concepts
+- Identify the disciplinary context and relevant subfields
+- Generate a preliminary topic map with major themes and subtopics
+- Formulate 5-10 seed questions that span the topic's breadth
+- Establish depth targets for each subtopic (survey, working knowledge, expert)
+
+**Phase 2: Breadth-First Exploration**
+- Execute seed questions as searches across academic databases
+- Collect and rank results by relevance, citation impact, and recency
+- Read abstracts and identify the most informative sources for each subtopic
+- Build a preliminary bibliography organized by subtopic
+- Identify key authors, institutions, and publication venues for the topic
+
+**Phase 3: Depth-First Investigation**
+- For each subtopic, select the highest-quality sources for detailed analysis
+- Extract key claims, evidence, and methodological details
+- Identify points of consensus and disagreement among sources
+- Note methodological trends and their evolution over time
+- Generate follow-up questions based on gaps in understanding
+
+**Phase 4: Iterative Refinement**
+- Use follow-up questions to drive additional targeted searches
+- Seek out primary sources cited by secondary sources
+- Look for contradictory evidence or alternative perspectives
+- Update the topic map with newly discovered themes
+- Continue until reaching diminishing returns (saturation)
+
+**Phase 5: Synthesis and Reporting**
+- Organize findings into a coherent narrative structure
+- Distinguish between established knowledge, active debates, and speculation
+- Provide evidence quality assessments for key claims
+- Identify the most impactful open questions and research opportunities
+- Generate a structured report with full citations
+
+## Search Strategy Automation
+
+The skill automates several sophisticated search strategies:
+
+**Query Expansion**
+- Use LLMs to generate semantically related query variations
+- Apply field-specific vocabulary and acronym expansion
+- Include both current terminology and historical terms for the same concepts
+- Generate queries in multiple languages when the topic has global research activity
+- Adapt query complexity based on the number of results returned
+
+**Source Triangulation**
+- Search multiple independent databases to avoid source bias
+- Cross-reference findings from different research traditions
+- Check for replication of key findings across independent studies
+- Weight evidence from systematic reviews and meta-analyses more heavily
+- Identify and note where evidence comes from a single research group
+
+**Citation Chain Analysis**
+- Follow backward citations from key papers to find foundational work
+- Follow forward citations to find the latest developments
+- Identify citation clusters indicating distinct research communities
+- Detect bridge papers connecting different research threads
+- Map the chronological evolution of ideas through citation chains
+
+## Report Generation
+
+The final output is a structured research report:
+
+**Report Structure**
+- Executive summary with key findings and confidence levels
+- Historical background tracing the topic's development
+- Current state of knowledge organized by subtopic
+- Methodological landscape describing dominant and emerging approaches
+- Key debates and unresolved questions with evidence for each position
+- Future directions and promising research opportunities
+- Complete bibliography organized by subtopic and relevance
+
+**Quality Indicators**
+- Each claim is annotated with its evidence strength (strong, moderate, limited)
+- Conflicting evidence is presented alongside each other with analysis
+- Gaps in the literature are explicitly flagged
+- The report distinguishes between empirical findings and theoretical arguments
+- Sources are evaluated for potential bias or conflicts of interest
+
+## Customization Options
+
+The deep research process can be customized for different use cases:
+
+**Grant Proposal Background** - Emphasize recent developments, open questions, and potential impact
+**Literature Review** - Emphasize comprehensiveness, systematic coverage, and gap identification
+**New Field Entry** - Emphasize foundational concepts, key terminology, and landmark papers
+**Thesis Background** - Emphasize the specific niche within the broader field and its context
+**Policy Brief** - Emphasize applied findings, real-world implications, and evidence quality
+
+## Integration with Research-Claw
+
+This skill leverages and feeds into other Research-Claw capabilities:
+
+- Uses literature search skills for database queries
+- Feeds results to paper-to-agent skill for detailed paper analysis
+- Outputs structured bibliographies compatible with citation management skills
+- Connects with writing skills for drafting review sections
+- Stores research reports in the local knowledge base for future reference
+
+## Best Practices
+
+- Always start with a clear, well-defined research question
+- Set a time budget and scope limit before beginning to prevent endless exploration
+- Review and redirect the automated process periodically rather than running fully unattended
+- Verify key claims by reading the original sources, not just relying on extracted summaries
+- Save intermediate results at each phase to enable resuming if interrupted
+- Use the generated report as a starting point for human analysis, not as a finished product

package/skills/research/deep-research/cognitive-kernel-guide/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: cognitive-kernel-guide
+description: "Autonomous agent with long-term memory for deep research tasks"
+metadata:
+  openclaw:
+    emoji: "🧠"
+    category: "research"
+    subcategory: "deep-research"
+    keywords: ["Cognitive Kernel", "autonomous agent", "long-term memory", "deep research", "reasoning", "knowledge accumulation"]
+    source: "https://github.com/Cognitive-Kernel/cognitive-kernel"
+---
+
+# Cognitive Kernel Guide
+
+## Overview
+
+Cognitive Kernel is an autonomous agent framework designed for deep research tasks that require sustained reasoning over long horizons. Unlike single-shot agents, it maintains long-term memory across research sessions, builds incremental knowledge representations, and uses structured planning to decompose complex research questions. The system combines web search, paper reading, and code execution with persistent memory for accumulating expertise over time.
+
+## Architecture
+
+### Core Components
+
+```
+Research Question
+      ↓
+  Planning Module (decomposes into subtasks)
+      ↓
+  Execution Engine
+  ├── Web Search Tool
+  ├── Paper Reader Tool
+  ├── Code Executor Tool
+  └── Calculator Tool
+      ↓
+  Working Memory (session state)
+      ↓
+  Long-term Memory (cross-session persistence)
+      ↓
+  Reflection Module (evaluate + revise)
+      ↓
+  Synthesized Answer
+```
+
+### Memory System
+
+| Memory Type | Scope | Purpose |
+|-------------|-------|---------|
+| **Working** | Current task | Active reasoning context |
+| **Episodic** | Cross-session | Past research experiences |
+| **Semantic** | Permanent | Accumulated domain knowledge |
+| **Procedural** | Permanent | Learned research strategies |
+
+## Usage
+
+```python
+from cognitive_kernel import CognitiveKernel
+
+kernel = CognitiveKernel(
+    llm_provider="anthropic",
+    memory_backend="chromadb",
+    tools=["web_search", "paper_reader", "code_executor"],
+)
+
+# Deep research with persistent memory
+result = kernel.research(
+    question="What are the theoretical limits of in-context learning "
+             "in transformer architectures, and how do recent results "
+             "on looped transformers change our understanding?",
+    max_iterations=10,
+    allow_code_execution=True,
+)
+
+print(result.answer)
+print(f"Sources consulted: {len(result.sources)}")
+print(f"Memory entries created: {result.new_memories}")
+```
+
+## Planning and Decomposition
+
+```python
+# The kernel automatically decomposes complex questions
+plan = kernel.plan(
+    "Compare the sample efficiency of model-based vs model-free "
+    "reinforcement learning in robotics manipulation tasks"
+)
+
+for step in plan.steps:
+    print(f"Step {step.id}: {step.description}")
+    print(f"  Tool: {step.tool}")
+    print(f"  Dependencies: {step.depends_on}")
+
+# Execute plan with monitoring
+result = kernel.execute_plan(plan, verbose=True)
+```
+
+## Long-term Memory
+
+```python
+# Memory persists across sessions
+kernel = CognitiveKernel(memory_path="./research_memory")
+
+# First session: research transformers
+kernel.research("What is the attention mechanism in transformers?")
+
+# Later session: builds on prior knowledge automatically
+result = kernel.research(
+    "How does flash attention improve transformer efficiency?"
+)
+# Kernel recalls prior attention mechanism knowledge
+
+# Query accumulated knowledge
+memories = kernel.memory.search(
+    "attention mechanism efficiency",
+    top_k=10,
+)
+for mem in memories:
+    print(f"[{mem.timestamp}] {mem.content[:100]}...")
+```
+
+## Reflection and Self-Correction
+
+```python
+# Built-in reflection after each research step
+kernel = CognitiveKernel(
+    reflection_config={
+        "enabled": True,
+        "frequency": "every_step",   # or "end_only"
+        "criteria": [
+            "factual_accuracy",
+            "completeness",
+            "logical_consistency",
+        ],
+        "max_revisions": 3,
+    }
+)
+
+# Access reflection log
+for entry in result.reflections:
+    print(f"Step {entry.step}: {entry.assessment}")
+    if entry.revision:
+        print(f"  Revised: {entry.revision_reason}")
+```
+
+## Tool Integration
+
+```python
+# Custom tool registration
+from cognitive_kernel import Tool
+
+@Tool(name="arxiv_search", description="Search arXiv papers")
+def search_arxiv(query: str, max_results: int = 10) -> list:
+    import arxiv
+    search = arxiv.Search(query=query, max_results=max_results)
+    return [{"title": r.title, "abstract": r.summary}
+            for r in search.results()]
+
+kernel.register_tool(search_arxiv)
+
+# Code execution for data analysis
+result = kernel.research(
+    "Analyze the publication trend of LLM papers on arXiv "
+    "from 2020 to 2025",
+    allow_code_execution=True,  # enables matplotlib, pandas
+)
+```
+
+## Configuration
+
+```python
+kernel = CognitiveKernel(
+    llm_provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    memory_config={
+        "backend": "chromadb",
+        "embedding_model": "all-MiniLM-L6-v2",
+        "max_memories": 10000,
+        "similarity_threshold": 0.7,
+    },
+    planning_config={
+        "max_depth": 3,          # Subtask nesting depth
+        "max_steps": 20,         # Max steps per plan
+        "allow_replanning": True,
+    },
+    execution_config={
+        "timeout_per_step": 120,   # seconds
+        "max_retries": 2,
+    },
+)
+```
+
+## Use Cases
+
+1. **Multi-session literature reviews**: Build expertise incrementally
+2. **Technical deep dives**: Complex questions requiring code + search
+3. **Research planning**: Decompose and explore research directions
+4. **Knowledge base building**: Accumulate domain expertise over time
+
+## References
+
+- [Cognitive Kernel GitHub](https://github.com/Cognitive-Kernel/cognitive-kernel)
+- [Cognitive Kernel Paper](https://arxiv.org/abs/2409.10925)

package/skills/research/deep-research/corvus-research-guide/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: corvus-research-guide
+description: "Multi-agent AI research with semantic search and citation snowballing"
+metadata:
+  openclaw:
+    emoji: "🐦‍⬛"
+    category: "research"
+    subcategory: "deep-research"
+    keywords: ["Corvus", "multi-agent", "semantic search", "citation snowballing", "research synthesis", "AI research"]
+    source: "https://github.com/corvus-research/corvus"
+---
+
+# Corvus Research Guide
+
+## Overview
+
+Corvus is a multi-agent AI research system that combines semantic search, forward/backward citation snowballing, and synthesis to conduct thorough literature investigations. It iteratively expands search results by following citation chains, identifies research gaps, and generates structured research briefs with full provenance.
+
+## Architecture
+
+### Agent Pipeline
+
+```
+Query → Semantic Search Agent
+           ↓
+     Citation Snowball Agent (forward + backward)
+           ↓
+     Relevance Filter Agent
+           ↓
+     Synthesis Agent
+           ↓
+     Report with Citation Graph
+```
+
+### Key Features
+
+1. **Semantic search**: Uses embedding-based search across Semantic Scholar, OpenAlex
+2. **Citation snowballing**: Iteratively follows references (backward) and citations (forward) to discover related work
+3. **Relevance scoring**: AI-based relevance assessment at each expansion step
+4. **Provenance tracking**: Every claim linked to source papers
+5. **Gap identification**: Identifies under-explored research areas
+
+## Usage
+
+```python
+from corvus import ResearchAgent
+
+agent = ResearchAgent(
+    llm_provider="anthropic",
+    search_backends=["semantic_scholar", "openalex"],
+    max_snowball_depth=2,
+)
+
+# Conduct deep research
+result = agent.research(
+    query="What are the current approaches to continual learning "
+          "in large language models?",
+    initial_papers=20,
+    snowball_per_paper=5,
+)
+
+# Access results
+print(f"Papers found: {len(result.papers)}")
+print(f"Unique clusters: {len(result.clusters)}")
+print(f"\nSynthesis:\n{result.synthesis}")
+
+# Export citation graph
+result.export_graph("citation_network.gexf")
+
+# Export bibliography
+result.export_bibtex("references.bib")
+```
+
+### Snowballing Configuration
+
+```python
+agent = ResearchAgent(
+    snowball_config={
+        "max_depth": 3,           # Citation chain depth
+        "backward_limit": 10,     # References per paper
+        "forward_limit": 10,      # Citations per paper
+        "relevance_threshold": 0.7,  # Min relevance to continue
+        "year_filter": 2020,      # Only papers from 2020+
+    }
+)
+```
+
+### Research Modes
+
+```python
+# Broad survey mode
+result = agent.research(query, mode="survey",
+                        initial_papers=50)
+
+# Focused deep-dive
+result = agent.research(query, mode="focused",
+                        initial_papers=10,
+                        snowball_depth=3)
+
+# Gap analysis
+result = agent.research(query, mode="gap_analysis")
+# Returns underexplored subtopics and suggested directions
+```
+
+## Output Format
+
+```python
+# Structured research brief
+brief = result.generate_brief()
+
+# Contains:
+# - Research question
+# - Methodology (search strategy, databases, snowball depth)
+# - Key themes (clustered by topic)
+# - Timeline (research evolution over time)
+# - Gap analysis (underexplored areas)
+# - Bibliography (all papers with citation counts)
+
+brief.save("research_brief.md")
+```
+
+## Use Cases
+
+1. **Literature reviews**: Comprehensive coverage via snowballing
+2. **Research gap identification**: Find underexplored subtopics
+3. **Trend analysis**: Track research evolution through citation chains
+4. **Grant proposals**: Quick evidence of research need
+
+## References
+
+- [Corvus GitHub](https://github.com/corvus-research/corvus)
+- Wohlin, C. (2014). "Guidelines for snowballing in systematic literature studies." *EASE 2014*.

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

@@ -0,0 +1,213 @@
+---
+name: deep-research-pro
+description: "Multi-source deep research agent with verification and synthesis"
+metadata:
+  openclaw:
+    emoji: "🕵️"
+    category: "research"
+    subcategory: "deep-research"
+    keywords: ["deep research", "multi-source", "source verification", "research agent", "evidence synthesis", "fact checking"]
+    source: "https://github.com/AcademicSkills/deep-research-pro"
+---
+
+# Deep Research Pro
+
+A professional-grade deep research methodology that coordinates multi-source information gathering, cross-reference verification, and structured synthesis. Designed for research tasks that require high confidence in factual accuracy, comprehensive coverage, and traceable evidence chains.
+
+## Overview
+
+Deep Research Pro implements an agent-based methodology where the research process is decomposed into specialized phases: query decomposition, parallel source gathering, cross-reference verification, contradiction resolution, and structured synthesis. Unlike simple search-and-summarize approaches, this skill emphasizes source triangulation, evidence grading, and explicit uncertainty marking.
+
+The methodology is particularly valuable for literature reviews, technology assessments, policy analyses, and any research task where decision-makers need to trust the completeness and accuracy of the findings. Every claim in the final output is linked to at least one verified source, with confidence levels assigned based on the quality and agreement of the evidence.
+
+## Research Agent Architecture
+
+### Phase 1: Query Decomposition
+
+```python
+def decompose_research_query(query: str) -> dict:
+    """
+    Break a complex research question into atomic sub-questions
+    that can be independently investigated.
+
+    Example:
+      Input: "What is the current state of quantum computing for
+              drug discovery, and which companies are leading?"
+
+      Output: {
+        'sub_questions': [
+          'What quantum computing methods are used in drug discovery?',
+          'What are the computational advantages over classical methods?',
+          'Which companies are actively working on quantum drug discovery?',
+          'What drugs or molecules have been studied using quantum methods?',
+          'What are the current limitations and timeline to practical use?'
+        ],
+        'cross_cutting_themes': [
+          'Cost-benefit vs classical computing',
+          'Regulatory considerations',
+          'Academic vs industry progress'
+        ],
+        'source_strategy': {
+          'academic': ['PubMed', 'arXiv', 'Google Scholar'],
+          'industry': ['company websites', 'press releases', 'patent databases'],
+          'grey': ['government reports', 'consulting firm analyses']
+        }
+      }
+    """
+    pass  # Implemented by the agent's reasoning
+```
+
+### Phase 2: Parallel Source Gathering
+
+For each sub-question, gather evidence from multiple independent source types:
+
+| Source Type | Examples | Strengths | Limitations |
+|------------|---------|-----------|-------------|
+| **Peer-reviewed** | Journal articles, conference papers | Rigorous review | Publication lag |
+| **Preprints** | arXiv, bioRxiv, SSRN | Current | Not peer-reviewed |
+| **Institutional** | WHO, NIH, government agencies | Authoritative | May be conservative |
+| **Industry** | Company blogs, press releases | Current, practical | Biased toward own products |
+| **News/Media** | Science journalism, trade publications | Accessible | May oversimplify |
+| **Expert opinion** | Interviews, blog posts, talks | Nuanced | Subjective |
+
+### Phase 3: Source Verification
+
+```python
+def verify_source(source: dict) -> dict:
+    """
+    Assess the credibility and reliability of a single source.
+    """
+    verification = {
+        'source_id': source['id'],
+        'url': source['url'],
+        'checks': {}
+    }
+
+    # Check 1: Author credibility
+    verification['checks']['author'] = {
+        'identifiable': bool(source.get('author')),
+        'affiliated': bool(source.get('institution')),
+        'h_index_available': bool(source.get('h_index')),
+        'domain_expert': source.get('expertise_match', False)
+    }
+
+    # Check 2: Publication venue
+    verification['checks']['venue'] = {
+        'peer_reviewed': source.get('peer_reviewed', False),
+        'impact_factor': source.get('impact_factor'),
+        'known_predatory': source.get('predatory_flag', False)
+    }
+
+    # Check 3: Currency
+    verification['checks']['currency'] = {
+        'publication_year': source.get('year'),
+        'is_recent': source.get('year', 0) >= 2023,
+        'superseded': source.get('retracted', False)
+    }
+
+    # Check 4: Corroboration
+    verification['checks']['corroboration'] = {
+        'cited_by_count': source.get('citation_count', 0),
+        'independent_confirmation': source.get('replicated', False),
+        'consistent_with_consensus': source.get('consensus_aligned', None)
+    }
+
+    # Overall confidence score
+    score = sum([
+        verification['checks']['author']['identifiable'],
+        verification['checks']['venue']['peer_reviewed'],
+        not verification['checks']['venue']['known_predatory'],
+        verification['checks']['currency']['is_recent'],
+        verification['checks']['corroboration']['cited_by_count'] > 5
+    ]) / 5.0
+
+    verification['confidence'] = round(score, 2)
+    verification['grade'] = (
+        'A' if score >= 0.8 else
+        'B' if score >= 0.6 else
+        'C' if score >= 0.4 else 'D'
+    )
+    return verification
+```
+
+## Cross-Reference and Contradiction Resolution
+
+### Triangulation Protocol
+
+For each factual claim in the research output:
+
+1. **Identify the claim**: Extract a specific, testable statement.
+2. **Find supporting sources**: At least 2 independent sources.
+3. **Check for contradicting sources**: Actively search for disconfirming evidence.
+4. **Assess source quality**: Weight evidence by source grade (A > B > C > D).
+5. **Assign confidence level**: Based on evidence agreement and quality.
+
+```
+Confidence Levels:
+  HIGH:   3+ Grade A/B sources agree, no contradictions
+  MEDIUM: 2+ sources agree, minor contradictions or lower-quality sources
+  LOW:    Single source, or significant contradictions among sources
+  UNCERTAIN: Conflicting evidence of similar quality; state both positions
+```
+
+### Contradiction Handling
+
+When sources disagree:
+
+1. Check if the disagreement is due to different definitions, timeframes, or contexts.
+2. Check if one source has been superseded or corrected.
+3. If genuine disagreement exists, present both positions with their evidence.
+4. Note the disagreement explicitly: "Source A (Grade B, 2024) reports X, while Source B (Grade A, 2023) reports Y. The discrepancy may be due to [possible explanation]."
+
+## Structured Synthesis Output
+
+### Report Template
+
+```markdown
+# Research Report: [Topic]
+
+## Executive Summary
+[3-5 sentence overview of key findings with confidence levels]
+
+## Methodology
+- Sub-questions investigated: [list]
+- Sources consulted: [count by type]
+- Date range of sources: [range]
+- Verification standard: [triangulation with Grade B+ sources]
+
+## Findings
+
+### Finding 1: [Title]
+**Confidence: HIGH**
+[Description with inline source references]
+Sources: [Source1 (Grade A)], [Source2 (Grade B)], [Source3 (Grade A)]
+
+### Finding 2: [Title]
+**Confidence: MEDIUM**
+[Description]
+Note: [Source4] reports a conflicting finding. See Contradictions section.
+
+## Contradictions and Uncertainties
+[Explicit list of unresolved disagreements]
+
+## Gaps in Evidence
+[What could not be determined from available sources]
+
+## Source Registry
+[Full list of all sources with grades and verification details]
+```
+
+## Best Practices
+
+- Always search for disconfirming evidence, not just supporting evidence.
+- Never assign HIGH confidence to a claim supported by only one source, regardless of its quality.
+- Mark the date of your research prominently; findings may become outdated.
+- Distinguish between "no evidence found" and "evidence of absence."
+- When synthesizing, prefer systematic reviews and meta-analyses over individual studies.
+- Keep the full source registry even if not all sources are cited in the final report.
+
+## References
+
+- Bates, M. J. (1989). The Design of Browsing and Berrypicking Techniques. *Online Review*, 13(5), 407-424.
+- Booth, A. (2006). Clear and Present Questions: Formulating Questions for Evidence-Based Practice. *Library Hi Tech*, 24(3), 355-368.
+- Grant, M. J. & Booth, A. (2009). A Typology of Reviews. *Health Information and Libraries Journal*, 26(2), 91-108.