@defai.digital/automatosx 5.6.35 → 5.7.2

package/examples/agents/.automatosx/abilities/etl-pipelines.md

@@ -0,0 +1,44 @@
+# ETL Pipelines
+
+Build robust Extract, Transform, Load pipelines for data integration. Handle incremental loading, error recovery, and monitoring.
+
+## Do's ✅
+
+```python
+# ✅ Good: Incremental loading
+last_sync = get_last_sync_timestamp()
+new_data = source.extract(where=f"updated_at > '{last_sync}'")
+transformed = transform(new_data)
+warehouse.upsert(transformed, key_columns=['id'])
+
+# ✅ Good: Idempotent operations
+warehouse.upsert(data, key_columns=['id'], update_columns=['name', 'updated_at'])
+
+# ✅ Good: Error handling with retry
+try:
+    data = extract_from_api()
+    load_to_warehouse(transform(data))
+except APIError as e:
+    log_error(e)
+    save_failed_batch(data)  # Retry later
+```
+
+## Don'ts ❌
+
+```python
+# ❌ Bad: Full table reload every time
+data = source.extract_all()  # Millions of rows!
+warehouse.truncate()
+warehouse.insert(data)
+
+# ❌ Bad: No schema validation
+for row in data:
+    warehouse.insert(row['id'], row['name'])  # What if fields missing?
+```
+
+## Best Practices
+- Use orchestration tools (Airflow, Prefect, Dagster)
+- Implement data quality checks
+- Monitor pipeline SLAs
+- Version control transformation logic
+- Document data lineage

package/examples/agents/.automatosx/abilities/feasibility-study.md

@@ -0,0 +1,20 @@
+Goal
+- Assess technical, operational, and economic feasibility with timelines and costs.
+
+How to do it
+- Define scope, constraints, and success criteria.
+- Technical: stack fit, complexity, integration risks.
+- Operational: processes, skills, SLAs, compliance.
+- Economic: cost drivers (build/run), ROI windows, sensitivities.
+
+Do
+- Provide a small matrix (dimension × 1–5 score) and rationale.
+- Add timeline bands (e.g., 2–4 weeks, 1–2 quarters) with key assumptions.
+
+Don’t
+- Don’t present estimates without assumptions.
+- Don’t ignore maintenance/operational costs.
+
+Output
+- A feasibility summary with scores, assumptions, timeline bands, and go/no‑go recommendation.
+

package/examples/agents/.automatosx/abilities/general-assistance.md

@@ -0,0 +1,26 @@
+# General Assistance
+
+## Description
+
+Provide helpful assistance for general tasks and inquiries.
+
+## Capabilities
+
+- Answer questions on various topics
+- Provide explanations and clarifications
+- Offer suggestions and recommendations
+- Break down complex problems into manageable steps
+
+## Usage Guidelines
+
+- Be clear and concise in responses
+- Ask clarifying questions when needed
+- Provide examples to illustrate concepts
+- Adapt communication style to user needs
+
+## Best Practices
+
+- Listen carefully to user requests
+- Provide accurate and reliable information
+- Be patient and understanding
+- Follow up to ensure user satisfaction

package/examples/agents/.automatosx/abilities/idea-evaluation.md

@@ -0,0 +1,21 @@
+Goal
+- Evaluate ideas against objectives, constraints, user value, and alternatives.
+
+How to do it
+- Clarify the objective, target users, and measurable outcomes.
+- Identify assumptions; label each as validated, unvalidated, or unknown.
+- Compare at least two alternatives; state trade‑offs.
+- Use simple scoring (e.g., 1–5) for value, cost, risk, and time.
+
+Do
+- Show a short decision table with criteria and scores.
+- Call out unknowns and how to validate them.
+- Provide an executive summary before details.
+
+Don’t
+- Don’t assume feasibility without evidence.
+- Don’t hide uncertainties; surface them with next steps.
+
+Output
+- A concise evaluation with assumptions, alternatives, scores, and a clear recommendation.
+

package/examples/agents/.automatosx/abilities/infra-as-code.md

@@ -0,0 +1,57 @@
+# Infrastructure as Code
+
+Define and manage infrastructure through code using Terraform, Pulumi, or AWS CDK. Enable version control, reproducibility, and automation.
+
+## Do's ✅
+
+```hcl
+# ✅ Good: Modular Terraform
+resource "aws_vpc" "main" {
+  cidr_block = var.vpc_cidr
+  enable_dns_hostnames = true
+
+  tags = {
+    Name = "${var.project}-vpc"
+    Environment = var.environment
+  }
+}
+
+# ✅ Good: Remote state with locking
+terraform {
+  backend "s3" {
+    bucket         = "terraform-state"
+    key            = "prod/terraform.tfstate"
+    region         = "us-east-1"
+    encrypt        = true
+    dynamodb_table = "terraform-locks"
+  }
+}
+
+# ✅ Good: Use modules
+module "vpc" {
+  source  = "terraform-aws-modules/vpc/aws"
+  version = "~> 3.0"
+  name    = "${var.project}-vpc"
+  cidr    = var.vpc_cidr
+}
+```
+
+## Don'ts ❌
+
+```hcl
+# ❌ Bad: Hardcoded values
+resource "aws_instance" "web" {
+  ami           = "ami-0c55b159cbfafe1f0"  # Region-specific!
+  subnet_id     = "subnet-12345"  # Hardcoded
+}
+
+# ❌ Bad: Manual changes
+# Never modify infrastructure manually in console
+```
+
+## Best Practices
+- Use workspaces for environments (dev/staging/prod)
+- Enable state locking
+- Always run `terraform plan` before apply
+- Version pin modules and providers
+- Implement automated testing (Terratest)

package/examples/agents/.automatosx/abilities/job-orchestration.md

@@ -0,0 +1,44 @@
+# Job Orchestration
+
+Schedule and orchestrate data jobs, pipelines, and workflows. Manage dependencies, retries, and monitoring using orchestration tools.
+
+## Do's ✅
+
+```python
+# ✅ Good: Clear task dependencies (Airflow)
+from airflow import DAG
+from airflow.operators.python import PythonOperator
+
+with DAG('user_pipeline', schedule='0 2 * * *') as dag:
+    extract = PythonOperator(task_id='extract', python_callable=extract_users)
+    transform = PythonOperator(task_id='transform', python_callable=transform_users)
+    load = PythonOperator(task_id='load', python_callable=load_users)
+
+    extract >> transform >> load
+
+# ✅ Good: Retry configuration
+PythonOperator(
+    task_id='api_call',
+    python_callable=call_api,
+    retries=3,
+    retry_delay=timedelta(minutes=5),
+    retry_exponential_backoff=True
+)
+```
+
+## Don'ts ❌
+
+```python
+# ❌ Bad: Complex dependencies
+task1 >> [task2, task3, task4] >> task5 >> [task6, task7] >> task8
+
+# ✅ Good: Logical groupings
+extract_tasks >> transform_task >> load_tasks
+```
+
+## Best Practices
+- Use task groups for related operations
+- Implement SLA monitoring
+- Configure alerting for failures
+- Version control DAG definitions
+- Use dynamic task generation when appropriate

package/examples/agents/.automatosx/abilities/literature-review.md

@@ -0,0 +1,19 @@
+Goal
+- Summarize prior work and credible sources; extract insights and gaps.
+
+How to do it
+- Collect 5–10 relevant sources; prefer primary research or official docs.
+- For each source: key claim, method, limits, and applicability.
+- Synthesize themes; identify contradictions and open questions.
+
+Do
+- Provide inline citations (Author/Org, Year or URL).
+- Group findings by theme; call out where evidence is weak.
+
+Don’t
+- Don’t copy long quotes; summarize.
+- Don’t mix citation and commentary without clearly separating them.
+
+Output
+- A thematic summary with citations and a short “Implications for this project” section.
+

package/examples/agents/.automatosx/abilities/logical-analysis.md

@@ -0,0 +1,21 @@
+Goal
+- Analyze arguments for validity, completeness, and hidden assumptions.
+
+How to do it
+- List premises and assumptions explicitly.
+- Check inference steps; note logical fallacies or gaps.
+- Consider counter‑examples and edge cases.
+- Separate facts (with citations) from opinions (qualified language).
+
+Do
+- Use bullet points for premises → conclusion.
+- Mark each step as sound/unsound with a brief note.
+- Provide a short “What would change my conclusion?” section.
+
+Don’t
+- Don’t conflate correlation with causation.
+- Don’t bury key assumptions.
+
+Output
+- A compact reasoning audit: premises, inferences, counter‑points, and a confidence rating.
+

package/examples/agents/.automatosx/abilities/longform-report.md

@@ -0,0 +1,25 @@
+Goal
+- Produce a structured, long‑form report suitable for stakeholders.
+
+Structure
+- Title, Author, Date
+- Executive Summary (bullets)
+- Background & Objectives
+- Methodology (how you reasoned / sources)
+- Findings (thematic)
+- Analysis (logic, feasibility, risks)
+- Options & Recommendations (w/ criteria)
+- Citations & Appendices
+
+Do
+- Use clear headings, short paragraphs, and lists.
+- Call out assumptions and uncertainties.
+- Add tables where helpful (scores, risks, timelines).
+
+Don’t
+- Don’t bury the lede—start with the summary.
+- Don’t omit sources when making claims.
+
+Output
+- A polished document following the above structure; aim for clarity over length.
+

package/examples/agents/.automatosx/abilities/mathematical-reasoning.md

@@ -0,0 +1,170 @@
+# Mathematical Reasoning
+
+## Description
+Rigorous mathematical analysis capabilities spanning linear algebra, calculus, probability, numerical methods, and symbolic reasoning to support research-grade problem solving, model verification, and algorithm design for Bob and Data Scientist while powering Quinn and Astrid workflows.
+
+## Core Domains
+
+### 1. Linear Algebra
+- Matrix algebra (addition, multiplication, transposition, trace/determinant)
+- Eigenvalue and eigenvector computation (power iteration, QR algorithm)
+- Singular value decomposition, low-rank approximations, and PCA linkage
+- Vector spaces, basis transformations, orthogonality, and projections
+- Positive definiteness checks, conditioning, and spectral properties
+
+```python
+import numpy as np
+
+A = np.array([[4., 2.], [1., 3.]])
+
+eigvals, eigvecs = np.linalg.eig(A)
+u, s, vt = np.linalg.svd(A)
+proj = A @ np.linalg.solve(A.T @ A, A.T)  # Least-squares projector
+
+cond_number = np.linalg.cond(A)
+```
+
+### 2. Calculus & Optimization
+- Differential calculus, gradients, Jacobians, Hessians
+- Line search, Newton, quasi-Newton, and trust-region methods
+- Constrained optimization (KKT conditions, Lagrange multipliers)
+- Convex analysis, duality, strong/weak convexity checks
+- Sensitivity analysis and automatic differentiation workflows
+
+```python
+import sympy as sp
+
+x, y = sp.symbols('x y', real=True)
+f = (x - 2)**2 + (y + 1)**2 + 3 * x * y
+grad = [sp.diff(f, var) for var in (x, y)]
+hessian = sp.hessian(f, (x, y))
+
+λ = sp.symbols('λ')
+constraint = x + y - 1
+lagrangian = f + λ * constraint
+kkt_eqs = [sp.diff(lagrangian, var) for var in (x, y, λ)]
+solution = sp.solve(kkt_eqs, (x, y, λ), dict=True)
+```
+
+### 3. Probability & Statistics
+- Probability distributions (continuous/discrete), conjugacy, transformations
+- Bayesian inference (posterior computation, MAP/MCMC, credible intervals)
+- Frequentist inference (hypothesis tests, p-values, confidence intervals)
+- Estimators, bias-variance trade-offs, sufficiency, asymptotics
+- Information measures (entropy, KL divergence, mutual information)
+
+```python
+import numpy as np
+from scipy import stats
+
+# Bayesian update for Beta-Binomial model
+prior_a, prior_b = 2, 2
+successes, trials = 18, 25
+posterior = stats.beta(prior_a + successes, prior_b + trials - successes)
+cred_interval = posterior.interval(0.95)
+evidence = stats.binom.pmf(successes, trials, prior_a / (prior_a + prior_b))
+
+# Frequentist hypothesis test
+sample = np.random.normal(loc=1.05, scale=0.2, size=40)
+t_stat, p_value = stats.ttest_1samp(sample, popmean=1.0)
+```
+
+### 4. Numerical Methods
+- Numerical integration (Gaussian quadrature, adaptive Simpson)
+- Root finding (Newton-Raphson, secant, bracketing methods)
+- ODE/PDE solvers (Runge-Kutta, implicit schemes, finite differences)
+- Stability and convergence analysis, stiffness diagnostics
+- Error bounds, conditioning, floating-point safeguards
+
+```python
+import numpy as np
+from scipy.integrate import quad, solve_ivp
+
+area, err = quad(lambda t: np.exp(-t**2), 0, np.inf)
+
+def logistic(t, y, r=1.2, K=10.0):
+    return r * y * (1 - y / K)
+
+solution = solve_ivp(logistic, (0, 20), [0.5], method="RK45", dense_output=True)
+stability = np.max(np.abs(np.linalg.eigvals([[0., 1.], [-4., -1.5]])))
+```
+
+### 5. Symbolic Computation
+- Formal manipulations (simplification, expansion, factorization)
+- Symbolic integration/differentiation and series expansions
+- Proof assistants for identity verification and equivalence checking
+- Symbolic linear algebra, polynomial resultants, Groebner bases
+- Derivation tracing with justification for documentation and review
+
+```python
+import sympy as sp
+
+t = sp.symbols('t', positive=True)
+series = sp.series(sp.sin(t) / t, t, 0, 6)
+identity = sp.simplify(sp.exp(sp.I * t) * sp.exp(-sp.I * t))
+proof = sp.Eq(sp.diff(sp.log(sp.factorial(t)), t), sp.digamma(t + 1))
+
+M = sp.Matrix([[1, 2], [3, 4]])
+eigen_decomp = M.eigenvects()
+```
+
+### 6. Mathematical Verification Notebooks
+- Structured Python notebooks using NumPy, SciPy, and SymPy for reproducible math experiments
+- Cells organized by assumptions → derivations → numerical validation → sensitivity checks
+- Parameterized widgets or YAML configs for scenario sweeps
+- Automatic assertion blocks to verify algebraic vs. numeric equivalence
+- Version-controlled notebooks (`.ipynb` or `.py` using Jupytext) with deterministic seeds
+
+```python
+# verification_notebook.py (Jupytext style)
+import numpy as np
+import sympy as sp
+from scipy.optimize import minimize
+
+np.random.seed(42)
+w = sp.symbols('w')
+symbolic_grad = sp.diff(sp.sin(w) + w**2, w)
+
+def objective(val):
+    return np.sin(val) + val**2
+
+res = minimize(objective, x0=[0.5])
+assert abs(symbolic_grad.subs({w: res.x[0]}) - 0) < 1e-6
+```
+
+## Best Practices
+1. **State Assumptions Explicitly**: Document domains, constraints, and approximation regimes before derivations.
+2. **Cross-Validate**: Confirm symbolic results with numerical experiments (Monte Carlo, sampling, discretization).
+3. **Track Units and Scaling**: Maintain dimensional consistency and rescale ill-conditioned problems.
+4. **Monitor Conditioning**: Inspect condition numbers and step sizes to pre-empt numerical instability.
+5. **Use Reproducible Seeds**: Fix random seeds and record solver tolerances for repeatability.
+6. **Validate Constraints**: Ensure solution candidates satisfy KKT or feasibility conditions post-optimization.
+
+## Common Workflows
+- Analytical derivation with SymPy → numerical verification via SciPy → documentation in notebook with Markdown proof steps.
+- Linear algebra pipelines converting symbolic expressions to callable NumPy functions for high-performance evaluation.
+- Bayesian model evaluation combining closed-form posteriors with MCMC diagnostics when conjugacy fails.
+- PDE prototyping using finite differences followed by spectral method comparison for convergence profiling.
+
+## Anti-patterns to Avoid
+1. ❌ Treating floating-point equality as exact; always compare with tolerance windows.
+2. ❌ Ignoring solver diagnostics (residual norms, iteration counts, Jacobian approximations).
+3. ❌ Skipping preconditioning for stiff or ill-conditioned linear systems.
+4. ❌ Mixing symbolic and numeric domains without explicit casting, leading to type errors or performance hits.
+5. ❌ Assuming convergence without verifying gradients/Hessians or constraint satisfaction.
+
+## Tooling & References
+- **Core Libraries**: NumPy, SciPy, SymPy, JAX, PyTorch (autograd), cvxpy
+- **Notebooks**: JupyterLab, VS Code notebooks, Jupytext for `.py` parity
+- **Visualization**: Matplotlib, Plotly, seaborn for residuals and convergence plots
+- **Verification**: hypothesis for property-based testing, pytest for deterministic assertions
+- **Resources**: Matrix Cookbook, Boyd & Vandenberghe’s Convex Optimization, Numerical Recipes, Probabilistic Machine Learning (Murphy)
+
+## Quick Checklist
+- [ ] Assumptions and variable domains documented
+- [ ] Symbolic derivations simplified and verified numerically
+- [ ] Conditioning and stability assessed with diagnostics
+- [ ] Optimization routines include gradient/Hessian validation
+- [ ] Probabilistic models report uncertainty (CI or posterior summaries)
+- [ ] Notebooks or scripts captured in version control with reproducible seeds
+

package/examples/agents/.automatosx/abilities/mission-analysis.md

@@ -0,0 +1,49 @@
+# Mission Analysis
+
+## Overview
+
+Plan space missions by evaluating launch windows, delta-v budgets, trajectory
+options, and risk trades to deliver payloads on schedule while maximizing
+scientific or commercial return.
+
+## Core Concepts & Best Practices
+
+- **Mission Phasing**: Decompose operations into launch, transfer, orbit
+  insertion, surface or operations, and disposal with clear success criteria.
+- **Launch Window Analysis**: Compute pork-chop plots, C3 requirements, and
+  planetary alignment windows; maintain contingency windows.
+- **Delta-v Accounting**: Build comprehensive budgets including injection,
+  transfer corrections, station-keeping, and end-of-life maneuvers.
+- **Trajectory Optimization**: Compare impulsive versus continuous thrust,
+  gravity assists, and ballistic capture; quantify schedule sensitivity.
+- **Risk Assessment**: Integrate failure modes, environmental hazards, and
+  regulatory constraints into mission timelines.
+
+## Tools & Methodologies
+
+- **Analytical Tools**: Use STK, GMAT, Copernicus, or Mission Analysis
+  Environment (MAE) for end-to-end trajectory design.
+- **Optimization Suites**: Apply collocation methods, direct transcription
+  (GPOPS-II), or evolutionary algorithms for complex trajectories.
+- **Trade Studies**: Perform design-to-cost, design-to-value, and SWOT analyses
+  for payload accommodation and launch vehicle selection.
+- **Sensitivity Studies**: Conduct Monte Carlo dispersions and covariance
+  analyses to assess robustness to launch delays and navigation errors.
+- **Documentation**: Produce Mission Concept Reviews (MCR), System Requirements
+  Reviews (SRR), and flight rule catalogs to align stakeholders.
+
+## Example Scenario
+
+An exploration program targets Mars orbit insertion in 2031. Analysts generate
+pork-chop plots to identify optimal synodic windows, run Copernicus to compare
+Hohmann versus low-thrust SEP transfers, and iterate delta-v budgets to
+downselect to a gravity-assist trajectory that meets payload mass margins.
+
+## Reference Resources
+
+- Wertz & Larson, *Space Mission Analysis and Design*, Microcosm Press
+- Brown, *Elements of Spacecraft Mission Design*, AIAA
+- NASA Systems Engineering Handbook, NASA/SP-2016-6105
+- GPOPS-II Documentation: <https://www.gpops2.com>
+- ESA Mission Analysis Environment:
+  <https://www.esa.int/gsp/ACT/mission_analysis_environment>

package/examples/agents/.automatosx/abilities/observability.md

@@ -0,0 +1,61 @@
+# Observability
+
+Implement logging, metrics, and tracing to understand system behavior. Monitor health, troubleshoot issues, and optimize performance.
+
+## Three Pillars
+
+### 1. Logs
+```javascript
+// ✅ Good: Structured logging
+logger.info('User login', {
+  user_id: user.id,
+  ip: req.ip,
+  timestamp: new Date().toISOString()
+});
+```
+
+### 2. Metrics
+```javascript
+// ✅ Good: Application metrics (Prometheus)
+const counter = new promClient.Counter({
+  name: 'http_requests_total',
+  help: 'Total HTTP requests',
+  labelNames: ['method', 'route', 'status']
+});
+
+app.use((req, res, next) => {
+  res.on('finish', () => {
+    counter.inc({ method: req.method, route: req.route, status: res.statusCode });
+  });
+});
+```
+
+### 3. Traces
+```javascript
+// ✅ Good: Distributed tracing
+const span = tracer.startSpan('get_user');
+try {
+  const user = await db.getUser(id);
+  res.json(user);
+} finally {
+  span.finish();
+}
+```
+
+## Don'ts ❌
+
+```javascript
+// ❌ Bad: Log sensitive data
+logger.info('Login', { username, password });  // Never!
+
+// ❌ Bad: Unstructured logs
+console.log('User ' + user.id + ' logged in');
+```
+
+## Best Practices
+- Use log levels appropriately
+- Implement correlation IDs for tracing
+- Set up dashboards for key metrics
+- Configure alerts with thresholds
+- Use APM tools (Datadog, New Relic)
+- Implement SLOs and error budgets

package/examples/agents/.automatosx/abilities/orbital-mechanics.md

@@ -0,0 +1,50 @@
+# Orbital Mechanics
+
+## Overview
+
+Analyze orbital dynamics for spacecraft, including multi-body perturbations,
+station-keeping strategies, and maneuver planning that respects mission
+constraints, propellant budgets, and operational safety.
+
+## Core Concepts & Best Practices
+
+- **Two-Body Foundations**: Master Keplerian elements, conic sections, Lambert
+  targeting, and orbital perturbation theory.
+- **Perturbation Modeling**: Incorporate J2 oblateness, atmospheric drag, solar
+  radiation pressure, and third-body effects in long-duration analyses.
+- **Maneuver Planning**: Design Hohmann, bi-elliptic, low-thrust, and
+  plane-change maneuvers; evaluate trade-offs between time, delta-v, and risk.
+- **Relative Motion**: Apply Clohessy-Wiltshire and Tschauner-Hempel equations
+  for rendezvous; integrate collision avoidance envelopes.
+- **Station-Keeping**: Develop periodic correction strategies for GEO, LEO
+  constellations, and Lagrange point orbits while balancing propellant and
+  pointing needs.
+
+## Tools & Methodologies
+
+- **Numerical Propagators**: Use GMAT, Orekit, STK, Basilisk, or custom
+  Runge-Kutta integrators with event detection for shadow entry or exit.
+- **Astrodynamics Libraries**: Leverage poliastro, NASA GMAT API, and JPL SPICE
+  kernels for ephemeris and frame transformations.
+- **Optimization Routines**: Employ differential correction, sequential
+  quadratic programming, or heuristic search for multi-burn sequences.
+- **Monte Carlo Analysis**: Simulate maneuver execution dispersions and
+  environmental uncertainties to bound state covariance growth.
+- **Validation & Verification**: Cross-check analytical solutions with
+  high-fidelity propagators; maintain traceability of gravitational models and
+  reference frames.
+
+## Example Scenario
+
+A mission team plans a lunar orbit insertion. They run Lambert targeting from
+translunar injection to perilune, account for Earth-Moon three-body
+perturbations using GMAT, and apply sequential quadratic programming to
+minimize delta-v while satisfying lighting constraints for optical navigation.
+
+## Reference Resources
+
+- Vallado, *Fundamentals of Astrodynamics and Applications*, Microcosm Press
+- Curtis, *Orbital Mechanics for Engineering Students*, Butterworth-Heinemann
+- NASA GMAT User Guide: <https://gmatcentral.org>
+- Orekit Documentation: <https://www.orekit.org>
+- JPL SPICE Toolkit: <https://naif.jpl.nasa.gov/naif/toolkit.html>