pi-skill-search 0.1.0

package/skills/ccg/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: ccg
+description: Claude-Codex-Gemini tri-model orchestration via /ask codex + /ask gemini, then Claude synthesizes results
+---
+
+
+# CCG - Claude-Codex-Gemini Tri-Model Orchestration
+
+CCG routes through the canonical `/ask` skill (`/ask codex` + `/ask gemini`), then Claude synthesizes both outputs into one answer.
+
+Use this when you want parallel external perspectives without launching tmux team workers.
+
+## When to Use
+
+- Backend/analysis + frontend/UI work in one request
+- Code review from multiple perspectives (architecture + design/UX)
+- Cross-validation where Codex and Gemini may disagree
+- Fast advisor-style parallel input without team runtime orchestration
+
+## Requirements
+
+- **Codex CLI**: `npm install -g @openai/codex` (or `@openai/codex`)
+- **Gemini CLI**: `npm install -g @google/gemini-cli`
+- `omc ask` command available
+- If either CLI is unavailable, continue with whichever provider is available and note the limitation
+
+## How It Works
+
+```text
+1. Claude decomposes the request into two advisor prompts:
+   - Codex prompt (analysis/architecture/backend)
+   - Gemini prompt (UX/design/docs/alternatives)
+
+2. Claude runs via CLI (skill nesting not supported):
+   - `omc ask codex "<codex prompt>"`
+   - `omc ask gemini "<gemini prompt>"`
+
+3. Artifacts are written under `.omc/artifacts/ask/`
+
+4. Claude synthesizes both outputs into one final response
+```
+
+## Execution Protocol
+
+When invoked, Claude MUST follow this workflow:
+
+### 1. Decompose Request
+Split the user request into:
+
+- **Codex prompt:** architecture, correctness, backend, risks, test strategy
+- **Gemini prompt:** UX/content clarity, alternatives, edge-case usability, docs polish
+- **Synthesis plan:** how to reconcile conflicts
+
+### 2. Invoke advisors via CLI
+
+> **Note:** Skill nesting (invoking a skill from within an active skill) is not supported in Claude Code. Always use the direct CLI path via Bash tool.
+
+Run both advisors:
+
+```bash
+omc ask codex "<codex prompt>"
+omc ask gemini "<gemini prompt>"
+```
+
+### 3. Collect artifacts
+
+Read latest ask artifacts from:
+
+```text
+.omc/artifacts/ask/codex-*.md
+.omc/artifacts/ask/gemini-*.md
+```
+
+### 4. Synthesize
+
+Return one unified answer with:
+
+- Agreed recommendations
+- Conflicting recommendations (explicitly called out)
+- Chosen final direction + rationale
+- Action checklist
+
+## Fallbacks
+
+If one provider is unavailable:
+
+

package/skills/celery-pipeline/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: celery-pipeline
+description: Distributed task queue, data pipeline orchestration, and workflow automation. Use when setting up asynchronous task processing, job scheduling, or distributed computing with Celery, Redis, or RabbitMQ. Trigger on imports of celery, or mentions of task queue, background job, pipeline, distributed computing, workflow automat.
+---
+# celery-pipeline
+
+Use this skill for distributed task processing and pipeline orchestration.
+
+## Core patterns
+
+- **Task**: `@app.task(bind=True)` → `self.request.id` for tracking.
+- **Chain**: `chain(task1.s(), task2.s(), task3.s())()` for sequential pipeline.
+- **Group**: `group(process.s(item) for item in items)()` for parallel execution.
+- **Chord**: `chord(group(tasks), callback.s())()` for map-reduce pattern.
+- **Monitoring**: `flower --broker=redis://localhost` for web dashboard.
+
+## Rules
+
+- Always set `time_limit` and `soft_time_limit` on tasks.
+- Use `acks_late=True` for idempotent tasks to prevent message loss.
+- Store results in backend (`result_backend='redis://'`) only when needed.
+- Use `task.retry()` for transient failures, not permanent ones.
+
+## Anti-patterns
+
+- Don't pass large objects as arguments — use storage references (S3 path, DB ID).
+- Don't create circular task dependencies — detect and break cycles.
+- Don't ignore `WorkerLostError` — it means OOM or segfault, not normal failure.
+
+

package/skills/cellxgene-census/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: cellxgene-census
+description: Query the CELLxGENE Census (61M+ cells) programmatically. Use when you need expression data across tissues, diseases, or cell types from the largest curated single-cell atlas. Best for population-scale queries, reference atlas comparisons. For analyzing your own data use scanpy or scvi-tools.
+---
+
+# CZ CELLxGENE Census
+
+## Overview
+
+The CZ CELLxGENE Census provides programmatic access to a comprehensive, versioned collection of standardized single-cell genomics data from CZ CELLxGENE Discover. This skill enables efficient querying and analysis of millions of cells across thousands of datasets.
+
+The Census includes:
+- **61+ million cells** from human and mouse
+- **Standardized metadata** (cell types, tissues, diseases, donors)
+- **Raw gene expression** matrices
+- **Pre-calculated embeddings** and statistics
+- **Integration with PyTorch, scanpy, and other analysis tools**
+
+## When to Use This Skill
+
+This skill should be used when:
+- Querying single-cell expression data by cell type, tissue, or disease
+- Exploring available single-cell datasets and metadata
+- Training machine learning models on single-cell data
+- Performing large-scale cross-dataset analyses
+- Integrating Census data with scanpy or other analysis frameworks
+- Computing statistics across millions of cells
+- Accessing pre-calculated embeddings or model predictions
+
+## Core Workflow Patterns
+
+### 1. Opening the Census
+
+Always use the context manager to ensure proper resource cleanup:
+
+```python
+import cellxgene_census
+
+# Open latest stable version
+with cellxgene_census.open_soma() as census:
+    # Work with census data
+
+# Open specific version for reproducibility
+with cellxgene_census.open_soma(census_version="2023-07-25") as census:
+    # Work with census data
+```
+
+**Key points:**
+- Use context manager (`with` statement) for automatic cleanup
+- Specify `census_version` for reproducible analyses
+- Default opens latest "stable" release
+
+# Get summary statistics
+summary = census["census_info"]["summary"].read().concat().to_pandas()
+print(f"Total cells: {summary['total_cell_count'][0]}")
+
+# Get all datasets
+datasets = census["census_info"]["datasets"].read().concat().to_pandas()
+
+# Filter datasets by criteria
+covid_datasets = datasets[datasets["disease"].str.contains("COVID", na=False)]
+```
+
+**Query cell metadata to understand available data:**
+```python
+# Get unique cell types in a tissue
+cell_metadata = cellxgene_census.get_obs(
+    census,
+    "homo_sapiens",
+    value_filter="tissue_general == 'brain' and is_primary_data == True",
+    column_names=["cell_type"]
+)
+unique_cell_types = cell_metadata["cell_type"].unique()
+print(f"Found {len(unique_cell_types)} cell types in brain")
+
+# Count cells by tissue
+tissue_counts = cell_metadata.groupby("tissue_general").size()
+```
+
+**Important:** Always filter for `is_primary_data == True` to avoid counting duplicate cells unless specifically analyzing duplicates.
+
+### 3. Querying Expression Data (Small to Medium Scale)
+
+For queries returning < 100k cells that fit in memory, use `get_anndata()`:
+
+```python
+# Basic query with cell type and tissue filters
+adata = cellxgene_census.get_anndata(
+    census=census,
+    organism="Homo sapiens",  # or "Mus musculus"
+    obs_value_filter="cell_type == 'B cell' and tissue_general == 'lung' and is_primary_data == True",
+    obs_column_names=["assay", "disease", "sex", "donor_id"],
+)
+
+# Query specific genes with multiple filters
+adata = cellxgene_census.get_anndata(
+    census=census,
+    organism="Homo sapiens",
+    var_value_filter="feature_name in ['CD4', 'CD8A', 'CD19', 'FOXP3']",
+    obs_value_filter="cell_type == 'T cell' and disease == 'COVID-19' and is_primary_data == True",
+    obs_column_names=["cell_type", "tissue_general", "donor_id"],
+)
+
+

package/skills/child-pi-spawning/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: child-pi-spawning
+description: Child Pi worker spawning, lifecycle callbacks, and failure modes. Use when debugging worker crashes, scaffold mode behavior, or spawn-time failures.
+---
+
+
+# child-pi-spawning
+
+Child Pi workers are subprocesses spawned by `task-runner.ts` via `runChildPi()` in `child-pi.ts`. Understanding the spawn flow, lifecycle events, and failure modes is essential for debugging worker crashes and "worker blinks" issues.
+
+## Spawn Flow
+
+```
+task-runner.ts (runTeamTask)
+  → runChildPi({ cwd, task, agent, model, skillPaths, signal, onLifecycleEvent })
+    → child-pi.ts (runChildPi main function)
+      → buildPiWorkerArgs() → getPiSpawnCommand() → spawn(command, args, options)
+        → ChildProcess spawned
+        → activeChildProcesses.set(pid, child)
+        → input.onLifecycleEvent({ type: "spawned", pid, ts })
+        → stdout.on("data") → ChildPiLineObserver
+        → stderr.on("data")
+        → child.on("error") → onLifecycleEvent("spawn_error")
+        → child.on("exit") → onLifecycleEvent("exit")
+        → child.on("close") → onLifecycleEvent("close"), settle(result)
+```
+
+### Key components
+
+- **ChildPiLineObserver**: Parses JSON events and stdout lines from child Pi's output stream
+- **Response timeout**: 5-minute timer resets on every stdout/stderr chunk; on timeout → SIGTERM
+- **Final drain**: After last assistant event, waits `finalDrainMs` (default 2s) then SIGTERM
+- **Hard kill**: After `hardKillMs` (default 2s) from SIGTERM, SIGKILL
+- **Active process tracking**: `activeChildProcesses` Map for global cleanup
+
+## Lifecycle Events
+
+`ChildPiLifecycleEvent` interface — emitted via `onLifecycleEvent` callback:
+
+```typescript
+interface ChildPiLifecycleEvent {
+  type: "spawned" | "spawn_error" | "response_timeout" | "final_drain" | "hard_kill" | "exit" | "close";
+  pid?: number;
+  exitCode?: number | null;
+  error?: string;
+  ts: string;
+}
+```
+
+### Event sequence for normal completion:
+
+```
+1. spawned      pid=12345            ← child.pid assigned
+2. [stdout events: message, tool_execution_start, tool_execution_end, message_end...]
+3. final_drain  pid=12345            ← last assistant event received, SIGTERM sent
+4. exit         exitCode=0           ← process exited
+5. close        exitCode=0           ← stdio fully closed
+```
+
+### Event sequence for crash:
+
+```
+1. spawned      pid=12345
+2. spawn_error   error="..."         ← OR →
+3. exit         exitCode=1
+4. close        exitCode=1
+```
+
+### Event sequence for timeout:
+
+```
+1. spawned      pid=12345
+2. [no stdout for 5 min]
+3. response_timeout error="No output for 300000ms"
+4. final_drain  pid=12345
+5. hard_kill    pid=12345            ← SIGKILL after hardKillMs
+6. exit         exitCode=null
+7. close        exitCode=null
+```
+
+## onLifecycleEvent Callback Pattern
+
+The callback bridges child-pi events → events.jsonl:
+
+```typescript

package/skills/cirq/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: cirq
+description: Google quantum computing framework. Use when targeting Google Quantum AI hardware, designing noise-aware circuits, or running quantum characterization experiments. Best for Google hardware, noise modeling, and low-level circuit design. For IBM hardware use qiskit; for quantum ML with autodiff use pennylane; for physics simulations use qutip.
+---
+
+# Cirq - Quantum Computing with Python
+
+Cirq is Google Quantum AI's open-source framework for designing, simulating, and running quantum circuits on quantum computers and simulators.
+
+# Google Quantum Engine
+uv pip install cirq-google
+
+# IonQ
+uv pip install cirq-ionq
+
+# AQT (Alpine Quantum Technologies)
+uv pip install cirq-aqt
+
+# Pasqal
+uv pip install cirq-pasqal
+
+# Azure Quantum
+uv pip install azure-quantum cirq
+```
+
+## Quick Start
+
+### Basic Circuit
+
+```python
+import cirq
+import numpy as np
+
+# Create qubits
+q0, q1 = cirq.LineQubit.range(2)
+
+# Build circuit
+circuit = cirq.Circuit(
+    cirq.H(q0),              # Hadamard on q0
+    cirq.CNOT(q0, q1),       # CNOT with q0 control, q1 target
+    cirq.measure(q0, q1, key='result')
+)
+
+print(circuit)
+
+# Simulate
+simulator = cirq.Simulator()
+result = simulator.run(circuit, repetitions=1000)
+
+# Display results
+print(result.histogram(key='result'))
+```
+
+### Parameterized Circuit
+
+```python
+import sympy
+
+# Define symbolic parameter
+theta = sympy.Symbol('theta')
+
+# Create parameterized circuit
+circuit = cirq.Circuit(
+    cirq.ry(theta)(q0),
+    cirq.measure(q0, key='m')
+)
+
+# Sweep over parameter values
+sweep = cirq.Linspace('theta', start=0, stop=2*np.pi, length=20)
+results = simulator.run_sweep(circuit, params=sweep, repetitions=1000)
+
+# Process results
+for params, result in zip(sweep, results):
+    theta_val = params['theta']
+    counts = result.histogram(key='m')
+    print(f"θ={theta_val:.2f}: {counts}")
+
+## Core Capabilities
+
+### Circuit Building
+For comprehensive information about building quantum circuits, including qubits, gates, operations, custom gates, and circuit patterns, see:
+- **(see docs) - Complete guide to circuit construction
+
+Common topics:
+- Qubit types (GridQubit, LineQubit, NamedQubit)
+- Single and two-qubit gates
+- Parameterized gates and operations
+- Custom gate decomposition
+- Circuit organization with moments
+- Standard circuit patterns (Bell states, GHZ, QFT)
+- Import/export (OpenQASM, JSON)
+- Working with qudits and observables
+
+### Simulation
+For detailed information about simulating quantum circuits, including exact simulation, noisy simulation, parameter sweeps, and the Quantum Virtual Machine, see:
+- **(see docs) - Complete guide to quantum simulation
+
+Common topics:
+- Exact simulation (state vector, density matrix)
+- Sampling and measurements
+- Parameter sweeps (single and multiple parameters)
+- Noisy simulation
+- State histograms and visualization
+- Quantum Virtual Machine (QVM)
+- Expectation values and observables
+- Performance optimization
+
+### Hardware Integration
+For information about running circuits on real quantum hardware from various providers, see:
+- **(see docs) - Complete guide to hardware integration
+
+Supported providers:
+

package/skills/citation-management/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: citation-management
+description: Comprehensive citation management for academic research. Search Google Scholar and PubMed for papers, extract accurate metadata, validate citations, and generate properly formatted BibTeX entries. This skill should be used when you need to find papers, verify citation information, convert DOIs to BibTeX, or ensure reference accuracy in scientific writing.
+---
+
+# Citation Management
+
+## Overview
+
+Manage citations systematically throughout the research and writing process. This skill provides tools and strategies for searching academic databases (Google Scholar, PubMed), extracting accurate metadata from multiple sources (CrossRef, PubMed, arXiv), validating citation information, and generating properly formatted BibTeX entries.
+
+Critical for maintaining citation accuracy, avoiding reference errors, and ensuring reproducible research. Integrates seamlessly with the literature-review skill for comprehensive research workflows.
+
+## When to Use This Skill
+
+Use this skill when:
+- Searching for specific papers on Google Scholar or PubMed
+- Converting DOIs, PMIDs, or arXiv IDs to properly formatted BibTeX
+- Extracting complete metadata for citations (authors, title, journal, year, etc.)
+- Validating existing citations for accuracy
+- Cleaning and formatting BibTeX files
+- Finding highly cited papers in a specific field
+- Verifying that citation information matches the actual publication
+- Building a bibliography for a manuscript or thesis
+- Checking for duplicate citations
+- Ensuring consistent citation formatting
+
+## 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 Workflow
+
+Citation management follows a systematic process:
+
+### Phase 1: Paper Discovery and Search
+
+**Goal**: Find relevant papers using academic search engines.
+
+#### Google Scholar Search
+
+Google Scholar provides the most comprehensive coverage across disciplines.
+
+**Basic Search**:
+```bash
+# Search for papers on a topic
+python scripts/search_google_scholar.py "CRISPR gene editing" \
+  --limit 50 \
+  --output results.json
+
+# Search with year filter
+python scripts/search_google_scholar.py "machine learning protein folding" \
+  --year-start 2020 \
+  --year-end 2024 \
+  --limit 100 \
+  --output ml_proteins.json
+```
+
+**Advanced Search Strategies** (see `(see docs)`):
+- Use quotation marks for exact phrases: `"deep learning"`
+- Search by author: `author:LeCun`
+- Search in title: `intitle:"neural networks"`
+- Exclude terms: `machine learning -survey`
+- Find highly cited papers using sort options
+- Filter by date ranges to get recent work
+
+# Search PubMed
+python scripts/search_pubmed.py "Alzheimer's disease treatment" \
+  --limit 100 \
+  --output alzheimers.json
+
+# Search with MeSH terms and filters
+python scripts/search_pubmed.py \
+  --query '"Alzheimer Disease"[MeSH] AND "Drug Therapy"[MeSH]' \
+  --date-start 2020 \
+  --date-end 2024 \
+  --publication-types "Clinical Trial,Review" \
+
+

package/skills/clinical-decision-support/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: clinical-decision-support
+description: Generate professional clinical decision support (CDS) documents for pharmaceutical and clinical research settings, including patient cohort analyses (biomarker-stratified with outcomes) and treatment recommendation reports (evidence-based guidelines with decision algorithms). Supports GRADE evidence grading, statistical analysis (hazard ratios, survival curves, waterfall plots), biomarker integration, and regulatory compliance. Outputs publication-ready LaTeX/PDF format optimized for drug development, clinical research, and evidence synthesis.
+---
+
+# Clinical Decision Support Documents
+
+## Description
+
+Generate professional clinical decision support (CDS) documents for pharmaceutical companies, clinical researchers, and medical decision-makers. This skill specializes in analytical, evidence-based documents that inform treatment strategies and drug development:
+
+1. **Patient Cohort Analysis** - Biomarker-stratified group analyses with statistical outcome comparisons
+2. **Treatment Recommendation Reports** - Evidence-based clinical guidelines with GRADE grading and decision algorithms
+
+All documents are generated as publication-ready LaTeX/PDF files optimized for pharmaceutical research, regulatory submissions, and clinical guideline development.
+
+**Note:** For individual patient treatment plans at the bedside, use the `treatment-plans` skill instead. This skill focuses on group-level analyses and evidence synthesis for pharmaceutical/research settings.
+
+**Writing Style:** For publication-ready documents targeting medical journals, consult the **venue-templates** skill's `medical_journal_styles.md` for guidance on structured abstracts, evidence language, and CONSORT/STROBE compliance.
+
+## Capabilities
+
+### Document Types
+
+**Patient Cohort Analysis**
+- Biomarker-based patient stratification (molecular subtypes, gene expression, IHC)
+- Molecular subtype classification (e.g., GBM mesenchymal-immune-active vs proneural, breast cancer subtypes)
+- Outcome metrics with statistical analysis (OS, PFS, ORR, DOR, DCR)
+- Statistical comparisons between subgroups (hazard ratios, p-values, 95% CI)
+- Survival analysis with Kaplan-Meier curves and log-rank tests
+- Efficacy tables and waterfall plots
+- Comparative effectiveness analyses
+- Pharmaceutical cohort reporting (trial subgroups, real-world evidence)
+
+**Treatment Recommendation Reports**
+- Evidence-based treatment guidelines for specific disease states
+- Strength of recommendation grading (GRADE system: 1A, 1B, 2A, 2B, 2C)
+
+### Clinical Features
+
+- **Biomarker Integration**: Genomic alterations (mutations, CNV, fusions), gene expression signatures, IHC markers, PD-L1 scoring
+- **Statistical Analysis**: Hazard ratios, p-values, confidence intervals, survival curves, Cox regression, log-rank tests
+- **Evidence Grading**: GRADE system (1A/1B/2A/2B/2C), Oxford CEBM levels, quality of evidence assessment
+- **Clinical Terminology**: SNOMED-CT, LOINC, proper medical nomenclature, trial nomenclature
+- **Regulatory Compliance**: HIPAA de-identification, confidentiality headers, ICH-GCP alignment
+- **Professional Formatting**: Compact 0.5in margins, color-coded recommendations, publication-ready, suitable for regulatory submissions
+
+## Pharmaceutical and Research Use Cases
+
+This skill is specifically designed for pharmaceutical and clinical research applications:
+
+**Drug Development**
+- **Phase 2/3 Trial Analyses**: Biomarker-stratified efficacy and safety analyses
+- **Subgroup Analyses**: Forest plots showing treatment effects across patient subgroups
+- **Companion Diagnostic Development**: Linking biomarkers to drug response
+- **Regulatory Submissions**: IND/NDA documentation with evidence summaries
+
+**Medical Affairs**
+- **KOL Education Materials**: Evidence-based treatment algorithms for thought leaders
+- **Medical Strategy Documents**: Competitive landscape and positioning strategies
+- **Advisory Board Materials**: Cohort analyses and treatment recommendation frameworks
+- **Publication Planning**: Manuscript-ready analyses for peer-reviewed journals
+
+## When to Use
+
+Use this skill when you need to:
+
+- **Analyze patient cohorts** stratified by biomarkers, molecular subtypes, or clinical characteristics
+- **Generate treatment recommendation reports** with evidence grading for clinical guidelines or pharmaceutical strategies
+- **Compare outcomes** between patient subgroups with statistical analysis (survival, response rates, hazard ratios)
+- **Produce pharmaceutical research documents** for drug development, clinical trials, or regulatory submissions
+- **Develop clinical practice guidelines** with GRADE evidence grading and decision algorithms
+- **Document biomarker-guided therapy selection** at the population level (not individual patients)
+- **Synthesize evidence** from multiple trials or real-world data sources
+- **Create clinical decision algorithms** with flowcharts for treatment sequencing
+
+**Do NOT use this skill for:**
+- Individual patient treatment plans (use `treatment-plans` skill)
+- Bedside clinical care documentation (use `treatment-plans` skill)
+- Simple patient-specific treatment protocols (use `treatment-plans` skill)
+
+## Visual Enhancement with Scientific Schematics
+
+**⚠️ MANDATORY: Every clinical decision support document MUST include at least 1-2 AI-generated figures using the scientific-schematics skill.**
+
+This is not optional. Clinical decision documents require clear visual algorithms. Before finalizing any document:
+1. Generate at minimum ONE schematic or diagram (e.g., clinical decision algorithm, treatment pathway, or biomarker stratification tree)
+2. For cohort analyses: include patient flow diagram
+3. For treatment recommendations: include decision flowchart
+
+**How to generate figures:**
+- 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
+
+**How to generate schematics:**
+
+## Document Structure
+
+**CRITICAL REQUIREMENT: All clinical decision support documents MUST begin with a complete executive summary on page 1 that spans the entire first page before any table of contents or detailed sections.**
+
+### Page 1 Executive Summary Structure
+
+The first page of every CDS document should contain ONLY the executive summary with the following components:
+
+**Required Elements (all on page 1):**
+1. **Document Title and Type**
+   - Main title (e.g., "Biomarker-Stratified Cohort Analysis" or "Evidence-Based Treatment Recommendations")
+   - Subtitle with disease state and focus
+   
+2. **Report Information Box** (using colored tcolorbox)
+   - Document type and purpose
+   - Date of analysis/report
+   - Disease state and patient population
+   - Author/institution (if applicable)
+
+