pi-skill-search 0.1.0

package/skills/resource-discovery-config/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: resource-discovery-config
+description: pi-crew resource and configuration discovery workflow. Use when changing agents, teams, workflows, skills, resource hooks, config precedence, or project/user overrides.
+---
+
+
+# resource-discovery-config
+
+Use this skill for pi-crew resource/config work.
+
+## Source patterns distilled
+
+- Pi resource loader: `source/pi-mono/packages/coding-agent/src/core/resource-loader.ts`, extension `resources_discover` hook
+- pi-crew discovery: `src/agents/discover-agents.ts`, `src/teams/discover-teams.ts`, `src/workflows/discover-workflows.ts`
+- Config: `src/config/config.ts`, `src/schema/config-schema.ts`, `schema.json`, `docs/resource-formats.md`
+
+## Rules
+
+- Respect discovery precedence: project resources should override user/builtin where supported.
+- Keep built-in resource formats stable and documented.
+- Project config (`.pi/pi-crew.json`) must be sanitized: do not allow dangerous user-only settings such as agent override injection if project trust is lower.
+- Resource paths exposed through Pi hooks must point to package-root resources after build; verify `__dirname` resolution carefully.
+- Avoid dynamic inline imports; keep discovery synchronous or async according to call-site expectations.
+- Validate config with schema and provide actionable errors.
+- When adding new config fields, update defaults, schema, docs, tests, and examples together.
+
+## Anti-patterns
+
+- Resolving package skills to `src/skills` instead of package-root `skills` after publishing.
+- Letting project-local config inject arbitrary global agent overrides.
+- Introducing precedence ambiguity between project/user/builtin resources.
+- Changing resource file syntax without migration notes.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/config-schema-validation.test.ts test/unit/config.test.ts test/unit/extension-api-surface.test.ts test/unit/agent-override-skills.test.ts
+npm test
+npm pack --dry-run
+```
+

package/skills/rowan/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: rowan
+description: Rowan is a cloud-native molecular modeling and medicinal-chemistry workflow platform with a Python API. Use for pKa and macropKa prediction, conformer and tautomer ensembles, docking and analogue docking, protein-ligand cofolding, MSA generation, molecular dynamics, permeability, descriptor workflows, and related small-molecule or protein modeling tasks. Ideal for programmatic batch screening, multi-step chemistry pipelines, and workflows that would otherwise require maintaining local HPC/GPU infrastructure.
+---
+
+# Rowan: Cloud-Native Molecular-Modeling and Drug-Design Workflows
+
+## Overview
+
+Rowan is a cloud-native workflow platform for molecular simulation, medicinal chemistry, and structure-based design. Its Python API exposes a unified interface for small-molecule modeling, property prediction, docking, molecular dynamics, and AI structure workflows.
+
+Use Rowan when you want to run medicinal-chemistry or molecular-design workflows programmatically without maintaining local HPC infrastructure, GPU provisioning, or a collection of separate modeling tools. Rowan handles all infrastructure, result management, and computation scaling.
+
+## When to use Rowan
+
+**Rowan is a good fit for:**
+
+- Quantum chemistry, semiempirical methods, or neural network potentials
+- Batch property prediction (pKa, descriptors, permeability, solubility)
+- Conformer and tautomer ensemble generation
+- Docking workflows (single-ligand, analogue series, pose refinement)
+- Protein-ligand cofolding and MSA generation
+- Multi-step chemistry pipelines (e.g., tautomer search → docking → pose analysis)
+- Batch medicinal-chemistry campaigns where you need consistent, scalable infrastructure
+
+**Rowan is not the right fit for:**
+- Simple molecular I/O (use RDKit directly)
+- Post-HF *ab initio* quantum chemistry or relativistic calculations
+
+## Access and pricing model
+
+Rowan uses a credit-based usage model. All users, including free-tier users, can create API keys and use the Python API.
+
+### Free-tier access
+
+- Access to all Rowan core workflows
+- 20 credits per week
+- 500 signup credits
+
+### Pricing and credit consumption
+
+Credits are consumed according to compute type:
+
+- **CPU**: 1 credit per minute
+- **GPU**: 3 credits per minute
+- **H100/H200 GPU**: 7 credits per minute
+
+Purchased credits are priced per credit and remain valid for up to one year from purchase.
+
+### Typical cost estimates
+
+| Workflow | Typical Runtime | Estimated Credits | Notes |
+|----------|----------------|-------------------|-------|
+| Descriptors | <1 min | 0.5–2 | Lightweight, good for triage |
+| pKa (single transition) | 2–5 min | 2–5 | Depends on molecule size |
+| MacropKa (pH 0–14) | 5–15 min | 5–15 | Broader sampling, higher cost |
+| Conformer search | 3–10 min | 3–10 | Ensemble quality matters |
+| Tautomer search | 2–5 min | 2–5 | Heterocyclic systems |
+| Docking (single ligand) | 5–20 min | 5–20 | Depends on pocket size, refinement |
+| Analogue docking series (10–50 ligands) | 30–120 min | 30–100+ | Shared reference frame |
+| MSA generation | 5–30 min | 5–30 | Sequence length dependent |
+| Protein-ligand cofolding | 15–60 min | 20–50+ | AI structure prediction, GPU-heavy |
+
+## Quick start
+
+```bash
+uv pip install rowan-python
+```
+
+```python
+import rowan
+rowan.api_key = "your_api_key_here"  # or set ROWAN_API_KEY env var
+
+# Submit a descriptors workflow — completes in under a minute
+wf = rowan.submit_descriptors_workflow("CC(=O)Oc1ccccc1C(=O)O", name="aspirin")
+result = wf.result()
+
+print(result.descriptors['MW'])    # 180.16
+print(result.descriptors['SLogP']) # 1.19
+print(result.descriptors['TPSA'])  # 59.44
+```
+
+If that prints without error, you're set up correctly.
+
+## User and webhook management
+
+### Authentication
+
+Set an API key via environment variable (recommended):
+
+```bash
+export ROWAN_API_KEY="your_api_key_here"
+```
+
+Or set directly in Python:
+
+```python
+import rowan
+rowan.api_key = "your_api_key_here"
+```

package/skills/runtime-state-reader/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: runtime-state-reader
+description: Safe read-only navigation of pi-crew run state. Use for inspecting manifests, tasks, events, agents, artifacts, health, and diagnostics without modifying state.
+---
+
+
+# runtime-state-reader
+
+Use this skill when debugging or auditing a pi-crew run.
+
+## Source patterns distilled
+
+- `src/state/types.ts`, `src/state/contracts.ts`, `src/state/state-store.ts`
+- `src/state/event-log.ts`, `src/state/artifact-store.ts`, `src/runtime/crew-agent-records.ts`
+- `src/extension/run-index.ts`, `src/extension/team-tool/status.ts`, `src/extension/team-tool/inspect.ts`
+
+## Rules
+
+- Prefer exported state APIs over direct file parsing: `loadRunManifestById(cwd, runId)`, run index/list helpers, event readers, and agent readers.
+- Treat state as append-mostly/durable. For review and debugging, do not mutate manifests/tasks/events.
+- Validate run IDs and path-derived IDs; never concatenate untrusted path segments outside state helpers.
+- Read events as JSONL; expect partial/corrupt trailing lines in crash scenarios and handle gracefully.
+- Check status contracts before inferring behavior: terminal vs active run/task statuses matter.
+- Agent aggregate records (`agents.json`) and per-agent status files can disagree briefly; prefer the latest loaded run state plus event log for final conclusions.
+- Include exact paths inspected and distinguish direct evidence from inference.
+
+## Common inspection order
+
+1. Load manifest/tasks.
+2. Check run/task statuses and timestamps.
+3. Read recent events.
+4. Read agent records and per-agent output/status if needed.
+5. Inspect artifacts/diagnostics only through contained paths.
+6. Report root cause and smallest safe remediation.
+
+## Verification
+
+For code changes to state readers:
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/run-index.test.ts test/unit/crew-contracts.test.ts test/unit/atomic-write.test.ts
+npm test
+```
+

package/skills/safe-bash/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: safe-bash
+description: Safe shell-command workflow. Use whenever a task may execute shell commands, especially to prefer read-only commands and avoid destructive actions without confirmation.
+---
+
+
+# safe-bash
+
+Use this skill whenever a task may execute shell commands. This skill covers cross-platform shell safety, destructive action confirmation, and Windows-specific patterns.
+
+## Classification
+
+Every shell command is either **read-only** or **mutating**. Always report which it is.
+
+### Read-only commands (safe)
+```bash
+pwd              # print working directory
+ls -la           # list files
+find . -name "*.ts" | head -20        # search without writing
+rg "pattern" --type ts | head -20     # ripgrep without write
+git status       # inspect state
+git log --oneline -5  # recent commits
+git diff --staged    # staged changes
+npm view <pkg>   # query registry (no install)
+npx tsc --noEmit  # typecheck (no write)
+node -e "console.log(process.version)"  # inspect version
+```
+
+### Mutating commands (require confirmation)
+```bash
+npm install      # changes node_modules
+git commit       # creates new commit
+git push         # publishes to remote
+rm -rf <path>    # DESTRUCTIVE
+git reset --hard # rewrites history
+npm publish      # publishes to registry
+```
+
+## Cross-Platform Considerations
+
+### Windows vs Unix paths
+
+```typescript
+// ❌ Never hardcode paths with forward slashes on Windows
+const path = "D:/project/src/file.ts";
+
+// ✅ Use path.join() or Node's path module
+import * as path from "path";
+const filePath = path.join(cwd, "src", "file.ts");
+
+// ✅ Or use forward slashes that work on both
+const filePath = "src/file.ts"; // relative paths work on both
+```
+
+### argv vs cmd /c
+
+```typescript
+// ✅ Preferred on Windows: argv-based execution (no shell)
+import { spawn } from "child_process";
+spawn("node", ["--version"], { stdio: "pipe" });
+
+// ✅ If shell needed: use cmd /c explicitly
+spawn("cmd", ["/c", "dir /b"], { stdio: "pipe" });
+
+// ❌ Don't use cmd /c with complex commands as single string
+spawn("cmd", ["/c", "node --version && npm test"], { stdio: "pipe" });
+```
+
+### Package manager detection
+
+```typescript
+// Detect npm vs pnpm vs yarn
+function detectPackageManager(cwd: string): "npm" | "pnpm" | "yarn" | "unknown" {
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+```
+
+## Heredoc and Quoting Gotchas
+
+### Quoting variables in commands
+
+```bash
+# ❌ Unsafe: variable expansion without quoting

package/skills/scanpy/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: scanpy
+description: Single-cell RNA-seq analysis toolkit. Use when working with scRNA-seq data, AnnData objects, cell clustering, marker gene detection, UMAP/t-SNE embedding, differential expression, or trajectory inference. Trigger on imports of scanpy, sc, anndata, or mentions of single-cell, transcriptomics, cell-type annotation.
+---
+# scanpy
+
+Use this skill for single-cell RNA-seq analysis workflows.
+
+## Core patterns
+
+- **Loading**: `sc.read_10x_mtx()` for 10X data; `sc.read_h5ad()` for AnnData files.
+- **QC**: Filter cells by `n_genes`, `n_counts`, `pct_mito`.
+- **Normalization**: `sc.pp.normalize_total()` → `sc.pp.log1p()` → `sc.pp.highly_variable_genes()`.
+- **PCA + Neighbors**: `sc.tl.pca()` → `sc.pp.neighbors()`.
+- **Clustering**: `sc.tl.leiden()` or `sc.tl.louvain()`.
+- **Embedding**: `sc.tl.umap()` → `sc.pl.umap(color='louvain')`.
+- **Markers**: `sc.tl.rank_genes_groups()` → `sc.pl.rank_genes_groups()`.
+
+## Rules
+
+- Always `.copy()` AnnData before destructive operations.
+- Store raw counts in `adata.raw` before normalization.
+- Use sparse matrices (`scipy.sparse`) for large datasets — don't densify unnecessarily.
+- Batch correction: consider `sc.pp.harmony_integrate()` or `sc.external.pp.bbknn()`.
+
+## Anti-patterns
+
+- Don't run UMAP before computing neighbors graph.
+- Don't interpret marker genes without statistical testing (use `rank_genes_groups` with `method='wilcoxon'`).
+- Don't filter genes before selecting highly variable genes.
+
+

package/skills/scholar-evaluation/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: scholar-evaluation
+description: Systematically evaluate scholarly work using the ScholarEval framework, providing structured assessment across research quality dimensions including problem formulation, methodology, analysis, and writing with quantitative scoring and actionable feedback.
+---
+
+# Scholar Evaluation
+
+## Overview
+
+Apply the ScholarEval framework to systematically evaluate scholarly and research work. This skill provides structured evaluation methodology based on peer-reviewed research assessment criteria, enabling comprehensive analysis of academic papers, research proposals, literature reviews, and scholarly writing across multiple quality dimensions.
+
+## When to Use This Skill
+
+Use this skill when:
+- Evaluating research papers for quality and rigor
+- Assessing literature review comprehensiveness and quality
+- Reviewing research methodology design
+- Scoring data analysis approaches
+- Evaluating scholarly writing and presentation
+- Providing structured feedback on academic work
+- Benchmarking research quality against established criteria
+- Assessing publication readiness for target venues
+- Providing quantitative evaluation to complement qualitative peer review
+
+## Visual Enhancement with Scientific Schematics
+
+**When creating documents with this skill, always consider adding scientific diagrams and schematics to enhance visual communication.**
+
+If your document does not already contain schematics or diagrams:
+- Use the **scientific-schematics** skill to generate AI-powered publication-quality diagrams
+- Simply describe your desired diagram in natural language
+- Nano Banana Pro will automatically generate, review, and refine the schematic
+
+**For new documents:** Scientific schematics should be generated by default to visually represent key concepts, workflows, architectures, or relationships described in the text.
+
+**How to generate schematics:**
+```bash
+python scripts/generate_schematic.py "your diagram description" -o figures/output.png
+```
+
+## Evaluation Workflow
+
+### Step 1: Initial Assessment and Scope Definition
+
+Begin by identifying the type of scholarly work being evaluated and the evaluation scope:
+
+**Work Types:**
+- Full research paper (empirical, theoretical, or review)
+- Research proposal or protocol
+- Literature review (systematic, narrative, or scoping)
+- Thesis or dissertation chapter
+- Conference abstract or short paper
+
+**Evaluation Scope:**
+- Comprehensive (all dimensions)
+- Targeted (specific aspects like methodology or writing)
+- Comparative (benchmarking against other work)
+
+Ask the user to clarify if the scope is ambiguous.
+
+### Step 2: Dimension-Based Evaluation
+
+Systematically evaluate the work across the ScholarEval dimensions. For each applicable dimension, assess quality, identify strengths and weaknesses, and provide scores where appropriate.
+
+Refer to `(see docs)` for detailed criteria and rubrics for each dimension.
+
+**Core Evaluation Dimensions:**
+
+1. **Problem Formulation & Research Questions**
+   - Clarity and specificity of research questions
+   - Theoretical or practical significance
+   - Feasibility and scope appropriateness
+   - Novelty and contribution potential
+
+2. **Literature Review**
+
+### Step 3: Scoring and Rating
+
+For each evaluated dimension, provide:
+
+**Qualitative Assessment:**
+- Key strengths (2-3 specific points)
+- Areas for improvement (2-3 specific points)
+- Critical issues (if any)
+
+**Quantitative Scoring (Optional):**
+Use a 5-point scale where applicable:
+- 5: Excellent - Exemplary quality, publishable in top venues
+- 4: Good - Strong quality with minor improvements needed
+- 3: Adequate - Acceptable quality with notable areas for improvement
+- 2: Needs Improvement - Significant revisions required
+
+### Step 4: Synthesize Overall Assessment
+
+Provide an integrated evaluation summary:
+
+1. **Overall Quality Assessment** - Holistic judgment of the work's scholarly merit
+2. **Major Strengths** - 3-5 key strengths across dimensions
+3. **Critical Weaknesses** - 3-5 primary areas requiring attention
+4. **Priority Recommendations** - Ranked list of improvements by impact
+5. **Publication Readiness** (if applicable) - Assessment of suitability for target venues
+
+### Step 5: Provide Actionable Feedback
+
+Transform evaluation findings into constructive, actionable feedback:
+
+**Feedback Structure:**
+- **Specific** - Reference exact sections, paragraphs, or page numbers
+- **Actionable** - Provide concrete suggestions for improvement
+- **Prioritized** - Rank recommendations by importance and feasibility
+- **Balanced** - Acknowledge strengths while addressing weaknesses
+- **Evidence-based** - Ground feedback in evaluation criteria
+
+**Feedback Format Options:**
+

package/skills/scientific-brainstorming/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: scientific-brainstorming
+description: Creative research ideation and exploration. Use for open-ended brainstorming sessions, exploring interdisciplinary connections, challenging assumptions, or identifying research gaps. Best for early-stage research planning when you do not have specific observations yet. For formulating testable hypotheses from data use hypothesis-generation.
+---
+
+# Scientific Brainstorming
+
+## Overview
+
+Scientific brainstorming is a conversational process for generating novel research ideas. Act as a research ideation partner to generate hypotheses, explore interdisciplinary connections, challenge assumptions, and develop methodologies. Apply this skill for creative scientific problem-solving.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Generating novel research ideas or directions
+- Exploring interdisciplinary connections and analogies
+- Challenging assumptions in existing research frameworks
+- Developing new methodological approaches
+- Identifying research gaps or opportunities
+- Overcoming creative blocks in problem-solving
+- Brainstorming experimental designs or study plans
+
+## Core Principles
+
+When engaging in scientific brainstorming:
+
+1. **Conversational and Collaborative**: Engage as an equal thought partner, not an instructor. Ask questions, build on ideas together, and maintain a natural dialogue.
+
+2. **Intellectually Curious**: Show genuine interest in the scientist's work. Ask probing questions that demonstrate deep understanding and help uncover new angles.
+
+3. **Creatively Challenging**: Push beyond obvious ideas. Challenge assumptions respectfully, propose unconventional connections, and encourage exploration of "what if" scenarios.
+
+4. **Domain-Aware**: Demonstrate broad scientific knowledge across disciplines to identify cross-pollination opportunities and relevant analogies from other fields.
+
+5. **Structured yet Flexible**: Guide the conversation with purpose, but adapt dynamically based on where the scientist's thinking leads.
+
+## Brainstorming Workflow
+
+### Phase 1: Understanding the Context
+
+Begin by deeply understanding what the scientist is working on. This phase establishes the foundation for productive ideation.
+
+**Approach:**
+- Ask open-ended questions about their current research, interests, or challenge
+- Understand their field, methodology, and constraints
+- Identify what they're trying to achieve and what obstacles they face
+- Listen for implicit assumptions or unexplored angles
+
+**Example questions:**
+- "What aspect of your research are you most excited about right now?"
+- "What problem keeps you up at night?"
+- "What assumptions are you making that might be worth questioning?"
+- "Are there any unexpected findings that don't fit your current model?"
+
+**Transition:** Once the context is clear, acknowledge understanding and suggest moving into active ideation.
+
+### Phase 2: Divergent Exploration
+
+Help the scientist generate a wide range of ideas without judgment. The goal is quantity and diversity, not immediate feasibility.
+
+**Techniques to employ:**
+
+1. **Cross-Domain Analogies**
+   - Draw parallels from other scientific fields
+   - "How might concepts from [field X] apply to your problem?"
+   - Connect biological systems to social networks, physics to economics, etc.
+
+2. **Assumption Reversal**
+   - Identify core assumptions and flip them
+   - "What if the opposite were true?"
+   - "What if you had unlimited resources/time/data?"
+
+### Phase 3: Connection Making
+
+Help identify patterns, themes, and unexpected connections among the generated ideas.
+
+**Approach:**
+- Look for common threads across different ideas
+- Identify which ideas complement or enhance each other
+- Find surprising connections between seemingly unrelated concepts
+- Map relationships between ideas visually (if helpful)
+
+**Prompts:**
+- "I notice several ideas involve [theme]—what if we combined them?"
+- "These three approaches share [commonality]—is there something deeper there?"
+- "What's the most unexpected connection you're seeing?"
+
+### Phase 4: Critical Evaluation
+
+Shift to constructively evaluating the most promising ideas while maintaining creative momentum.
+
+**Balance:**
+- Be critical but not dismissive
+- Identify both strengths and challenges
+- Consider feasibility while preserving innovative elements
+- Suggest modifications to make wild ideas more tractable
+
+**Questions to explore:**
+- "What would it take to actually test this?"
+- "What's the first small experiment to run?"
+- "What existing data or tools could be leveraged?"
+- "Who else would need to be involved?"
+- "What's the biggest obstacle, and how might it be overcome?"
+
+### Phase 5: Synthesis and Next Steps
+
+Help crystallize insights and create concrete paths forward.
+
+**Deliverables:**
+- Summarize the most promising directions identified
+- Highlight novel connections or perspectives discovered
+- Suggest immediate next steps (literature search, pilot experiments, collaborations)
+- Capture key questions that emerged for future exploration
+- Identify resources or expertise that would be valuable
+
+**Close with encouragement:**
+
+

package/skills/scientific-critical-thinking/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: scientific-critical-thinking
+description: Evaluate scientific claims and evidence quality. Use for assessing experimental design validity, identifying biases and confounders, applying evidence grading frameworks (GRADE, Cochrane Risk of Bias), or teaching critical analysis. Best for understanding evidence quality, identifying flaws. For formal peer review writing use peer-review.
+---
+
+# Scientific Critical Thinking
+
+## Overview
+
+Critical thinking is a systematic process for evaluating scientific rigor. Assess methodology, experimental design, statistical validity, biases, confounding, and evidence quality using GRADE and Cochrane ROB frameworks. Apply this skill for critical analysis of scientific claims.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Evaluating research methodology and experimental design
+- Assessing statistical validity and evidence quality
+- Identifying biases and confounding in studies
+- Reviewing scientific claims and conclusions
+- Conducting systematic reviews or meta-analyses
+- Applying GRADE or Cochrane risk of bias assessments
+- Providing critical analysis of research papers
+
+## Visual Enhancement with Scientific Schematics
+
+**When creating documents with this skill, always consider adding scientific diagrams and schematics to enhance visual communication.**
+
+If your document does not already contain schematics or diagrams:
+- Use the **scientific-schematics** skill to generate AI-powered publication-quality diagrams
+- Simply describe your desired diagram in natural language
+- Nano Banana Pro will automatically generate, review, and refine the schematic
+
+**For new documents:** Scientific schematics should be generated by default to visually represent key concepts, workflows, architectures, or relationships described in the text.
+
+**How to generate schematics:**
+```bash
+python scripts/generate_schematic.py "your diagram description" -o figures/output.png
+```
+
+## Core Capabilities
+
+### 1. Methodology Critique
+
+Evaluate research methodology for rigor, validity, and potential flaws.
+
+**Apply when:**
+- Reviewing research papers
+- Assessing experimental designs
+- Evaluating study protocols
+- Planning new research
+
+**Evaluation framework:**
+
+1. **Study Design Assessment**
+   - Is the design appropriate for the research question?
+   - Can the design support causal claims being made?
+
+### 2. Bias Detection
+
+Identify and evaluate potential sources of bias that could distort findings.
+
+**Apply when:**
+- Reviewing published research
+- Designing new studies
+- Interpreting conflicting evidence
+- Assessing research quality
+
+**Systematic bias review:**
+
+1. **Cognitive Biases (Researcher)**
+   - **Confirmation bias:** Are only supporting findings highlighted?
+   - **HARKing:** Were hypotheses stated a priori or formed after seeing results?
+
+### 3. Statistical Analysis Evaluation
+
+Critically assess statistical methods, interpretation, and reporting.
+
+**Apply when:**
+- Reviewing quantitative research
+- Evaluating data-driven claims
+- Assessing clinical trial results
+- Reviewing meta-analyses
+
+**Statistical review checklist:**
+
+1. **Sample Size and Power**
+   - Was a priori power analysis conducted?
+   - Is sample adequate for detecting meaningful effects?
+
+### 4. Evidence Quality Assessment
+
+Evaluate the strength and quality of evidence systematically.
+
+**Apply when:**
+- Weighing evidence for decisions
+- Conducting literature reviews
+- Comparing conflicting findings
+- Determining confidence in conclusions
+
+**Evidence evaluation framework:**
+
+1. **Study Design Hierarchy**
+   - Systematic reviews/meta-analyses (highest for intervention effects)
+   - Randomized controlled trials
+
+### 5. Logical Fallacy Identification
+
+Detect and name logical errors in scientific arguments and claims.
+
+**Apply when:**
+- Evaluating scientific claims
+- Reviewing discussion/conclusion sections
+- Assessing popular science communication
+- Identifying flawed reasoning
+
+**Common fallacies in science:**
+
+1. **Causation Fallacies**
+
+