aether-quant 0.2.0__tar.gz → 0.3.0__tar.gz

aether_quant-0.3.0/.env.live.example

@@ -0,0 +1,15 @@
+# Copy this file to .env.live (untracked, .gitignore'd) and fill in real
+# values before switching phase_v2.runtime.mode to "live" (V2-22). Never
+# commit .env.live.
+#
+# This is read by execution/live_credentials_io.py as a pre-flight
+# credential-presence check only. It does NOT wire Lean itself - Lean's
+# BrokerageSetupHandler reads ib-account/ib-user-name/ib-password/
+# ib-trading-mode directly out of lean.json (also gitignored); populate
+# those fields by hand as a separate step (see development/infrastructure.md's
+# "Live Deployment Betreiben (V2-22)" runbook).
+
+AETHER_IB_ACCOUNT=
+AETHER_IB_USER_NAME=
+AETHER_IB_PASSWORD=
+AETHER_IB_TRADING_MODE=paper

{aether_quant-0.2.0 → aether_quant-0.3.0}/.gitignore

@@ -16,6 +16,7 @@ env/
 .env
 .env.*
 !.env.compose.example
+!.env.live.example
 ib_config.py
 *_config.local.py
 config.json

aether_quant-0.3.0/Dockerfile.workers

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements/requirements-workers.txt .
+RUN pip install --no-cache-dir -r requirements-workers.txt
+COPY execution/ ./execution/
+COPY experience/ ./experience/
+COPY performance/ ./performance/
+COPY notifications/ ./notifications/

{aether_quant-0.2.0 → aether_quant-0.3.0}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: aether-quant
-Version: 0.2.0
+Version: 0.3.0
 Summary: Aether Quant convenience CLI
 Requires-Python: >=3.10

aether_quant-0.3.0/README.md

@@ -0,0 +1,536 @@
+<p align="center">
+  <img src="development/logo.png" width="220" alt="Aether Quant logo">
+</p>
+
+<h1 align="center">Aether Quant</h1>
+
+<p align="center">
+  <strong>My state-of-the-art flagship trading model — a dynamic, self-adapting algorithmic trading system built on QuantConnect Lean and PyTorch, engineered to prove that dynamic models belong in dynamic markets.</strong>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/python-3.10%2B-FF8C00?style=flat-square&labelColor=1A1A1A&logo=python&logoColor=white" alt="Python 3.10+">
+  <!-- AQ:TEST_BADGE_START --><img src="https://img.shields.io/badge/tests-528%2F528%20passing-brightgreen?style=flat-square&labelColor=1A1A1A" alt="528 of 528 tests passing"><!-- AQ:TEST_BADGE_END -->
+  <img src="https://img.shields.io/pypi/v/aether-quant?style=flat-square&labelColor=1A1A1A&color=FF8C00" alt="PyPI version">
+  <img src="https://img.shields.io/badge/docker-ghcr.io%2Faether--quant-2496ED?style=flat-square&labelColor=1A1A1A&logo=docker&logoColor=white" alt="Docker image on GHCR">
+</p>
+
+Aether Quant is not a single static strategy — it's a **dynamic system**: a
+Mixture-of-Experts ensemble (bullish/bearish/sideways/volatility specialists)
+routed by a learned gating network, a market-regime detector, a 3D market
+topology layer that combines a deterministic correlation embedding with a
+learned probabilistic overlay, a liquidity/market-impact engine that adjusts
+position sizing to real trading conditions, and a controlled retraining loop
+that lets the model itself evolve as markets do — all wired together and
+validated end-to-end inside QuantConnect's Lean engine. The thesis this
+project exists to test is simple to state and hard to prove: **markets are
+non-stationary, so a trading model should be too.** Every subsystem here
+exists to make the model adapt — to regime shifts, to changing correlation
+structure, to liquidity conditions — rather than to fit one historical
+window and hope it generalizes.
+
+## Table of Contents
+
+- [Download](#download)
+- [Getting Started](#getting-started)
+- [Requirements](#requirements)
+- [Architecture](#architecture)
+- [Project Structure](#project-structure)
+- [Module Documentation](#module-documentation)
+- [Development Documentation](#development-documentation)
+- [Backtest Results](#backtest-results)
+- [Test Suite](#test-suite)
+- [CLI Reference](#cli-reference)
+- [Release Process](#release-process)
+- [Runbook](#runbook)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+
+---
+
+## Download
+
+If you just want to use Aether Quant rather than develop on it, no local
+`pip install -e .` or source checkout is needed — the CLI and backend are
+published as ready-to-use releases:
+
+```powershell
+pip install aether-quant
+docker pull ghcr.io/leon1706-lol/aether-quant:latest
+```
+
+`aq --help` is then available immediately (see [CLI Reference](#cli-reference)
+below). `aq` checks PyPI at most once every 24h (short timeout, never
+blocking) for a newer version and prints a one-line notice if one's
+available — disable with `AQ_SKIP_UPDATE_CHECK=1`.
+
+The Docker image is the same one `docker-compose.yml`'s `aether-quant`
+service pulls by default (override with the `AETHER_QUANT_IMAGE` env var,
+e.g. to use a locally built image instead).
+
+## Getting Started
+
+For local development (this repo cloned, a virtual environment active):
+
+1. Install dependencies:
+
+   ```powershell
+   pip install -r requirements/requirements.txt
+   pip install -r requirements/requirements-dev.txt   # local dev extras
+   ```
+
+2. Refresh the data inventory only:
+
+   ```powershell
+   python train.py --init-only
+   ```
+
+3. Build the dataset and train the model:
+
+   ```powershell
+   python train.py
+   ```
+
+   Or build dataset artifacts only, without training:
+
+   ```powershell
+   python train.py --dataset-only
+   ```
+
+4. Start the webui locally (two processes):
+
+   ```powershell
+   uvicorn monitoring.api_server:app --port 8001 --reload
+   ```
+
+   ```powershell
+   cd webui
+   npm install
+   npm run dev
+   ```
+
+   Then open `http://localhost:3002`.
+
+5. Run a real backtest and refresh this README's [Backtest Results](#backtest-results):
+
+   ```powershell
+   pip install -e .   # registers the `aq` command from source
+   aq backtest
+   ```
+
+## Requirements
+
+- **Python ≥ 3.10** for the training pipeline, `main.py`'s Lean algorithm, the FastAPI monitoring server, and the `aq` CLI.
+- **QuantConnect Lean CLI** (`pip install lean`) for running backtests and paper/live trading.
+- **Docker & Docker Compose** for the local infrastructure (Redis, PostgreSQL, and the background workers — experience persistence, performance triggers, controlled retraining, Telegram alerts).
+- **Node.js** (for the `webui/` React/Vite dashboard).
+
+This repo splits its Python dependencies across several `requirements*.txt`
+files (full training stack vs. minimal per-Docker-image installs vs. local
+dev extras) rather than one monolithic file. See
+**[`requirements/README.md`](requirements/README.md)** for the exact
+`pip install` command for every variant and which Dockerfile consumes each one.
+
+## Architecture
+
+Aether Quant runs a daily-bar decision pipeline entirely inside Lean's
+`on_data()` callback: features flow through regime detection and 3D topology
+modeling, both feed a gating network that routes across four specialized
+experts, the central market analyzer combines all of that with the liquidity
+engine's sizing input into one categorical action per asset per bar, and
+every decision is persisted through a Redis → PostgreSQL experience pipeline
+that a controlled retraining loop reads from to evolve the model over time.
+
+#### System Flow
+
+```mermaid
+flowchart LR
+    A["Lean data folder<br/>stocks, ETFs, crypto"] --> B["Feature pipeline<br/>train.py"]
+    B --> C["Regime detection<br/>trend, volatility, drawdown, correlation"]
+    B --> D["3D topology modeling<br/>market structure and clusters"]
+    C --> E["Gating network<br/>the manager"]
+    D --> E
+    E --> F["Expert modules"]
+    F --> G["Bullish expert"]
+    F --> H["Bearish expert"]
+    F --> I["Sideways expert"]
+    F --> J["Volatility expert"]
+    G --> K["Market analyzer<br/>central decision layer"]
+    H --> K
+    I --> K
+    J --> K
+    C --> K
+    D --> K
+    L["Liquidity engine<br/>DDV, participation rate,<br/>slippage estimate"] --> K
+    K --> M["Action categorization<br/>trade / simulate / observe<br/>reduce_risk / retrain_candidate"]
+    M --> N["Lean order execution<br/>InteractiveBrokersFeeModel"]
+    M --> O["Observation / simulation record"]
+    N --> P["Redis event stream<br/>temporary low-latency buffer"]
+    O --> P
+    P --> Q["Experience worker<br/>async batch persistence"]
+    Q --> R["PostgreSQL experience database<br/>single source of truth"]
+    R --> S["Performance triggers<br/>100 observations, drawdown, Sharpe, regime shift"]
+    S --> T["Controlled retraining<br/>versioned weights and rollback"]
+    T --> E
+```
+
+#### Tech Stack
+
+```mermaid
+flowchart TB
+    A["Infrastructure"] --> A1["Docker Compose<br/>(Redis, Postgres, aether-quant app)"]
+    A --> A2["Lean CLI<br/>(backtest + paper trading)"]
+    A --> A3["30-day observation phase before live mode"]
+    B["Development"] --> B1["VS Code + Claude Code"]
+    B --> B2["GitHub"]
+    C["Data and storage"] --> C1["Lean data folder for training/backtesting"]
+    C --> C2["Redis temporary event stream"]
+    C --> C3["PostgreSQL permanent experience database"]
+    D["AI and modeling"] --> D1["PyTorch"]
+    D --> D2["scikit-learn"]
+    D --> D3["NumPy / Pandas"]
+    D --> D4["MoE experts and gating network"]
+    E["Monitoring and UI"] --> E1["React/Vite webui — Tracing dashboard (port 3002 dev / 8001 Docker)"]
+    E --> E2["FastAPI JSON API (port 8000)"]
+    E --> E3["Telegram alerts (V2-19)<br/>notifications/telegram_worker.py"]
+```
+
+These two diagrams are the high-level summary. For the full system —
+every per-phase "contract" (Observation Mode, Performance Triggers,
+Controlled Retraining, 3D Topology, Liquidity Engine, Paper/Live Deployment,
+and more), the module map, and an honest analysis of what would need to
+change for this to become a genuinely low-latency/HFT system — see
+**[`development/v2_architecture.md`](development/v2_architecture.md)**.
+
+## Project Structure
+
+```text
+aether-quant/
+├── .github/                     # CI workflows (tests, webui build, release)
+├── development/                 # Architecture docs, changelog, problems log, backtest chart
+├── data/                        # Local Lean data folder (equities, crypto)
+├── data_pipeline/                # Lean-data contract + Yahoo Finance historical backfill
+├── analyzer/                    # Central market analyzer (final per-asset decision layer)
+├── moe/                         # Mixture-of-Experts gating network
+├── experts/                     # Bullish / bearish / sideways / volatility expert models
+├── regime/                      # Market regime detection
+├── topology/                    # 3D market topology (deterministic SMACOF + learned overlay)
+├── liquidity/                   # Liquidity / market-impact engine
+├── risk/                        # Dynamic position sizing, leverage, drawdown controls
+├── execution/                   # Order gating, paper/live broker readiness, config caching
+├── inference/                   # Vectorized neural-network forward-pass interpreter
+├── experience/                  # Redis -> PostgreSQL observation/decision history pipeline
+├── performance/                 # Performance trigger system (drawdown, Sharpe, regime-shift, ...)
+├── retraining/                  # Controlled retraining: plan/train/validate/backtest/promote
+├── monitoring/                  # FastAPI JSON API serving runtime state to the webui
+├── notifications/               # Telegram alerting worker
+├── visualization/               # Shared runtime-state JSON/CSV exports
+├── webui/                       # React/Vite dashboard (Overview, Risk, Topology, Neural Network, Tracing)
+├── ml/                          # Model weights, datasets, versioned retraining candidates
+├── storage/                     # Reserved for future persistent artifact storage
+├── requirements/                # All requirements*.txt variants
+├── tests/                       # Full pytest suite (507 tests)
+├── backtests/                   # Lean backtest run outputs (gitignored)
+├── Aether-quant-Obsidian-Vault/ # Auto-generated code-graph / architecture vault
+├── main.py                      # Lean algorithm: inference, signal engine, risk controls
+├── train.py                     # Training pipeline: dataset build, model training, validation
+├── train_topology.py            # Offline trainer for the learned topology overlay
+├── generate_backtest_report.py  # Regenerates this README's Backtest Results section
+├── aq_cli.py                    # `aq` convenience CLI
+├── config.json                  # Runtime configuration (phase1 / phase_v2 blocks)
+├── lean.json                    # Lean engine + brokerage configuration
+├── docker-compose.yml           # Local infrastructure (Lean, Redis, PostgreSQL, workers)
+└── pyproject.toml               # Package metadata, `aq` entry point, pytest config
+```
+
+## Module Documentation
+
+Every package below has its own README with the full detail on what it owns
+and how it's wired in — this table is the index.
+
+| Module | What it owns | Docs |
+|---|---|---|
+| `analyzer/` | Central market analyzer — the final per-asset action categorization layer | [README](analyzer/README.md) |
+| `data/` | Local Lean data-folder format documentation | [README](data/README.md) |
+| `data_pipeline/` | Lean-data contract + Yahoo Finance historical backfill | [README](data_pipeline/README.md) |
+| `execution/` | Order gating, paper/live broker readiness, config-read caching | [README](execution/README.md) |
+| `experience/` | Observation/decision history — Redis buffer + PostgreSQL persistence | [README](experience/README.md) |
+| `experts/` | Bullish, bearish, sideways, and volatility expert models | [README](experts/README.md) |
+| `inference/` | Vectorized forward-pass interpreter for the exported neural networks | [README](inference/README.md) |
+| `liquidity/` | Liquidity and market-impact engine | [README](liquidity/README.md) |
+| `ml/` | Model & dataset artifacts, including versioned retraining candidates | [README](ml/README.md) |
+| `moe/` | Mixture-of-Experts gating network | [README](moe/README.md) |
+| `monitoring/` | FastAPI JSON API serving runtime state to the webui | [README](monitoring/README.md) |
+| `notifications/` | Telegram alerting worker | [README](notifications/README.md) |
+| `performance/` | Performance trigger system (14 trigger functions) | [README](performance/README.md) |
+| `regime/` | Market regime detection | [README](regime/README.md) |
+| `requirements/` | All `requirements*.txt` variants and what consumes each | [README](requirements/README.md) |
+| `retraining/` | Controlled retraining — plan/train/validate/backtest/commit/promote/rollback | [README](retraining/README.md) |
+| `risk/` | Dynamic position sizing, leverage caps, drawdown-aware sizing | [README](risk/README.md) |
+| `storage/` | Reserved placeholder for future persistent artifact storage | [README](storage/README.md) |
+| `tests/` | Pytest suite conventions (507 tests) | [README](tests/README.md) |
+| `topology/` | 3D market topology — deterministic SMACOF embedding + learned overlay | [README](topology/README.md) |
+| `visualization/` | Shared runtime-state JSON/CSV exports | [README](visualization/README.md) |
+| `webui/` | React/Vite dashboard (Overview, Risk, Topology, Neural Network, Tracing) | [README](webui/README.md) |
+| `Aether-quant-Obsidian-Vault/` | Auto-generated Obsidian vault mirroring the repo's architecture/code graph | [README](Aether-quant-Obsidian-Vault/README.md) |
+
+## Development Documentation
+
+| Document | Contents |
+|---|---|
+| [`development/README.md`](development/README.md) | Index of this folder |
+| [`development/v2_architecture.md`](development/v2_architecture.md) | The full V2 system architecture: process-flow and tech-stack diagrams, the module map, per-phase "contract" sections, and the HFT-readiness analysis |
+| [`development/infrastructure.md`](development/infrastructure.md) | Docker Compose runbook — start commands for every service, SQL inspection snippets, port reference |
+| [`development/Changelog.md`](development/Changelog.md) | Detailed, append-only, per-phase build history — what was built, when, and why |
+| [`development/Problems.md`](development/Problems.md) | Append-only audit log of bugs and infrastructure issues, each with a severity rating and fixed/open status |
+
+## Backtest Results
+
+<!-- AQ:BACKTEST_START -->
+![Backtest equity curve](development/backtest_equity_chart.png)
+
+| Metric | Value |
+|---|---|
+| Backtest window | 2014-12-01 to 2016-07-06 |
+| Last updated | 2026-07-05 15:37 UTC (auto-generated by `aq backtest`) |
+<!-- AQ:BACKTEST_END -->
+
+This section is regenerated automatically every time you run `aq backtest`
+(see [`generate_backtest_report.py`](generate_backtest_report.py)) — it
+always reflects your most recent successful Lean backtest, reading directly
+from Lean's own result JSON (strategy equity curve, its native SPY benchmark
+series, and the full statistics block), so it never goes stale as long as
+you keep backtesting.
+
+## Test Suite
+
+507 tests, one file per source module, run via:
+
+```powershell
+aq test
+```
+
+which — like the backtest chart above — automatically keeps the badge at
+the top of this README in sync with the real pass count every time you run
+it. See [`tests/README.md`](tests/README.md) for the suite's conventions.
+
+## CLI Reference
+
+The easiest way to get the `aq` command is straight from PyPI (see
+[Download](#download) above) — no source checkout needed:
+
+```powershell
+pip install aether-quant
+```
+
+For local development (this repo cloned, a virtual environment active),
+`pip install -e .` registers the same `aq` command directly from source
+instead, without waiting on a PyPI release:
+
+```powershell
+pip install -e .
+```
+
+Either way, `aq --help` gives the full command list:
+
+```text
+aq train [--dataset-only|--init-only|--experts-only]
+aq test
+aq backtest
+aq report <backtest-folder> <result-id>
+aq api
+aq webui
+aq docker up [--lean|--all]
+aq docker build
+aq retrain <plan|train|validate|backtest|commit|promote|rollback|status> [...]
+aq trade-lock --on|--off|--auto|--status
+aq status
+```
+
+Every command except `aq trade-lock` is a thin `subprocess` wrapper around a
+command already documented elsewhere in this README:
+
+- **`aq train`** — runs `train.py`: builds the dataset and trains the baseline + expert models.
+- **`aq test`** — runs the pytest suite and refreshes this README's test badge.
+- **`aq backtest`** — runs `lean backtest .` and refreshes this README's [Backtest Results](#backtest-results) section.
+- **`aq report <backtest-folder> <result-id>`** — generates Lean's own HTML backtest report (trade blotter, standard Lean charts) at `backtests/<backtest-folder>/report.html`.
+- **`aq api`** — starts the FastAPI monitoring server on `:8001`.
+- **`aq webui`** — starts the webui dev server (`npm run dev`).
+- **`aq docker up [--lean|--all]`** — starts local infrastructure (default: Redis + PostgreSQL only).
+- **`aq docker build`** — rebuilds the `aether-quant` app image.
+- **`aq retrain <stage>`** — dispatches to `python -m retraining.orchestrator <stage> ...` for a single manual pipeline stage.
+- **`aq trade-lock --on|--off|--auto|--status`** — manually overrides `main.py`'s sticky total-drawdown trade lock (see `development/v2_architecture.md`'s Manual Trade-Lock Override Contract). `--off` deliberately clears an otherwise-permanent lock; `--auto` returns to fully automatic behavior.
+- **`aq status`** — shows `git status`.
+
+## Release Process
+
+A release is exactly one manual step — deliberately no automatic release on
+every push to `main`, only on an explicitly pushed version tag
+(`.github/workflows/release.yml`, triggered on `push: tags: ["v*.*.*"]`):
+
+```powershell
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+This then automatically runs (no manual version bump anywhere in the repo —
+`pyproject.toml` reads the version straight from the tag via
+`setuptools-scm`):
+
+1. The test suite (`pytest`) — a failure blocks the release entirely.
+2. PyPI publishing via Trusted Publishing (OIDC) — no PyPI token is stored as a GitHub secret.
+3. Docker image build and push to `ghcr.io/leon1706-lol/aether-quant`, tagged with the version number and `:latest`.
+
+**One-time manual setup, before the first tag is ever pushed** (can't be
+done from here):
+
+- Create a "Trusted Publisher" on pypi.org for this project (pointing at `leon1706-lol/Aether-quant` + the `release.yml` workflow file).
+- After the very first tag push: check the **Packages** tab of this repo to see whether the new `aether-quant` package is private, and switch it to public if needed so `docker pull` works for everyone.
+
+## Runbook
+
+Everyday local commands.
+
+Activate the virtual environment:
+
+```powershell
+.\.venv\Scripts\Activate.ps1
+```
+
+Rebuild training artifacts:
+
+```powershell
+python train.py
+```
+
+Rebuild only the dataset/scaler/manifest:
+
+```powershell
+python train.py --dataset-only
+```
+
+Run the tests:
+
+```powershell
+pytest tests/
+```
+
+Recommended full workflow:
+
+```powershell
+python train.py
+pytest tests/
+aq backtest
+aq report <backtest-folder> <result-id>
+git status
+```
+
+Start a Lean backtest from the project folder:
+
+```powershell
+lean backtest .
+```
+
+Find a finished backtest:
+
+```powershell
+Get-ChildItem .\backtests\<backtest-folder>\*-summary.json
+```
+
+Generate the official Lean HTML report:
+
+```powershell
+lean report --backtest-results .\backtests\<backtest-folder>\<result-id>.json --report-destination .\backtests\<backtest-folder>\report.html --overwrite
+```
+
+Start the webui locally (API server and frontend, two terminals):
+
+```powershell
+uvicorn monitoring.api_server:app --port 8001 --reload
+```
+
+```powershell
+cd webui
+npm run dev
+```
+
+Then:
+
+```text
+http://localhost:3002          (Overview)
+http://localhost:3002/risk     (Risk)
+```
+
+Check git status before a commit:
+
+```powershell
+git status
+```
+
+## Roadmap
+
+### V1 — ✅ Finished
+
+The first universe was deliberately small and mixed:
+
+- `AAPL`
+- `SPY`
+- `QQQ`
+- `BTCUSD`
+
+Shared V1 data coverage:
+
+- Start: `2014-12-01`
+- End: `2018-08-13`
+- Resolution: `Daily`
+
+First windows:
+
+- Training: `2014-12-01` to `2017-06-30`
+- Validation: `2017-07-01` to `2017-12-31`
+- Backtest: `2018-01-01` to `2018-08-13`
+
+First target definition:
+
+- Target type: next day's direction
+- Label: `1` if the next close-to-close return is positive, else `0`
+
+First feature ideas:
+
+- 1d, 5d, and 20d returns
+- 5d and 20d volatility
+- 5d and 20d momentum
+- Daily range and open-close range
+- Volume change
+
+Detailed phase results (Phase 2 through Phase 10, Phase V2-1 through Phase
+V2-15, Visualization Unification) live in
+[`development/Changelog.md`](development/Changelog.md) to keep this README short.
+
+### V3 — 🔜 Incoming Soon
+
+`development/v2_architecture.md`'s own "Why This Is Not HFT, And What It
+Would Take" analysis is the honest starting point for what V3 needs to
+close — not marketing aspiration, but a concrete gap list the system's own
+architecture docs already identify:
+
+- **Tick/L1-L2 market data pipeline** — replacing the daily Lean zip files with a genuinely higher-frequency data source and storage layer.
+- **A shorter-horizon model** — a new model operating at sub-second/tick granularity with a much shorter prediction horizon, not a retrained version of today's daily classifier.
+- **Real slippage- and latency-aware execution** — an actual fill simulator and limit-order support, replacing today's `SetHoldings`/`Liquidate` market orders with no slippage model wired to fills.
+- **A low-latency, event-driven runtime** — replacing the daily-bar `on_data()` callback and the 30s+ polling background workers with something closer to a real-time event loop.
+- **Real broker/exchange connectivity beyond paper trading** — building on the credential/readiness groundwork V2-21/V2-22 already laid.
+- **Continuous / online retraining** — moving beyond today's offline, cooldown-gated batch retraining pipeline.
+- Further out: an expanded asset universe, multi-timeframe ensembles, and reinforcement-learning-based position sizing/execution.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Commit your changes following the existing module structure (see [`development/Changelog.md`](development/Changelog.md) for this project's development history)
+4. Open a Pull Request
+
+---
+
+<div align="center">
+  <sub>Built with Python · PyTorch · QuantConnect Lean · FastAPI · React · Redis · PostgreSQL · Docker</sub>
+</div>

{aether_quant-0.2.0 → aether_quant-0.3.0}/aether_quant.egg-info/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: aether-quant
-Version: 0.2.0
+Version: 0.3.0
 Summary: Aether Quant convenience CLI
 Requires-Python: >=3.10

{aether_quant-0.2.0 → aether_quant-0.3.0}/aether_quant.egg-info/SOURCES.txt

@@ -1,15 +1,15 @@
 .dockerignore
 .env.compose.example
+.env.live.example
 .gitattributes
 .gitignore
 Dockerfile
 Dockerfile.retraining_worker
-Dockerfile.telegram_worker
-Dockerfile.trigger_worker
-Dockerfile.worker
+Dockerfile.workers
 README.md
 aq_cli.py
 docker-compose.yml
+generate_backtest_report.py
 main.py
 pyproject.toml
 risk_controls.py
@@ -43,11 +43,19 @@ data_pipeline/yfinance_backfill.py
 development/Changelog.md
 development/Problems.md
 development/README.md
+development/backtest_equity_chart.png
 development/infrastructure.md
 development/v2_architecture.md
 execution/README.md
 execution/__init__.py
+execution/config_cache.py
+execution/live_credentials.py
+execution/live_credentials_io.py
 execution/order_gate.py
+execution/paper_readiness.py
+execution/paper_readiness_io.py
+execution/paper_readiness_report.py
+execution/runtime_config_io.py
 experience/README.md
 experience/__init__.py
 experience/observation_metrics.py
@@ -57,6 +65,9 @@ experience/simulated_portfolio.py
 experts/README.md
 experts/__init__.py
 experts/expert_datasets.py
+inference/README.md
+inference/__init__.py
+inference/exported_model.py
 liquidity/README.md
 liquidity/__init__.py
 liquidity/market_liquidity.py
@@ -86,9 +97,7 @@ requirements/README.md
 requirements/requirements-dev.txt
 requirements/requirements-retraining-worker.txt
 requirements/requirements-runtime.txt
-requirements/requirements-telegram-worker.txt
-requirements/requirements-trigger-worker.txt
-requirements/requirements-worker.txt
+requirements/requirements-workers.txt
 requirements/requirements.txt
 retraining/README.md
 retraining/__init__.py
@@ -110,13 +119,18 @@ risk/position_sizing.py
 tests/README.md
 tests/test_aq_cli.py
 tests/test_backtest_gate.py
+tests/test_config_cache.py
 tests/test_experience_queue.py
 tests/test_expert_datasets.py
 tests/test_expert_models.py
+tests/test_exported_model.py
 tests/test_gating_network.py
+tests/test_generate_backtest_report.py
 tests/test_lean_backtest.py
 tests/test_lean_backtest_ml_coverage.py
 tests/test_learned_topology.py
+tests/test_live_credentials.py
+tests/test_live_credentials_io.py
 tests/test_manual_override.py
 tests/test_market_analyzer.py
 tests/test_market_liquidity.py
@@ -125,6 +139,9 @@ tests/test_market_topology.py
 tests/test_neural_network_state.py
 tests/test_observation_metrics.py
 tests/test_order_gate.py
+tests/test_paper_readiness.py
+tests/test_paper_readiness_io.py
+tests/test_paper_readiness_report.py
 tests/test_position_sizing.py
 tests/test_postgres_telegram.py
 tests/test_postgres_triggers.py
@@ -135,6 +152,7 @@ tests/test_retraining_planning.py
 tests/test_retraining_postgres_registry.py
 tests/test_retraining_worker.py
 tests/test_risk_controls.py
+tests/test_runtime_config_io.py
 tests/test_simulated_portfolio.py
 tests/test_status_export.py
 tests/test_telegram_alerts.py
@@ -179,6 +197,7 @@ webui/src/components/layout/Panel.tsx
 webui/src/components/monitoring/CountTable.tsx
 webui/src/components/monitoring/MonitoringFeeds.tsx
 webui/src/components/monitoring/ObservationPanel.tsx
+webui/src/components/monitoring/PaperReadinessPanel.tsx
 webui/src/components/monitoring/PerformanceTriggersPanel.tsx
 webui/src/components/monitoring/RawStateViewer.tsx
 webui/src/components/monitoring/RetrainingStatusPanel.tsx