@wentorai/research-plugins 1.2.2 → 1.3.0

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

@@ -1,254 +0,0 @@
----
-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

@@ -1,190 +0,0 @@
----
-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*.

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

@@ -1,200 +0,0 @@
----
-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)