@wentorai/research-plugins 1.0.0

package/skills/domains/business/strategic-management-guide/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: strategic-management-guide
+description: "Frameworks for strategic planning, resource allocation, and organizational an..."
+metadata:
+  openclaw:
+    emoji: "chess_pawn"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["strategic management", "operations management", "market analysis", "organizational strategy", "resource allocation"]
+    source: "wentor"
+---
+
+# Strategic Management Guide
+
+A research-oriented skill for applying strategic management theories and frameworks to academic case studies, organizational analysis, and business research. Covers classical and contemporary strategy frameworks with rigorous analytical methods.
+
+## Core Strategic Frameworks
+
+### Resource-Based View (RBV)
+
+The RBV framework (Barney, 1991) evaluates competitive advantage through internal resources and capabilities. Apply the VRIO test:
+
+| Criterion | Question | If "No" |
+|-----------|----------|---------|
+| Valuable | Does it exploit opportunity or neutralize threat? | Competitive disadvantage |
+| Rare | Is it controlled by few firms? | Competitive parity |
+| Inimitable | Is it costly to imitate? | Temporary advantage |
+| Organized | Is the firm organized to capture value? | Unrealized advantage |
+
+All four "Yes" answers indicate a **sustained competitive advantage**.
+
+```python
+# VRIO analysis scoring framework
+def vrio_analysis(resources: list[dict]) -> dict:
+    results = {}
+    for r in resources:
+        name = r['name']
+        v, r_score, i, o = r['valuable'], r['rare'], r['inimitable'], r['organized']
+        if not v:
+            results[name] = 'competitive_disadvantage'
+        elif not r_score:
+            results[name] = 'competitive_parity'
+        elif not i:
+            results[name] = 'temporary_advantage'
+        elif not o:
+            results[name] = 'unrealized_advantage'
+        else:
+            results[name] = 'sustained_advantage'
+    return results
+
+# Example usage
+resources = [
+    {'name': 'proprietary_algorithm', 'valuable': True, 'rare': True, 'inimitable': True, 'organized': True},
+    {'name': 'office_space', 'valuable': True, 'rare': False, 'inimitable': False, 'organized': True},
+]
+print(vrio_analysis(resources))
+# {'proprietary_algorithm': 'sustained_advantage', 'office_space': 'competitive_parity'}
+```
+
+## Strategic Planning Process
+
+A structured approach to strategy formulation for research purposes:
+
+### Phase 1: Environmental Scanning
+
+- **External analysis**: PESTEL (Political, Economic, Social, Technological, Environmental, Legal)
+- **Industry analysis**: Porter's Five Forces with quantified metrics
+- **Stakeholder mapping**: Power-interest matrix to prioritize engagement
+
+### Phase 2: Strategy Formulation
+
+Apply Ansoff's Growth Matrix to map strategic options:
+
+```
+                Existing Products    New Products
+Existing Markets  Market Penetration   Product Development
+New Markets       Market Development   Diversification
+```
+
+For academic research, operationalize each quadrant with measurable indicators: market share growth rate, R&D investment ratio, geographic expansion metrics, and portfolio diversification index.
+
+### Phase 3: Strategy Evaluation
+
+Use the SAFe criteria (Johnson, Whittington & Scholes):
+
+1. **Suitability** -- Does the strategy address key strategic issues?
+2. **Acceptability** -- Risk, return, and stakeholder reactions
+3. **Feasibility** -- Resources, capabilities, and timeline
+
+## Balanced Scorecard Implementation
+
+Translate strategy into measurable objectives across four perspectives:
+
+```yaml
+financial:
+  objectives:
+    - "Increase revenue by 15% YoY"
+    - "Reduce cost-to-serve by 10%"
+  kpis: ["revenue_growth_rate", "operating_margin"]
+
+customer:
+  objectives:
+    - "Achieve NPS > 50"
+    - "Reduce churn below 5%"
+  kpis: ["net_promoter_score", "monthly_churn_rate"]
+
+internal_process:
+  objectives:
+    - "Reduce cycle time by 20%"
+    - "Achieve 99.9% uptime"
+  kpis: ["avg_cycle_time_days", "system_uptime_pct"]
+
+learning_growth:
+  objectives:
+    - "Increase training hours per employee"
+    - "Launch 3 new capabilities per quarter"
+  kpis: ["training_hours_per_fte", "new_capabilities_shipped"]
+```
+
+## Quantitative Strategy Tools
+
+### Game Theory Applications
+
+Model competitive interactions using payoff matrices:
+
+```python
+import numpy as np
+
+# Prisoner's Dilemma payoff matrix
+# (Row player payoff, Column player payoff)
+# Strategies: Cooperate (0), Defect (1)
+payoffs_row = np.array([[3, 0],
+                         [5, 1]])
+payoffs_col = np.array([[3, 5],
+                         [0, 1]])
+
+# Find Nash equilibria
+for i in range(2):
+    for j in range(2):
+        row_best = payoffs_row[i, j] >= max(payoffs_row[:, j])
+        col_best = payoffs_col[i, j] >= max(payoffs_col[i, :])
+        if row_best and col_best:
+            print(f"Nash Equilibrium at ({i}, {j})")
+```
+
+### Scenario Planning
+
+Structure scenario analysis with two critical uncertainties on perpendicular axes. Develop four internally consistent narratives, assign probability weights, and compute expected values for key decision variables. This approach enables robust strategy under deep uncertainty.
+
+## References
+
+- Barney, J. (1991). Firm Resources and Sustained Competitive Advantage. *Journal of Management*, 17(1), 99-120.
+- Porter, M. E. (1980). *Competitive Strategy*. Free Press.
+- Kaplan, R. S., & Norton, D. P. (1996). *The Balanced Scorecard*. Harvard Business Press.

package/skills/domains/chemistry/computational-chemistry-guide/SKILL.md

@@ -0,0 +1,266 @@
+---
+name: computational-chemistry-guide
+description: "DFT, molecular simulation, and reaction prediction tools for chemists"
+metadata:
+  openclaw:
+    emoji: "⚗"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["computational chemistry", "DFT", "quantum chemistry", "reaction prediction"]
+    source: "N/A"
+---
+
+# Computational Chemistry Guide
+
+## Overview
+
+Computational chemistry bridges quantum mechanics and practical chemistry, enabling researchers to predict molecular properties, reaction mechanisms, and material behaviors without stepping into a wet lab. From drug design to catalyst optimization, computational methods accelerate discovery by screening thousands of candidates before committing to synthesis.
+
+This guide covers the major computational chemistry paradigms: Density Functional Theory (DFT) for electronic structure calculations, molecular dynamics (MD) for simulating atomic motion, machine learning potentials for scaling up simulations, and reaction prediction tools for retrosynthesis and mechanism elucidation. Each section includes tool recommendations, typical workflows, and code examples.
+
+Whether you are a chemistry PhD student running your first Gaussian calculations, a materials scientist exploring new alloys with VASP, or a medicinal chemist using ML-based property prediction, this skill provides the conceptual framework and practical recipes to get productive quickly.
+
+## Density Functional Theory (DFT)
+
+### When to Use DFT
+
+DFT is the workhorse of quantum chemistry. It provides a good balance of accuracy and computational cost for systems of up to a few hundred atoms.
+
+| Property | DFT Suitability | Typical Error |
+|----------|----------------|---------------|
+| Molecular geometry | Excellent | < 0.02 Angstrom |
+| Vibrational frequencies | Good | 3-5% |
+| Reaction barriers | Good with correction | 2-5 kcal/mol |
+| Band gaps | Fair (tends to underestimate) | 0.5-1.0 eV |
+| Van der Waals interactions | Requires dispersion correction | Varies |
+| Excited states | Fair (TD-DFT) | 0.2-0.5 eV |
+
+### Software Comparison
+
+| Software | License | Strengths | Basis Sets |
+|----------|---------|-----------|-----------|
+| Gaussian | Commercial | Broad functionality, well-documented | Gaussian-type |
+| ORCA | Free (academic) | DFT + wavefunction methods, excellent support | Gaussian-type |
+| VASP | Commercial | Periodic systems, materials science | Plane-wave |
+| Quantum ESPRESSO | Open source | Periodic DFT, phonons | Plane-wave |
+| Psi4 | Open source | Reference implementations, Python API | Gaussian-type |
+| CP2K | Open source | Mixed Gaussian/plane-wave, large systems | Mixed |
+
+### ORCA DFT Workflow Example
+
+```
+# geometry_optimization.inp
+! B3LYP def2-TZVP D3BJ OPT FREQ
+# B3LYP functional, triple-zeta basis, D3 dispersion, optimize + frequencies
+
+%pal
+  nprocs 8
+end
+
+%maxcore 4000
+
+* xyz 0 1
+C  0.000  0.000  0.000
+O  1.200  0.000  0.000
+H -0.500  0.866  0.000
+H -0.500 -0.866  0.000
+*
+```
+
+Run with:
+```bash
+orca geometry_optimization.inp > geometry_optimization.out
+```
+
+### Analyzing DFT Results with Python
+
+```python
+from ase.io import read
+from ase.visualize import view
+
+# Read optimized geometry from ORCA output
+atoms = read('geometry_optimization.xyz')
+
+# Extract energies from output file
+import re
+
+with open('geometry_optimization.out') as f:
+    text = f.read()
+
+# Total energy
+energy = float(re.search(r'FINAL SINGLE POINT ENERGY\s+([-\d.]+)', text).group(1))
+print(f"Total energy: {energy:.6f} Hartree")
+print(f"Total energy: {energy * 627.509:.2f} kcal/mol")
+
+# Thermochemistry
+gibbs_match = re.search(r'Final Gibbs free energy\s+\.\.\.\s+([-\d.]+)', text)
+if gibbs_match:
+    gibbs = float(gibbs_match.group(1))
+    print(f"Gibbs free energy: {gibbs:.6f} Hartree")
+```
+
+## Molecular Dynamics Simulations
+
+### MD Pipeline
+
+```
+Initial Structure (.pdb/.mol2)
+    |
+    v
+[Parameterization] --> Force field assignment (AMBER, CHARMM, OPLS)
+    |
+    v
+[Solvation] --> Add solvent box, ions
+    |
+    v
+[Minimization] --> Energy minimization (steepest descent)
+    |
+    v
+[Equilibration] --> NVT then NPT ensemble (100 ps - 1 ns)
+    |
+    v
+[Production] --> NPT ensemble (10 ns - microseconds)
+    |
+    v
+[Analysis] --> RMSD, RMSF, hydrogen bonds, free energy
+```
+
+### OpenMM Quick Start
+
+```python
+from openmm.app import *
+from openmm import *
+from openmm.unit import *
+
+# Load structure
+pdb = PDBFile('protein.pdb')
+forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
+
+# Create system
+modeller = Modeller(pdb.topology, pdb.positions)
+modeller.addSolvent(forcefield, model='tip3p', padding=1.0*nanometers)
+
+system = forcefield.createSystem(
+    modeller.topology,
+    nonbondedMethod=PME,
+    nonbondedCutoff=1.0*nanometers,
+    constraints=HBonds
+)
+
+# Set up simulation
+integrator = LangevinMiddleIntegrator(300*kelvin, 1/picosecond, 0.004*picoseconds)
+simulation = Simulation(modeller.topology, system, integrator)
+simulation.context.setPositions(modeller.positions)
+
+# Minimize
+simulation.minimizeEnergy()
+
+# Run production (10 ns)
+simulation.reporters.append(DCDReporter('trajectory.dcd', 1000))
+simulation.reporters.append(
+    StateDataReporter('log.csv', 1000, step=True,
+                      potentialEnergy=True, temperature=True)
+)
+simulation.step(2500000)  # 10 ns at 4 fs timestep
+```
+
+## Machine Learning in Computational Chemistry
+
+### ML Potential Energy Surfaces
+
+Machine learning potentials achieve near-DFT accuracy at a fraction of the cost:
+
+| Method | Speed vs DFT | Accuracy | Training Data |
+|--------|-------------|----------|---------------|
+| ANI | 1000x faster | ~1 kcal/mol | Pre-trained |
+| SchNet | 100-1000x | ~1 kcal/mol | 1K-100K configs |
+| MACE | 100-1000x | < 1 kcal/mol | 1K-100K configs |
+| GemNet | 100-1000x | < 1 kcal/mol | 1K-100K configs |
+
+### Property Prediction with RDKit
+
+```python
+from rdkit import Chem
+from rdkit.Chem import Descriptors, AllChem
+import numpy as np
+
+def compute_molecular_features(smiles):
+    """Compute molecular descriptors from SMILES string."""
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+
+    features = {
+        'molecular_weight': Descriptors.MolWt(mol),
+        'logp': Descriptors.MolLogP(mol),
+        'hbd': Descriptors.NumHDonors(mol),
+        'hba': Descriptors.NumHAcceptors(mol),
+        'tpsa': Descriptors.TPSA(mol),
+        'rotatable_bonds': Descriptors.NumRotatableBonds(mol),
+        'aromatic_rings': Descriptors.NumAromaticRings(mol),
+        'heavy_atoms': mol.GetNumHeavyAtoms(),
+    }
+
+    # Morgan fingerprint (ECFP4)
+    fp = AllChem.GetMorganFingerprintAsBitVect(mol, 2, nBits=2048)
+    features['fingerprint'] = np.array(fp)
+
+    return features
+
+# Lipinski's Rule of Five check
+def check_druglikeness(smiles):
+    feats = compute_molecular_features(smiles)
+    if feats is None:
+        return False
+    return (feats['molecular_weight'] <= 500 and
+            feats['logp'] <= 5 and
+            feats['hbd'] <= 5 and
+            feats['hba'] <= 10)
+```
+
+## Reaction Prediction
+
+### Retrosynthesis Tools
+
+| Tool | Approach | Access |
+|------|----------|--------|
+| ASKCOS | Template-based + ML | MIT, web interface |
+| IBM RXN | Transformer-based | Free API |
+| Syntheseus | Multi-model framework | Open source |
+| RetroTRAE | Transformer | Open source |
+
+### Using RDKit for Reaction Processing
+
+```python
+from rdkit.Chem import AllChem, Draw
+
+# Define a reaction (Suzuki coupling)
+rxn_smarts = '[c:1][B](O)O.[c:2][Cl]>>[c:1][c:2]'
+rxn = AllChem.ReactionFromSmarts(rxn_smarts)
+
+# Apply reaction
+reactant1 = Chem.MolFromSmiles('c1ccc(B(O)O)cc1')  # Phenylboronic acid
+reactant2 = Chem.MolFromSmiles('c1ccc(Cl)cc1')      # Chlorobenzene
+
+products = rxn.RunReactants((reactant1, reactant2))
+for product_set in products:
+    for product in product_set:
+        print(Chem.MolToSmiles(product))  # Biphenyl
+```
+
+## Best Practices
+
+- **Benchmark your method.** Always validate your computational protocol against known experimental data before applying it to new systems.
+- **Use appropriate levels of theory.** Do not use MP2 when B3LYP suffices, and do not use B3LYP when you need CCSD(T) accuracy.
+- **Include dispersion corrections.** D3BJ or D4 corrections are essential for non-covalent interactions.
+- **Check convergence.** Verify that geometry optimizations, SCF calculations, and MD simulations have properly converged.
+- **Report computational details completely.** Functional, basis set, dispersion correction, solvent model, and software version should all be stated.
+- **Archive your input/output files.** Computational chemistry is reproducible only if all parameters are preserved.
+
+## References
+
+- [ORCA Documentation](https://www.faccts.de/docs/orca/6.0/manual/) -- Free quantum chemistry software
+- [OpenMM Documentation](http://docs.openmm.org/) -- GPU-accelerated molecular dynamics
+- [RDKit Documentation](https://www.rdkit.org/docs/) -- Cheminformatics toolkit
+- [Psi4 Documentation](https://psicode.org/) -- Open-source quantum chemistry
+- [A Hitchhiker's Guide to DFT](https://onlinelibrary.wiley.com/doi/book/10.1002/3527600043) -- Koch and Holthausen

package/skills/domains/chemistry/retrosynthesis-guide/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: retrosynthesis-guide
+description: "Retrosynthetic analysis and computational reaction prediction"
+metadata:
+  openclaw:
+    emoji: "flask"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["retrosynthesis", "reaction prediction", "organic chemistry", "computational chemistry"]
+    source: "wentor-research-plugins"
+---
+
+# Retrosynthesis Guide
+
+Plan synthetic routes for target molecules using retrosynthetic analysis principles and computational tools, from Corey's logic to modern AI-driven approaches.
+
+## What Is Retrosynthesis?
+
+Retrosynthesis works backward from a target molecule to identify simpler, commercially available precursors:
+
+```
+Target Molecule (TM)
+       |
+   [Disconnection 1] ← Apply transform (reverse of a known reaction)
+       |
+   Synthon A + Synthon B
+       |            |
+   [Available]  [Disconnection 2]
+                    |
+                Synthon C + Synthon D
+                    |            |
+                [Available]  [Available]
+```
+
+Key terminology:
+- **Target Molecule (TM)**: The molecule you want to synthesize
+- **Synthon**: Idealized reactive fragment from a disconnection
+- **Synthetic Equivalent**: Real reagent corresponding to a synthon
+- **Transform**: Reverse of a chemical reaction (retro-reaction)
+- **FGI (Functional Group Interconversion)**: Convert one functional group to another to enable a disconnection
+
+## Corey's Retrosynthetic Strategies
+
+### Strategic Bond Disconnections
+
+| Strategy | Description | When to Use |
+|----------|-------------|------------|
+| **FGI** | Convert functional groups to enable disconnections | When direct disconnection is not possible |
+| **C-C Bond disconnection** | Break carbon-carbon bonds | Building the carbon skeleton |
+| **C-X Bond disconnection** | Break carbon-heteroatom bonds | Functional group installation |
+| **Ring disconnection** | Open rings to identify acyclic precursors | Cyclic target molecules |
+| **Symmetry exploitation** | Use molecular symmetry to simplify analysis | Symmetric molecules |
+| **Convergent synthesis** | Combine two complex fragments late | Minimize linear step count |
+
+### Common Disconnection Patterns
+
+```
+# Alcohol (C-OH) → Carbonyl reduction
+R-CH(OH)-R' ⟹ R-CO-R' + NaBH4/LiAlH4
+
+# Amine (C-N) → Reductive amination
+R-CH2-NH-R' ⟹ R-CHO + R'-NH2
+
+# C-C Bond (aldol) → Aldol retro
+R-CH(OH)-CH2-CO-R' ⟹ R-CHO + CH3-CO-R'
+
+# C-C Bond (Grignard) → Grignard retro
+R-CH(OH)-R' ⟹ R-CHO + R'-MgBr
+
+# Ester (C-O) → Fischer esterification retro
+R-COO-R' ⟹ R-COOH + R'-OH
+
+# Amide (C-N) → Amide coupling retro
+R-CO-NH-R' ⟹ R-COOH + R'-NH2
+
+# Diels-Alder → Retro Diels-Alder
+Cyclohexene derivative ⟹ Diene + Dienophile
+
+# Wittig → Retro Wittig
+R-CH=CH-R' ⟹ R-CHO + R'-CH2-PPh3
+```
+
+## Computational Retrosynthesis Tools
+
+### Tool Comparison
+
+| Tool | Developer | Method | Access |
+|------|-----------|--------|--------|
+| ASKCOS | MIT | Template-based + neural | Free (askcos.mit.edu) |
+| IBM RXN | IBM Research | Transformer seq2seq | Free (rxn.res.ibm.com) |
+| Reaxys | Elsevier | Database-backed | Subscription |
+| SciFinder-n | CAS | Database + AI | Subscription |
+| Spaya | Iktos | Graph neural network | Commercial |
+| AiZynthFinder | AstraZeneca | Monte Carlo tree search | Open source |
+
+### Using ASKCOS
+
+```python
+import requests
+
+# ASKCOS API for retrosynthetic planning
+# (requires running ASKCOS locally or using the hosted version)
+
+target_smiles = "CC(=O)Oc1ccccc1C(=O)O"  # Aspirin
+
+# One-step retrosynthesis
+response = requests.post(
+    "https://askcos.mit.edu/api/retro/",
+    json={
+        "smiles": target_smiles,
+        "num_results": 10,
+        "max_depth": 5
+    }
+)
+
+results = response.json()
+for i, result in enumerate(results.get("precursors", [])[:5]):
+    print(f"Route {i+1}:")
+    print(f"  Precursors: {result['smiles']}")
+    print(f"  Template: {result.get('template', 'N/A')}")
+    print(f"  Score: {result.get('score', 'N/A')}")
+```
+
+### Using IBM RXN for Chemistry
+
+```python
+# IBM RXN API
+from rxn4chemistry import RXN4ChemistryWrapper
+
+api_key = os.environ["RXN4CHEM_API_KEY"]
+rxn = RXN4ChemistryWrapper(api_key=api_key)
+rxn.create_project("retrosynthesis_example")
+
+# Predict retrosynthesis
+response = rxn.predict_automatic_retrosynthesis(
+    product="CC(=O)Oc1ccccc1C(=O)O",  # Aspirin
+    max_steps=3
+)
+
+# Get results
+results = rxn.get_predict_automatic_retrosynthesis_results(response["prediction_id"])
+for route in results.get("retrosynthetic_paths", []):
+    print(f"Route confidence: {route.get('confidence', 'N/A')}")
+    for step in route.get("steps", []):
+        print(f"  Reaction: {step.get('reaction_smiles', 'N/A')}")
+```
+
+### Using AiZynthFinder (Open Source)
+
+```python
+from aizynthfinder.aizynthfinder import AiZynthFinder
+
+# Configure the finder
+finder = AiZynthFinder()
+finder.stock.load("zinc_stock.hdf5")  # Commercial building blocks
+finder.expansion_policy.load("expansion_policy_model.onnx")  # Retro model
+
+# Set target
+finder.target_smiles = "CC(=O)Oc1ccccc1C(=O)O"  # Aspirin
+
+# Run tree search
+finder.config.search.time_limit = 120  # seconds
+finder.config.search.iteration_limit = 500
+finder.tree_search()
+
+# Extract and analyze routes
+finder.build_routes()
+for i, route in enumerate(finder.routes):
+    print(f"Route {i+1} (score: {route.score:.3f}):")
+    print(f"  Steps: {len(route.reactions)}")
+    for rxn in route.reactions:
+        print(f"    {rxn}")
+```
+
+## SMILES Notation for Chemistry
+
+SMILES (Simplified Molecular Input Line Entry System) is the standard text representation:
+
+```
+# Common SMILES patterns
+Water:          O
+Ethanol:        CCO
+Benzene:        c1ccccc1
+Aspirin:        CC(=O)Oc1ccccc1C(=O)O
+Caffeine:       Cn1c(=O)c2c(ncn2C)n(C)c1=O
+Ibuprofen:      CC(C)Cc1ccc(cc1)C(C)C(=O)O
+
+# SMILES rules
+# Atoms: C, N, O, S, P, F, Cl, Br, I
+# Bonds: - (single, implicit), = (double), # (triple)
+# Branches: () for branching
+# Rings: numbers for ring closure (c1ccccc1 = benzene)
+# Aromatic: lowercase letters
+# Stereochemistry: / \ for E/Z, @ @@ for R/S
+```
+
+## Reaction Databases
+
+| Database | Coverage | Features | Access |
+|----------|----------|----------|--------|
+| Reaxys | 130M+ reactions | Experimental conditions, yields | Subscription |
+| SciFinder / CAS | 160M+ reactions | Commercial availability, safety data | Subscription |
+| USPTO | 3.7M reactions | US patent reactions | Free (open data) |
+| Open Reaction Database (ORD) | Growing | Structured reaction data, conditions | Free |
+| RMG (Reaction Mechanism Generator) | Kinetics | Automated mechanism generation | Free (MIT) |
+
+## Best Practices for Route Planning
+
+1. **Start simple**: Begin with the most obvious disconnections before trying exotic transforms.
+2. **Consider availability**: Check if precursors are commercially available (Sigma-Aldrich, TCI, Alfa Aesar).
+3. **Minimize steps**: Convergent synthesis (combining two complex halves) is generally preferred over linear synthesis.
+4. **Protect and deprotect wisely**: Minimize protecting group manipulations; each adds 2 steps (protection + deprotection).
+5. **Check literature**: Search Reaxys or SciFinder for precedent before attempting novel transformations.
+6. **Validate computationally**: Use forward reaction prediction to verify that proposed retrosynthetic steps are feasible.
+7. **Consider scale**: Reactions that work at milligram scale may fail at gram scale. Check for scalability issues (exothermic reactions, heterogeneous mixing).