@defai.digital/automatosx 5.6.35 → 5.7.2

package/examples/agents/.automatosx/abilities/our-project-structure.md

@@ -0,0 +1,183 @@
+# Our Project Structure - AutomatosX v5
+
+> AutomatosX project organization and file structure conventions
+
+## Directory Structure
+
+```
+automatosx/
+├── src/                      # TypeScript source code
+│   ├── core/                 # Router, PathResolver, MemoryManager, SessionManager
+│   ├── agents/               # ProfileLoader, AbilitiesManager, ContextManager, Executor
+│   ├── providers/            # Claude, Gemini, OpenAI implementations
+│   ├── cli/                  # CLI entry point and commands/
+│   ├── types/                # TypeScript type definitions
+│   └── utils/                # Logger, errors, formatters
+│
+├── tests/                    # 1,149 tests (100% pass)
+│   ├── unit/                 # Core modules, utilities
+│   ├── integration/          # CLI command flows
+│   ├── e2e/                  # Complete workflows
+│   └── fixtures/             # Test helpers, mock providers
+│
+├── examples/
+│   ├── agents/               # Example agent profiles (YAML)
+│   ├── abilities/            # Example abilities (Markdown)
+│   └── templates/            # Agent templates (v5.0.0+)
+│
+├── dist/                     # Build output (381KB, gitignored)
+│   ├── index.js              # Bundled CLI (ESM)
+│   ├── index.js.map
+│   └── index.d.ts
+│
+├── .automatosx/              # User project directory (created by init)
+│   ├── config.json           # User configuration
+│   ├── agents/               # User's custom agents
+│   ├── abilities/            # User's custom abilities
+│   ├── memory/               # SQLite database (memory.db)
+│   ├── sessions/             # Session persistence
+│   └── logs/                 # Application logs
+│
+├── automatosx/               # Workspace directory (v5.2+)
+│   ├── PRD/                  # Planning documents (permanent)
+│   └── tmp/                  # Temporary files (auto-cleanup)
+│
+└── tmp/                      # Temporary files (gitignored)
+```
+
+## Module Import Hierarchy
+
+**Dependency flow (imports only from lower layers):**
+
+```
+Layer 1: types/              → No dependencies
+Layer 2: utils/              → types/
+Layer 3: core/               → types/, utils/
+Layer 4: providers/          → types/, core/
+Layer 5: agents/             → types/, utils/, core/
+Layer 6: cli/                → All of the above
+```
+
+**Rule:** Higher layers can import from lower layers, never vice versa.
+
+## File Naming Conventions
+
+**TypeScript files:** `kebab-case.ts`
+
+```
+✅ path-resolver.ts, memory-manager.ts, claude-provider.ts
+❌ PathResolver.ts, path_resolver.ts, pathResolver.ts
+```
+
+**Test files:** `{module-name}.test.ts`
+
+```
+✅ path-resolver.test.ts, memory-manager.test.ts
+❌ path-resolver.spec.ts, test-path-resolver.ts
+```
+
+**Type files:** `{concept}.ts` (no -types suffix)
+
+```
+✅ types/agent.ts, types/provider.ts
+❌ types/agent-types.ts, types/AgentTypes.ts
+```
+
+**Configuration files:**
+
+- YAML for agents: `examples/agents/backend.yaml`
+- Markdown for abilities: `examples/abilities/code-generation.md`
+- JSON for config: `.automatosx/config.json`
+
+## Import Patterns
+
+**ESM imports (always use .js extension):**
+
+```typescript
+// ✅ Good: Full path with .js
+import { PathResolver } from '../core/path-resolver.js';
+import type { AgentProfile } from '../types/agent.js';
+
+// ❌ Bad: Missing .js extension
+import { PathResolver } from '../core/path-resolver';
+```
+
+**Type-only imports:**
+
+```typescript
+// ✅ Good: type-only imports (better tree-shaking)
+import type { AgentProfile } from '../types/agent.js';
+import type { Provider } from '../types/provider.js';
+```
+
+## Configuration Hierarchy
+
+**Priority order:**
+
+1. `.automatosx/config.json` (project-specific, created by `ax init`)
+2. `automatosx.config.json` (project root, manually created)
+3. `~/.automatosx/config.json` (user global)
+4. `DEFAULT_CONFIG` (defaults in `src/types/config.ts`)
+
+**Agent profiles search order:**
+
+1. `.automatosx/agents/{name}.yaml` (user custom)
+2. `examples/agents/{name}.yaml` (built-in)
+
+**Abilities search order:**
+
+1. `.automatosx/abilities/{name}.md` (user custom)
+2. `examples/abilities/{name}.md` (built-in)
+
+## Build Output
+
+**Location:** `dist/`
+
+- `index.js` - Bundled CLI (ESM, 381KB)
+- `index.js.map` - Source map
+- `index.d.ts` - Type definitions
+
+**Bundle target:** ESM, Node 20+, <250KB target
+
+## Workspace Structure (v5.2.0)
+
+**Shared workspaces:**
+
+- `automatosx/PRD/` - Planning documents, feature designs, proposals (permanent)
+- `automatosx/tmp/` - Test scripts, analysis tools, temporary reports (auto-cleanup)
+
+**All agents** have equal read/write access to both directories.
+
+**Memory storage:** `.automatosx/memory/memory.db`
+
+- SQLite database with FTS5 full-text search
+- < 1ms search performance
+
+**Session storage:** `.automatosx/sessions/sessions.json`
+
+- JSON-based persistence
+- 100ms debounced saves
+- Automatic cleanup (7+ days old)
+
+## Security Boundaries
+
+**Allowed reads:**
+
+- `{projectRoot}/**/*` (validated by PathResolver)
+
+**Allowed writes:**
+
+- `automatosx/PRD/**/*` - Planning documents
+- `automatosx/tmp/**/*` - Temporary files
+
+**Forbidden:**
+
+- Empty paths or current directory (`''`, `'.'`)
+- Path traversal (`../../../etc/passwd`)
+- Symbolic links outside project
+- Absolute paths
+
+---
+
+**Last Updated:** 2025-10-11
+**For:** AutomatosX v5.2+

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

@@ -0,0 +1,56 @@
+# Performance Analysis Ability
+
+Identify and fix performance bottlenecks.
+
+## Performance Metrics
+
+1. **Response Time**
+   - Target: <100ms for API calls
+   - Target: <1s for page loads
+   - Measure: p50, p95, p99 latencies
+
+2. **Throughput**
+   - Requests per second
+   - Concurrent users supported
+   - Resource utilization
+
+3. **Resource Usage**
+   - CPU: Target <70% average
+   - Memory: No leaks, stable usage
+   - Disk I/O: Minimize random access
+   - Network: Bandwidth optimization
+
+## Analysis Process
+
+1. **Measure** (establish baseline)
+   - Use profilers (Chrome DevTools, Python cProfile)
+   - Monitor production metrics
+   - Identify slow operations
+
+2. **Analyze** (find bottlenecks)
+   - Check database queries (N+1 problem)
+   - Review algorithm complexity
+   - Identify network round trips
+   - Check memory allocations
+
+3. **Optimize** (targeted improvements)
+   - Add caching (Redis, CDN)
+   - Optimize database queries (indexes, query optimization)
+   - Use async/parallel processing
+   - Reduce payload sizes
+
+4. **Verify** (measure improvements)
+   - Re-run benchmarks
+   - Compare before/after
+   - Check for regressions
+   - Monitor in production
+
+## Common Performance Issues
+
+- N+1 query problem (ORM)
+- Missing database indexes
+- Synchronous I/O blocking
+- Large payload sizes
+- No caching strategy
+- Memory leaks
+- Inefficient algorithms (O(n²) when O(n) possible)

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

@@ -0,0 +1,80 @@
+# Frontend Performance Optimization
+
+Optimize React applications for speed and efficiency.
+
+## Core Web Vitals
+
+Target metrics:
+- **LCP** (Largest Contentful Paint): < 2.5s
+- **FID** (First Input Delay): < 100ms
+- **CLS** (Cumulative Layout Shift): < 0.1
+- **FCP** (First Contentful Paint): < 1.8s
+- **TTI** (Time to Interactive): < 3.8s
+
+## Optimization Strategies
+
+### 1. Code Splitting
+- Use React.lazy() for route-based splitting
+- Split heavy components (charts, editors, modals)
+- Use Suspense with meaningful fallbacks
+- Analyze bundle with webpack-bundle-analyzer
+
+### 2. Memoization
+- useMemo() for expensive calculations
+- useCallback() for callbacks passed to child components
+- React.memo() for components that re-render with same props
+- Don't over-memoize (profile first)
+
+### 3. Virtualization
+- Use react-window or react-virtualized for long lists (>100 items)
+- Implement infinite scroll for large datasets
+- Lazy load images in viewport
+
+### 4. Asset Optimization
+- Compress images (WebP format, use srcset)
+- Lazy load images (loading="lazy")
+- Use CDN for static assets
+- Enable gzip/brotli compression
+- Optimize fonts (font-display: swap, preload critical fonts)
+
+### 5. Render Optimization
+- Avoid inline function/object creation in render
+- Use key prop correctly for lists
+- Lift state up sparingly (keep state local when possible)
+- Debounce/throttle expensive operations (search, scroll handlers)
+- Use production build for deployment
+
+### 6. Network Optimization
+- Implement caching strategies (Cache-Control headers)
+- Use service workers for offline support
+- Prefetch critical resources
+- Minimize API calls (batch requests)
+- Use GraphQL field selection to fetch only needed data
+
+### 7. Bundle Optimization
+- Tree-shake unused code
+- Use dynamic imports for conditional features
+- Remove unused dependencies
+- Use lighter alternatives (date-fns instead of moment)
+- Configure webpack to split vendor bundles
+
+## Performance Profiling
+
+Tools and techniques:
+- Chrome DevTools Performance tab
+- React DevTools Profiler
+- Lighthouse CI
+- Web Vitals library
+- Bundle analyzer
+
+## Quick Checklist
+
+Before deploying:
+- [ ] Bundle size analyzed and optimized
+- [ ] Images compressed and lazy loaded
+- [ ] Long lists virtualized
+- [ ] Expensive computations memoized
+- [ ] Route-based code splitting implemented
+- [ ] Core Web Vitals measured and acceptable
+- [ ] Production build tested
+- [ ] Caching strategy configured

package/examples/agents/.automatosx/abilities/problem-solving.md

@@ -0,0 +1,50 @@
+# Problem-Solving Ability
+
+Systematically approach and solve complex problems.
+
+## Problem-Solving Framework
+
+1. **Define** the problem
+   - State the problem clearly
+   - Identify root cause (5 Whys)
+   - Separate symptoms from causes
+   - Define constraints
+
+2. **Analyze** the situation
+   - Gather relevant information
+   - Identify patterns
+   - Consider multiple perspectives
+   - List assumptions
+
+3. **Generate** solutions
+   - Brainstorm alternatives
+   - Don't judge initially (divergent thinking)
+   - Consider unconventional approaches
+   - Document all ideas
+
+4. **Evaluate** options
+   - List pros and cons
+   - Consider trade-offs
+   - Assess feasibility
+   - Estimate impact
+
+5. **Implement** solution
+   - Create action plan
+   - Start with small experiments
+   - Monitor progress
+   - Adjust as needed
+
+6. **Review** and learn
+   - Did it solve the problem?
+   - What worked well?
+   - What could be improved?
+   - Document lessons learned
+
+## Techniques
+
+- **5 Whys**: Dig deeper by asking "why" repeatedly
+- **First Principles**: Break down to fundamental truths
+- **Rubber Duck Debugging**: Explain problem out loud
+- **Divide and Conquer**: Break into smaller sub-problems
+- **Work Backwards**: Start from desired outcome
+- **Analogies**: Apply solutions from similar domains

package/examples/agents/.automatosx/abilities/propulsion-systems.md

@@ -0,0 +1,50 @@
+# Propulsion Systems
+
+## Overview
+
+Engineer and evaluate spacecraft propulsion systems, encompassing chemical and
+electric propulsion performance envelopes, reliability modeling, and
+integration with vehicle architecture and mission requirements.
+
+## Core Concepts & Best Practices
+
+- **Propulsion Taxonomy**: Compare bipropellant, monopropellant, solid,
+  hybrid, electric (Hall, ion, MPD), and advanced concepts (nuclear thermal,
+  solar sail).
+- **Performance Metrics**: Calculate specific impulse, thrust-to-weight, mass
+  flow, and efficiency; assess throttling capability and response time.
+- **System Integration**: Design feed systems (pressurization, valves,
+  regulators), thermal management, and structural interfaces with redundancy.
+- **Reliability Modeling**: Apply fault tree analysis, Weibull statistics, and
+  Bayesian updating to predict MTBF and mission success probabilities.
+- **Contamination & Plume Effects**: Model plume impingement, erosion, and
+  electromagnetic interference on spacecraft subsystems.
+
+## Tools & Methodologies
+
+- **Analysis Suites**: Use NASA CEA, RPA, or in-house CFD tools for combustion
+  and nozzle performance prediction.
+- **Electric Propulsion Modeling**: Employ Hall thruster simulators, ion optics
+  codes, and particle-in-cell (PIC) methods to analyze plasma behavior.
+- **System Sizing**: Develop Excel, Modelica, or Amesim models for propellant
+  budget, tank sizing, and pressurization cycles.
+- **Test Campaign Planning**: Define hot-fire, vibration, thermal vacuum, and
+  life tests; collect telemetry for model correlation.
+- **Verification & Validation**: Execute acceptance test procedures (ATP) and
+  qualification plans while enforcing strict configuration control.
+
+## Example Scenario
+
+A GEO comsat program selects a hybrid propulsion architecture: chemical
+thrusters for orbit raising and Hall-effect thrusters for station-keeping.
+Engineers use NASA CEA to size bipropellant engines, run PIC simulations to
+verify Hall thruster plume interactions, and apply reliability block diagrams
+to ensure mission lifetime exceeds 15 years with 0.98 probability.
+
+## Reference Resources
+
+- Sutton & Biblarz, *Rocket Propulsion Elements*, Wiley
+- Humble, Henry & Larson, *Space Propulsion Analysis and Design*, McGraw-Hill
+- Goebel & Katz, *Fundamentals of Electric Propulsion*, JPL/NASA
+- NASA Chemical Equilibrium with Applications (CEA): <https://cearun.grc.nasa.gov>
+- AIAA Propulsion and Energy Forum Proceedings

package/examples/agents/.automatosx/abilities/quantum-algorithm-design.md

@@ -0,0 +1,54 @@
+# Quantum Algorithm Design
+
+## Overview
+
+Architect and tailor quantum algorithms such as QAOA, VQE, phase estimation,
+Grover, and Shor to solve optimization, simulation, and search problems while
+balancing gate depth, noise resilience, and classical-quantum workflow
+integration.
+
+## Core Concepts & Best Practices
+
+- **Problem Mapping**: Encode cost Hamiltonians or oracle functions that capture
+  the classical objective while minimizing qubit requirements.
+- **Ansatz Engineering**: Choose hardware-efficient or problem-inspired
+  ansätze; analyze expressibility versus trainability to avoid barren plateaus.
+- **Hybrid Loops**: Couple classical optimizers (e.g., SPSA, COBYLA, Adam) with
+  quantum evaluations; reuse measurement data with parameter-shift gradients
+  where available.
+- **Resource Estimation**: Quantify logical depth, T-count, and qubit footprint
+  prior to execution; evaluate circuit cut options for limited hardware.
+- **Error Mitigation**: Integrate zero-noise extrapolation, symmetry
+  verification, and probabilistic error cancellation early in algorithm design.
+
+## Tools & Methodologies
+
+- **Algorithm Templates**: Start from QAOA/VQE scaffolds and customize mixers,
+  cost layers, and measurement strategies.
+- **Classical Preprocessing**: Leverage problem reductions, graph
+  sparsification, or symmetry analysis to shrink the search space.
+- **Parameter Initialization**: Apply warm-start heuristics (e.g., classical
+  solutions, layer-wise training) to accelerate convergence.
+- **Performance Benchmarking**: Run simulators with realistic noise models and
+  track expected energy, fidelity, or success probability across layer depths.
+- **Result Verification**: Validate solutions against classical solvers (exact
+  or approximate) and quantify quantum advantage via scaling studies.
+
+## Example Scenario
+
+A logistics team models vehicle routing as a constrained optimization problem.
+By formulating the cost Hamiltonian for QAOA, selecting a tailored mixer that
+respects route feasibility, and combining SPSA with layer-wise parameter
+growth, they achieve improved approximation ratios on a noisy
+intermediate-scale quantum (NISQ) device relative to classical heuristics.
+
+## Reference Resources
+
+- Farhi et al., “A Quantum Approximate Optimization Algorithm,” arXiv:1411.4028
+- Peruzzo et al., “A Variational Eigenvalue Solver on a Photonic Quantum
+  Processor,” *Nature Communications* (2014)
+- Schuld & Killoran, “Quantum Machine Learning in Feature Hilbert Spaces,”
+  *PRL* (2019)
+- Nielsen & Chuang, *Quantum Computation and Quantum Information*, Cambridge
+  University Press
+- Qiskit Textbook: <https://qiskit.org/textbook>

package/examples/agents/.automatosx/abilities/quantum-error-correction.md

@@ -0,0 +1,56 @@
+# Quantum Error Correction
+
+## Overview
+
+Design and analyze quantum error-correcting codes, including surface codes and
+fault-tolerant logical operations, while applying error mitigation techniques
+to bridge current hardware limitations.
+
+## Core Concepts & Best Practices
+
+- **Code Families**: Evaluate stabilizer, surface, color, and LDPC codes; match
+  code distance and threshold to hardware constraints.
+- **Fault Tolerance**: Implement transversal gates, lattice surgery, and magic
+  state distillation while tracking logical error budgets.
+- **Syndrome Extraction**: Optimize measurement circuits to minimize hook
+  errors and leakage; schedule parallelism carefully.
+- **Decoding Strategies**: Apply minimum-weight perfect matching, belief
+  propagation, or neural decoders; benchmark latency versus accuracy.
+- **Error Mitigation**: Combine post-selection, probabilistic error
+  cancellation, and Clifford data regression with error correction for
+  near-term devices.
+
+## Tools & Methodologies
+
+- **Simulation Frameworks**: Use Qiskit Ignis, QEC frameworks, Stim, or LDPC
+  simulation libraries to evaluate logical error rates.
+- **Decoder Implementations**: Integrate PyMatching, tensor network decoders,
+  or custom FPGA-based solutions for real-time performance.
+- **Threshold Analysis**: Perform Monte Carlo sampling over noise channels
+  (Pauli, amplitude damping, biased dephasing) to estimate thresholds.
+- **Logical Circuit Compilation**: Map high-level algorithms onto logical
+  qubits, schedule patch moves, and analyze lattice surgery costs.
+- **Cross-Layer Co-Design**: Coordinate hardware calibration teams with QEC
+  architects to ensure stabilizer measurements align with physical gate
+  capabilities.
+
+## Example Scenario
+
+A quantum computing platform targets a 10⁻³ logical error rate. Engineers
+select rotated surface codes with distance nine, implement syndrome extraction
+sequences with tailored CNOT ordering, and deploy PyMatching for decoding.
+Post-implementation Monte Carlo runs confirm the logical failure rate meets
+the reliability target under measured device noise.
+
+## Reference Resources
+
+- Fowler et al., “Surface Codes: Towards Practical Large-Scale Quantum
+  Computation,” *PR A* (2012)
+- Dennis et al., “Topological Quantum Memory,” *Journal of Mathematical
+  Physics* (2002)
+- Gottesman, “An Introduction to Quantum Error Correction and Fault-Tolerant
+  Quantum Computation,” arXiv:0904.2557
+- Stim: <https://github.com/quantumlib/Stim>
+- PyMatching: <https://github.com/Quantum-Computing-UK/pymatching>
+- Terhal, “Quantum Error Correction for Quantum Memories,” *Reviews of Modern
+  Physics* (2015)

package/examples/agents/.automatosx/abilities/quantum-frameworks-transpilation.md

@@ -0,0 +1,53 @@
+# Quantum Frameworks & Transpilation
+
+## Overview
+
+Leverage Qiskit, Cirq, and related toolchains to build quantum circuits,
+perform transpilation and optimization passes, and tailor executions to
+specific backend topologies and calibration data for maximal performance.
+
+## Core Concepts & Best Practices
+
+- **Circuit Abstraction**: Separate algorithm logic from backend configuration
+  using parameterized circuits and modular subroutines.
+- **Compilation Stages**: Understand high-level synthesis, basis translation,
+  layout selection, and scheduling; tune each stage for depth and fidelity.
+- **Hardware Awareness**: Align qubit allocation with device coupling maps and
+  apply gate direction corrections plus SWAP insertion strategies judiciously.
+- **Optimization Heuristics**: Employ gate cancellation, commutation analysis,
+  and resynthesis passes; iterate on pass managers to hit depth or width
+  targets.
+- **Calibration Integration**: Consume backend calibration data (gate errors,
+  T1/T2, readout errors) to inform transpiler cost models and pulse-level
+  adjustments.
+
+## Tools & Methodologies
+
+- **Qiskit Workflow**: Use `QuantumCircuit`, `transpile`, and `PassManager`
+  with custom passes; export to QASM or pulse schedules when required.
+- **Cirq Workflow**: Build `Circuit` objects with PhasedFSim gates, optimize
+  via `cirq.optimize_for_target_gateset`, and serialize using `cirq.to_json`.
+- **Cross-Framework Interop**: Convert circuits via `qasm3` or `tket` bridges
+  for comparative benchmarking.
+- **Pulse-Level Control**: Employ Qiskit Pulse or Cirq’s `pulses` module for
+  custom calibrations and dynamical decoupling sequences.
+- **Automation Pipelines**: Script transpilation sweeps across optimization
+  levels, collect performance metrics, and store build artifacts for
+  reproducibility.
+
+## Example Scenario
+
+An R&D team migrates a chemistry VQE circuit to new superconducting hardware.
+They create a custom Qiskit `PassManager` that performs layout selection via
+SABRE, enables commutation-aware gate cancellations, and inserts echoed
+cross-resonance calibrations, cutting circuit depth by 27% while preserving
+expected energy accuracy.
+
+## Reference Resources
+
+- Qiskit Documentation: <https://qiskit.org/documentation>
+- Cirq Documentation: <https://quantumai.google/cirq>
+- Murali et al., “Noise-Adaptive Compiler Mappings for Noisy
+  Intermediate-Scale Quantum Computers,” *ASPLOS* (2019)
+- Cowtan et al., “On the Qubit Routing Problem,” *ACM TECS* (2020)
+- TKET Compiler: <https://cqcl.github.io/tket/pytket/api>

package/examples/agents/.automatosx/abilities/quantum-noise-modeling.md

@@ -0,0 +1,58 @@
+# Quantum Noise Modeling
+
+## Overview
+
+Model and mitigate noise in quantum systems by characterizing decoherence
+channels, gate error rates, and calibration drift to improve reliability of
+algorithm execution on NISQ and emerging fault-tolerant hardware.
+
+## Core Concepts & Best Practices
+
+- **Noise Channels**: Represent errors via Kraus operators (depolarizing,
+  amplitude damping, phase damping) or Lindblad master equations for
+  continuous-time modeling.
+- **Decoherence Metrics**: Track T1/T2 times, Ramsey fringes, and spin-echo
+  results; monitor temperature and flux bias stability.
+- **Gate Characterization**: Use randomized benchmarking, interleaved RB, gate
+  set tomography, and cycle benchmarking to quantify fidelity.
+- **Readout Analysis**: Build confusion matrices, apply measurement error
+  mitigation, and detect drift through auto-calibration routines.
+- **Calibration Strategies**: Schedule frequent recalibrations, employ
+  closed-loop optimization, and maintain calibration history with anomaly
+  alerts.
+
+## Tools & Methodologies
+
+- **Simulation Platforms**: Employ Qiskit Aer noise models, Cirq’s
+  `NoiseModel`, or QuTiP for density-matrix simulations.
+- **Characterization Pipelines**: Automate RB experiments, fit exponential
+  decay to extract error per Clifford, and store metadata in configuration
+  databases.
+- **Drift Detection**: Apply statistical process control (SPC) on calibration
+  metrics; trigger recalibration when control charts exceed thresholds.
+- **Noise-Aware Scheduling**: Route circuits through lower-error qubits, adjust
+  scheduling to avoid crosstalk hotspots, and insert dynamical decoupling
+  pulses.
+- **Mitigation Techniques**: Combine zero-noise extrapolation, probabilistic
+  error cancellation, and measurement mitigation with robust statistical
+  post-processing.
+
+## Example Scenario
+
+An operations team observes declining algorithm fidelity on a trapped-ion
+device. They run interleaved RB to isolate a two-qubit gate with rising error,
+update the Qiskit Aer noise model with new Kraus parameters, and deploy
+adaptive recalibration routines that restore average gate fidelity above
+99.5%, improving VQE energy convergence.
+
+## Reference Resources
+
+- Wallman & Emerson, “Noise Tailoring for Scalable Quantum Computation via
+  Randomized Compiling,” *PRL* (2016)
+- Kjaergaard et al., “Superconducting Qubits: Current State of Play,” *Annual
+  Review of Condensed Matter Physics* (2020)
+- Magesan et al., “Scalable and Robust Randomized Benchmarking of Quantum
+  Processes,” *PRL* (2011)
+- QuTiP Documentation: <https://qutip.org>
+- Kandala et al., “Error Mitigation Extends the Computational Reach of a Noisy
+  Quantum Processor,” *Nature* (2019)