@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/biomedical/ncbi-datasets-api/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: ncbi-datasets-api
+description: "Access genomes, genes, and taxonomy data via NCBI Datasets v2 API"
+metadata:
+  openclaw:
+    emoji: "🧬"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["NCBI", "genome data", "gene data", "taxonomy", "RefSeq", "GenBank"]
+    source: "https://www.ncbi.nlm.nih.gov/datasets/"
+---
+
+# NCBI Datasets v2 API
+
+## Overview
+
+NCBI Datasets is the modern API for accessing NCBI's genomic, gene, and taxonomic data — replacing older E-utilities for sequence data retrieval. It provides clean REST endpoints for genome assemblies, gene records, taxonomy trees, and sequence downloads. Covers all organisms in NCBI's databases including RefSeq and GenBank. Free, no authentication required.
+
+## API Endpoints
+
+### Base URL
+
+```
+https://api.ncbi.nlm.nih.gov/datasets/v2
+```
+
+### Genome Data
+
+```bash
+# Search genome assemblies by organism
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/genome/taxon/9606?page_size=5"
+
+# Get assembly by accession
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/genome/accession/GCF_000001405.40"
+
+# Download genome package
+curl -o genome.zip \
+  "https://api.ncbi.nlm.nih.gov/datasets/v2/genome/accession/GCF_000001405.40/download?\
+include_annotation_type=GENOME_FASTA,GENOME_GFF"
+```
+
+### Gene Data
+
+```bash
+# Search genes by symbol
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/gene/symbol/TP53/taxon/human"
+
+# Get gene by NCBI Gene ID
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/gene/id/7157"
+
+# Search genes by keyword
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/gene/search?query=BRCA&taxon=9606&page_size=20"
+
+# Download gene data package
+curl -o gene.zip \
+  "https://api.ncbi.nlm.nih.gov/datasets/v2/gene/id/7157/download?include_annotation_type=FASTA_GENE"
+```
+
+### Taxonomy
+
+```bash
+# Get taxonomy info
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/taxonomy/taxon/9606"
+
+# Search taxonomy by name
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/taxonomy/name_report?taxon_query=Homo+sapiens"
+
+# Get taxonomy tree (subtree)
+curl "https://api.ncbi.nlm.nih.gov/datasets/v2/taxonomy/taxon/9443/subtree"
+```
+
+### Query Parameters
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `page_size` | Results per page | `page_size=20` |
+| `page_token` | Pagination token | From previous response |
+| `include_annotation_type` | Download content | `GENOME_FASTA`, `GENOME_GFF`, `PROT_FASTA` |
+| `filters.assembly_level` | Assembly quality | `complete_genome`, `chromosome` |
+| `filters.refseq_only` | RefSeq assemblies | `true` |
+
+## Response Structure (Gene)
+
+```json
+{
+  "genes": [
+    {
+      "gene": {
+        "gene_id": 7157,
+        "symbol": "TP53",
+        "description": "tumor protein p53",
+        "taxname": "Homo sapiens",
+        "tax_id": 9606,
+        "type": "PROTEIN_CODING",
+        "chromosomes": ["17"],
+        "genomic_ranges": [
+          {
+            "accession_version": "NC_000017.11",
+            "range": [{"begin": 7668402, "end": 7687550, "orientation": "minus"}]
+          }
+        ],
+        "nomenclature": {
+          "symbol": "TP53",
+          "name": "tumor protein p53"
+        },
+        "annotations": [
+          {"release_date": "2024-03-15", "release_name": "GRCh38.p14"}
+        ]
+      }
+    }
+  ]
+}
+```
+
+## Python Usage
+
+```python
+import requests
+import zipfile
+import io
+
+BASE_URL = "https://api.ncbi.nlm.nih.gov/datasets/v2"
+
+
+def search_genes(query: str, taxon: str = "human",
+                 page_size: int = 20) -> list:
+    """Search NCBI genes by keyword."""
+    resp = requests.get(
+        f"{BASE_URL}/gene/search",
+        params={"query": query, "taxon": taxon,
+                "page_size": page_size},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for item in data.get("genes", []):
+        gene = item.get("gene", {})
+        results.append({
+            "gene_id": gene.get("gene_id"),
+            "symbol": gene.get("symbol"),
+            "description": gene.get("description"),
+            "type": gene.get("type"),
+            "chromosomes": gene.get("chromosomes", []),
+            "taxname": gene.get("taxname"),
+        })
+    return results
+
+
+def get_gene(gene_id: int) -> dict:
+    """Get detailed gene information."""
+    resp = requests.get(f"{BASE_URL}/gene/id/{gene_id}")
+    resp.raise_for_status()
+    genes = resp.json().get("genes", [])
+    return genes[0].get("gene", {}) if genes else {}
+
+
+def search_genomes(taxon: str, refseq_only: bool = True,
+                   page_size: int = 10) -> list:
+    """Search genome assemblies by organism."""
+    params = {"page_size": page_size}
+    if refseq_only:
+        params["filters.refseq_only"] = "true"
+
+    resp = requests.get(
+        f"{BASE_URL}/genome/taxon/{taxon}",
+        params=params,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for report in data.get("reports", []):
+        assembly = report.get("assembly_info", {})
+        stats = report.get("assembly_stats", {})
+        results.append({
+            "accession": report.get("accession"),
+            "name": assembly.get("assembly_name"),
+            "level": assembly.get("assembly_level"),
+            "organism": report.get("organism", {}).get("organism_name"),
+            "total_length": stats.get("total_sequence_length"),
+            "contig_n50": stats.get("contig_n50"),
+        })
+    return results
+
+
+# Example: search cancer-related genes
+genes = search_genes("tumor suppressor", taxon="human")
+for g in genes[:5]:
+    print(f"{g['symbol']} (ID: {g['gene_id']}): {g['description']}")
+    print(f"  Type: {g['type']} | Chr: {', '.join(g['chromosomes'])}")
+
+# Example: find reference genomes
+genomes = search_genomes("Mus musculus", refseq_only=True)
+for g in genomes[:3]:
+    print(f"{g['accession']}: {g['name']} ({g['level']})")
+    print(f"  Length: {g['total_length']:,} bp")
+```
+
+## CLI Tool
+
+NCBI also provides a command-line tool:
+
+```bash
+# Install
+curl -o datasets "https://ftp.ncbi.nlm.nih.gov/pub/datasets/command-line/v2/linux-amd64/datasets"
+chmod +x datasets
+
+# Download human genome
+./datasets download genome taxon "Homo sapiens" --reference --include genome
+
+# Download gene data
+./datasets download gene gene-id 7157 --include gene
+```
+
+## References
+
+- [NCBI Datasets](https://www.ncbi.nlm.nih.gov/datasets/)
+- [Datasets API Reference](https://www.ncbi.nlm.nih.gov/datasets/docs/v2/reference-docs/rest-api/)
+- [Datasets CLI](https://www.ncbi.nlm.nih.gov/datasets/docs/v2/download-and-install/)

package/skills/domains/biomedical/quickgo-api/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: quickgo-api
+description: "Browse and search Gene Ontology annotations via the QuickGO API"
+metadata:
+  openclaw:
+    emoji: "🧬"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["Gene Ontology", "GO annotations", "protein function", "QuickGO", "EBI", "functional genomics"]
+    source: "https://www.ebi.ac.uk/QuickGO/"
+---
+
+# QuickGO API
+
+## Overview
+
+QuickGO is the EBI's fast browser and API for Gene Ontology (GO) annotations — the standard framework for describing gene/protein functions across all organisms. It provides access to 800M+ GO annotations covering biological processes, molecular functions, and cellular components. Essential for functional genomics, pathway analysis, and gene set enrichment. Free, no authentication.
+
+## API Endpoints
+
+### Base URL
+
+```
+https://www.ebi.ac.uk/QuickGO/services
+```
+
+### Search GO Terms
+
+```bash
+# Search terms by keyword
+curl "https://www.ebi.ac.uk/QuickGO/services/ontology/go/search?query=apoptosis&limit=20"
+
+# Get term details
+curl "https://www.ebi.ac.uk/QuickGO/services/ontology/go/terms/GO:0006915"
+
+# Get term ancestors/descendants
+curl "https://www.ebi.ac.uk/QuickGO/services/ontology/go/terms/GO:0006915/ancestors"
+curl "https://www.ebi.ac.uk/QuickGO/services/ontology/go/terms/GO:0006915/descendants"
+```
+
+### Query Annotations
+
+```bash
+# Get annotations for a protein (UniProt ID)
+curl "https://www.ebi.ac.uk/QuickGO/services/annotation/search?geneProductId=P04637&limit=50"
+
+# Annotations for a GO term
+curl "https://www.ebi.ac.uk/QuickGO/services/annotation/search?goId=GO:0006915&taxonId=9606&limit=50"
+
+# Filter by evidence code
+curl "https://www.ebi.ac.uk/QuickGO/services/annotation/search?\
+goId=GO:0006915&taxonId=9606&evidence=EXP,IDA,IMP&limit=50"
+
+# Filter by aspect (ontology branch)
+curl "https://www.ebi.ac.uk/QuickGO/services/annotation/search?\
+geneProductId=P04637&aspect=biological_process"
+```
+
+### Download Annotations
+
+```bash
+# Download as TSV
+curl "https://www.ebi.ac.uk/QuickGO/services/annotation/downloadSearch?\
+goId=GO:0006915&taxonId=9606&downloadLimit=10000" -o annotations.tsv
+```
+
+### GO Aspects
+
+| Aspect | Code | Description |
+|--------|------|-------------|
+| Biological Process | `biological_process` | What the gene does |
+| Molecular Function | `molecular_function` | Biochemical activity |
+| Cellular Component | `cellular_component` | Where in the cell |
+
+### Evidence Codes
+
+| Code | Meaning | Reliability |
+|------|---------|-------------|
+| `EXP` | Inferred from Experiment | High |
+| `IDA` | Inferred from Direct Assay | High |
+| `IMP` | Inferred from Mutant Phenotype | High |
+| `IPI` | Inferred from Physical Interaction | Medium |
+| `ISS` | Inferred from Sequence Similarity | Medium |
+| `IEA` | Inferred from Electronic Annotation | Lower |
+
+## Python Usage
+
+```python
+import requests
+
+BASE_URL = "https://www.ebi.ac.uk/QuickGO/services"
+
+
+def search_go_terms(query: str, limit: int = 20) -> list:
+    """Search Gene Ontology terms."""
+    resp = requests.get(
+        f"{BASE_URL}/ontology/go/search",
+        params={"query": query, "limit": limit},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for term in data.get("results", []):
+        results.append({
+            "id": term.get("id"),
+            "name": term.get("name"),
+            "aspect": term.get("aspect"),
+            "definition": term.get("definition", {}).get("text", ""),
+        })
+    return results
+
+
+def get_protein_annotations(uniprot_id: str,
+                            aspect: str = None,
+                            experimental_only: bool = False) -> list:
+    """Get GO annotations for a protein."""
+    params = {"geneProductId": uniprot_id, "limit": 100}
+    if aspect:
+        params["aspect"] = aspect
+    if experimental_only:
+        params["evidence"] = "EXP,IDA,IMP,IPI,IGI,IEP"
+
+    resp = requests.get(
+        f"{BASE_URL}/annotation/search",
+        params=params,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    annotations = []
+    for ann in data.get("results", []):
+        annotations.append({
+            "go_id": ann.get("goId"),
+            "go_name": ann.get("goName"),
+            "aspect": ann.get("goAspect"),
+            "evidence": ann.get("goEvidence"),
+            "reference": ann.get("reference"),
+        })
+    return annotations
+
+
+def get_term_genes(go_id: str, taxon_id: int = 9606,
+                   limit: int = 100) -> list:
+    """Get genes annotated with a GO term."""
+    params = {
+        "goId": go_id,
+        "taxonId": taxon_id,
+        "limit": limit,
+    }
+    resp = requests.get(
+        f"{BASE_URL}/annotation/search",
+        params=params,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    genes = set()
+    for ann in data.get("results", []):
+        genes.add(ann.get("geneProductId", ""))
+    return sorted(genes)
+
+
+# Example: search for apoptosis-related GO terms
+terms = search_go_terms("programmed cell death")
+for t in terms[:5]:
+    print(f"{t['id']}: {t['name']} ({t['aspect']})")
+
+# Example: get p53 protein annotations
+annotations = get_protein_annotations("P04637",
+                                      experimental_only=True)
+for a in annotations[:10]:
+    print(f"  {a['go_id']} {a['go_name']} [{a['evidence']}]")
+```
+
+## References
+
+- [QuickGO](https://www.ebi.ac.uk/QuickGO/)
+- [QuickGO API Docs](https://www.ebi.ac.uk/QuickGO/api)
+- [Gene Ontology](http://geneontology.org/)
+- Binns, D. et al. (2009). "QuickGO: a web-based tool for Gene Ontology searching." *Bioinformatics* 25(22).

package/skills/domains/business/architecture-design-guide/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: architecture-design-guide
+description: "Design principles of form, function, sustainability in architecture"
+metadata:
+  openclaw:
+    emoji: "🏗️"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["architecture", "design", "sustainability", "urban planning", "BIM", "parametric design"]
+    source: "https://github.com/architecture-research/resources"
+---
+
+# Architecture Design Guide
+
+## Overview
+
+Architectural research spans the technical, aesthetic, social, and environmental dimensions of the built environment. From structural engineering and building physics to urban theory and computational design, the discipline demands integration across multiple domains. Academic architecture research increasingly focuses on sustainability, computational methods, and evidence-based design -- areas where rigorous methodology is essential.
+
+This guide covers the core principles that inform architectural research: the interplay of form and function, structural logic, environmental performance, and human experience. It also addresses the computational tools (BIM, parametric design, simulation) that have transformed how architects investigate and validate design decisions.
+
+Whether you are conducting research on building performance, urban morphology, computational design methods, or the social impact of built environments, this guide provides the frameworks and tools to ground your work in established architectural theory and current best practices.
+
+## Fundamental Design Principles
+
+### The Vitruvian Triad (Updated)
+
+```
+Classical framework (Vitruvius, 1st century BCE):
+
+FIRMITAS (Structural Integrity)
+- Structural systems: load paths, material behavior, safety factors
+- Building physics: thermal, acoustic, moisture performance
+- Durability: service life, maintenance, resilience to hazards
+- Modern addition: seismic, wind, and climate resilience
+
+UTILITAS (Function)
+- Program: spatial organization, adjacency requirements
+- Circulation: movement patterns, wayfinding, accessibility
+- Flexibility: adaptability to changing uses over time
+- Modern addition: Universal design, inclusive environments
+
+VENUSTAS (Delight)
+- Proportion, rhythm, scale, materiality
+- Light: natural and artificial, atmosphere, perception
+- Cultural meaning: symbolism, context, identity
+- Modern addition: Biophilic design, multisensory experience
+
+Contemporary additions:
+SUSTAINABILITY (since 1990s)
+- Energy performance, carbon footprint, resource efficiency
+- Lifecycle assessment, circular economy principles
+- Passive strategies, renewable energy integration
+
+SOCIAL RESPONSIBILITY (since 2000s)
+- Equity, community engagement, participatory design
+- Affordable housing, public space, social infrastructure
+- Post-occupancy evaluation, evidence-based design
+```
+
+### Design Thinking Process
+
+| Phase | Activities | Outputs |
+|-------|-----------|---------|
+| Research | Site analysis, precedent study, user research | Brief, program, constraints |
+| Concept | Parti development, diagramming, massing | Concept diagrams, parti models |
+| Schematic Design | Spatial organization, form development | Floor plans, sections, elevations |
+| Design Development | Material selection, systems integration | Detailed drawings, specifications |
+| Documentation | Construction documents, specifications | Building permit package |
+| Post-Occupancy | Performance monitoring, user satisfaction | POE report, design feedback |
+
+## Structural Systems
+
+### Structural Logic for Researchers
+
+```
+Primary structural systems and their research applications:
+
+FRAME STRUCTURES
+- Material: Steel, reinforced concrete, timber
+- Behavior: Moment-resisting frames, braced frames
+- Research topics: Connection design, progressive collapse,
+  fire resistance, seismic performance
+
+SHELL STRUCTURES
+- Types: Vaults, domes, hyperbolic paraboloids
+- Behavior: Membrane forces (compression/tension), minimal bending
+- Research topics: Form-finding, buckling, computational geometry
+- Key method: Thrust network analysis (Block, 2009)
+
+TENSILE STRUCTURES
+- Types: Cable-stayed, membrane, tensegrity
+- Behavior: Pure tension, anticlastic curvature
+- Research topics: Form-finding, wind loading, material durability
+- Key method: Dynamic relaxation, force density method
+
+MASS TIMBER
+- Types: CLT (cross-laminated timber), glulam, mass plywood
+- Behavior: Orthotropic, fire charring provides structural reserve
+- Research topics: Tall timber buildings, connections, moisture
+- Growing field: embodied carbon advantages over concrete/steel
+```
+
+### Structural Analysis Methods
+
+```python
+# Simple structural analysis for research
+# Finite element analysis using Python (for educational purposes)
+
+import numpy as np
+
+def analyze_simply_supported_beam(
+    length: float,       # meters
+    load: float,         # kN/m (uniform distributed load)
+    E: float,            # Young's modulus (GPa)
+    I: float,            # Moment of inertia (mm^4)
+    n_elements: int = 20,
+) -> dict:
+    """
+    Analyze a simply supported beam under uniform load.
+    Returns deflection, moment, and shear diagrams.
+    """
+    x = np.linspace(0, length, n_elements + 1)
+    dx = length / n_elements
+
+    # Analytical solutions
+    # Maximum moment: wL^2/8
+    max_moment = load * length**2 / 8  # kN-m
+
+    # Moment diagram: M(x) = (w*x/2)*(L-x)
+    moment = (load * x / 2) * (length - x)
+
+    # Shear diagram: V(x) = w*(L/2 - x)
+    shear = load * (length / 2 - x)
+
+    # Deflection: delta(x) = (w*x)/(24*E*I) * (L^3 - 2*L*x^2 + x^3)
+    E_pa = E * 1e9  # Convert GPa to Pa
+    I_m4 = I * 1e-12  # Convert mm^4 to m^4
+    w_nm = load * 1e3  # Convert kN/m to N/m
+    deflection = (w_nm * x) / (24 * E_pa * I_m4) * (
+        length**3 - 2 * length * x**2 + x**3
+    )
+    max_deflection = 5 * w_nm * length**4 / (384 * E_pa * I_m4)
+
+    return {
+        "x": x,
+        "moment_kNm": moment,
+        "shear_kN": shear,
+        "deflection_mm": deflection * 1000,
+        "max_moment_kNm": max_moment,
+        "max_deflection_mm": max_deflection * 1000,
+        "span_to_deflection_ratio": length / max_deflection if max_deflection > 0 else float("inf"),
+    }
+```
+
+## Sustainability and Performance
+
+### Building Performance Metrics
+
+| Metric | Unit | Benchmark (Office) | Tool |
+|--------|------|-------------------|------|
+| Energy Use Intensity (EUI) | kWh/m2/yr | < 100 (LEED Gold) | EnergyPlus, IES-VE |
+| Embodied carbon | kgCO2e/m2 | < 500 (RIBA 2030) | One Click LCA, Tally |
+| Operational carbon | kgCO2e/m2/yr | < 20 (net zero target) | EnergyPlus |
+| Daylight factor | % | > 2% in 80% of area | Radiance, DIVA |
+| Thermal comfort | PMV/PPD | PMV -0.5 to +0.5 | CBE Thermal Comfort Tool |
+| Indoor air quality | CO2 ppm | < 800 ppm | CONTAM, CFD |
+
+### Passive Design Strategies
+
+```
+Climate-responsive design strategies:
+
+HOT-ARID CLIMATE
+- Thermal mass: Thick walls absorb daytime heat, release at night
+- Courtyard typology: Microclimate creation, stack ventilation
+- Shading: Deep overhangs, mashrabiya screens
+- Evaporative cooling: Water features, vegetation
+
+HOT-HUMID CLIMATE
+- Cross ventilation: Openings on opposite facades
+- Elevated structures: Raise above ground for air circulation
+- Lightweight construction: Low thermal mass (rapid cooling)
+- Solar shading: Extended roofs, louvers
+
+COLD CLIMATE
+- Compact form: Minimize surface-to-volume ratio
+- Superinsulation: R-40+ walls, R-60+ roof, triple glazing
+- Solar gain: South-facing glazing (N hemisphere), thermal storage
+- Air tightness: < 0.6 ACH50 (Passive House standard)
+
+TEMPERATE CLIMATE
+- Mixed-mode: Natural ventilation + mechanical when needed
+- Balanced glazing: Optimize daylight vs. heat gain/loss
+- Thermal mass: Moderate mass with night purge ventilation
+- Responsive facades: Operable shading, automated louvers
+```
+
+## Computational Design Methods
+
+### Parametric Design with Grasshopper/Python
+
+```python
+# Example: Parametric facade panel generation
+# (Illustrative -- actual implementation uses Grasshopper + RhinoCommon)
+
+import numpy as np
+
+def generate_parametric_facade(
+    width: float,
+    height: float,
+    panel_count_x: int,
+    panel_count_y: int,
+    solar_data: np.ndarray,  # Solar radiation per panel position
+    min_opening: float = 0.1,
+    max_opening: float = 0.8,
+) -> list:
+    """
+    Generate facade panel openings responsive to solar radiation.
+    Higher radiation = smaller opening (reduce heat gain).
+    """
+    panels = []
+    for i in range(panel_count_x):
+        for j in range(panel_count_y):
+            radiation = solar_data[i, j]
+            normalized = (radiation - solar_data.min()) / (solar_data.max() - solar_data.min())
+            # Inverse: more sun = smaller opening
+            opening_ratio = max_opening - normalized * (max_opening - min_opening)
+
+            panels.append({
+                "position": (i * width / panel_count_x, j * height / panel_count_y),
+                "size": (width / panel_count_x, height / panel_count_y),
+                "opening_ratio": round(opening_ratio, 3),
+                "solar_radiation": round(radiation, 1),
+            })
+    return panels
+```
+
+### BIM for Research
+
+```
+Building Information Modeling (BIM) in academic research:
+
+APPLICATIONS:
+1. Performance simulation integration (energy, daylight, acoustics)
+2. Construction logistics and scheduling research
+3. Facility management and digital twin studies
+4. Heritage documentation and conservation
+5. Parametric and generative design exploration
+
+INTEROPERABILITY STANDARDS:
+- IFC (Industry Foundation Classes): Open BIM exchange format
+- gbXML: Energy simulation data exchange
+- COBie: Facility management data
+- CityGML: Urban-scale modeling
+
+RESEARCH TOOLS:
+- Revit + Dynamo: Parametric BIM authoring
+- ArchiCAD + Grasshopper Live Connection
+- BlenderBIM: Open-source BIM (IFC native)
+- OpenStudio + EnergyPlus: Energy simulation
+- Ladybug/Honeybee: Environmental analysis (Grasshopper)
+```
+
+## Best Practices
+
+- **Ground design claims in evidence.** Post-occupancy evaluation and simulation results strengthen design arguments.
+- **Use multiple performance metrics.** Energy, daylight, thermal comfort, and embodied carbon often trade off against each other.
+- **Document design rationale.** The reasoning behind decisions is as important as the decisions themselves.
+- **Engage with architectural theory.** Computational methods are tools, not substitutes for critical thinking about space, meaning, and experience.
+- **Validate simulations against measured data.** Calibrated models are far more credible than uncalibrated predictions.
+- **Consider the full lifecycle.** Embodied carbon in materials can exceed operational carbon over 60 years.
+
+## References
+
+- Ching, F. D. K. (2014). Architecture: Form, Space, and Order, 4th ed. Wiley.
+- [ArchDaily](https://www.archdaily.com/) -- Architectural project database and analysis
+- [Ladybug Tools](https://www.ladybug.tools/) -- Environmental analysis for Grasshopper
+- Block, P. et al. (2017). Beyond Bending: Reimagining Compression Shells. DETAIL.
+- [RIBA 2030 Climate Challenge](https://www.architecture.com/about/policy/climate-action/2030-climate-challenge) -- Carbon benchmarks