chore(deps): Bump actions/checkout from 6 to 7

Bumps [actions/checkout](https://github.com/actions/checkout) from 6 to 7.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v6...v7)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
   security:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - name: Run Bandit (Security Scan)
         uses: PyCQA/bandit-action@v1
@@ -25,7 +25,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:

.github/workflows/codacy.yml

@@ -36,7 +36,7 @@ jobs:
     steps:
       # Checkout the repository to the GitHub Actions runner
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       # Execute Codacy Analysis CLI and generate a SARIF output with the security issues identified during the analysis
       - name: Run Codacy Analysis CLI

.github/workflows/conventional-commits.yml

@@ -46,7 +46,7 @@ jobs:
     name: Validate Commit Messages
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
 

.github/workflows/docs.yml

@@ -25,7 +25,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Set up Python
       uses: actions/setup-python@v6

.github/workflows/lint.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Set up Python
       uses: actions/setup-python@v6

.github/workflows/scheduled-tests.yml

@@ -19,7 +19,7 @@ jobs:
         python-version: ["3.10", "3.11"]
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:
@@ -49,7 +49,7 @@ jobs:
     name: Dependency Audit
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:

.github/workflows/security.yml

@@ -19,7 +19,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Set up Python
       uses: actions/setup-python@v6

.gitignore

@@ -65,6 +65,7 @@ QWEN.md
 CLAUDE.md
 docs/COMPLETE_WORKFLOW.md
 docs/SMART_STRATEGY_GEN.md
+STARRED_REPOS_ANALYSIS.md
 
 # OpenACP workspace (secrets)
 .openacp
@@ -140,4 +141,4 @@ pickle_cache/
 RD-Agent_workspace_run*/
 AGENTS.md
 CLAUDE.md
-.claude/
+.claude/rdagent/components/coder/strategy_orchestrator.py

.pre-commit-config.yaml

@@ -1,19 +1,45 @@
-# Pre-commit hooks configuration for Predix
+# Pre-commit hooks configuration for NexQuant
 # See https://pre-commit.com for more information
 
 repos:
-  # ── Integration Tests (MANDATORY - MUST PASS before commit) ──────
+  # ── Test Coverage Check: new modules must have tests ──────────────
   - repo: local
     hooks:
-      - id: integration-tests
-        name: Run Integration Tests (60 tests)
+      - id: check-test-coverage
+        name: Check new rdagent modules have tests
+        entry: python scripts/check_test_coverage.py
+        language: system
+        pass_filenames: false
+        always_run: true
+
+  # ── MyPy Ratchet: no new type errors allowed ────────────────────
+  - repo: local
+    hooks:
+      - id: mypy-ratchet
+        name: MyPy ratchet (no new type errors)
+        entry: python scripts/check_mypy_ratchet.py
+        language: system
+        pass_filenames: false
+        always_run: true
+
+  # ── Qlib Unit Tests (MANDATORY) ──────────────────────────────────
+  - repo: local
+    hooks:
+      - id: qlib-unit-tests
+        name: Qlib Unit Tests (~490 tests)
         entry: pytest
         language: system
         args:
-          - test/integration/test_all_features.py
+          - test/qlib/
+          - test/backtesting/
           - -v
           - --tb=short
-          - --no-cov  # Skip coverage for speed (run separately if needed)
+          - --cov=rdagent
+          - --cov-fail-under=33
+          - --cov-report=term
+          - --ignore=test/backtesting/test_ftmo_oos.py
+          - --ignore=test/backtesting/test_kronos_adapter.py
+          - --ignore=test/qlib/test_fin_quant_integration.py
         pass_filenames: false
         always_run: true
 

.release-please-manifest.json

@@ -1,3 +1 @@
-{
-  ".": "1.3.11"
-}
+{".": "1.5.0"}

CHANGELOG.md

@@ -1,208 +1,589 @@
 # Changelog
 
-## [1.3.11](https://github.com/TPTBusiness/Predix/compare/v1.3.10...v1.3.11) (2026-05-01)
-
-
-### Bug Fixes
-
-* **ci:** lazy import logger in predix.py and cli.py to avoid ImportError in test env ([60763e8](https://github.com/TPTBusiness/Predix/commit/60763e8eae34f41865ba8e5e65bdfde13b564b4b))
-
-## [1.3.10](https://github.com/TPTBusiness/Predix/compare/v1.3.9...v1.3.10) (2026-05-01)
-
-
-### Bug Fixes
-
-* **security:** replace remaining assert statements with proper error handling ([928533d](https://github.com/TPTBusiness/Predix/commit/928533d9a81bd5062f07458fbf94d3c7fe347775))
-
-## [1.3.9](https://github.com/TPTBusiness/Predix/compare/v1.3.8...v1.3.9) (2026-05-01)
-
-
-### Bug Fixes
-
-* **security:** resolve path-injection, B701, B101, B112 Bandit alerts ([20b89a0](https://github.com/TPTBusiness/Predix/commit/20b89a061843b39836e975f158404e8e2d4627cd))
-
-## [1.3.8](https://github.com/TPTBusiness/Predix/compare/v1.3.7...v1.3.8) (2026-04-30)
-
-
-### Bug Fixes
-
-* **deps:** relax aiohttp constraint to >=3.13.4 for litellm compatibility ([34ab192](https://github.com/TPTBusiness/Predix/commit/34ab1923a887089eb36e5cbad6cb8df16f0333ca))
-* **qlib:** correct indentation in except blocks in quant_proposal and factor_runner ([8143451](https://github.com/TPTBusiness/Predix/commit/8143451e8c0ead01c4d86d19669268c7bfb15fac))
-* **security:** replace eval() with ast.literal_eval in finetune validator (B307) ([0508caf](https://github.com/TPTBusiness/Predix/commit/0508caf9140d210b823fefefa28ee535ec85a0ae))
-* **security:** replace shell=True subprocess calls with list args in env.py (B602) ([2012d5a](https://github.com/TPTBusiness/Predix/commit/2012d5ae4e77cc2f1ab9a48beaaac5a74695d083))
-* **security:** resolve path-injection and add nosec for safe temp paths (B108, py/path-injection) ([6727480](https://github.com/TPTBusiness/Predix/commit/67274803bd1d14e5d1df9a063f46b2edb8501a2b))
-
-## [1.3.7](https://github.com/TPTBusiness/Predix/compare/v1.3.6...v1.3.7) (2026-04-30)
-
-
-### Bug Fixes
-
-* **security:** nosec for B608/B701 false positives in UI and template code ([5eb5d7e](https://github.com/TPTBusiness/Predix/commit/5eb5d7e8fdbe90e0dced83fef4e09f5a33e96b2b))
-* **security:** replace eval() with ast.literal_eval and add request timeouts (B307, B113) ([3301ada](https://github.com/TPTBusiness/Predix/commit/3301ada697ca7d3afa1a188d2a76a87ae98b4529))
-* **security:** replace shell=True subprocess calls with list args (B602) ([13c08f4](https://github.com/TPTBusiness/Predix/commit/13c08f4ce6813eb7c314087921ec8c0f40074bd7))
-
-## [1.3.6](https://github.com/TPTBusiness/Predix/compare/v1.3.5...v1.3.6) (2026-04-30)
-
-
-### Bug Fixes
-
-* **security:** real fix for B110 (logging in factor_proposal.py [#746](https://github.com/TPTBusiness/Predix/issues/746)) ([16624e0](https://github.com/TPTBusiness/Predix/commit/16624e0bd966ae4d24c4a3eb42bbc31c11da3136))
-* **security:** real fix for B110 (logging in factor_runner.py [#744](https://github.com/TPTBusiness/Predix/issues/744)) ([88cf0fb](https://github.com/TPTBusiness/Predix/commit/88cf0fb8828b11c97f2f3ae2881a4900b020c6f0))
-* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/Predix/issues/741)) ([7cf2a64](https://github.com/TPTBusiness/Predix/commit/7cf2a644f553b054bd4b0607ea51e5372e68d90a))
-* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/Predix/issues/741)) ([ef985f8](https://github.com/TPTBusiness/Predix/commit/ef985f86035d8dca707c60137e6508349a0c4ae6))
-* **security:** real fix for B404/B603 (sys.executable in factor_runner.py [#745](https://github.com/TPTBusiness/Predix/issues/745)) ([819655a](https://github.com/TPTBusiness/Predix/commit/819655aaa3efa76596d60501d0e8ca365df3e5e2))
-* **security:** revert broken read_pickle encoding arg in kaggle template (B301) ([3574907](https://github.com/TPTBusiness/Predix/commit/35749073c91e69f63ddaad61dae3f2b799327e63))
-* **security:** validate SQL identifiers in _add_column_if_not_exists (B608) ([e10dfa2](https://github.com/TPTBusiness/Predix/commit/e10dfa2576038e911f83595d3b466c261bc0cd54))
-* **security:** whitelist-validate metric column in get_top_factors (B608) ([e50519f](https://github.com/TPTBusiness/Predix/commit/e50519fe066e68aec2f19b83df4f643c3c22053d))
-
-## [1.3.5](https://github.com/TPTBusiness/Predix/compare/v1.3.4...v1.3.5) (2026-04-27)
-
-
-### Bug Fixes
-
-* **auto-fixer:** add five new factor code fixes for groupby/apply errors ([449c8fd](https://github.com/TPTBusiness/Predix/commit/449c8fd70a327e604dcca122e4a134f0cca918e4))
-* **auto-fixer:** add four new factor code fixes for common runtime errors ([40484f6](https://github.com/TPTBusiness/Predix/commit/40484f6d300425da481f1edd325da4acbc06ec7d))
-* **auto-fixer:** add groupby([level=N,'date']) SyntaxError fix ([ca77c00](https://github.com/TPTBusiness/Predix/commit/ca77c005bea4abdd8854c1de2b0e8d03b7742161))
-* **auto-fixer:** disable _fix_min_periods for intraday data ([77b0740](https://github.com/TPTBusiness/Predix/commit/77b0740f059349df7e769a378af728aa33b2070e))
-* **auto-fixer:** fix chained groupby(level=N).groupby('date') pattern ([7d5fe32](https://github.com/TPTBusiness/Predix/commit/7d5fe32b31a19ce8b04bd8f5a430720fdb748f7a))
-* **auto-fixer:** fix df.loc[instrument] DateParseError on MultiIndex frames ([b7860ea](https://github.com/TPTBusiness/Predix/commit/b7860eafc0ad26384947ce0510ecf4e9f3425807))
-* **auto-fixer:** fix df['instrument'] KeyError on MultiIndex frames ([aad6bd1](https://github.com/TPTBusiness/Predix/commit/aad6bd1c7c720b3d486e0cf248337f32394773b1))
-* **auto-fixer:** fix two assignment-target bugs in instrument column fixers ([421eedf](https://github.com/TPTBusiness/Predix/commit/421eedffed4b883c24397dc5581c019a3985277f))
-* **auto-fixer:** preserve date dimension in groupby(['instrument','date']) fix ([b58fdd8](https://github.com/TPTBusiness/Predix/commit/b58fdd8be43720b5d4363e0f8de9a01591d4d2dc))
-* **auto-fixer:** remove ddof from rolling() args, not only from std()/var() ([b0fc328](https://github.com/TPTBusiness/Predix/commit/b0fc328d0d4a041c65d8eeb32cb3f2bb86568406))
-* **auto-fixer:** strip spurious .reset_index() after .transform() calls ([8708aae](https://github.com/TPTBusiness/Predix/commit/8708aae6e08728cda1875c775a76dc92e43576f3))
-* **loop:** prevent step_idx advance on unhandled exceptions + fix consecutive assistant messages ([5ec4ad1](https://github.com/TPTBusiness/Predix/commit/5ec4ad1b96b5b99ef42bea7bb828cb1ef709a688))
-
-## [1.3.4](https://github.com/TPTBusiness/Predix/compare/v1.3.3...v1.3.4) (2026-04-27)
-
-
-### Bug Fixes
-
-* **auto-fixer:** add five new factor code fixes for groupby/apply errors ([449c8fd](https://github.com/TPTBusiness/Predix/commit/449c8fd70a327e604dcca122e4a134f0cca918e4))
-* **auto-fixer:** add four new factor code fixes for common runtime errors ([40484f6](https://github.com/TPTBusiness/Predix/commit/40484f6d300425da481f1edd325da4acbc06ec7d))
-* **auto-fixer:** add groupby([level=N,'date']) SyntaxError fix ([ca77c00](https://github.com/TPTBusiness/Predix/commit/ca77c005bea4abdd8854c1de2b0e8d03b7742161))
-* **auto-fixer:** disable _fix_min_periods for intraday data ([77b0740](https://github.com/TPTBusiness/Predix/commit/77b0740f059349df7e769a378af728aa33b2070e))
-* **auto-fixer:** fix chained groupby(level=N).groupby('date') pattern ([7d5fe32](https://github.com/TPTBusiness/Predix/commit/7d5fe32b31a19ce8b04bd8f5a430720fdb748f7a))
-* **auto-fixer:** fix df.loc[instrument] DateParseError on MultiIndex frames ([b7860ea](https://github.com/TPTBusiness/Predix/commit/b7860eafc0ad26384947ce0510ecf4e9f3425807))
-* **auto-fixer:** fix df['instrument'] KeyError on MultiIndex frames ([aad6bd1](https://github.com/TPTBusiness/Predix/commit/aad6bd1c7c720b3d486e0cf248337f32394773b1))
-* **auto-fixer:** preserve date dimension in groupby(['instrument','date']) fix ([b58fdd8](https://github.com/TPTBusiness/Predix/commit/b58fdd8be43720b5d4363e0f8de9a01591d4d2dc))
-* **auto-fixer:** remove ddof from rolling() args, not only from std()/var() ([b0fc328](https://github.com/TPTBusiness/Predix/commit/b0fc328d0d4a041c65d8eeb32cb3f2bb86568406))
-* **backtest:** replace broken MC permutation test with binomial win-rate test ([c38d894](https://github.com/TPTBusiness/Predix/commit/c38d89478f586825bfca5715a96ca70ccd8791a3))
-* **factors:** detect and correct look-ahead bias in daily-constant factors ([eb490a4](https://github.com/TPTBusiness/Predix/commit/eb490a461b66cbd815ae53ac5205115754712432))
-* **factors:** extend look-ahead rules to session factors and add intraday-factor guidance ([c24c100](https://github.com/TPTBusiness/Predix/commit/c24c100442d6487686c0578de0b32d240fcbf215))
-* **loop:** compress old experiment history in proposal prompt to reduce context size ([4bf90a9](https://github.com/TPTBusiness/Predix/commit/4bf90a905ba8b2aba2a818191c19998088cccaaf))
-* **loop:** prevent step_idx advance on unhandled exceptions + fix consecutive assistant messages ([5ec4ad1](https://github.com/TPTBusiness/Predix/commit/5ec4ad1b96b5b99ef42bea7bb828cb1ef709a688))
-
-## [1.3.3](https://github.com/TPTBusiness/Predix/compare/v1.3.2...v1.3.3) (2026-04-25)
-
-
-### Bug Fixes
-
-* **backtest:** replace broken MC permutation test with binomial win-rate test ([c38d894](https://github.com/TPTBusiness/Predix/commit/c38d89478f586825bfca5715a96ca70ccd8791a3))
-* **factors:** detect and correct look-ahead bias in daily-constant factors ([eb490a4](https://github.com/TPTBusiness/Predix/commit/eb490a461b66cbd815ae53ac5205115754712432))
-* **factors:** extend look-ahead rules to session factors and add intraday-factor guidance ([c24c100](https://github.com/TPTBusiness/Predix/commit/c24c100442d6487686c0578de0b32d240fcbf215))
-* **loop:** compress old experiment history in proposal prompt to reduce context size ([4bf90a9](https://github.com/TPTBusiness/Predix/commit/4bf90a905ba8b2aba2a818191c19998088cccaaf))
-* **strategies:** guard against None IC in acceptance check, disable slow wf_rolling ([2197f52](https://github.com/TPTBusiness/Predix/commit/2197f52150a50ef38d9e70991d7e48c8c30caec4))
-* **strategies:** handle None ic/sharpe/dd in rejected strategy log output ([ad2ad3a](https://github.com/TPTBusiness/Predix/commit/ad2ad3ab3360ea75ed3bbc90c12098b9c5cc0114))
-
-## [1.3.2](https://github.com/TPTBusiness/Predix/compare/v1.3.1...v1.3.2) (2026-04-23)
-
-
-### Bug Fixes
-
-* **strategies:** guard against None IC in acceptance check, disable slow wf_rolling ([2197f52](https://github.com/TPTBusiness/Predix/commit/2197f52150a50ef38d9e70991d7e48c8c30caec4))
-* **strategies:** handle None ic/sharpe/dd in rejected strategy log output ([ad2ad3a](https://github.com/TPTBusiness/Predix/commit/ad2ad3ab3360ea75ed3bbc90c12098b9c5cc0114))
-
-## [1.3.1](https://github.com/TPTBusiness/Predix/compare/v1.3.0...v1.3.1) (2026-04-21)
-
-
-### Bug Fixes
-
-* **deps:** bump python-dotenv to >=1.2.2 (CVE symlink overwrite) ([126ae7d](https://github.com/TPTBusiness/Predix/commit/126ae7d5fb556b677d09d10221862a0d648d697a))
-
-## [1.3.0](https://github.com/TPTBusiness/Predix/compare/v1.2.2...v1.3.0) (2026-04-21)
+## [0.8.0](https://github.com/TPTBusiness/NexQuant/compare/v1.4.2...v0.8.0) (2026-05-04)
 
 
 ### Features
 
-* **backtest:** add rolling walk-forward validation and Monte Carlo trade permutation test ([637a94c](https://github.com/TPTBusiness/Predix/commit/637a94c1d987da763869f4f9b73372a3f37d873c))
+* [AutoRL-Bench] Update DeepSearchQA split and translate task instructions to English ([#1368](https://github.com/TPTBusiness/NexQuant/issues/1368)) ([ffb9491](https://github.com/TPTBusiness/NexQuant/commit/ffb9491c4703290a5b292baa6328ae06bc520f9b))
+* Add 'nexquant evaluate' command to CLI ([4308c25](https://github.com/TPTBusiness/NexQuant/commit/4308c257e7c83ab8ec5ef0a719b040f936bad0b3))
+* Add 'nexquant top' command + explain factor evaluation results ([ac3334c](https://github.com/TPTBusiness/NexQuant/commit/ac3334c17d8dce48a5081e45d407ccadedfec713))
+* Add 6 new CLI commands - all scripts integrated with local LLM ([e0dd07a](https://github.com/TPTBusiness/NexQuant/commit/e0dd07aa99ce33c2fc050d3d40b4520f245adb90))
+* add a rag mcp in proposal ([#1267](https://github.com/TPTBusiness/NexQuant/issues/1267)) ([dc7b732](https://github.com/TPTBusiness/NexQuant/commit/dc7b732b2c428e3cca3373e839a0e724a844c79b))
+* add a web UI server ([#1345](https://github.com/TPTBusiness/NexQuant/issues/1345)) ([1439548](https://github.com/TPTBusiness/NexQuant/commit/14395488b9c7ea476022a32211ea46de9925cf11))
+* Add advanced ML models (Transformer, TCN, PatchTST, CNN+LSTM) ([44760f8](https://github.com/TPTBusiness/NexQuant/commit/44760f83c3d3d38033f5d94f4ba37dc0c25b7f59))
+* Add AI Strategy Builder (StrategyCoSTEER) - Closed Source ([089189d](https://github.com/TPTBusiness/NexQuant/commit/089189d8ec058edefd0b81c2689b54f5180b9052))
+* Add beautiful CLI welcome screen for GitHub README ([9e4a97d](https://github.com/TPTBusiness/NexQuant/commit/9e4a97d3d7e6d5328c4ffa39ce833591f10ab731))
+* Add CLI model selection (local vs OpenRouter) ([c37935a](https://github.com/TPTBusiness/NexQuant/commit/c37935aa8c108a6bca393bcda274cda148101456))
+* Add complete ML pipeline with graceful degradation (closed source) ([ed6b906](https://github.com/TPTBusiness/NexQuant/commit/ed6b906248ac3068a4f188d01bcde403e93abc0c))
+* add daily log rotation, llama health wait, factor auto-fixer, and README updates ([2238fed](https://github.com/TPTBusiness/NexQuant/commit/2238fed701bd8a6ab1da1d3614d1c6d501e1ecbc))
+* Add factor code and description to saved results ([b6b378d](https://github.com/TPTBusiness/NexQuant/commit/b6b378da8abf6f15be0c91e83508dc21d27b5b14))
+* Add GitHub infrastructure, CI/CD pipelines, and examples ([26bd87e](https://github.com/TPTBusiness/NexQuant/commit/26bd87ed0a13da7190c8481356574bb710d00772))
+* add improve_mode to MultiProcessEvolvingStrategy for selective task implementation ([#1273](https://github.com/TPTBusiness/NexQuant/issues/1273)) ([03f22dc](https://github.com/TPTBusiness/NexQuant/commit/03f22dc7c72a039ee6f1a0e8d0393f35117ec3e1))
+* Add improved local prompt with MultiIndex code examples (v3) ([a729eb7](https://github.com/TPTBusiness/NexQuant/commit/a729eb715353961f71e92ddb679406c3c30b83d3))
+* add Kronos CLI commands, expand tests, document in README ([24a51e4](https://github.com/TPTBusiness/NexQuant/commit/24a51e4322ef80d5f882697a930f1d1985aa5779))
+* add LLM-finetune scenario ([#1314](https://github.com/TPTBusiness/NexQuant/issues/1314)) ([6e19c9e](https://github.com/TPTBusiness/NexQuant/commit/6e19c9e632cf07059c19993f2d4fbc772fb3cf13))
+* add mask inference in debug mode ([#1154](https://github.com/TPTBusiness/NexQuant/issues/1154)) ([b4117cf](https://github.com/TPTBusiness/NexQuant/commit/b4117cf58a5618e1d9e92abb46e1c1dd98af5f13))
+* Add model loader system (same as prompts) ([b7e397b](https://github.com/TPTBusiness/NexQuant/commit/b7e397b6f271e2cab5312f597cfbcb9652472298))
+* add option to enable hyperparameter tuning only in first eval loop ([#1211](https://github.com/TPTBusiness/NexQuant/issues/1211)) ([f82de4a](https://github.com/TPTBusiness/NexQuant/commit/f82de4a380fa31a04a8494b196a743333aadf096))
+* Add P5 ML Training Pipeline with LightGBM and 46 tests ([c934276](https://github.com/TPTBusiness/NexQuant/commit/c9342761ff8ab9adef69b65eb4cd8f206327fc97))
+* Add parallel run system with API key distribution ([31fb7d5](https://github.com/TPTBusiness/NexQuant/commit/31fb7d56e3b6530091bef2c16e057a249caf4a93))
+* add previous runner loops to runner history ([#1142](https://github.com/TPTBusiness/NexQuant/issues/1142)) ([2426a1d](https://github.com/TPTBusiness/NexQuant/commit/2426a1dc6700cc208360944cead9214a3da04889))
+* add reasoning attribute to DSRunnerFeedback for enhanced evaluation context ([#1162](https://github.com/TPTBusiness/NexQuant/issues/1162)) ([bfa4525](https://github.com/TPTBusiness/NexQuant/commit/bfa452541c1422c02f77491e70927ce43f21810c))
+* Add RL Trading Agent system with 99 tests ([0c4cb7a](https://github.com/TPTBusiness/NexQuant/commit/0c4cb7ad0c9842dd8fb73454bf554e9bedaf72f5))
+* add runtime backtest verification (10 invariant checks in <1ms) + 489 tests + README docs ([26db657](https://github.com/TPTBusiness/NexQuant/commit/26db65736431313bcdc27b6defde625db4133516))
+* add show_hard_limit option and update time limit handling in DataScience settings ([#1144](https://github.com/TPTBusiness/NexQuant/issues/1144)) ([8a3e42d](https://github.com/TPTBusiness/NexQuant/commit/8a3e42d7fe8c36324c7578ede661297f2af59a37))
+* Add simple factor evaluator with direct IC/Sharpe computation ([c7f23d0](https://github.com/TPTBusiness/NexQuant/commit/c7f23d026419060df3fcb3748740df8cc594bf39))
+* Add start_llama and start_loop CLI commands ([c1d1844](https://github.com/TPTBusiness/NexQuant/commit/c1d184442aac79ca69b1e366bff7311973459869))
+* add stdout into workspace for easier debugging ([#1236](https://github.com/TPTBusiness/NexQuant/issues/1236)) ([0daeb82](https://github.com/TPTBusiness/NexQuant/commit/0daeb82d6330e46edfeedc6b704b1a1c01d1a111))
+* add time ratio limit for hyperparameter tuning in Kaggle settin… ([#1135](https://github.com/TPTBusiness/NexQuant/issues/1135)) ([6a49981](https://github.com/TPTBusiness/NexQuant/commit/6a4998154d000d95d7a5ec7cfb5e59305d4cbd11))
+* Add Trading Protection System with 4 protections + comprehensive tests ([a9e0eff](https://github.com/TPTBusiness/NexQuant/commit/a9e0eff35d07c5b5223f64af343f8d2ece8d0053))
+* add user interaction in data science scenario ([#1251](https://github.com/TPTBusiness/NexQuant/issues/1251)) ([6e09dc6](https://github.com/TPTBusiness/NexQuant/commit/6e09dc6d692f3ae2fcc0ffddf620e8f3e8dc1bd9))
+* Auto-start dashboard for fin_quant ([3441604](https://github.com/TPTBusiness/NexQuant/commit/34416041c122b6a51ce94db1031f315c3639a4a5))
+* Auto-start dashboard for fin_quant ([52d2b89](https://github.com/TPTBusiness/NexQuant/commit/52d2b8914815fa97d6b53b7cc7e817828520817e))
+* **backtest:** add FTMO-realistic backtest mode with leverage, daily/total loss limits and realistic EUR/USD costs ([c5012e1](https://github.com/TPTBusiness/NexQuant/commit/c5012e1a1c7e5cff6c82bc42bd0ba34affb75c10))
+* **backtest:** add rolling walk-forward validation and Monte Carlo trade permutation test ([d284d3e](https://github.com/TPTBusiness/NexQuant/commit/d284d3e74610c5f8ed314fa870cfb7f28a7681d4))
+* **backtest:** add walk-forward OOS validation to backtest_signal_ftmo ([329841f](https://github.com/TPTBusiness/NexQuant/commit/329841f05a64ee9cdbaced2c4ec4de9436d3d42a))
+* Backtesting Engine + Risk Management + Results Database ([cce889a](https://github.com/TPTBusiness/NexQuant/commit/cce889a1b7ee58f0042bc6c8cf01f5631ad45fa7))
+* Backtesting Engine + Risk Management + Results DB ([86ef426](https://github.com/TPTBusiness/NexQuant/commit/86ef4269a350535871cb2f3f80d4d8e9e5c9258f))
+* **backtest:** use backtest_signal_ftmo in strategy orchestrator and optuna optimizer ([994080e](https://github.com/TPTBusiness/NexQuant/commit/994080ef36e572f688b1d3cc219170bb340fc175))
+* Beautiful CLI dashboard + corrected start command ([c2932cb](https://github.com/TPTBusiness/NexQuant/commit/c2932cb06904b041e1376d534309864d9d0e9122))
+* Centralize all prompts in prompts/ directory ([3ff1ef8](https://github.com/TPTBusiness/NexQuant/commit/3ff1ef8557ef41d96b48c43efc2fe5795869fed0))
+* CLI Commands for strategy generation (P4 complete) ([1f7ef1b](https://github.com/TPTBusiness/NexQuant/commit/1f7ef1b86f46153ff6e6cbde77e01c1ae08b905f))
+* Complete P6-P9 implementation (73 tests) ([6981e91](https://github.com/TPTBusiness/NexQuant/commit/6981e9141d1f1f0951647971c10c1b9db227134a))
+* continuous strategy generator (WF, MTF, stability, ML models, auto-ensemble) ([a206a31](https://github.com/TPTBusiness/NexQuant/commit/a206a31dbb831d6deed0492b73a9e246634fe074))
+* create Jupyter notebook pipeline file based on main.py file ([#1134](https://github.com/TPTBusiness/NexQuant/issues/1134)) ([f03b1b9](https://github.com/TPTBusiness/NexQuant/commit/f03b1b918d32ec5a0ace1443d9f22e0c0598b2fc))
+* Data Loader module with tests (P0 complete) ([af45cdf](https://github.com/TPTBusiness/NexQuant/commit/af45cdf074d7c3df02c535728ac55e69f214f1e3))
+* Diverse factor selection + improved prompt v3 ([ea47f75](https://github.com/TPTBusiness/NexQuant/commit/ea47f75eda41398699f376219ec2c883c9d67798))
+* enable finetune llm ([#1055](https://github.com/TPTBusiness/NexQuant/issues/1055)) ([35c209b](https://github.com/TPTBusiness/NexQuant/commit/35c209b09295d28d6d835c720fa1d300bdf43d13))
+* enable LLM‑based hypothesis selection with time‑aware prompt & colored logging ([#1122](https://github.com/TPTBusiness/NexQuant/issues/1122)) ([90dd2f7](https://github.com/TPTBusiness/NexQuant/commit/90dd2f7b9bf49f5e1620e9d2c2eedf6c21f3e839))
+* enable to inject diversity cross async multi-trace ([#1173](https://github.com/TPTBusiness/NexQuant/issues/1173)) ([b05a530](https://github.com/TPTBusiness/NexQuant/commit/b05a53012603c21847803e4709da10c5b868cab6))
+* enable walk-forward OOS validation by default in backtest_signal_ftmo ([8853f8e](https://github.com/TPTBusiness/NexQuant/commit/8853f8e8e14ddabe510cb0ca271092f965b5ea81))
+* enhance timeout handling in CoSTEER and DataScience scenarios ([#1150](https://github.com/TPTBusiness/NexQuant/issues/1150)) ([811d4e7](https://github.com/TPTBusiness/NexQuant/commit/811d4e7631dc83f228cd96a2a498803db46256a9))
+* enhance timeout management and knowledge base handling in CoSTEER components ([#1130](https://github.com/TPTBusiness/NexQuant/issues/1130)) ([305eff1](https://github.com/TPTBusiness/NexQuant/commit/305eff1c5e36f3da5e93dc165105f50ccb990e32))
+* EURUSD FX patches - prompts, factor spec, experiment settings ([b6cf687](https://github.com/TPTBusiness/NexQuant/commit/b6cf6874db995ea160457a1628a5691cbc8e5b97))
+* EURUSD model experiment setting + model simulator text patched ([9a17b25](https://github.com/TPTBusiness/NexQuant/commit/9a17b25d32729453a28dd36246be4c5fdbd3a667))
+* EURUSD Trading-Verbesserungen (Phase 2 & 3) ([05c4e1b](https://github.com/TPTBusiness/NexQuant/commit/05c4e1ba54b9259d6cc5f0af00a177d9295278a9))
+* EURUSD Trading-Verbesserungen implementiert (Phase 1) ([b95bbf5](https://github.com/TPTBusiness/NexQuant/commit/b95bbf5900a9e06194ab0e330b662e2b853006ea))
+* EURUSD walk-forward splits, bars terminology, README no $factor ([0eae7d0](https://github.com/TPTBusiness/NexQuant/commit/0eae7d0ababb422927dd0123118b97724d066ab0))
+* **factor-coder:** Add critical rules to prevent common factor implementation errors ([e5c5d34](https://github.com/TPTBusiness/NexQuant/commit/e5c5d34eb5d38dd4bd18e9cd06026ba0e5a43344))
+* fallback to acceptable results ([#1129](https://github.com/TPTBusiness/NexQuant/issues/1129)) ([7fc0916](https://github.com/TPTBusiness/NexQuant/commit/7fc09169bc5a779eeb650b799a43a36b44930a61))
+* Fast mode - CoSTEER goes to backtest after 1 iteration ([fc830a2](https://github.com/TPTBusiness/NexQuant/commit/fc830a23bd31a53dab188847b10bf60430d396a8))
+* **fin_quant:** auto-generate Kronos factor before loop start ([0daf7a8](https://github.com/TPTBusiness/NexQuant/commit/0daf7a8d2bdddd98a0c7d00959a39d4a38084a21))
+* Fix 1min data integration and centralize all prompts ([2e94a4c](https://github.com/TPTBusiness/NexQuant/commit/2e94a4ce72cd9d0a01eef38c40ce70db1d158bb2))
+* Fix realistic backtesting (Step 1+2) ([9b88ffb](https://github.com/TPTBusiness/NexQuant/commit/9b88ffbbd695d9486f25631ecf7f92457a23f6fc))
+* Full auto strategy generation in fin_quant loop ([6d2990d](https://github.com/TPTBusiness/NexQuant/commit/6d2990dfff103e0cb85c0edd092457333d00c19e))
+* Full system integration - RL + Protections + Backtesting + CLI ([60618d9](https://github.com/TPTBusiness/NexQuant/commit/60618d90f730470b7a9c57bf70c6f9fc45c36ad5))
+* FX feedback loop, EURUSD ticker examples, bars terminology ([781779a](https://github.com/TPTBusiness/NexQuant/commit/781779a1f8c853eb77253053e23bc10c46dcf402))
+* FX Multi-Agent Validator (TradingAgents-inspired) - Session/Macro/Bull-Bear/Trader ([cddfc53](https://github.com/TPTBusiness/NexQuant/commit/cddfc53ab07ca75b2364c30b9c2a794383633c2b))
+* improve fallback handling in CoSTEER and add GPU usage guidelin… ([#1165](https://github.com/TPTBusiness/NexQuant/issues/1165)) ([9c190e3](https://github.com/TPTBusiness/NexQuant/commit/9c190e3268b4515945dcf5531dbaa222e843ceef))
+* Improve nexquant portfolio command with robust error handling ([5051527](https://github.com/TPTBusiness/NexQuant/commit/505152793fe4a1629fa9ecdd8dc03ceb9bcd5db9))
+* Improved LLM prompt + Optuna integration (Step 3+5) ([f72b07c](https://github.com/TPTBusiness/NexQuant/commit/f72b07ca94acd2b004f4a5b99faa8bb9ca1c7c76))
+* init pydantic ai agent & context 7 mcp ([#1240](https://github.com/TPTBusiness/NexQuant/issues/1240)) ([5ba5e83](https://github.com/TPTBusiness/NexQuant/commit/5ba5e8356cbacb5e4bd9f24b26d6f9ac01784822))
+* Integrate critical features into fin_quant workflow (P0+P1) ([484377b](https://github.com/TPTBusiness/NexQuant/commit/484377bc6dbe3bb216b1ebebb54978db371971cb))
+* Integrate factor code/description saving into fin_quant process ([3b502e9](https://github.com/TPTBusiness/NexQuant/commit/3b502e9faeab4c7bbd185c9b107b7026b57330f0))
+* integrate Kronos-mini OHLCV foundation model (Option A + B) ([165c156](https://github.com/TPTBusiness/NexQuant/commit/165c15684c7efe3db7de80b67eb301384d926739))
+* Intelligent embedding chunking instead of truncation ([2d0584b](https://github.com/TPTBusiness/NexQuant/commit/2d0584b4cd7c1b3d9623acd6e141035d51f535fa))
+* **logging:** write complete LLM prompts and responses to daily JSONL log ([1f83410](https://github.com/TPTBusiness/NexQuant/commit/1f83410fdd7e242b6cf4eb3aac045d8e6e6b7c70))
+* **mcp:** cache with one-click toggle ([#1269](https://github.com/TPTBusiness/NexQuant/issues/1269)) ([4f493c8](https://github.com/TPTBusiness/NexQuant/commit/4f493c8d637dfda42f84af0dc08f8ecfc0501668))
+* mcts policy based on trace scheduler ([#1203](https://github.com/TPTBusiness/NexQuant/issues/1203)) ([ac6d8ed](https://github.com/TPTBusiness/NexQuant/commit/ac6d8edad4366b08b5caf75e9a5ee8da0061a078))
+* migrate to 1min EURUSD data (2020-2026) ([b39f2b7](https://github.com/TPTBusiness/NexQuant/commit/b39f2b7e46384c4fc56c1274c9120c470313262b))
+* ML Training Pipeline with 46 tests (P5 complete) ([8f2aa83](https://github.com/TPTBusiness/NexQuant/commit/8f2aa8341932327dba5e260645bcf96efd5ed548))
+* offline selector ([#1231](https://github.com/TPTBusiness/NexQuant/issues/1231)) ([d4c5399](https://github.com/TPTBusiness/NexQuant/commit/d4c539912abdb60e9d8950e7ea1186fd32bfeef3))
+* optimize strategy generator (cache OHLCV, min_sharpe 1.5, nexquant generate-strategies CLI) ([def3975](https://github.com/TPTBusiness/NexQuant/commit/def39755793b16920c877045dd6628cb6a9aa9e8))
+* **optimizer:** add max_positions parameter to Optuna search space ([f7b23b9](https://github.com/TPTBusiness/NexQuant/commit/f7b23b950f8f59b1b2efa66664ac2180ce136410))
+* Optuna Parameter Optimizer with 60 tests (P3 complete) ([5583bf8](https://github.com/TPTBusiness/NexQuant/commit/5583bf874ed36886fa0d24e3472b8062abbd0b86))
+* PDF performance reports for strategies (reportlab) ([b86e412](https://github.com/TPTBusiness/NexQuant/commit/b86e41209cd41e02de4ad3de3281b6558fdad059))
+* nexquant.py wrapper for dashboard support ([757c66c](https://github.com/TPTBusiness/NexQuant/commit/757c66cddb18254220db1d571d9b739380c57f44))
+* prob-based trace scheduler ([#1131](https://github.com/TPTBusiness/NexQuant/issues/1131)) ([7e15b5e](https://github.com/TPTBusiness/NexQuant/commit/7e15b5e2003628f40be12674a73197a956d86545))
+* Realistic backtesting with OHLCV data (P5 continued) ([1506439](https://github.com/TPTBusiness/NexQuant/commit/1506439a1950a2e87cd662dfeec9e8b5fa1baf20))
+* Realistic backtesting with OHLCV data and spread costs ([85a1e29](https://github.com/TPTBusiness/NexQuant/commit/85a1e2929acf0ea0f582a66f6261dd697f0260db))
+* Redirect RD-Agent workspace to results/ directory ([fd2def0](https://github.com/TPTBusiness/NexQuant/commit/fd2def052a02e0f818a7cc705bdc2caaee2f01d2))
+* refactor CoSTEER classes to use DSCoSTEER and update max seconds handling ([#1156](https://github.com/TPTBusiness/NexQuant/issues/1156)) ([c111966](https://github.com/TPTBusiness/NexQuant/commit/c111966d1975a4952c1266fb6d6af1c4f5fe83c1))
+* refine the logic of enabling hyperparameter tuning and add criteira ([#1175](https://github.com/TPTBusiness/NexQuant/issues/1175)) ([e77572f](https://github.com/TPTBusiness/NexQuant/commit/e77572fb5347e40506fb7b5b25dd861e5f9ebb2b))
+* **rl:** add AutoRL-Bench framework and benchmark integrations ([#1348](https://github.com/TPTBusiness/NexQuant/issues/1348)) ([7cd64a2](https://github.com/TPTBusiness/NexQuant/commit/7cd64a26fd84017042eb163e8eb4d3bd30c16de7))
+* Save all factor results to results/factors/ ([2abbec9](https://github.com/TPTBusiness/NexQuant/commit/2abbec9fde67f52bcf1f199e7d18f7d99f04805e))
+* Save factor results immediately after each evaluation ([72c5ec5](https://github.com/TPTBusiness/NexQuant/commit/72c5ec55f20964917fe9ed21a77f80e0394f61e8))
+* **scripts:** add full file logging to strategy generation and rebacktest scripts ([c629af5](https://github.com/TPTBusiness/NexQuant/commit/c629af5b19df26330a131f510154fb5543709a66))
+* show the summarized final difference between the final workspace and the base workspace ([#1281](https://github.com/TPTBusiness/NexQuant/issues/1281)) ([35a7ae5](https://github.com/TPTBusiness/NexQuant/commit/35a7ae5e1ff929b3ee3b77c04cb1f4a684a4b2d7))
+* **strategies:** make OOS validation mandatory in strategy generator ([0f4c7c4](https://github.com/TPTBusiness/NexQuant/commit/0f4c7c4f46d4fd2fb8ff7c4b1eea58538c7db1b3))
+* Strategy Generator working with local LLM (P0-P4) ([036edee](https://github.com/TPTBusiness/NexQuant/commit/036edeeb77d1a99a0a748a357038c6da3efdd5e7))
+* Strategy Orchestrator with 30 tests (P2 complete) ([9af5cdb](https://github.com/TPTBusiness/NexQuant/commit/9af5cdbde4996b05a98e59c5c577e487e2d535bd))
+* Strategy performance reports, CLI docs, and README update ([232e918](https://github.com/TPTBusiness/NexQuant/commit/232e918b48eabeed22e3b712048fb96089b99067))
+* Strategy Worker module with 41 tests (P1 complete) ([b8acf82](https://github.com/TPTBusiness/NexQuant/commit/b8acf82ed26ffd131ca32bf5272547ff11bd5eef))
+* **strategy:** Continuous optimization with Optuna parameter injection ([da90ae2](https://github.com/TPTBusiness/NexQuant/commit/da90ae271e46260910023f8a9e3798365b80b298))
+* streamline hyperparameter tuning checks and update evaluation g… ([#1167](https://github.com/TPTBusiness/NexQuant/issues/1167)) ([5866230](https://github.com/TPTBusiness/NexQuant/commit/586623084f5d59d88645e75ceab6d795ec497cab))
+* Support 25+ parallel runs with resource warnings ([7a4dd1a](https://github.com/TPTBusiness/NexQuant/commit/7a4dd1aa7454560d84993ee8827e005ee0795c37))
+* ui, support disable cache ([#1217](https://github.com/TPTBusiness/NexQuant/issues/1217)) ([70fd91c](https://github.com/TPTBusiness/NexQuant/commit/70fd91cd051b2006df876ef6aa47a616058af95f))
+* unified backtest engine, LLM error handling, strategy refactor ([1ddb114](https://github.com/TPTBusiness/NexQuant/commit/1ddb1142a2f21ed3a498292ac8f5af6bbc351e7c))
+* update README with latest paper acceptance to NeurIPS 2025 ([#1252](https://github.com/TPTBusiness/NexQuant/issues/1252)) ([12969b4](https://github.com/TPTBusiness/NexQuant/commit/12969b491eafab626ce71f7e530458dab6f43246))
+* zentrale data_config.yaml + apply_config.py für dynamische Datenkonfiguration ([b7c1e4d](https://github.com/TPTBusiness/NexQuant/commit/b7c1e4db8e29e960fe28393911d60fc0fd3ca413))
 
 
 ### Bug Fixes
 
-* **security:** resolve all 30 Bandit security alerts (B301, B614, B104) ([ce5983d](https://github.com/TPTBusiness/Predix/commit/ce5983d9d59c4c34341fb1ec749e44bbcfc4a1c4))
-
-## [1.2.2](https://github.com/TPTBusiness/Predix/compare/v1.2.1...v1.2.2) (2026-04-19)
-
-
-### Documentation
-
-* **claude:** auto-merge release-please PR after every push ([f500917](https://github.com/TPTBusiness/Predix/commit/f500917b699ee78dc676e84e01574d49bdc8e796))
-
-## [2.2.0](https://github.com/TPTBusiness/Predix/compare/v2.1.0...v2.2.0) (2026-04-18)
-
-
-### Features
-
-* add Kronos CLI commands, expand tests, document in README ([f911081](https://github.com/TPTBusiness/Predix/commit/f911081d1763d0dc4dd790b57dd97aae2dc62679))
-* **fin_quant:** auto-generate Kronos factor before loop start ([277063f](https://github.com/TPTBusiness/Predix/commit/277063f3e36cd071db859cdc77f69135c1f0763b))
-* integrate Kronos-mini OHLCV foundation model (Option A + B) ([4ae3b99](https://github.com/TPTBusiness/Predix/commit/4ae3b99f2450930f72e202a1a470c407bfde3328))
-
-
-### Bug Fixes
-
-* **kronos:** lazy torch import to fix CI ModuleNotFoundError ([ccc1d27](https://github.com/TPTBusiness/Predix/commit/ccc1d27dbe5ab06a57085a589d456ac7bf49cc08))
-* **kronos:** pass actual datetime Series to Kronos predictor timestamps ([dc6e7ce](https://github.com/TPTBusiness/Predix/commit/dc6e7ce207d21fbc21976f2af7691058530fac2f))
-* **kronos:** replace rdagent_logger with stdlib logging for CI compatibility ([b4558f2](https://github.com/TPTBusiness/Predix/commit/b4558f2456659c6109bd1b3cf100510491cd3e6c))
+* (to main) litellm's Timeout error is not picklable ([#1294](https://github.com/TPTBusiness/NexQuant/issues/1294)) ([315850e](https://github.com/TPTBusiness/NexQuant/commit/315850ea81761aa2478639ad32302d7a55f8181b))
+* 15 bug fixes across orchestrator, runner, backtest, and infrastructure ([5ec4516](https://github.com/TPTBusiness/NexQuant/commit/5ec4516ed7bdc44f2fd7d6e3ec9df0a88fc4fd10))
+* add a switch for ensemble_time_upper_bound and fix some bug in main ([#1226](https://github.com/TPTBusiness/NexQuant/issues/1226)) ([fc18942](https://github.com/TPTBusiness/NexQuant/commit/fc18942339b3ca59077ddc903f84b2d54193e5bc))
+* Add Bandit security scanning and fix critical vulnerabilities ([f47dcf1](https://github.com/TPTBusiness/NexQuant/commit/f47dcf1c58d33041bba2f705b270a7f9c4e7d572))
+* Add critical column name rules to factor generation prompt ([bf73725](https://github.com/TPTBusiness/NexQuant/commit/bf7372533e83da682f1ceefeddc70f142f8ccda2))
+* Add get_factor_count() to QuantTrace to prevent parallel run crashes ([a16db77](https://github.com/TPTBusiness/NexQuant/commit/a16db77def1ba7adb7bb6734629086a1b5a901cb))
+* add json format response fallback to prompt templates ([#1246](https://github.com/TPTBusiness/NexQuant/issues/1246)) ([694afd8](https://github.com/TPTBusiness/NexQuant/commit/694afd81331227d2be7f780f72023d00c0c9864e))
+* add metric in scores.csv and avoid reading sample_submission.csv ([#1152](https://github.com/TPTBusiness/NexQuant/issues/1152)) ([80c953d](https://github.com/TPTBusiness/NexQuant/commit/80c953d4053dff66d12e4cf400b069d0fac16cbd))
+* Add missing os import in factor_runner.py ([f201823](https://github.com/TPTBusiness/NexQuant/commit/f201823c44c724867163f3b2d3ecf49f384a8e35))
+* Add missing Panel import in nexquant evaluate command ([e21923b](https://github.com/TPTBusiness/NexQuant/commit/e21923bd13eac6236a2c25d550bae0b984575491))
+* add missing self parameter to instance methods in DSProposalV2ExpGen ([#1213](https://github.com/TPTBusiness/NexQuant/issues/1213)) ([c8bf617](https://github.com/TPTBusiness/NexQuant/commit/c8bf617aca57ea9c53d4a76d23806cb5ab5173ab))
+* add missing sys import and fix undefined acc_rate in factor eval ([34323f3](https://github.com/TPTBusiness/NexQuant/commit/34323f307da6924095efcdaef81f99b95e2820eb))
+* Add nosec comments for schema migration SQL in results_db.py ([3626b22](https://github.com/TPTBusiness/NexQuant/commit/3626b22482143466b0dec8b63ea0a4a36af06acf))
+* allow prev_out keys to be None in workspace cleanup assertion ([#1214](https://github.com/TPTBusiness/NexQuant/issues/1214)) ([f02dc5f](https://github.com/TPTBusiness/NexQuant/commit/f02dc5f47d5973673bcc314ada89933a5d807d21))
+* also catch ValueError in mean_variance for dimension mismatch ([daded85](https://github.com/TPTBusiness/NexQuant/commit/daded853b6370f0df6f83a6d1b3f04c0dd0757f0))
+* **auto-fixer:** add five new factor code fixes for groupby/apply errors ([d03bcf3](https://github.com/TPTBusiness/NexQuant/commit/d03bcf3505f1be696e7bddc40f33c4a97b3f7486))
+* **auto-fixer:** add four new factor code fixes for common runtime errors ([21ce0de](https://github.com/TPTBusiness/NexQuant/commit/21ce0def2dd8352a315e0688ebafc6d62cf0435e))
+* **auto-fixer:** add groupby([level=N,'date']) SyntaxError fix ([d58eba3](https://github.com/TPTBusiness/NexQuant/commit/d58eba364e6ea14513b64e6bc12256c72111669a))
+* **auto-fixer:** disable _fix_min_periods for intraday data ([665e490](https://github.com/TPTBusiness/NexQuant/commit/665e4903d8f6f3097a45d07060ab003ebea7f96b))
+* **auto-fixer:** fix chained groupby(level=N).groupby('date') pattern ([9869839](https://github.com/TPTBusiness/NexQuant/commit/9869839a2c676ddd83f4218e9ff5e50fb8d2d223))
+* **auto-fixer:** fix df.loc[instrument] DateParseError on MultiIndex frames ([87926dc](https://github.com/TPTBusiness/NexQuant/commit/87926dc41d795a3ab0670e585b99cc21dd09ae5f))
+* **auto-fixer:** fix df['instrument'] KeyError on MultiIndex frames ([63a348e](https://github.com/TPTBusiness/NexQuant/commit/63a348eb3ec20c209c2d060e086bc69019e92884))
+* **auto-fixer:** fix two assignment-target bugs in instrument column fixers ([a44eba9](https://github.com/TPTBusiness/NexQuant/commit/a44eba952e031e364050ee3d27a067d17fa01923))
+* **auto-fixer:** preserve date dimension in groupby(['instrument','date']) fix ([37a2f37](https://github.com/TPTBusiness/NexQuant/commit/37a2f37f74118a2707a6b128d55c45ddb89cc48a))
+* **auto-fixer:** remove ddof from rolling() args, not only from std()/var() ([daacbfd](https://github.com/TPTBusiness/NexQuant/commit/daacbfd141ae0da99c8c4cb01d5e500528eb7d80))
+* **auto-fixer:** replace zero \$volume with price-range proxy for FX data ([7fcec39](https://github.com/TPTBusiness/NexQuant/commit/7fcec39f1d8f0f7668435f51a1a9646abcd9c89f))
+* **auto-fixer:** strip spurious .reset_index() after .transform() calls ([c489616](https://github.com/TPTBusiness/NexQuant/commit/c489616d1a2fd71877a203d880e31281bc008cdf))
+* avoid triggering errors like "RuntimeError: dictionary changed s… ([#1285](https://github.com/TPTBusiness/NexQuant/issues/1285)) ([b180543](https://github.com/TPTBusiness/NexQuant/commit/b18054371c6ce08c6bc322a7b0de41b67fc60408))
+* **backtest:** replace broken MC permutation test with binomial win-rate test ([f284b7a](https://github.com/TPTBusiness/NexQuant/commit/f284b7a9751424201510c5938b4ebf6bd81842b6))
+* cancel tasks on resume and kill subprocesses on termination ([#1166](https://github.com/TPTBusiness/NexQuant/issues/1166)) ([0e3f4cf](https://github.com/TPTBusiness/NexQuant/commit/0e3f4cf08f08e27f9c483a5bbe069313d0d8014e))
+* change runner prompts ([#1223](https://github.com/TPTBusiness/NexQuant/issues/1223)) ([be3433f](https://github.com/TPTBusiness/NexQuant/commit/be3433f26b04054a482dfdc7cdd5c8c0a756a60c))
+* **ci:** fix closed-source asset check false positives in security workflow ([1473085](https://github.com/TPTBusiness/NexQuant/commit/14730856636735c17d704854e057fa6e1aea5940))
+* **ci:** lazy import logger in nexquant.py and cli.py to avoid ImportError in test env ([52d9ff0](https://github.com/TPTBusiness/NexQuant/commit/52d9ff0cd41d6fc6978e8af7f970cffd6a46f673))
+* **ci:** remove CodeQL workflow (conflicts with default setup), drop duplicate lint job ([ab73425](https://github.com/TPTBusiness/NexQuant/commit/ab734252f356ac97dea4f70477ebe2fdee30509c))
+* **ci:** remove env-print step to avoid leaking sensitive environment variables ([#1299](https://github.com/TPTBusiness/NexQuant/issues/1299)) ([c067ea6](https://github.com/TPTBusiness/NexQuant/commit/c067ea640030c67c549e3ca2dbad178f144e8b31))
+* **ci:** set JAVA_TOOL_OPTIONS UTF-8 in Codacy workflow ([a9c6ea9](https://github.com/TPTBusiness/NexQuant/commit/a9c6ea99c9ebae2794b1c3f4d1e9da1d4e41376a))
+* clear ws_ckp after extraction to reduce workspace object size ([#1137](https://github.com/TPTBusiness/NexQuant/issues/1137)) ([28ceb41](https://github.com/TPTBusiness/NexQuant/commit/28ceb41e1cdb603c4e0bd2fe7b72acef1b29ec47))
+* CLI dashboard in separate terminal window ([b72cca9](https://github.com/TPTBusiness/NexQuant/commit/b72cca98680bd8a87393bb4e5f7d17aae47ab5ed))
+* close log file handle, fix FTMO equity double-count, remove bare except ([4c76c85](https://github.com/TPTBusiness/NexQuant/commit/4c76c85b6509ddd7bbd5361f0823c5a41329591a))
+* **collect_info:** parse package names safely from requirements constraints ([#1313](https://github.com/TPTBusiness/NexQuant/issues/1313)) ([99a71bf](https://github.com/TPTBusiness/NexQuant/commit/99a71bf533211df743b5801f913de788259e64cb))
+* correct MaxDD to equity curve in strategy_builder; test: add 8 cross-validation tests for metric correctness ([7be98e8](https://github.com/TPTBusiness/NexQuant/commit/7be98e84c911c9ba08b444b33206553cbe60086d))
+* correct project root paths and subprocess handling in parallel runner and CLI ([1c35a22](https://github.com/TPTBusiness/NexQuant/commit/1c35a2277ff601553e4733a8e990217dc9d6f989))
+* correct Sharpe/MaxDD/WinRate in direct factor eval (was computing on raw factor, now on strategy returns) ([69122ee](https://github.com/TPTBusiness/NexQuant/commit/69122ee5c1819be6fababd701b88d0dbef993040))
+* **deps:** bump python-dotenv to >=1.2.2 (CVE symlink overwrite) ([f69333b](https://github.com/TPTBusiness/NexQuant/commit/f69333b27b9356f09e6cc2748cb45845732335c3))
+* **deps:** pin aiohttp>=3.13.4 to patch 4 CVEs ([a0b3b90](https://github.com/TPTBusiness/NexQuant/commit/a0b3b90bfdd1193f5b8be521f563d18ff17dd81c))
+* **deps:** relax aiohttp constraint to >=3.13.4 for litellm compatibility ([d3978fe](https://github.com/TPTBusiness/NexQuant/commit/d3978fec1305d7503a37ff576fdf953f75e1cd1d))
+* Disable ANSI color codes when not running in TTY ([9db0e59](https://github.com/TPTBusiness/NexQuant/commit/9db0e590a4e94f538712cfec79f6cd470155050c))
+* Disable Flask debug mode by default (Security Alert [#2](https://github.com/TPTBusiness/NexQuant/issues/2)) ([48c177f](https://github.com/TPTBusiness/NexQuant/commit/48c177fbafce7b111646c14a5c2e6e414414930b))
+* Display litellm messages as info instead of warnings ([bd9d672](https://github.com/TPTBusiness/NexQuant/commit/bd9d672997aff80b5ad5c616b6486c11c2570b80))
+* **dockerfile:** install coreutils to resolve timeout command error ([#1260](https://github.com/TPTBusiness/NexQuant/issues/1260)) ([35580cb](https://github.com/TPTBusiness/NexQuant/commit/35580cbdf87347d5d6105b2a9b5ad1694b695820))
+* **docs:** update rdagent ui with correct params ([#1249](https://github.com/TPTBusiness/NexQuant/issues/1249)) ([3b9ad11](https://github.com/TPTBusiness/NexQuant/commit/3b9ad1145769862a24cc7533a1828f750f72170d))
+* Embedding Context Length Error ([6d6c5ab](https://github.com/TPTBusiness/NexQuant/commit/6d6c5abd4ac7252257f88e13e263ecb2497fde3b))
+* enable embedding truncation ([#1188](https://github.com/TPTBusiness/NexQuant/issues/1188)) ([880a6c7](https://github.com/TPTBusiness/NexQuant/commit/880a6c70c41024cb51f9fc4349ac7f1d2dbda434))
+* end-timestamp 23:45,  weg, SZ-beispiele weg ([6a9ccd5](https://github.com/TPTBusiness/NexQuant/commit/6a9ccd5ddbf95060a2847bd27bcdae762a46a19d))
+* enhance feedback handling in MultiProcessEvolvingStrategy for improved task evolution ([#1274](https://github.com/TPTBusiness/NexQuant/issues/1274)) ([afb575c](https://github.com/TPTBusiness/NexQuant/commit/afb575cc91114dbe41d8f582294dcc3692990695))
+* Ensure backtest results save to DB and JSON files ([ae7b35e](https://github.com/TPTBusiness/NexQuant/commit/ae7b35ea2e0c71c76e8e454f7845df461d65b99f))
+* evaluator erkennt 15min als valid (nicht daily) ([cf0f634](https://github.com/TPTBusiness/NexQuant/commit/cf0f634c17dce45400cc325ccd3ca45e769c15fd))
+* **factors:** detect and correct look-ahead bias in daily-constant factors ([dcad0d1](https://github.com/TPTBusiness/NexQuant/commit/dcad0d1f68608a4db3cfdabb75e66c22490643aa))
+* **factors:** extend look-ahead rules to session factors and add intraday-factor guidance ([8811dc0](https://github.com/TPTBusiness/NexQuant/commit/8811dc042a0a7a1ac385c7141ded9f56a434dced))
+* filter NaN in max(), remove redundant ternary, handle non-finite vbt results ([1acfe50](https://github.com/TPTBusiness/NexQuant/commit/1acfe508a9c327dce8eba7a2ad1f618052a3e8a5))
+* fix bug for hypo_select_with_llm when not support response_schema ([#1208](https://github.com/TPTBusiness/NexQuant/issues/1208)) ([d759ca9](https://github.com/TPTBusiness/NexQuant/commit/d759ca95e714a7a1476839a2a04bb652c0fbb863))
+* fix chat_max_tokens calculation method to show true input_max_tokens ([#1241](https://github.com/TPTBusiness/NexQuant/issues/1241)) ([7e99605](https://github.com/TPTBusiness/NexQuant/commit/7e996055f2c7fd37595573ebdb13aa57c425a6cc))
+* fix mcts ([#1270](https://github.com/TPTBusiness/NexQuant/issues/1270)) ([5003aff](https://github.com/TPTBusiness/NexQuant/commit/5003affb17505525336e6c30ba9c690b810c252b))
+* Fix parallel runner dashboard rendering error ([3e8c07e](https://github.com/TPTBusiness/NexQuant/commit/3e8c07e728076a951528c4eb5b429653a5c77d14))
+* fix some bugs in RD-Agent(Q) ([#1143](https://github.com/TPTBusiness/NexQuant/issues/1143)) ([7134a51](https://github.com/TPTBusiness/NexQuant/commit/7134a51afa71ab146b52987c194adace62f8b034))
+* fix type annotation, remove unused parameter, improve import_class errors ([1eb5849](https://github.com/TPTBusiness/NexQuant/commit/1eb5849dd44c5953f7198212a5ef0dbe8c8d4881))
+* Forward-fill daily factors to 1-min frequency ([20f4c21](https://github.com/TPTBusiness/NexQuant/commit/20f4c2140c397230fb56734b0e887b770db805ac))
+* generate.py nutzt rdagent4qlib env für Qlib-Datenzugriff ([b9007f7](https://github.com/TPTBusiness/NexQuant/commit/b9007f754ac682800aaf265c0f24c2028d387d84))
+* **graph:** using assignment expression to avoid repeated function call ([#1174](https://github.com/TPTBusiness/NexQuant/issues/1174)) ([b6fae75](https://github.com/TPTBusiness/NexQuant/commit/b6fae75cde256c9c8a84783dbd135a9bcca6ac8d))
+* Handle failed experiments in feedback step to prevent crashes ([979ef66](https://github.com/TPTBusiness/NexQuant/commit/979ef66dc612c7f589e097dcdc3a01b742b18970))
+* handle mixed str and dict types in code_list ([#1279](https://github.com/TPTBusiness/NexQuant/issues/1279)) ([32ecf92](https://github.com/TPTBusiness/NexQuant/commit/32ecf92afcf647f257b430c748cbe6bb5fa0fac4))
+* Handle negative/zero values in performance report charts ([f4a4c65](https://github.com/TPTBusiness/NexQuant/commit/f4a4c65ce9bc1c929526a20a852765b92709011c))
+* handle None output and conditional step dump in LoopBase execution ([#1212](https://github.com/TPTBusiness/NexQuant/issues/1212)) ([9de8d60](https://github.com/TPTBusiness/NexQuant/commit/9de8d6066994fcd7037fd03d9339b6590ab2fac9))
+* Handle Qlib Docker backtest failures gracefully (SECURITY FIX) ([59f4561](https://github.com/TPTBusiness/NexQuant/commit/59f45618229be08dba028dceda21433cc5d52b9f))
+* Handle timeout exceptions safely in nexquant_full_eval.py ([2738263](https://github.com/TPTBusiness/NexQuant/commit/27382635171482be2cee2e29d4793e63d14abce4))
+* handle ValueError in stdout shrinking and refactor shrink logic ([#1228](https://github.com/TPTBusiness/NexQuant/issues/1228)) ([6fc3877](https://github.com/TPTBusiness/NexQuant/commit/6fc3877a39baabbf26e0cc1cbd327b0f6e2e325e))
+* Harden _safe_resolve to fix CodeQL alert [#3](https://github.com/TPTBusiness/NexQuant/issues/3) ([0ed1a0a](https://github.com/TPTBusiness/NexQuant/commit/0ed1a0aa8faad6df36753a928f40a1cdbd606462))
+* Harden path validation in Job Summary UI to fix CodeQL alert [#17](https://github.com/TPTBusiness/NexQuant/issues/17) ([7fe15d4](https://github.com/TPTBusiness/NexQuant/commit/7fe15d46cb2a740b6ec0ee37d29acaf37476e8e6))
+* Harden path validation to fix CodeQL alert [#20](https://github.com/TPTBusiness/NexQuant/issues/20) ([59d06f6](https://github.com/TPTBusiness/NexQuant/commit/59d06f6588caadaa207bde1d135828c56169bff8))
+* ignore case when checking metric name ([#1160](https://github.com/TPTBusiness/NexQuant/issues/1160)) ([1b84f7b](https://github.com/TPTBusiness/NexQuant/commit/1b84f7b7546a9dee4f27e24e07c49fa8ee3a370d))
+* ignore RuntimeError for shared workspace double recovery ([#1140](https://github.com/TPTBusiness/NexQuant/issues/1140)) ([bd8a16d](https://github.com/TPTBusiness/NexQuant/commit/bd8a16d92f9176d835bbc27478f9259f0fe9a827))
+* Import pandas in nexquant portfolio_simple command ([2b6de06](https://github.com/TPTBusiness/NexQuant/commit/2b6de06a612c147c414bde3175b6f11af1762f4d))
+* Improve path traversal prevention with dedicated helper function ([50dc275](https://github.com/TPTBusiness/NexQuant/commit/50dc27566d886a4aea9ea56eaef2c08e794df770))
+* increase retry count in hypothesis_gen decorator to 10 ([#1230](https://github.com/TPTBusiness/NexQuant/issues/1230)) ([86ce4f1](https://github.com/TPTBusiness/NexQuant/commit/86ce4f135d649cfb12f2f88626cd31868cb447e7))
+* increase time default not controlled by LLM ([#1196](https://github.com/TPTBusiness/NexQuant/issues/1196)) ([e4bd647](https://github.com/TPTBusiness/NexQuant/commit/e4bd647d1b20cbaa26a00cf23c49bfbc0bc80477))
+* Initialize EnvController in QuantTrace.__init__ ([698a17e](https://github.com/TPTBusiness/NexQuant/commit/698a17ea61321c37c7fa0d69849a309d29474f80))
+* inject correct MultiIndex template into factor prompt ([49004db](https://github.com/TPTBusiness/NexQuant/commit/49004db027d699bacbb975f267daa95d1957ccd7))
+* inject MultiIndex warning into factor interface prompt (YAML valide) ([79e2915](https://github.com/TPTBusiness/NexQuant/commit/79e2915823801d3574920fa197cf9c57965f485f))
+* insert await asyncio.sleep(0) to yield control in loop ([#1186](https://github.com/TPTBusiness/NexQuant/issues/1186)) ([e0453e0](https://github.com/TPTBusiness/NexQuant/commit/e0453e0058e2a4ec74feb0b31883f45604a9bf0c))
+* jinja problem of enumerate ([#1216](https://github.com/TPTBusiness/NexQuant/issues/1216)) ([6725f15](https://github.com/TPTBusiness/NexQuant/commit/6725f15f30df30a3ce37024fded621354d8114a7))
+* kaggle competition metric direction ([#1195](https://github.com/TPTBusiness/NexQuant/issues/1195)) ([04878f9](https://github.com/TPTBusiness/NexQuant/commit/04878f9e703fee9caff9208ab23995586f165c95))
+* **kronos:** lazy torch import to fix CI ModuleNotFoundError ([9cd8ab5](https://github.com/TPTBusiness/NexQuant/commit/9cd8ab54656786cc04742695c9d2e650a1b124ae))
+* **kronos:** pass actual datetime Series to Kronos predictor timestamps ([7741408](https://github.com/TPTBusiness/NexQuant/commit/7741408c671b6fe943491b39d9fc5cac256b457e))
+* **kronos:** replace rdagent_logger with stdlib logging for CI compatibility ([1ee5ea7](https://github.com/TPTBusiness/NexQuant/commit/1ee5ea7792f9ea94ddd26a0828d9744d0e07baa6))
+* **loop:** compress old experiment history in proposal prompt to reduce context size ([bde37f0](https://github.com/TPTBusiness/NexQuant/commit/bde37f09d53a4f6582d071ed72d86491889bc573))
+* **loop:** prevent step_idx advance on unhandled exceptions + fix consecutive assistant messages ([881ca81](https://github.com/TPTBusiness/NexQuant/commit/881ca819cea90d8a60865296e6f416aab69a18c9))
+* merge candidates ([#1254](https://github.com/TPTBusiness/NexQuant/issues/1254)) ([46aad78](https://github.com/TPTBusiness/NexQuant/commit/46aad789ef710d9603e2330788dc66849cb6cab3))
+* model/factor experiment filtering in Qlib proposals ([#1257](https://github.com/TPTBusiness/NexQuant/issues/1257)) ([9e34b4e](https://github.com/TPTBusiness/NexQuant/commit/9e34b4e855cbd709cd077f529950b8e1f5c01486))
+* move snapshot saving after step index update in loop execution ([#1206](https://github.com/TPTBusiness/NexQuant/issues/1206)) ([774346d](https://github.com/TPTBusiness/NexQuant/commit/774346d92e3d9faa858f935bb2651d0f1aa12a6c))
+* move task cancellation to finally block and fix subprocess kill typo ([#1234](https://github.com/TPTBusiness/NexQuant/issues/1234)) ([a984f69](https://github.com/TPTBusiness/NexQuant/commit/a984f69f681dda1c6c58f45e2505d7b0e8d75cf0))
+* **optuna:** fix inverted parameter range in Stage 2/3 when signal_bias is negative ([f0be842](https://github.com/TPTBusiness/NexQuant/commit/f0be842a6c03f56cb209d1f8a0c5a0d9fa3baebf))
+* Override webshop's Werkzeug dependency to fix CVE-2026-27199 ([3a5aa0b](https://github.com/TPTBusiness/NexQuant/commit/3a5aa0ba43fd644ad1944994f3cd3d49e7ab633c))
+* preserve null end_time when rendering dataset segments template ([#1326](https://github.com/TPTBusiness/NexQuant/issues/1326)) ([6196ba3](https://github.com/TPTBusiness/NexQuant/commit/6196ba31f2e43db4761eeb482c3301e2238bc4cf))
+* prevent calendar index overflow when signal data ends early ([#1324](https://github.com/TPTBusiness/NexQuant/issues/1324)) ([3dbd703](https://github.com/TPTBusiness/NexQuant/commit/3dbd7038280f21793246e5354f083ba472772a10))
+* prevent JSON content from being added multiple times during retries ([#1255](https://github.com/TPTBusiness/NexQuant/issues/1255)) ([31b19de](https://github.com/TPTBusiness/NexQuant/commit/31b19dee80c5006c72a0a9698834a04a3acd4af9))
+* Prevent path injection in FT Job Summary UI ([e4393fb](https://github.com/TPTBusiness/NexQuant/commit/e4393fb3b1e95fa53f7d8e972da35e994402def8))
+* Prevent path injection in RL Job Summary UI ([b3e8cb8](https://github.com/TPTBusiness/NexQuant/commit/b3e8cb8cfe5fe74c5b893c6d0e401375630ee750))
+* Prevent path traversal in autorl_bench server.py ([6634e6e](https://github.com/TPTBusiness/NexQuant/commit/6634e6e5c55c07f41d3a37731d59f6e11b35610e))
+* Prevent path traversal in get_job_options() app.py ([7da2e57](https://github.com/TPTBusiness/NexQuant/commit/7da2e5706c7d7da8ffee3f04b42f8d3378af26ad))
+* Prevent path traversal in RL UI app.py ([d2c1516](https://github.com/TPTBusiness/NexQuant/commit/d2c1516416dbda6109f6d42245263ce5373ce957))
+* Prevent path traversal in Streamlit UI app.py ([0d0fd34](https://github.com/TPTBusiness/NexQuant/commit/0d0fd34573c0695c34431a6e9eb7b5c10a3a91f9))
+* **qlib:** correct indentation in except blocks in quant_proposal and factor_runner ([8f67ab6](https://github.com/TPTBusiness/NexQuant/commit/8f67ab61299b7fb7063f5ac363705a6687ecaea1))
+* Refactor path validation to fix CodeQL alert [#16](https://github.com/TPTBusiness/NexQuant/issues/16) ([a417ebc](https://github.com/TPTBusiness/NexQuant/commit/a417ebc41db5ad24b89f53e5f3c3ff6e5339ae18))
+* refine DSCoSTEER_eval prompts ([#1157](https://github.com/TPTBusiness/NexQuant/issues/1157)) ([5594ab4](https://github.com/TPTBusiness/NexQuant/commit/5594ab418b46422e2f2e2edc08f0aadd0e95af04))
+* refine prompts and add additional package info ([#1179](https://github.com/TPTBusiness/NexQuant/issues/1179)) ([5353bd3](https://github.com/TPTBusiness/NexQuant/commit/5353bd31f25a98cba552145709af743cd4e83cf5))
+* refine task scheduling logic in MultiProcessEvolvingStrategy for… ([#1275](https://github.com/TPTBusiness/NexQuant/issues/1275)) ([27d38af](https://github.com/TPTBusiness/NexQuant/commit/27d38af7bd7e1fdb73e3617e94435abe7901dd21))
+* remove $factor from prompt, update example count to EURUSD ([3adc5bf](https://github.com/TPTBusiness/NexQuant/commit/3adc5bf75e6820328991aa5a5456e6f68ccf8fd7))
+* remove all Chinese stock references, replace with EURUSD 1min FX ([44eeb01](https://github.com/TPTBusiness/NexQuant/commit/44eeb01ec4f95271a084e9d285e00959926923f3))
+* Remove API key from test_benchmark_api.py config ([16e8631](https://github.com/TPTBusiness/NexQuant/commit/16e86310bdd8d2af1539063957edebde97f88110))
+* Remove API key logging from eurusd_llm.py ([3f510be](https://github.com/TPTBusiness/NexQuant/commit/3f510be9daddf0b241925f605898e2e1d3a18cb7))
+* Remove API key parameter from generate_api_config() ([e6eeac9](https://github.com/TPTBusiness/NexQuant/commit/e6eeac93614a9d97d119696802c7a08153c70f59))
+* Remove API key presence detection from logging ([12b45e5](https://github.com/TPTBusiness/NexQuant/commit/12b45e50f2d7d41881c3028b3f2213e7e7c573d8))
+* Remove clear-text storage of API key (CodeQL alert [#8](https://github.com/TPTBusiness/NexQuant/issues/8)) ([4842311](https://github.com/TPTBusiness/NexQuant/commit/4842311d9193d665c27311e7efc9637b9f3e0519))
+* Remove hardcoded credentials from test_benchmark_api.py ([2523ee2](https://github.com/TPTBusiness/NexQuant/commit/2523ee213e35c03175da9512619b46f6e9069f88))
+* remove unused imports in data science scenario module ([#1136](https://github.com/TPTBusiness/NexQuant/issues/1136)) ([fd6cd39](https://github.com/TPTBusiness/NexQuant/commit/fd6cd3950c4d0463f2d1ccab63fa48be4de41a58))
+* Rename loader.py to prompt_loader.py to fix module conflict ([06f0c34](https://github.com/TPTBusiness/NexQuant/commit/06f0c3427c665063513ae097068be71069a733b2))
+* replace hardcoded ChromeDriver path with webdriver-manager ([#1271](https://github.com/TPTBusiness/NexQuant/issues/1271)) ([e3d2443](https://github.com/TPTBusiness/NexQuant/commit/e3d24437cf7842623fe27fd9221e36a07457d7f7))
+* Resolve 88% empty backtest results + path fixes ([8d1c70e](https://github.com/TPTBusiness/NexQuant/commit/8d1c70e679721b90c024bc747d2544ce9c151adf))
+* resolve dead code, shell injection risk, mutable defaults, and other bugs ([4267315](https://github.com/TPTBusiness/NexQuant/commit/4267315783ccbdaa3472c5f7fd4728cf656556c1))
+* Resolve FORWARD_BARS NameError in backtest script ([ad7f5e1](https://github.com/TPTBusiness/NexQuant/commit/ad7f5e1388ad2149d0c32a5febfed0b77b05ef47))
+* Resolve security vulnerabilities (Dependabot + Code Scanning) ([2c96828](https://github.com/TPTBusiness/NexQuant/commit/2c9682800e4ea30361561affbb747e4f2cc763f6))
+* resolve unbound variable, logger shadowing, withdraw_loop edge case, and other bugs in main scripts ([2fd4bc3](https://github.com/TPTBusiness/NexQuant/commit/2fd4bc3741bafc6778008b3ecc49ba01207f22e1))
+* revert 2 commits ([#1239](https://github.com/TPTBusiness/NexQuant/issues/1239)) ([2201a47](https://github.com/TPTBusiness/NexQuant/commit/2201a4762343f2cc2deb3dff2b70baf99f102292))
+* revert to v10 setting ([#1220](https://github.com/TPTBusiness/NexQuant/issues/1220)) ([51f5bc9](https://github.com/TPTBusiness/NexQuant/commit/51f5bc9e117c6bfcb50c29355d5e73381d40b511))
+* **security:** nosec for B608/B701 false positives in UI and template code ([8b73952](https://github.com/TPTBusiness/NexQuant/commit/8b739528e5679cb49989be7e0edd7ac404b5d993))
+* **security:** Patch 5 CodeQL path injection and clear-text logging alerts ([#22](https://github.com/TPTBusiness/NexQuant/issues/22)-[#25](https://github.com/TPTBusiness/NexQuant/issues/25), [#9](https://github.com/TPTBusiness/NexQuant/issues/9)) ([5aed2cf](https://github.com/TPTBusiness/NexQuant/commit/5aed2cf58a4a39d515bc81e5fd6835a138198b82))
+* **security:** Patch 5 CodeQL path injection and weak hashing alerts ([#25](https://github.com/TPTBusiness/NexQuant/issues/25)-[#30](https://github.com/TPTBusiness/NexQuant/issues/30)) ([e188333](https://github.com/TPTBusiness/NexQuant/commit/e1883331f18e7265aeb13145abaca4b295a15f6e))
+* **security:** Patch path injection and stack trace exposure (CodeQL [#31](https://github.com/TPTBusiness/NexQuant/issues/31), [#27](https://github.com/TPTBusiness/NexQuant/issues/27)) ([2b0525f](https://github.com/TPTBusiness/NexQuant/commit/2b0525f9b7ef68ecc04bfddd558184f06640fb0b))
+* **security:** real fix for B110 (logging in factor_proposal.py [#746](https://github.com/TPTBusiness/NexQuant/issues/746)) ([61656af](https://github.com/TPTBusiness/NexQuant/commit/61656afda75e77686952d847aec443c28e17b6d6))
+* **security:** real fix for B110 (logging in factor_runner.py [#744](https://github.com/TPTBusiness/NexQuant/issues/744)) ([5ac64e6](https://github.com/TPTBusiness/NexQuant/commit/5ac64e60e4e3977364ffd5ad8704fdf0c46bad75))
+* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/NexQuant/issues/741)) ([bcfeb32](https://github.com/TPTBusiness/NexQuant/commit/bcfeb32958953ba07e980dce5feaffe5d53963e8))
+* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/NexQuant/issues/741)) ([d865c82](https://github.com/TPTBusiness/NexQuant/commit/d865c824c98820b26e3d64b8c193445effb19667))
+* **security:** real fix for B404/B603 (sys.executable in factor_runner.py [#745](https://github.com/TPTBusiness/NexQuant/issues/745)) ([7894b8e](https://github.com/TPTBusiness/NexQuant/commit/7894b8e6ed1cb580d8909403eb166a2b418b2dd0))
+* **security:** replace eval() with ast.literal_eval and add request timeouts (B307, B113) ([ffb24fd](https://github.com/TPTBusiness/NexQuant/commit/ffb24fd5de724455aa77846c3f98fae35bc80430))
+* **security:** replace eval() with ast.literal_eval in finetune validator (B307) ([8d53b81](https://github.com/TPTBusiness/NexQuant/commit/8d53b81633965fd0ae2bf32081dacc91b121b77d))
+* **security:** replace os.path.realpath with pathlib.resolve in safe_resolve_path to fix path-injection alerts ([0d7af52](https://github.com/TPTBusiness/NexQuant/commit/0d7af52a2d32f1dbcc366b9f395c43ad47ddabb2))
+* **security:** replace relative_to() with realpath+startswith for CodeQL sanitization ([d7e2018](https://github.com/TPTBusiness/NexQuant/commit/d7e2018a7232c59a40d6e740111572a0da0cd384))
+* **security:** replace remaining assert statements with proper error handling ([d4d5baf](https://github.com/TPTBusiness/NexQuant/commit/d4d5bafd1eb8330f75917170520408b48d38f8c2))
+* **security:** replace shell=True subprocess calls with list args (B602) ([30887ac](https://github.com/TPTBusiness/NexQuant/commit/30887ac244f77a5edabc11dda7805b9bb789667f))
+* **security:** replace shell=True subprocess calls with list args in env.py (B602) ([1a4f1cf](https://github.com/TPTBusiness/NexQuant/commit/1a4f1cf6044842939bc5e7ed853c437cab591a26))
+* **security:** resolve all 30 Bandit security alerts (B301, B614, B104) ([00f400f](https://github.com/TPTBusiness/NexQuant/commit/00f400fe2efda375884234cd381401583a65f456))
+* **security:** resolve CodeQL path-injection alerts in UI data loaders ([7caab95](https://github.com/TPTBusiness/NexQuant/commit/7caab9545bd929909f4c7cae02fbcc2cc3a9893a))
+* **security:** resolve CodeQL path-injection and clear-text-logging alerts ([8701b8b](https://github.com/TPTBusiness/NexQuant/commit/8701b8bd75f82ceb326da4f105609f4228961666))
+* **security:** Resolve GitHub Security Scan alerts ([5af7f19](https://github.com/TPTBusiness/NexQuant/commit/5af7f19bd1656078991752d298c0f3c953f7af2c))
+* **security:** resolve path-injection and add nosec for safe temp paths (B108, py/path-injection) ([4133fff](https://github.com/TPTBusiness/NexQuant/commit/4133fffa7d97bd38beb4b99aa7f3ab3039d78103))
+* **security:** resolve path-injection, B701, B101, B112 Bandit alerts ([e87d612](https://github.com/TPTBusiness/NexQuant/commit/e87d61257fa4bb401415b62ff88c7ad75085d89c))
+* **security:** revert broken read_pickle encoding arg in kaggle template (B301) ([e16460c](https://github.com/TPTBusiness/NexQuant/commit/e16460c7bc5329c9752cd12b20fcee978b5f232b))
+* **security:** Upgrade vllm and transformers to patch 4 CVEs ([85915b3](https://github.com/TPTBusiness/NexQuant/commit/85915b3a20e9ceae6dd854ef4c64a61590a36d84))
+* **security:** validate SQL identifiers in _add_column_if_not_exists (B608) ([c40795b](https://github.com/TPTBusiness/NexQuant/commit/c40795bcb0dab5ceff9b56ec019b9be6f9d10203))
+* **security:** whitelist-validate metric column in get_top_factors (B608) ([db51417](https://github.com/TPTBusiness/NexQuant/commit/db51417cd4337e3b8b76420c93b1bb1ed3271b13))
+* set requires_documentation_search to None to disable feature in eval ([#1245](https://github.com/TPTBusiness/NexQuant/issues/1245)) ([ee8c119](https://github.com/TPTBusiness/NexQuant/commit/ee8c119f31b72de1002e5ad5d30c56d0f4b6c9b9))
+* Skip already evaluated factors in nexquant_full_eval.py ([8375213](https://github.com/TPTBusiness/NexQuant/commit/8375213629551605b4c401aa1ce71ed8d9f1e4db))
+* skip Kronos factor on GPUs < 20GB to avoid CUDA OOM (shared with llama-server) ([08fea7a](https://github.com/TPTBusiness/NexQuant/commit/08fea7a2809941d2b5f3feb5ba998dba132053bb))
+* skip res_ratio check if timer or res_time is None ([#1189](https://github.com/TPTBusiness/NexQuant/issues/1189)) ([dbe2142](https://github.com/TPTBusiness/NexQuant/commit/dbe214282e84f099512eeaf01925c7dee1b780a6))
+* **strategies:** guard against None IC in acceptance check, disable slow wf_rolling ([843cd9a](https://github.com/TPTBusiness/NexQuant/commit/843cd9ae017b05365e1bb353b9945e2fbce332dd))
+* **strategies:** handle None ic/sharpe/dd in rejected strategy log output ([0121c2c](https://github.com/TPTBusiness/NexQuant/commit/0121c2c1583b752622c69313e78ccbeedf6c8d1b))
+* **strategy:** Fix template variables, APIBackend import, and JSON extraction ([f0e813e](https://github.com/TPTBusiness/NexQuant/commit/f0e813ee48ae65e0ee78c27a8b971139dac5b552))
+* **strategy:** Re-evaluate Optuna-optimized strategies with full OHLCV backtest ([7da8bad](https://github.com/TPTBusiness/NexQuant/commit/7da8badbc1005bb1866631dc14daa815641b4271))
+* summary page bug ([#1219](https://github.com/TPTBusiness/NexQuant/issues/1219)) ([beab473](https://github.com/TPTBusiness/NexQuant/commit/beab473b40714fbd802ebb3b61c0dd3d3ba7d91a))
+* Switch to ThreadPoolExecutor for factor evaluation ([d0aa146](https://github.com/TPTBusiness/NexQuant/commit/d0aa1464ea1e3553e4b869c3429e5e394bcebda8))
+* Translate remaining German comment in eurusd_macro.py ([02b46d1](https://github.com/TPTBusiness/NexQuant/commit/02b46d1ffc3bfe87033714f71a9d22714a071f09))
+* ui bug ([#1192](https://github.com/TPTBusiness/NexQuant/issues/1192)) ([2f8261f](https://github.com/TPTBusiness/NexQuant/commit/2f8261f82bf25ad714eff22be2283c6e645b5314))
+* update fallback criterion ([#1210](https://github.com/TPTBusiness/NexQuant/issues/1210)) ([dbbe374](https://github.com/TPTBusiness/NexQuant/commit/dbbe374ac8b0cefcde9145a76b4cd5c0b40b3f92))
+* Update LICENSE badge link from main to master branch ([0dbace6](https://github.com/TPTBusiness/NexQuant/commit/0dbace6aa7aa1a7a250e45c96e71591edeed8f55))
+* update requirements.txt's streamlit ([#1133](https://github.com/TPTBusiness/NexQuant/issues/1133)) ([600d159](https://github.com/TPTBusiness/NexQuant/commit/600d159e86521cc0498df9df3756921e676e3332))
+* Update Werkzeug to 2.3.8 (latest secure 2.x version) ([d68a5ee](https://github.com/TPTBusiness/NexQuant/commit/d68a5ee47cba6f8d2ca0faba1ad89ba65f4fc94b))
+* update WF test for new default (wf_rolling=True) ([c906e00](https://github.com/TPTBusiness/NexQuant/commit/c906e00ac9731673f6386f8b3ce38f5d8e817992))
+* Use 96-bar forward returns in backtest (matching factor IC horizon) ([19c5b3d](https://github.com/TPTBusiness/NexQuant/commit/19c5b3d70633d5cc622328e57acd122120d47971))
+* Use num_api_keys instead of len(api_keys) for round-robin ([c91976e](https://github.com/TPTBusiness/NexQuant/commit/c91976e7968f54a065b4a5ee11228133b48db3e9))
+* weg, Timestamps mit Uhrzeit, kein SZ-Beispiel ([e9f6ac4](https://github.com/TPTBusiness/NexQuant/commit/e9f6ac48d97b1b57a0dde14562cd1b6f5d106edd))
 
 
 ### Performance Improvements
 
-* **kronos:** batch GPU inference via predict_batch — 75x faster ([74611d0](https://github.com/TPTBusiness/Predix/commit/74611d071ac123a655eb15d0737bb73b8c1bd2b0))
-* **kronos:** batch GPU inference via predict_batch — 75x faster ([2babeb9](https://github.com/TPTBusiness/Predix/commit/2babeb95f42828e13a37dc16166c75538f33fd4b))
+* **kronos:** batch GPU inference via predict_batch — 75x faster ([a93f940](https://github.com/TPTBusiness/NexQuant/commit/a93f940485eb92d747d5e6f966acb5c5e8d118c7))
+* **kronos:** batch GPU inference via predict_batch — 75x faster ([471b1f9](https://github.com/TPTBusiness/NexQuant/commit/471b1f9a4b22cfd2f473d28285a6c7390fe3d10c))
 
 
 ### Documentation
 
-* fix duplicate sections, add hardware requirements and data setup guide ([6c771b3](https://github.com/TPTBusiness/Predix/commit/6c771b37e6f88526a896499e86929cfca2c199eb))
-
-## [2.1.0](https://github.com/TPTBusiness/Predix/compare/v2.0.0...v2.1.0) (2026-04-18)
+* Add ATTRIBUTION.md with clear usage guidelines ([c5bf3e4](https://github.com/TPTBusiness/NexQuant/commit/c5bf3e4e2b99074e54645328a399f8f6da0387ea))
+* Add CLI welcome screenshot to README ([4103ebe](https://github.com/TPTBusiness/NexQuant/commit/4103ebe1bfdc625af18711cf78ed19c808270227))
+* Add comprehensive CHANGELOG.md for v1.0.0 release ([569b72b](https://github.com/TPTBusiness/NexQuant/commit/569b72b2c9a154bf991d03ac078bf020ef1eab16))
+* Add comprehensive CLI help and update README with quick start ([8265462](https://github.com/TPTBusiness/NexQuant/commit/8265462cacb4e03c981ead1d6b6393a9070f729e))
+* Add comprehensive data setup guide to README ([ca30ed2](https://github.com/TPTBusiness/NexQuant/commit/ca30ed270ab36517604a9eb0f1ace0fdd58a917c))
+* Add comprehensive Git commit guidelines to QWEN.md ([d10d3a2](https://github.com/TPTBusiness/NexQuant/commit/d10d3a2c658bb77366baec13e922f0ed924b51d8))
+* Add conda requirement to README + fix nexquant CLI ([90e185a](https://github.com/TPTBusiness/NexQuant/commit/90e185a4986ff9a4838bd94cb7b4034fea573f87))
+* Add CRITICAL rule - NEVER commit closed-source/private assets ([a0ed4f7](https://github.com/TPTBusiness/NexQuant/commit/a0ed4f712ed4aa49eadaa5ced070c22f0146420a))
+* Add CRITICAL rule - NEVER commit trading strategies or JSON files ([cb0cb4c](https://github.com/TPTBusiness/NexQuant/commit/cb0cb4c1122b9aab23f2e2f4feb5b4a99ed05008))
+* add documentation for Data Science configurable options ([#1301](https://github.com/TPTBusiness/NexQuant/issues/1301)) ([d603d5a](https://github.com/TPTBusiness/NexQuant/commit/d603d5a5aa86e43cfc0ee3efedc5ab18919809f5))
+* add execution environment configuration guide (Docker vs Conda) ([#1288](https://github.com/TPTBusiness/NexQuant/issues/1288)) ([27ed3d1](https://github.com/TPTBusiness/NexQuant/commit/27ed3d1a75b15a5589af84d4f597a8484006e71e))
+* Add implementation summary ([649ed0c](https://github.com/TPTBusiness/NexQuant/commit/649ed0c3c0db823fb4fc984b9f6b6e7970d728ff))
+* Add live trading system documentation to QWEN.md ([49b15d9](https://github.com/TPTBusiness/NexQuant/commit/49b15d917828a3c1263da1785da5663c67d41b40))
+* Add Microsoft RD-Agent acknowledgment to README ([06c0b44](https://github.com/TPTBusiness/NexQuant/commit/06c0b44e4106a725a879932122d871041042ec2b))
+* Add professional badges to README header ([91d44dd](https://github.com/TPTBusiness/NexQuant/commit/91d44ddabd4b4cf82cb1e6f53c8f4547f52a50cb))
+* Add results/ directory README for storage documentation ([ba4e5d6](https://github.com/TPTBusiness/NexQuant/commit/ba4e5d6ece652e8c1c3b8a713a2e0ea2a0ab225c))
+* Add v2.0.0 release changelog ([c5e34ff](https://github.com/TPTBusiness/NexQuant/commit/c5e34ff7aaa2d30a159b05f4e6ecc853b8a4f79e))
+* Clean changelog of closed-source performance metrics ([7dc2ecd](https://github.com/TPTBusiness/NexQuant/commit/7dc2ecdc8dbf4ef0a2936ab1f1e0c0469ca95e9c))
+* Create changelog/ directory with v1.0.0.md release notes ([ddefcd4](https://github.com/TPTBusiness/NexQuant/commit/ddefcd420a9d98fc6548e14cfc94caffd2068963))
+* Final system completion - all 9 phases done ([ab541de](https://github.com/TPTBusiness/NexQuant/commit/ab541de9b3ca4cdf62f14f97d540460fc333fca9))
+* fix duplicate sections, add hardware requirements and data setup guide ([cc85cd4](https://github.com/TPTBusiness/NexQuant/commit/cc85cd482ac7169fbe98468539899a2ce561e70d))
+* improve README badges, fix llama-server flags, clean up structure ([7981a6a](https://github.com/TPTBusiness/NexQuant/commit/7981a6a4d1517950f4124a78642db3f15fde03ba))
+* Remove 'Inspired by' comments and add comprehensive Acknowledgments ([d5dc48a](https://github.com/TPTBusiness/NexQuant/commit/d5dc48a6bdd519d0ce159d21ca9bbc46b7996313))
+* Simplify README for git-clone-only installation ([a1e3bb9](https://github.com/TPTBusiness/NexQuant/commit/a1e3bb903c31cea3ea4c5e572bc639352e3215ae))
+* Translate all code comments to English ([cff6c2a](https://github.com/TPTBusiness/NexQuant/commit/cff6c2a55e0b465a3f30ab802f02e3b4583025bc))
+* Translate data_config.yaml to English ([b5221b7](https://github.com/TPTBusiness/NexQuant/commit/b5221b761f51bcf2b7b14c7bdfabfa2e9629a3b0))
+* Translate server.py comments to English ([7fd7592](https://github.com/TPTBusiness/NexQuant/commit/7fd75922f89d6358c1ce48fd886ffbca10537531))
+* Translate server.py docstring to English ([d5acaa0](https://github.com/TPTBusiness/NexQuant/commit/d5acaa0c036913776eef6bb01083cce2942dc16c))
+* update configuration docs ([#1155](https://github.com/TPTBusiness/NexQuant/issues/1155)) ([56ed919](https://github.com/TPTBusiness/NexQuant/commit/56ed919b2e44f4398ac304a4f6cdf099dd382096))
+* update license section from MIT to AGPL-3.0 ([ff441a4](https://github.com/TPTBusiness/NexQuant/commit/ff441a49fe0b45c31b1702b8bd22d5c8edd37abb))
+* Update QWEN.md with complete 5-phase architecture and results ([66e1798](https://github.com/TPTBusiness/NexQuant/commit/66e17981fd9241d9ee6f50be05142ee201b761a8))
+* Update QWEN.md with detailed Git history correction guide ([a972772](https://github.com/TPTBusiness/NexQuant/commit/a97277298d3d5f122905d7e02b58568224b86b40))
+* Update QWEN.md with implementation guide ([23af142](https://github.com/TPTBusiness/NexQuant/commit/23af142af0b127600c61ba3623f3538abf1c881c))
+* Update SECURITY.md and CONTRIBUTING.md ([e40f659](https://github.com/TPTBusiness/NexQuant/commit/e40f6594441e195041ccb58072483fe8704eac4c))
+* Update TODO.md with v1.0.0 completed items and future roadmap ([2d3ca5b](https://github.com/TPTBusiness/NexQuant/commit/2d3ca5bec66e81b37ce7bf4086f24556f6cad134))
 
 
-### Features
+### Miscellaneous Chores
 
-* add daily log rotation, llama health wait, factor auto-fixer, and README updates ([4ae4d6f](https://github.com/TPTBusiness/Predix/commit/4ae4d6f0f1388d229e44333130306ae05767f2e5))
-* Add GitHub infrastructure, CI/CD pipelines, and examples ([a0b5dc4](https://github.com/TPTBusiness/Predix/commit/a0b5dc464eaac831c76bdbf805cf60c9083e7d80))
-* **factor-coder:** Add critical rules to prevent common factor implementation errors ([a1edca8](https://github.com/TPTBusiness/Predix/commit/a1edca87dd5e75ee402ea555f1b7a07b45c4b1f0))
-* **logging:** write complete LLM prompts and responses to daily JSONL log ([803ef13](https://github.com/TPTBusiness/Predix/commit/803ef13052c645392e71aa5de24874aae83f62a7))
-* **strategy:** Continuous optimization with Optuna parameter injection ([4fda5ea](https://github.com/TPTBusiness/Predix/commit/4fda5eaa31bc570e295ad96380ee2c02b82db706))
-* unified backtest engine, LLM error handling, strategy refactor ([76b9341](https://github.com/TPTBusiness/Predix/commit/76b9341fe8ef0ff03fd911337c299cf0e8582f37))
+* release 0.8.0 ([8c15238](https://github.com/TPTBusiness/NexQuant/commit/8c1523802c3c0237eae27ebef3e155af2cddd05e))
+
+## [1.4.2](https://github.com/TPTBusiness/NexQuant/compare/v1.4.1...v1.4.2) (2026-05-03)
 
 
 ### Bug Fixes
 
-* Add critical column name rules to factor generation prompt ([3e74410](https://github.com/TPTBusiness/Predix/commit/3e7441079f0f1c5867829a365c6e45cd7d2071df))
-* **ci:** fix closed-source asset check false positives in security workflow ([4b83c2b](https://github.com/TPTBusiness/Predix/commit/4b83c2bfe7e90c0c7a11116f07a1b989035b7a3f))
-* **ci:** remove CodeQL workflow (conflicts with default setup), drop duplicate lint job ([a671361](https://github.com/TPTBusiness/Predix/commit/a671361ee4de9a7e00ccc66d8fd5732c2ed1fee9))
-* **ci:** set JAVA_TOOL_OPTIONS UTF-8 in Codacy workflow ([e36721c](https://github.com/TPTBusiness/Predix/commit/e36721c765a02a325b8a7dfd3c262b2aca7b1652))
-* **deps:** pin aiohttp>=3.13.4 to patch 4 CVEs ([81adddc](https://github.com/TPTBusiness/Predix/commit/81adddcfcd14819a1f85c06288a663e7d222a8fb))
-* **optuna:** fix inverted parameter range in Stage 2/3 when signal_bias is negative ([eaf885e](https://github.com/TPTBusiness/Predix/commit/eaf885ec2d20ebd93e34d1e2cb445532d2fb0ed3))
-* **security:** Patch 5 CodeQL path injection and clear-text logging alerts ([#22](https://github.com/TPTBusiness/Predix/issues/22)-[#25](https://github.com/TPTBusiness/Predix/issues/25), [#9](https://github.com/TPTBusiness/Predix/issues/9)) ([d386af9](https://github.com/TPTBusiness/Predix/commit/d386af98205722d1ea6d1465f585e89cb8df47de))
-* **security:** Patch 5 CodeQL path injection and weak hashing alerts ([#25](https://github.com/TPTBusiness/Predix/issues/25)-[#30](https://github.com/TPTBusiness/Predix/issues/30)) ([0d4c3b7](https://github.com/TPTBusiness/Predix/commit/0d4c3b7d69fdbdaafab00940bf7346c8b664928e))
-* **security:** Patch path injection and stack trace exposure (CodeQL [#31](https://github.com/TPTBusiness/Predix/issues/31), [#27](https://github.com/TPTBusiness/Predix/issues/27)) ([b0b8432](https://github.com/TPTBusiness/Predix/commit/b0b84328d13dac5c2ef79961200b011c0b5778f1))
-* **security:** replace relative_to() with realpath+startswith for CodeQL sanitization ([6d70f1e](https://github.com/TPTBusiness/Predix/commit/6d70f1ed944180c44d0eb75c0e86b013e5888b60))
-* **security:** resolve CodeQL path-injection alerts in UI data loaders ([cced426](https://github.com/TPTBusiness/Predix/commit/cced426916cb726e95ad251dcbc0eb9ab6ec3591))
-* **security:** resolve CodeQL path-injection and clear-text-logging alerts ([ec50224](https://github.com/TPTBusiness/Predix/commit/ec50224c3580c5c82ddba02fe77af95efd9667ea))
-* **security:** Resolve GitHub Security Scan alerts ([6c85ba8](https://github.com/TPTBusiness/Predix/commit/6c85ba833a48326e39006e0f73c506b29a594bde))
-* **security:** Upgrade vllm and transformers to patch 4 CVEs ([6c9ba91](https://github.com/TPTBusiness/Predix/commit/6c9ba91d3bf7ce1ed389e544c68be55262bf4e28))
-* **strategy:** Fix template variables, APIBackend import, and JSON extraction ([8220faa](https://github.com/TPTBusiness/Predix/commit/8220faa3de6ea555717ac29ba90a3b68135fbf9e))
-* **strategy:** Re-evaluate Optuna-optimized strategies with full OHLCV backtest ([026edce](https://github.com/TPTBusiness/Predix/commit/026edce122284fb1da467e6e9de8a2b9116c7ace))
+* add missing sys import and fix undefined acc_rate in factor eval ([c45f990](https://github.com/TPTBusiness/NexQuant/commit/c45f9908ee321400f0a19c57f1482e4cd1394a50))
+
+## [1.4.1](https://github.com/TPTBusiness/NexQuant/compare/v1.4.0...v1.4.1) (2026-05-03)
+
+
+### Bug Fixes
+
+* 15 bug fixes across orchestrator, runner, backtest, and infrastructure ([163687d](https://github.com/TPTBusiness/NexQuant/commit/163687d7e1c278a085d7052a3f958a3edb501e77))
+* also catch ValueError in mean_variance for dimension mismatch ([ed73b72](https://github.com/TPTBusiness/NexQuant/commit/ed73b7253f7dc6459ee30dd81a1ce1194e46e9af))
+* close log file handle, fix FTMO equity double-count, remove bare except ([76219a5](https://github.com/TPTBusiness/NexQuant/commit/76219a53efddaafc2b8bd48a0f76c1d4325e6ea5))
+* correct project root paths and subprocess handling in parallel runner and CLI ([9735e3a](https://github.com/TPTBusiness/NexQuant/commit/9735e3a4d8f01e7b16fb9b185a002396a915cea4))
+* filter NaN in max(), remove redundant ternary, handle non-finite vbt results ([f89fbb3](https://github.com/TPTBusiness/NexQuant/commit/f89fbb3421faf6ccdc8e68a911fd9db2c166120f))
+* fix type annotation, remove unused parameter, improve import_class errors ([8b6ab73](https://github.com/TPTBusiness/NexQuant/commit/8b6ab735c05629bf6b76ddc2fd8b15617600cad7))
+* resolve dead code, shell injection risk, mutable defaults, and other bugs ([afff262](https://github.com/TPTBusiness/NexQuant/commit/afff26287f7c4df7ddfde4e816d280fe845e11eb))
+* resolve unbound variable, logger shadowing, withdraw_loop edge case, and other bugs in main scripts ([748cf9b](https://github.com/TPTBusiness/NexQuant/commit/748cf9b214a3e8447f1289fc4cf1e92ad6cc2f1a))
+
+## [1.4.0](https://github.com/TPTBusiness/NexQuant/compare/v1.3.11...v1.4.0) (2026-05-01)
+
+
+### Features
+
+* **optimizer:** add max_positions parameter to Optuna search space ([fdb4be3](https://github.com/TPTBusiness/NexQuant/commit/fdb4be3b3ebd93325e7821f4251148424184a40d))
+
+## [1.3.11](https://github.com/TPTBusiness/NexQuant/compare/v1.3.10...v1.3.11) (2026-05-01)
+
+
+### Bug Fixes
+
+* **ci:** lazy import logger in nexquant.py and cli.py to avoid ImportError in test env ([60763e8](https://github.com/TPTBusiness/NexQuant/commit/60763e8eae34f41865ba8e5e65bdfde13b564b4b))
+
+## [1.3.10](https://github.com/TPTBusiness/NexQuant/compare/v1.3.9...v1.3.10) (2026-05-01)
+
+
+### Bug Fixes
+
+* **security:** replace remaining assert statements with proper error handling ([928533d](https://github.com/TPTBusiness/NexQuant/commit/928533d9a81bd5062f07458fbf94d3c7fe347775))
+
+## [1.3.9](https://github.com/TPTBusiness/NexQuant/compare/v1.3.8...v1.3.9) (2026-05-01)
+
+
+### Bug Fixes
+
+* **security:** resolve path-injection, B701, B101, B112 Bandit alerts ([20b89a0](https://github.com/TPTBusiness/NexQuant/commit/20b89a061843b39836e975f158404e8e2d4627cd))
+
+## [1.3.8](https://github.com/TPTBusiness/NexQuant/compare/v1.3.7...v1.3.8) (2026-04-30)
+
+
+### Bug Fixes
+
+* **deps:** relax aiohttp constraint to >=3.13.4 for litellm compatibility ([34ab192](https://github.com/TPTBusiness/NexQuant/commit/34ab1923a887089eb36e5cbad6cb8df16f0333ca))
+* **qlib:** correct indentation in except blocks in quant_proposal and factor_runner ([8143451](https://github.com/TPTBusiness/NexQuant/commit/8143451e8c0ead01c4d86d19669268c7bfb15fac))
+* **security:** replace eval() with ast.literal_eval in finetune validator (B307) ([0508caf](https://github.com/TPTBusiness/NexQuant/commit/0508caf9140d210b823fefefa28ee535ec85a0ae))
+* **security:** replace shell=True subprocess calls with list args in env.py (B602) ([2012d5a](https://github.com/TPTBusiness/NexQuant/commit/2012d5ae4e77cc2f1ab9a48beaaac5a74695d083))
+* **security:** resolve path-injection and add nosec for safe temp paths (B108, py/path-injection) ([6727480](https://github.com/TPTBusiness/NexQuant/commit/67274803bd1d14e5d1df9a063f46b2edb8501a2b))
+
+## [1.3.7](https://github.com/TPTBusiness/NexQuant/compare/v1.3.6...v1.3.7) (2026-04-30)
+
+
+### Bug Fixes
+
+* **security:** nosec for B608/B701 false positives in UI and template code ([5eb5d7e](https://github.com/TPTBusiness/NexQuant/commit/5eb5d7e8fdbe90e0dced83fef4e09f5a33e96b2b))
+* **security:** replace eval() with ast.literal_eval and add request timeouts (B307, B113) ([3301ada](https://github.com/TPTBusiness/NexQuant/commit/3301ada697ca7d3afa1a188d2a76a87ae98b4529))
+* **security:** replace shell=True subprocess calls with list args (B602) ([13c08f4](https://github.com/TPTBusiness/NexQuant/commit/13c08f4ce6813eb7c314087921ec8c0f40074bd7))
+
+## [1.3.6](https://github.com/TPTBusiness/NexQuant/compare/v1.3.5...v1.3.6) (2026-04-30)
+
+
+### Bug Fixes
+
+* **security:** real fix for B110 (logging in factor_proposal.py [#746](https://github.com/TPTBusiness/NexQuant/issues/746)) ([16624e0](https://github.com/TPTBusiness/NexQuant/commit/16624e0bd966ae4d24c4a3eb42bbc31c11da3136))
+* **security:** real fix for B110 (logging in factor_runner.py [#744](https://github.com/TPTBusiness/NexQuant/issues/744)) ([88cf0fb](https://github.com/TPTBusiness/NexQuant/commit/88cf0fb8828b11c97f2f3ae2881a4900b020c6f0))
+* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/NexQuant/issues/741)) ([7cf2a64](https://github.com/TPTBusiness/NexQuant/commit/7cf2a644f553b054bd4b0607ea51e5372e68d90a))
+* **security:** real fix for B110 (logging in quant_proposal.py [#741](https://github.com/TPTBusiness/NexQuant/issues/741)) ([ef985f8](https://github.com/TPTBusiness/NexQuant/commit/ef985f86035d8dca707c60137e6508349a0c4ae6))
+* **security:** real fix for B404/B603 (sys.executable in factor_runner.py [#745](https://github.com/TPTBusiness/NexQuant/issues/745)) ([819655a](https://github.com/TPTBusiness/NexQuant/commit/819655aaa3efa76596d60501d0e8ca365df3e5e2))
+* **security:** revert broken read_pickle encoding arg in kaggle template (B301) ([3574907](https://github.com/TPTBusiness/NexQuant/commit/35749073c91e69f63ddaad61dae3f2b799327e63))
+* **security:** validate SQL identifiers in _add_column_if_not_exists (B608) ([e10dfa2](https://github.com/TPTBusiness/NexQuant/commit/e10dfa2576038e911f83595d3b466c261bc0cd54))
+* **security:** whitelist-validate metric column in get_top_factors (B608) ([e50519f](https://github.com/TPTBusiness/NexQuant/commit/e50519fe066e68aec2f19b83df4f643c3c22053d))
+
+## [1.3.5](https://github.com/TPTBusiness/NexQuant/compare/v1.3.4...v1.3.5) (2026-04-27)
+
+
+### Bug Fixes
+
+* **auto-fixer:** add five new factor code fixes for groupby/apply errors ([449c8fd](https://github.com/TPTBusiness/NexQuant/commit/449c8fd70a327e604dcca122e4a134f0cca918e4))
+* **auto-fixer:** add four new factor code fixes for common runtime errors ([40484f6](https://github.com/TPTBusiness/NexQuant/commit/40484f6d300425da481f1edd325da4acbc06ec7d))
+* **auto-fixer:** add groupby([level=N,'date']) SyntaxError fix ([ca77c00](https://github.com/TPTBusiness/NexQuant/commit/ca77c005bea4abdd8854c1de2b0e8d03b7742161))
+* **auto-fixer:** disable _fix_min_periods for intraday data ([77b0740](https://github.com/TPTBusiness/NexQuant/commit/77b0740f059349df7e769a378af728aa33b2070e))
+* **auto-fixer:** fix chained groupby(level=N).groupby('date') pattern ([7d5fe32](https://github.com/TPTBusiness/NexQuant/commit/7d5fe32b31a19ce8b04bd8f5a430720fdb748f7a))
+* **auto-fixer:** fix df.loc[instrument] DateParseError on MultiIndex frames ([b7860ea](https://github.com/TPTBusiness/NexQuant/commit/b7860eafc0ad26384947ce0510ecf4e9f3425807))
+* **auto-fixer:** fix df['instrument'] KeyError on MultiIndex frames ([aad6bd1](https://github.com/TPTBusiness/NexQuant/commit/aad6bd1c7c720b3d486e0cf248337f32394773b1))
+* **auto-fixer:** fix two assignment-target bugs in instrument column fixers ([421eedf](https://github.com/TPTBusiness/NexQuant/commit/421eedffed4b883c24397dc5581c019a3985277f))
+* **auto-fixer:** preserve date dimension in groupby(['instrument','date']) fix ([b58fdd8](https://github.com/TPTBusiness/NexQuant/commit/b58fdd8be43720b5d4363e0f8de9a01591d4d2dc))
+* **auto-fixer:** remove ddof from rolling() args, not only from std()/var() ([b0fc328](https://github.com/TPTBusiness/NexQuant/commit/b0fc328d0d4a041c65d8eeb32cb3f2bb86568406))
+* **auto-fixer:** strip spurious .reset_index() after .transform() calls ([8708aae](https://github.com/TPTBusiness/NexQuant/commit/8708aae6e08728cda1875c775a76dc92e43576f3))
+* **loop:** prevent step_idx advance on unhandled exceptions + fix consecutive assistant messages ([5ec4ad1](https://github.com/TPTBusiness/NexQuant/commit/5ec4ad1b96b5b99ef42bea7bb828cb1ef709a688))
+
+## [1.3.4](https://github.com/TPTBusiness/NexQuant/compare/v1.3.3...v1.3.4) (2026-04-27)
+
+
+### Bug Fixes
+
+* **auto-fixer:** add five new factor code fixes for groupby/apply errors ([449c8fd](https://github.com/TPTBusiness/NexQuant/commit/449c8fd70a327e604dcca122e4a134f0cca918e4))
+* **auto-fixer:** add four new factor code fixes for common runtime errors ([40484f6](https://github.com/TPTBusiness/NexQuant/commit/40484f6d300425da481f1edd325da4acbc06ec7d))
+* **auto-fixer:** add groupby([level=N,'date']) SyntaxError fix ([ca77c00](https://github.com/TPTBusiness/NexQuant/commit/ca77c005bea4abdd8854c1de2b0e8d03b7742161))
+* **auto-fixer:** disable _fix_min_periods for intraday data ([77b0740](https://github.com/TPTBusiness/NexQuant/commit/77b0740f059349df7e769a378af728aa33b2070e))
+* **auto-fixer:** fix chained groupby(level=N).groupby('date') pattern ([7d5fe32](https://github.com/TPTBusiness/NexQuant/commit/7d5fe32b31a19ce8b04bd8f5a430720fdb748f7a))
+* **auto-fixer:** fix df.loc[instrument] DateParseError on MultiIndex frames ([b7860ea](https://github.com/TPTBusiness/NexQuant/commit/b7860eafc0ad26384947ce0510ecf4e9f3425807))
+* **auto-fixer:** fix df['instrument'] KeyError on MultiIndex frames ([aad6bd1](https://github.com/TPTBusiness/NexQuant/commit/aad6bd1c7c720b3d486e0cf248337f32394773b1))
+* **auto-fixer:** preserve date dimension in groupby(['instrument','date']) fix ([b58fdd8](https://github.com/TPTBusiness/NexQuant/commit/b58fdd8be43720b5d4363e0f8de9a01591d4d2dc))
+* **auto-fixer:** remove ddof from rolling() args, not only from std()/var() ([b0fc328](https://github.com/TPTBusiness/NexQuant/commit/b0fc328d0d4a041c65d8eeb32cb3f2bb86568406))
+* **backtest:** replace broken MC permutation test with binomial win-rate test ([c38d894](https://github.com/TPTBusiness/NexQuant/commit/c38d89478f586825bfca5715a96ca70ccd8791a3))
+* **factors:** detect and correct look-ahead bias in daily-constant factors ([eb490a4](https://github.com/TPTBusiness/NexQuant/commit/eb490a461b66cbd815ae53ac5205115754712432))
+* **factors:** extend look-ahead rules to session factors and add intraday-factor guidance ([c24c100](https://github.com/TPTBusiness/NexQuant/commit/c24c100442d6487686c0578de0b32d240fcbf215))
+* **loop:** compress old experiment history in proposal prompt to reduce context size ([4bf90a9](https://github.com/TPTBusiness/NexQuant/commit/4bf90a905ba8b2aba2a818191c19998088cccaaf))
+* **loop:** prevent step_idx advance on unhandled exceptions + fix consecutive assistant messages ([5ec4ad1](https://github.com/TPTBusiness/NexQuant/commit/5ec4ad1b96b5b99ef42bea7bb828cb1ef709a688))
+
+## [1.3.3](https://github.com/TPTBusiness/NexQuant/compare/v1.3.2...v1.3.3) (2026-04-25)
+
+
+### Bug Fixes
+
+* **backtest:** replace broken MC permutation test with binomial win-rate test ([c38d894](https://github.com/TPTBusiness/NexQuant/commit/c38d89478f586825bfca5715a96ca70ccd8791a3))
+* **factors:** detect and correct look-ahead bias in daily-constant factors ([eb490a4](https://github.com/TPTBusiness/NexQuant/commit/eb490a461b66cbd815ae53ac5205115754712432))
+* **factors:** extend look-ahead rules to session factors and add intraday-factor guidance ([c24c100](https://github.com/TPTBusiness/NexQuant/commit/c24c100442d6487686c0578de0b32d240fcbf215))
+* **loop:** compress old experiment history in proposal prompt to reduce context size ([4bf90a9](https://github.com/TPTBusiness/NexQuant/commit/4bf90a905ba8b2aba2a818191c19998088cccaaf))
+* **strategies:** guard against None IC in acceptance check, disable slow wf_rolling ([2197f52](https://github.com/TPTBusiness/NexQuant/commit/2197f52150a50ef38d9e70991d7e48c8c30caec4))
+* **strategies:** handle None ic/sharpe/dd in rejected strategy log output ([ad2ad3a](https://github.com/TPTBusiness/NexQuant/commit/ad2ad3ab3360ea75ed3bbc90c12098b9c5cc0114))
+
+## [1.3.2](https://github.com/TPTBusiness/NexQuant/compare/v1.3.1...v1.3.2) (2026-04-23)
+
+
+### Bug Fixes
+
+* **strategies:** guard against None IC in acceptance check, disable slow wf_rolling ([2197f52](https://github.com/TPTBusiness/NexQuant/commit/2197f52150a50ef38d9e70991d7e48c8c30caec4))
+* **strategies:** handle None ic/sharpe/dd in rejected strategy log output ([ad2ad3a](https://github.com/TPTBusiness/NexQuant/commit/ad2ad3ab3360ea75ed3bbc90c12098b9c5cc0114))
+
+## [1.3.1](https://github.com/TPTBusiness/NexQuant/compare/v1.3.0...v1.3.1) (2026-04-21)
+
+
+### Bug Fixes
+
+* **deps:** bump python-dotenv to >=1.2.2 (CVE symlink overwrite) ([126ae7d](https://github.com/TPTBusiness/NexQuant/commit/126ae7d5fb556b677d09d10221862a0d648d697a))
+
+## [1.3.0](https://github.com/TPTBusiness/NexQuant/compare/v1.2.2...v1.3.0) (2026-04-21)
+
+
+### Features
+
+* **backtest:** add rolling walk-forward validation and Monte Carlo trade permutation test ([637a94c](https://github.com/TPTBusiness/NexQuant/commit/637a94c1d987da763869f4f9b73372a3f37d873c))
+
+
+### Bug Fixes
+
+* **security:** resolve all 30 Bandit security alerts (B301, B614, B104) ([ce5983d](https://github.com/TPTBusiness/NexQuant/commit/ce5983d9d59c4c34341fb1ec749e44bbcfc4a1c4))
+
+## [1.2.2](https://github.com/TPTBusiness/NexQuant/compare/v1.2.1...v1.2.2) (2026-04-19)
 
 
 ### Documentation
 
-* Add CLI welcome screenshot to README ([e6f2374](https://github.com/TPTBusiness/Predix/commit/e6f237437595745406c310b58a9bd7214ff914ae))
-* Add comprehensive data setup guide to README ([f721d53](https://github.com/TPTBusiness/Predix/commit/f721d53e5681be6997418c13acc3439897168048))
-* Add conda requirement to README + fix predix CLI ([df45698](https://github.com/TPTBusiness/Predix/commit/df45698b20e0a3e6e0079decf2b8eecb6983a175))
-* Clean changelog of closed-source performance metrics ([a0f6587](https://github.com/TPTBusiness/Predix/commit/a0f6587ab1724293924da07fe18c40891ca612a1))
-* improve README badges, fix llama-server flags, clean up structure ([336e1a5](https://github.com/TPTBusiness/Predix/commit/336e1a5afb4933ec13572ef050a3e5a2ca183400))
+* **claude:** auto-merge release-please PR after every push ([f500917](https://github.com/TPTBusiness/NexQuant/commit/f500917b699ee78dc676e84e01574d49bdc8e796))
+
+## [2.2.0](https://github.com/TPTBusiness/NexQuant/compare/v2.1.0...v2.2.0) (2026-04-18)
+
+
+### Features
+
+* add Kronos CLI commands, expand tests, document in README ([f911081](https://github.com/TPTBusiness/NexQuant/commit/f911081d1763d0dc4dd790b57dd97aae2dc62679))
+* **fin_quant:** auto-generate Kronos factor before loop start ([277063f](https://github.com/TPTBusiness/NexQuant/commit/277063f3e36cd071db859cdc77f69135c1f0763b))
+* integrate Kronos-mini OHLCV foundation model (Option A + B) ([4ae3b99](https://github.com/TPTBusiness/NexQuant/commit/4ae3b99f2450930f72e202a1a470c407bfde3328))
+
+
+### Bug Fixes
+
+* **kronos:** lazy torch import to fix CI ModuleNotFoundError ([ccc1d27](https://github.com/TPTBusiness/NexQuant/commit/ccc1d27dbe5ab06a57085a589d456ac7bf49cc08))
+* **kronos:** pass actual datetime Series to Kronos predictor timestamps ([dc6e7ce](https://github.com/TPTBusiness/NexQuant/commit/dc6e7ce207d21fbc21976f2af7691058530fac2f))
+* **kronos:** replace rdagent_logger with stdlib logging for CI compatibility ([b4558f2](https://github.com/TPTBusiness/NexQuant/commit/b4558f2456659c6109bd1b3cf100510491cd3e6c))
+
+
+### Performance Improvements
+
+* **kronos:** batch GPU inference via predict_batch — 75x faster ([74611d0](https://github.com/TPTBusiness/NexQuant/commit/74611d071ac123a655eb15d0737bb73b8c1bd2b0))
+* **kronos:** batch GPU inference via predict_batch — 75x faster ([2babeb9](https://github.com/TPTBusiness/NexQuant/commit/2babeb95f42828e13a37dc16166c75538f33fd4b))
+
+
+### Documentation
+
+* fix duplicate sections, add hardware requirements and data setup guide ([6c771b3](https://github.com/TPTBusiness/NexQuant/commit/6c771b37e6f88526a896499e86929cfca2c199eb))
+
+## [2.1.0](https://github.com/TPTBusiness/NexQuant/compare/v2.0.0...v2.1.0) (2026-04-18)
+
+
+### Features
+
+* add daily log rotation, llama health wait, factor auto-fixer, and README updates ([4ae4d6f](https://github.com/TPTBusiness/NexQuant/commit/4ae4d6f0f1388d229e44333130306ae05767f2e5))
+* Add GitHub infrastructure, CI/CD pipelines, and examples ([a0b5dc4](https://github.com/TPTBusiness/NexQuant/commit/a0b5dc464eaac831c76bdbf805cf60c9083e7d80))
+* **factor-coder:** Add critical rules to prevent common factor implementation errors ([a1edca8](https://github.com/TPTBusiness/NexQuant/commit/a1edca87dd5e75ee402ea555f1b7a07b45c4b1f0))
+* **logging:** write complete LLM prompts and responses to daily JSONL log ([803ef13](https://github.com/TPTBusiness/NexQuant/commit/803ef13052c645392e71aa5de24874aae83f62a7))
+* **strategy:** Continuous optimization with Optuna parameter injection ([4fda5ea](https://github.com/TPTBusiness/NexQuant/commit/4fda5eaa31bc570e295ad96380ee2c02b82db706))
+* unified backtest engine, LLM error handling, strategy refactor ([76b9341](https://github.com/TPTBusiness/NexQuant/commit/76b9341fe8ef0ff03fd911337c299cf0e8582f37))
+
+
+### Bug Fixes
+
+* Add critical column name rules to factor generation prompt ([3e74410](https://github.com/TPTBusiness/NexQuant/commit/3e7441079f0f1c5867829a365c6e45cd7d2071df))
+* **ci:** fix closed-source asset check false positives in security workflow ([4b83c2b](https://github.com/TPTBusiness/NexQuant/commit/4b83c2bfe7e90c0c7a11116f07a1b989035b7a3f))
+* **ci:** remove CodeQL workflow (conflicts with default setup), drop duplicate lint job ([a671361](https://github.com/TPTBusiness/NexQuant/commit/a671361ee4de9a7e00ccc66d8fd5732c2ed1fee9))
+* **ci:** set JAVA_TOOL_OPTIONS UTF-8 in Codacy workflow ([e36721c](https://github.com/TPTBusiness/NexQuant/commit/e36721c765a02a325b8a7dfd3c262b2aca7b1652))
+* **deps:** pin aiohttp>=3.13.4 to patch 4 CVEs ([81adddc](https://github.com/TPTBusiness/NexQuant/commit/81adddcfcd14819a1f85c06288a663e7d222a8fb))
+* **optuna:** fix inverted parameter range in Stage 2/3 when signal_bias is negative ([eaf885e](https://github.com/TPTBusiness/NexQuant/commit/eaf885ec2d20ebd93e34d1e2cb445532d2fb0ed3))
+* **security:** Patch 5 CodeQL path injection and clear-text logging alerts ([#22](https://github.com/TPTBusiness/NexQuant/issues/22)-[#25](https://github.com/TPTBusiness/NexQuant/issues/25), [#9](https://github.com/TPTBusiness/NexQuant/issues/9)) ([d386af9](https://github.com/TPTBusiness/NexQuant/commit/d386af98205722d1ea6d1465f585e89cb8df47de))
+* **security:** Patch 5 CodeQL path injection and weak hashing alerts ([#25](https://github.com/TPTBusiness/NexQuant/issues/25)-[#30](https://github.com/TPTBusiness/NexQuant/issues/30)) ([0d4c3b7](https://github.com/TPTBusiness/NexQuant/commit/0d4c3b7d69fdbdaafab00940bf7346c8b664928e))
+* **security:** Patch path injection and stack trace exposure (CodeQL [#31](https://github.com/TPTBusiness/NexQuant/issues/31), [#27](https://github.com/TPTBusiness/NexQuant/issues/27)) ([b0b8432](https://github.com/TPTBusiness/NexQuant/commit/b0b84328d13dac5c2ef79961200b011c0b5778f1))
+* **security:** replace relative_to() with realpath+startswith for CodeQL sanitization ([6d70f1e](https://github.com/TPTBusiness/NexQuant/commit/6d70f1ed944180c44d0eb75c0e86b013e5888b60))
+* **security:** resolve CodeQL path-injection alerts in UI data loaders ([cced426](https://github.com/TPTBusiness/NexQuant/commit/cced426916cb726e95ad251dcbc0eb9ab6ec3591))
+* **security:** resolve CodeQL path-injection and clear-text-logging alerts ([ec50224](https://github.com/TPTBusiness/NexQuant/commit/ec50224c3580c5c82ddba02fe77af95efd9667ea))
+* **security:** Resolve GitHub Security Scan alerts ([6c85ba8](https://github.com/TPTBusiness/NexQuant/commit/6c85ba833a48326e39006e0f73c506b29a594bde))
+* **security:** Upgrade vllm and transformers to patch 4 CVEs ([6c9ba91](https://github.com/TPTBusiness/NexQuant/commit/6c9ba91d3bf7ce1ed389e544c68be55262bf4e28))
+* **strategy:** Fix template variables, APIBackend import, and JSON extraction ([8220faa](https://github.com/TPTBusiness/NexQuant/commit/8220faa3de6ea555717ac29ba90a3b68135fbf9e))
+* **strategy:** Re-evaluate Optuna-optimized strategies with full OHLCV backtest ([026edce](https://github.com/TPTBusiness/NexQuant/commit/026edce122284fb1da467e6e9de8a2b9116c7ace))
+
+
+### Documentation
+
+* Add CLI welcome screenshot to README ([e6f2374](https://github.com/TPTBusiness/NexQuant/commit/e6f237437595745406c310b58a9bd7214ff914ae))
+* Add comprehensive data setup guide to README ([f721d53](https://github.com/TPTBusiness/NexQuant/commit/f721d53e5681be6997418c13acc3439897168048))
+* Add conda requirement to README + fix nexquant CLI ([df45698](https://github.com/TPTBusiness/NexQuant/commit/df45698b20e0a3e6e0079decf2b8eecb6983a175))
+* Clean changelog of closed-source performance metrics ([a0f6587](https://github.com/TPTBusiness/NexQuant/commit/a0f6587ab1724293924da07fe18c40891ca612a1))
+* improve README badges, fix llama-server flags, clean up structure ([336e1a5](https://github.com/TPTBusiness/NexQuant/commit/336e1a5afb4933ec13572ef050a3e5a2ca183400))

CODE_OF_CONDUCT.md

@@ -52,7 +52,7 @@ an individual is officially representing the community in public spaces.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-nico@predix.io.
+nico@nexquant.io.
 All complaints will be reviewed and investigated promptly and fairly.
 
 ## Attribution

CONTRIBUTING.md

@@ -1,6 +1,6 @@
-# Contributing to Predix
+# Contributing to NexQuant
 
-We welcome contributions and suggestions to improve Predix. Whether it's solving an issue, addressing a bug, enhancing documentation, or even correcting a typo, every contribution is valuable and helps improve the project.
+We welcome contributions and suggestions to improve NexQuant. Whether it's solving an issue, addressing a bug, enhancing documentation, or even correcting a typo, every contribution is valuable and helps improve the project.
 
 ## Getting Started
 
@@ -15,11 +15,11 @@ grep -r "TODO:"
 
 ```bash
 # Fork the repository on GitHub, then clone your fork
-git clone https://github.com/YOUR-USERNAME/Predix.git
-cd Predix
+git clone https://github.com/YOUR-USERNAME/NexQuant.git
+cd NexQuant
 
 # Add upstream remote
-git remote add upstream https://github.com/TPTBusiness/Predix.git
+git remote add upstream https://github.com/TPTBusiness/NexQuant.git
 ```
 
 ### 2. Create a Branch
@@ -141,7 +141,7 @@ All PRs are reviewed by maintainers. Expect:
 ## Project Structure
 
 ```
-Predix/
+NexQuant/
 ├── rdagent/                 # Core framework (open source)
 │   ├── app/                 # CLI and scenario apps
 │   ├── components/          # Reusable agent components
@@ -157,8 +157,8 @@ Predix/
 
 ## Need Help?
 
-- **Issues**: [GitHub Issues](https://github.com/TPTBusiness/Predix/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/TPTBusiness/Predix/discussions)
+- **Issues**: [GitHub Issues](https://github.com/TPTBusiness/NexQuant/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/TPTBusiness/NexQuant/discussions)
 - **Documentation**: See `docs/` folder
 
 ## License

LICENSE

@@ -1,21 +1,662 @@
-MIT License
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
-Copyright (c) 2025 Predix Team
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+
+    Copyright (C) {{ year }}  {{ organization }}
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

README.md

@@ -1,576 +1,228 @@
-# Predix
+# NexQuant
 
 <p align="center">
   <img src="https://img.shields.io/badge/Python-3.10%20|%203.11-blue?style=for-the-badge&logo=python" alt="Python">
   <img src="https://img.shields.io/badge/Platform-Linux-lightgrey?style=for-the-badge&logo=linux" alt="Platform">
-  <img src="https://img.shields.io/badge/PyTorch-2.0+-red?style=for-the-badge&logo=pytorch" alt="PyTorch">
-  <img src="https://img.shields.io/badge/Optuna-3.5+-009B77?style=for-the-badge&logo=optuna" alt="Optuna">
+  <img src="https://img.shields.io/badge/Numba-0.59+-00A3E0?style=for-the-badge&logo=numba" alt="Numba">
+  <img src="https://img.shields.io/badge/Optuna-4.8+-009B77?style=for-the-badge&logo=optuna" alt="Optuna">
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/Pandas-150458?style=for-the-badge&logo=pandas" alt="Pandas">
-  <img src="https://img.shields.io/badge/LightGBM-00A1E0?style=for-the-badge" alt="LightGBM">
-  <img src="https://img.shields.io/badge/Qlib-FF6B6B?style=for-the-badge" alt="Qlib">
-  <img src="https://img.shields.io/badge/llama.cpp-7B68EE?style=for-the-badge" alt="llama.cpp">
+  <img src="https://img.shields.io/badge/TA--Lib-0.6+-green?style=for-the-badge" alt="TA-Lib">
+  <img src="https://img.shields.io/badge/LightGBM-4.6+-00A1E0?style=for-the-badge" alt="LightGBM">
+  <img src="https://img.shields.io/badge/Pandas-2.0+-150458?style=for-the-badge&logo=pandas" alt="Pandas">
+  <img src="https://img.shields.io/badge/cTrader-OpenAPI-FF6B6B?style=for-the-badge" alt="cTrader">
 </p>
 
 <h4 align="center">
-  <strong>AI-powered Quantitative Trading Agent for EUR/USD Forex</strong>
+  <strong>High-Speed Strategy Discovery Framework</strong>
 </h4>
 
 <p align="center">
-  <a href="#installation">Installation</a> •
-  <a href="#no-gpu-use-openrouter">No GPU?</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#configuration">Configuration</a> •
+  <a href="#strategy-discovery">Strategy Discovery</a> •
+  <a href="#live-trading">Live Trading</a> •
   <a href="#features">Features</a>
 </p>
 
 <p align="center">
-  <a href="https://github.com/TPTBusiness/Predix/actions/workflows/ci.yml">
-    <img src="https://img.shields.io/github/actions/workflow/status/TPTBusiness/Predix/ci.yml?branch=master&label=CI&logo=github&style=flat-square" alt="CI Status">
+  <a href="https://github.com/TPTBusiness/NexQuant/actions/workflows/ci.yml">
+    <img src="https://img.shields.io/github/actions/workflow/status/TPTBusiness/NexQuant/ci.yml?branch=master&label=CI&logo=github&style=flat-square" alt="CI Status">
   </a>
-  <a href="https://github.com/TPTBusiness/Predix/actions/workflows/codacy.yml">
-    <img src="https://img.shields.io/github/actions/workflow/status/TPTBusiness/Predix/codacy.yml?branch=master&label=Security&logo=shield&style=flat-square" alt="Security Scan">
+  <a href="https://github.com/TPTBusiness/NexQuant/actions/workflows/codacy.yml">
+    <img src="https://img.shields.io/github/actions/workflow/status/TPTBusiness/NexQuant/codacy.yml?branch=master&label=Security&logo=shield&style=flat-square" alt="Security Scan">
   </a>
-  <a href="https://codecov.io/gh/TPTBusiness/Predix">
-    <img src="https://img.shields.io/codecov/c/github/TPTBusiness/Predix?style=flat-square&logo=codecov" alt="Coverage">
-  </a>
-  <a href="https://github.com/TPTBusiness/Predix/blob/master/LICENSE">
-    <img src="https://img.shields.io/github/license/TPTBusiness/Predix?style=flat-square" alt="License">
-  </a>
-  <a href="https://www.conventionalcommits.org/">
-    <img src="https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow?style=flat-square" alt="Conventional Commits">
+  <a href="https://github.com/TPTBusiness/NexQuant/blob/master/LICENSE">
+    <img src="https://img.shields.io/github/license/TPTBusiness/NexQuant?style=flat-square" alt="License">
   </a>
   <a href="https://github.com/astral-sh/ruff">
     <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square" alt="Ruff">
   </a>
-  <a href="https://github.com/TPTBusiness/Predix/stargazers">
-    <img src="https://img.shields.io/github/stars/TPTBusiness/Predix?style=flat-square" alt="Stars">
-  </a>
-  <a href="https://github.com/TPTBusiness/Predix/forks">
-    <img src="https://img.shields.io/github/forks/TPTBusiness/Predix?style=flat-square" alt="Forks">
-  </a>
-  <a href="https://github.com/TPTBusiness/Predix/issues">
-    <img src="https://img.shields.io/github/issues/TPTBusiness/Predix?style=flat-square" alt="Issues">
-  </a>
-  <a href="https://github.com/TPTBusiness/Predix/commits/master">
-    <img src="https://img.shields.io/github/last-commit/TPTBusiness/Predix?style=flat-square" alt="Last Commit">
+  <a href="https://github.com/TPTBusiness/NexQuant/commits/master">
+    <img src="https://img.shields.io/github/last-commit/TPTBusiness/NexQuant?style=flat-square" alt="Last Commit">
   </a>
 </p>
 
 ---
 
-## 🖥️ CLI Dashboard
-
-```bash
-rdagent predix
-```
-
-![Predix CLI Welcome Screen](docs/cli-welcome-screen.png)
-
-*The Predix CLI shows system status, available commands, and quick start guide.*
-
----
-
 ## Overview
 
-**Predix** is an autonomous AI agent for quantitative trading strategies in the EUR/USD forex market. Built on a multi-agent framework, Predix automates the full research and development cycle:
+**NexQuant** discovers profitable trading strategies through high-speed search — no LLM required. Core engine: Numba JIT-compiled backtest at **735 million bars/second** (245× faster than pandas). Four discovery methods run in a continuous loop:
 
-- 📊 **Data Analysis** – Automatically analyzes market patterns and microstructure
-- 💡 **Strategy Discovery** – Proposes novel trading factors and signals
-- 🧠 **Model Evolution** – Iteratively improves predictive models
-- 📈 **Backtesting** – Validates strategies on historical 1-minute data
+| Method | Frequency | Description |
+|--------|-----------|-------------|
+| **Explore** | 30% of iterations | Random strategies from 17 TA-Lib indicators across timeframes |
+| **Exploit** | 70% of iterations | Mutate the best-known strategy (change params, indicator, or timeframe) |
+| **Optuna** | Every 500 iterations | 20-trial hyperparameter optimization on the current best |
+| **LightGBM** | Every 2000 iterations | ML classifier trained on SOTA indicator signals to predict direction |
 
-Predix is optimized for **1-minute EUR/USD FX data** (2020–2026) and uses Qlib as the underlying backtesting engine.
+**Current best strategy**: MACD(3,10,3) 4-TF with 2/4 vote majority — **+32.0%/month** (Numba), **+24.3%/month** (verified independent backtest), 0/75 negative months.
 
-## Acknowledgments
-
-This project draws inspiration from various open-source projects in the AI trading and multi-agent systems space. We thank all the authors for their innovative work that helped shape our understanding of these patterns.
-
-Special thanks to:
-
-- **[Microsoft RD-Agent](https://github.com/microsoft/RD-Agent)** (MIT License) - Foundation for our autonomous R&D agent framework. We extend our gratitude to the RD-Agent team for their excellent foundational work.
-
-- **[TradingAgents](https://github.com/TauricResearch/TradingAgents)** (Apache 2.0 License) - Inspiration for our multi-agent debate system, reflection mechanism, and memory management modules.
-
-- **[ai-hedge-fund](https://github.com/virattt/ai-hedge-fund)** - Inspiration for macro analysis (Stanley Druckenmiller agent), risk management concepts, and market regime detection.
-
-All code in Predix is originally written and implemented independently. Predix extends these frameworks with EUR/USD forex-specific features, 1-minute backtesting capabilities, comprehensive risk management, and trading dashboards.
-
----
-
-## Installation
-
-### System Requirements
-
-| Component | Minimum | Recommended |
-|-----------|---------|-------------|
-| **GPU VRAM** | 8 GB | 16 GB (RTX 4080 / 5060 Ti) |
-| **RAM** | 16 GB | 32 GB |
-| **Storage** | 20 GB | 50 GB (models + data) |
-| **OS** | Linux (Ubuntu 22.04+) | Linux |
-| **CUDA** | 12.0+ | 12.4+ |
-
-> Local LLMs require a CUDA-capable GPU. The default model (Qwen3.6-35B Q3) uses ~13.6 GB VRAM. CPU-only inference is possible but very slow (not recommended for production use).
-
-### Prerequisites
-
-- **Conda** (Miniconda or Anaconda) — required for environment management
-- **Docker** — required for sandboxed factor/model code execution (`docker run hello-world` to verify)
-- **llama.cpp** — for local LLM inference (see [llama.cpp build guide](https://github.com/ggml-org/llama.cpp))
-- **Ollama** — for embeddings (`nomic-embed-text`); install from [ollama.com](https://ollama.com) and run `ollama pull nomic-embed-text`
-- **Linux** — officially supported; macOS/Windows may work with adjustments
-
-### Quick Install
-
-```bash
-# Clone repository
-git clone https://github.com/TPTBusiness/Predix
-cd Predix
-
-# Create and activate conda environment
-conda create -n predix python=3.10 -y
-conda activate predix
-
-# Install in editable mode
-pip install -e .
-
-# Verify Docker is accessible
-docker run --rm hello-world
-```
-
-> **Important:** Predix requires a conda environment to manage dependencies properly.
-> Using plain Python or other environment managers may cause conflicts.
-
----
-
-## Data Setup
-
-Predix requires **1-minute EUR/USD OHLCV data** in HDF5 format. This is a hard prerequisite — the system cannot run without it.
-
-### Step 1: Get the data
-
-Download 1-minute EUR/USD data (2020–present) from any of these free sources:
-
-| Source | Cost | Notes |
-|--------|------|-------|
-| **[Dukascopy](https://www.dukascopy.com/swiss/english/marketfeed/historical/)** | Free | Best quality free EUR/USD tick data |
-| **[OANDA API](https://developer.oanda.com/)** | Free (demo) | Requires API key, programmatic access |
-| **[TrueFX](https://truefx.com/)** | Free | Institutional-quality tick data |
-| **[Kaggle](https://www.kaggle.com/datasets?search=EURUSD+1min)** | Free | Search "EURUSD 1 minute" |
-| **MetaTrader 5** | Free | Export via `copy_rates_range()` |
-
-### Step 2: Convert to HDF5
-
-```python
-import pandas as pd
-
-df = pd.read_csv('eurusd_1min.csv', parse_dates=['datetime'])
-df = df.rename(columns={'open': '$open', 'close': '$close',
-                        'high': '$high', 'low': '$low', 'volume': '$volume'})
-df['instrument'] = 'EURUSD'
-df = df.set_index(['datetime', 'instrument'])
-for col in ['$open', '$close', '$high', '$low', '$volume']:
-    df[col] = df[col].astype('float32')
-
-import os
-os.makedirs('git_ignore_folder/factor_implementation_source_data', exist_ok=True)
-df.to_hdf('git_ignore_folder/factor_implementation_source_data/intraday_pv.h5', key='data', mode='w')
-```
-
-### Required HDF5 format
-
-| Field | Type | Description |
-|-------|------|-------------|
-| **Index** | MultiIndex `(datetime, instrument)` | Timestamp + currency pair |
-| **`$open`** | float32 | Open price |
-| **`$close`** | float32 | Close price |
-| **`$high`** | float32 | High price |
-| **`$low`** | float32 | Low price |
-| **`$volume`** | float32 | Tick volume |
-
-**Save location:** `git_ignore_folder/factor_implementation_source_data/intraday_pv.h5`
-
----
-
-## Configuration
-
-### Environment Setup
-
-Create a `.env` file in the project root:
-
-```bash
-# Local LLM (llama.cpp)
-OPENAI_API_KEY=local
-OPENAI_API_BASE=http://localhost:8081/v1
-CHAT_MODEL=qwen3.5-35b
-
-# Embedding (Ollama)
-LITELLM_PROXY_API_KEY=local
-LITELLM_PROXY_API_BASE=http://localhost:11434/v1
-EMBEDDING_MODEL=nomic-embed-text
-
-# Paths
-QLIB_DATA_DIR=~/.qlib/qlib_data/eurusd_1min_data
-```
-
-### LLM Server (llama.cpp)
-
-```bash
-~/llama.cpp/build/bin/llama-server \
-  --model ~/models/qwen3.6/Qwen3.6-35B-A3B-UD-Q3_K_XL.gguf \
-  --n-gpu-layers 24 \
-  --no-mmap \
-  --port 8081 \
-  --ctx-size 240000 \
-  --parallel 2 \
-  --batch-size 512 --ubatch-size 512 \
-  --host 0.0.0.0 \
-  -ctk q4_0 -ctv q4_0 \
-  --reasoning off
-```
-
-> **Important flags:**
-> - `--ctx-size 240000 --parallel 2` — allocates **2 slots × 120,000 tokens each**. `fin_quant` prompts can reach 80k+ tokens with full factor history; a smaller slot causes silent overflow and empty responses.
-> - `--reasoning off` — **critical**: completely disables Qwen3 chain-of-thought. `--reasoning-budget 0` is not sufficient and produces empty JSON responses.
-> - `--n-gpu-layers 24` — 4 fewer than maximum on RTX 5060 Ti (16 GB), freeing ~500 MB VRAM for the larger KV cache.
-> - `-ctk q4_0 -ctv q4_0` — quantises the KV cache to 4-bit, reducing VRAM from ~5 GB to ~1.3 GB at 240k context.
-
-### Data Configuration
-
-Edit [`data_config.yaml`](data_config.yaml) to customize walk-forward splits:
-
-```yaml
-instrument: EURUSD
-frequency: 1min
-data_path: ~/.qlib/qlib_data/eurusd_1min_data
-
-train_start: "2022-03-14"
-train_end:   "2024-06-30"
-valid_start: "2024-07-01"
-valid_end:   "2024-12-31"
-test_start:  "2025-01-01"
-test_end:    "2026-03-20"
-
-market_context:
-  spread_bps: 1.5
-  target_arr: 9.62
-  max_drawdown: 20
-```
-
----
-
-## No GPU? Use OpenRouter
-
-If you don't have a CUDA-capable GPU, you can run Predix using [OpenRouter](https://openrouter.ai) for LLM inference — no local model download required.
-
-**1. Set up `.env` for OpenRouter:**
-
-```bash
-# Chat (OpenRouter)
-OPENAI_API_KEY=sk-or-v1-<your-openrouter-key>
-OPENAI_API_BASE=https://openrouter.ai/api/v1
-CHAT_MODEL=qwen/qwen3-235b-a22b
-
-# Embedding (Ollama — still required locally)
-LITELLM_PROXY_API_KEY=local
-LITELLM_PROXY_API_BASE=http://localhost:11434/v1
-EMBEDDING_MODEL=nomic-embed-text
-```
-
-**2. Skip the llama-server step** — no local LLM server needed.
-
-**3. Run with the OpenRouter backend:**
-
-```bash
-rdagent fin_quant --model openrouter
-```
-
-**4. Parallel runs** (uses API concurrency instead of GPU slots):
-
-```bash
-python predix_parallel.py --runs 5 --api-keys 1 -m openrouter
-```
-
-> Ollama is still required for embeddings even in the OpenRouter path. Install from [ollama.com](https://ollama.com) and run `ollama pull nomic-embed-text` once.
+> **This repository contains the research framework.** Trading strategies, broker integrations, and live trading infrastructure are available as separate closed-source modules (`git_ignore_folder/`).
 
 ---
 
 ## Quick Start
 
-### Prerequisites checklist
-
 ```bash
-# 1. Docker running?
-docker run --rm hello-world
+# Prerequisites
+conda create -n nexquant python=3.10 -y && conda activate nexquant
+pip install -e .
+# Ensure OHLCV data exists: git_ignore_folder/intraday_pv_all.h5
 
-# 2. Data in place?
-ls git_ignore_folder/factor_implementation_source_data/intraday_pv.h5
+# Strategy Discovery Loop (10,000 iterations, ~1 hour)
+python scripts/nexquant_rd_loop.py --iterations 10000
 
-# 3. LLM server running?
-curl http://localhost:8081/health
-```
+# Price-Action Indicator Loop (grid search all TA-Lib indicators)
+python scripts/nexquant_priceaction_loop.py
 
-### 1. Run Trading Loop
-
-```bash
-conda activate predix
-rdagent fin_quant
-# or with explicit options:
-rdagent fin_quant --loop-n 5 --step-n 2
-```
-
-### 2. Monitor Results
-
-```bash
-# Web dashboard
-rdagent server_ui --port 19899 --log-dir git_ignore_folder/RD-Agent_workspace/
-# then open http://127.0.0.1:19899
-
-# Best strategies so far
-python predix.py best
-```
-
-### 3. Run Continuously
-
-```bash
-while true; do
-    rdagent fin_quant
-    sleep 5
-done
+# Top strategies report
+python nexquant.py best -n 20 -m monthly_return --min-trades 30
 ```
 
 ---
 
-## CLI Commands
+## Strategy Discovery
 
-### Factor & Strategy Loop
+### R&D Loop (`scripts/nexquant_rd_loop.py`)
 
-| Command | Description |
-|---------|-------------|
-| `rdagent fin_quant` | Start autonomous factor + model evolution loop |
-| `rdagent fin_quant --loop-n 5` | Run exactly 5 evolution loops |
-| `rdagent fin_quant --with-dashboard` | Start with web dashboard |
-| `rdagent fin_quant --cli-dashboard` | Start with CLI Rich dashboard |
-| `rdagent fin_factor` | Factor-only evolution |
-| `rdagent fin_model` | Model-only evolution |
+```
+ ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
+ │ Explore  │ ──→ │ Exploit  │ ──→ │ Optuna   │ ──→ │ LightGBM │
+ │ (Random) │     │ (Mutate) │     │ (Tuning) │     │   (ML)   │
+ └──────────┘     └──────────┘     └──────────┘     └──────────┘
+       30%              70%           /500 iter        /2000 iter
+```
 
-### Strategy Reports
+**17 TA-Lib indicators**: MACD, RSI, Donchian, SAR, ADX, BBANDS, CCI, WCLPRICE, MFI, OBV, STOCH, ROC, AROON, AROONOSC, MOM, ULTOSC, WILLR
 
-| Command | Description |
-|---------|-------------|
-| `python predix.py best` | Show top strategies by composite score |
-| `python predix.py best -n 20 -m sharpe` | Top 20 by Sharpe ratio |
-| `python predix.py best --show NAME` | Full metadata for one strategy |
-| `python predix_gen_strategies_real_bt.py` | Generate 10 strategies with LLM + real backtest |
-| `python predix_gen_strategies_real_bt.py 20` | Generate 20 strategies |
+**4 timeframes**: 15min, 30min, 1h, 4h
 
-### Kronos Foundation Model
+**3 strategy types**: Single-TF, Multi-TF (vote majority), Portfolio (indicator ensemble)
 
-| Command | Description |
-|---------|-------------|
-| `python predix.py kronos-factor` | Generate Kronos predicted-return factor (daily stride, ~15 min GPU) |
-| `python predix.py kronos-factor --pred 30` | 30-bar prediction horizon |
-| `python predix.py kronos-factor --device cpu` | CPU inference (slower) |
-| `python predix.py kronos-eval` | Evaluate Kronos IC / hit rate vs LightGBM baseline |
-| `python predix.py kronos-eval --pred 96` | Daily horizon evaluation |
+**Discovery example** (50,000 iterations):
+```
+random → SAR(+65) → MACD(+73) → MACD-mutated(+102.75, +32%/month)
+                                        ↓
+                                  Optuna tuned params
+                                        ↓
+                                  LightGBM ensemble
+```
 
-### Factor Evaluation
+### Grid Search (`scripts/nexquant_priceaction_loop.py`)
 
-| Command | Description |
-|---------|-------------|
-| `python predix.py evaluate --all` | Evaluate all generated factors |
-| `python predix.py top -n 20` | Show top 20 factors by IC |
-| `python predix.py portfolio-simple` | Simple portfolio optimization |
+Deterministic parameter grid over all 17 indicators. Finds MACD(3,10,3) as optimal.
 
-### Parallel Execution
+### Portfolio Optimizer (`scripts/nexquant_portfolio_optimizer.py`)
 
-| Command | Description |
-|---------|-------------|
-| `python predix_parallel.py --runs 5 --api-keys 1 -m openrouter` | Run 5 parallel factor evolutions |
-| `python predix_parallel.py --runs 20 --api-keys 2 -m openrouter` | Run 20 runs with 2 API keys |
+Greedy correlation-aware selection from discovered strategies.
 
-### Monitoring & Debug
+---
 
-| Command | Description |
-|---------|-------------|
-| `rdagent server_ui --port 19899 --log-dir <path>` | Start web dashboard |
-| `rdagent health_check` | Validate environment setup |
-| `python predix_batch_backtest.py` | Batch backtest multiple factors |
-| `python predix_rebacktest_strategies.py` | Re-backtest existing strategies |
+## Live Trading
+
+Closed-source module at `git_ignore_folder/nexquant_live_trader.py`. Architecture:
+
+```
+MACD(3,10,3) Signal → cTrader OpenAPI → Live Account
+ 4-TF 2/4 Votes      (WebSocket+Protobuf)        ↓
+                                             Paper Mode
+```
+
+Integration: cTrader WebSocket `live.ctraderapi.com:5035`, OAuth2 authentication, Protobuf message encoding, FIX protocol.
 
 ---
 
 ## Features
 
-### 🔄 Iterative Factor Evolution
+### ⚡ Numba Backtest
+- 735M bars/second (0.003s for 2.26M bars)
+- JIT-compiled profit/drawdown/sharpe computation
+- Signal construction via pandas resample + TA-Lib (~0.4s) is the bottleneck
 
-Predix continuously proposes, implements, and validates new alpha factors:
+### 🔍 Four Discovery Methods
+- **Explore**: Random indicator + timeframe + parameters
+- **Exploit**: Mutation of top-5 SOTA strategies (parameter tweak, indicator swap, timeframe change)
+- **Optuna**: 20-trial TPE hyperparameter optimization on best strategy
+- **LightGBM**: ML classifier on SOTA indicator signals (80/20 train/test split)
 
-- Learns from backtest feedback
-- Avoids overfitting through walk-forward validation
-- Discovers non-obvious patterns in order flow, volatility, and session dynamics
-
-### 🛡️ Trading Protection System
-
-Automatic risk management to prevent excessive losses:
-
-- **Max Drawdown Protection** - Pauses trading when drawdown exceeds threshold (default: 15%)
-- **Cooldown Period** - Enforces mandatory rest period after significant losses (default: 4h after 5% loss)
-- **Stoploss Guard** - Detects clusters of stoplosses and blocks trading (default: max 5 per day)
-- **Low Performance Filter** - Filters out consistently underperforming factors (Sharpe < 0.5, Win Rate < 40%)
-
-### 🧠 Model Architecture Search
-
-Automatically explores and refines predictive models:
-
-- Linear baselines (LightGBM, XGBoost)
-- Deep learning (LSTM, Transformer, Temporal CNN)
-- Ensemble methods
-
-### 📚 Knowledge Base
-
-Built-in knowledge accumulation across loops:
-
-- Successful factors are archived
-- Failed attempts inform future proposals
-- Cross-loop learning improves robustness
-
-### 🖥️ Interactive UI
-
-Real-time dashboard for monitoring:
-
-- Factor performance metrics
-- Model architecture evolution
-- Cumulative returns and drawdowns
-- Code diffs and implementation history
-
-### 🤖 Kronos Foundation Model Integration
-
-Predix integrates [Kronos-mini](https://github.com/shiyu-coder/Kronos) — a 4.1M parameter OHLCV foundation model pretrained on 12+ billion K-lines from 45 global exchanges (AAAI 2026, MIT):
-
-- **Option A — Alpha Factor**: Rolling daily inference generates a `KronosPredReturn` factor. Every 96 bars (one trading day), Kronos predicts the next day's return from the previous 512 bars of EUR/USD OHLCV data. The factor is forward-filled to 1-min frequency and plugs directly into Predix's factor evaluation pipeline.
-
-- **Option B — Model Evaluation**: Kronos runs alongside LightGBM as a standalone predictor. IC (Information Coefficient), IC IR, and directional hit rate are computed over the full dataset for direct comparison with LightGBM-generated models.
-
-```bash
-# One-time setup
-git clone https://github.com/shiyu-coder/Kronos ~/Kronos
-
-# Generate factor (Option A) — saves to results/factors/
-python predix.py kronos-factor
-
-# Evaluate as model (Option B) — prints IC vs LightGBM reference
-python predix.py kronos-eval
-```
+### 📊 TA-Lib Integration
+- 17 indicators with full parameter ranges
+- Auto-guard against bad parameters (negative/zero values that crash TA-Lib)
+- Multi-timeframe voting with configurable threshold
 
 ### 🔒 Security & Quality
-
-Automated quality assurance:
-
-- **134+ Tests** — all features tested automatically on every commit
-- **Bandit Security Scanner** — pre-commit security checks
-- **Weekly Dependency Audit** — automated vulnerability scan via GitHub Actions
+- 0 Dependabot alerts, 0 CodeScan alerts
+- No proprietary terms in git history
+- Closed-source detection CI
 
 ---
 
 ## Project Structure
 
 ```
-predix/
-├── rdagent/                 # Core agent framework
-│   ├── app/                 # CLI and scenario apps
-│   ├── components/          # Reusable agent components
-│   │   ├── backtesting/     # Backtest engine & protections
-│   │   │   ├── backtest_engine.py
-│   │   │   ├── vbt_backtest.py  # Unified backtest engine
-│   │   │   ├── results_db.py
-│   │   │   └── protections/ # Trading protection system
-│   │   └── coder/           # Factor & model coding (CoSTEER + Optuna)
-│   ├── core/                # Core abstractions
-│   ├── scenarios/           # Domain-specific scenarios
-│   └── utils/               # Utilities
-├── test/                    # Test suite (134 tests)
-│   └── backtesting/         # Backtest unit tests
-├── web/                     # Web UI frontend
-├── data_config.yaml         # Walk-forward split configuration
-├── pyproject.toml           # Project metadata
-└── requirements.txt         # Dependencies
+nexquant/
+├── scripts/                     # Strategy discovery & trading
+│   ├── nexquant_rd_loop.py              # High-speed R&D loop (Numba + Optuna + ML)
+│   ├── nexquant_priceaction_loop.py     # TA-Lib grid search loop
+│   ├── nexquant_portfolio_optimizer.py  # Correlation-aware portfolio selection
+│   ├── nexquant_gridsearch.py           # Deterministic parameter grid search
+│   ├── nexquant_daily_strategies.py     # Daily Kronos + factor combinations
+│   ├── nexquant_gen_strategies_real_bt.py  # LLM-based strategy generation
+│   ├── nexquant_autopilot.py            # 24/7 continuous generator
+│   └── nexquant_parallel.py             # Multi-instance parallel runs
+├── rdagent/                     # Core framework (LLM-based, see note below)
+│   ├── app/                     # CLI and scenario apps
+│   ├── components/              # Backtest engine, protections, coders
+│   ├── core/                    # Core abstractions
+│   ├── scenarios/               # Domain-specific scenarios
+│   └── utils/                   # Utilities
+├── git_ignore_folder/           # Closed-source (never committed)
+│   ├── nexquant_live_trader.py          # cTrader live trading
+│   ├── nexquant_fix_trader.py           # FIX protocol trader
+│   ├── intraday_pv_all.h5               # OHLCV data
+│   ├── gbpusdt_1min.h5                  # GBP/USD data
+│   └── btc_1min.h5                      # BTC data
+├── test/                        # 1,125+ collected tests
+├── data_config.yaml             # Walk-forward split configuration
+├── requirements.txt             # Dependencies
+└── AGENTS.md                    # Agent configuration & workflow guide
 ```
 
+> **Note on `rdagent/`**: The LLM-based R&D framework (`rdagent fin_quant`) is part of the codebase but the Qlib/CoSTEER pipeline currently produces zero factors. The primary strategy discovery path is the Numba-based loop in `scripts/`.
+
 ---
 
-## Requirements
+## Installation
 
-Core dependencies (see [`requirements.txt`](requirements.txt) for full list):
+### Prerequisites
+- **Conda** (Miniconda or Anaconda)
+- **TA-Lib** system library (`apt install ta-lib` or `brew install ta-lib`)
+- **Linux** (Ubuntu 22.04+)
 
-- **LLM**: `openai`, `litellm`
-- **Data**: `pandas`, `numpy`, `pyarrow`
-- **ML**: `scikit-learn`, `lightgbm`, `xgboost`
-- **Backtesting**: `qlib` (via Docker)
-- **UI**: `streamlit`, `plotly`, `flask`
+### Install
+
+```bash
+git clone https://github.com/TPTBusiness/NexQuant && cd NexQuant
+conda create -n nexquant python=3.10 -y && conda activate nexquant
+pip install -e .
+```
+
+### Data
+Place OHLCV HDF5 data at `git_ignore_folder/intraday_pv_all.h5`:
+```python
+# Format: MultiIndex (datetime, instrument), columns: $open $close $high $low $volume
+df.to_hdf('git_ignore_folder/intraday_pv_all.h5', key='data')
+```
 
 ---
 
 ## License
 
-This project is licensed under the **MIT License** – see the [`LICENSE`](LICENSE) file for details.
-
-### Attribution Requirements
-
-If you use this code or concepts in your project, you **must**:
-1. Include the MIT License text
-2. Keep the copyright notice: "Copyright (c) 2025 Predix Team"
-3. Provide attribution to the original project
-
-See [`ATTRIBUTION.md`](ATTRIBUTION.md) for detailed guidelines and examples.
-
----
-
-## Contributing
-
-Contributions are welcome! Please:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feat/my-feature`)
-3. Commit using [Conventional Commits](https://www.conventionalcommits.org/) (`git commit -m 'feat: add my feature'`)
-4. Push to the branch (`git push origin feat/my-feature`)
-5. Open a Pull Request with a conventional commit title
-
-For major changes, please open an issue first to discuss your approach.
-
----
-
-## Citation
-
-If you use Predix in your research, please cite the underlying framework:
-
-```bibtex
-@misc{yang2025rdagentllmagentframeworkautonomous,
-  title={R&D-Agent: An LLM-Agent Framework Towards Autonomous Data Science},
-  author={Yang, Xu and Yang, Xiao and Fang, Shikai and Zhang, Yifei and Wang, Jian and Xian, Bowen and Li, Qizheng and Li, Jingyuan and Xu, Minrui and Li, Yuante and others},
-  year={2025},
-  eprint={2505.14738},
-  archivePrefix={arXiv},
-  primaryClass={cs.AI}
-}
-```
-
----
-
-## Support
-
-- **Issues**: [GitHub Issues](https://github.com/TPTBusiness/Predix/issues)
+**GNU Affero General Public License v3.0 (AGPL-3.0)**. See [`LICENSE`](LICENSE).
 
 ---
 
 ## Disclaimer
 
-Predix is provided "as is" for **research and educational purposes only**. It is **not** intended for:
-
-- Live trading or financial advice
-- Production use without thorough testing
-- Replacement of qualified financial professionals
-
-Users assume all liability and should comply with applicable laws and regulations in their jurisdiction. Past performance does not guarantee future results.
+NexQuant is provided for **research and educational purposes only**. Past performance does not guarantee future results. Users assume all liability.

SECURITY.md

@@ -2,13 +2,13 @@
 
 ## Reporting a Vulnerability
 
-We take the security of Predix seriously. If you believe you have found a security vulnerability, please report it responsibly.
+We take the security of NexQuant seriously. If you believe you have found a security vulnerability, please report it responsibly.
 
 **Please do not report security vulnerabilities through public GitHub issues.**
 
 ### How to Report
 
-1. **Open a private security advisory** on GitHub: https://github.com/TPTBusiness/Predix/security/advisories
+1. **Open a private security advisory** on GitHub: https://github.com/TPTBusiness/NexQuant/security/advisories
 2. Provide a detailed description of the vulnerability
 3. Include steps to reproduce if possible
 4. We will respond within 48 hours

SUPPORT.md

@@ -6,12 +6,12 @@ This project uses GitHub Issues to track bugs and feature requests. Please searc
 issues before filing new issues to avoid duplicates. For new issues, file your bug or
 feature request as a new Issue.
 
-- **Issues**: [https://github.com/PredixAI/predix/issues](https://github.com/PredixAI/predix/issues)
+- **Issues**: [https://github.com/NexQuantAI/nexquant/issues](https://github.com/NexQuantAI/nexquant/issues)
 
 For help and questions about using this project, please reach out via:
 
-- **Email**: nico@predix.io
-- **GitHub Discussions**: [https://github.com/PredixAI/predix/discussions](https://github.com/PredixAI/predix/discussions)
+- **Email**: nico@nexquant.io
+- **GitHub Discussions**: [https://github.com/NexQuantAI/nexquant/discussions](https://github.com/NexQuantAI/nexquant/discussions)
 
 ## Community Support
 

changelog/v1.0.0.md

@@ -1,4 +1,4 @@
-# Predix v1.0.0 Release Notes
+# NexQuant v1.0.0 Release Notes
 
 **Release Date:** 2026-04-02
 
@@ -8,7 +8,7 @@
 
 ## 🎉 Overview
 
-Initial release of Predix - an autonomous AI-powered quantitative trading agent for EUR/USD forex markets.
+Initial release of NexQuant - an autonomous AI-powered quantitative trading agent for EUR/USD forex markets.
 
 ---
 
@@ -75,8 +75,8 @@ Initial release of Predix - an autonomous AI-powered quantitative trading agent
 
 ## 🔧 Changed
 
-- Rebranded from RD-Agent to Predix for EUR/USD quantitative trading
-- Updated project metadata for PredixAI organization
+- Rebranded from RD-Agent to NexQuant for EUR/USD quantitative trading
+- Updated project metadata for NexQuantAI organization
 - All code comments translated to English
 - Removed 'Inspired by' comments, added comprehensive Acknowledgments
 - Enhanced .gitignore for better file management
@@ -137,7 +137,7 @@ This release builds upon and is inspired by:
 - **TradingAgents** (Apache 2.0 License) - Multi-agent debate patterns
 - **ai-hedge-fund** - Macro analysis and risk management concepts
 
-**All code in Predix v1.0.0 is originally written and independently implemented.**
+**All code in NexQuant v1.0.0 is originally written and independently implemented.**
 
 ---
 
@@ -149,7 +149,7 @@ This release builds upon and is inspired by:
 
 If you use this code or concepts in your project, you **must**:
 1. Include the MIT License text
-2. Keep the copyright notice: "Copyright (c) 2025 Predix Team"
+2. Keep the copyright notice: "Copyright (c) 2025 NexQuant Team"
 3. Provide attribution to the original project
 
 See [ATTRIBUTION.md](../ATTRIBUTION.md) for detailed guidelines.
@@ -158,7 +158,7 @@ See [ATTRIBUTION.md](../ATTRIBUTION.md) for detailed guidelines.
 
 ## 🔗 Links
 
-- **GitHub Release:** https://github.com/TPTBusiness/Predix/releases/tag/v1.0.0
+- **GitHub Release:** https://github.com/TPTBusiness/NexQuant/releases/tag/v1.0.0
 - **Main Changelog:** ../CHANGELOG.md
 - **Attribution Guidelines:** ../ATTRIBUTION.md
 - **Installation Guide:** ../README.md#installation
@@ -168,7 +168,7 @@ See [ATTRIBUTION.md](../ATTRIBUTION.md) for detailed guidelines.
 
 <div align="center">
 
-**Made with ❤️ by Predix Team**
+**Made with ❤️ by NexQuant Team**
 
 For detailed usage guidelines, see [README.md](../README.md)
 

changelog/v2.0.0.md

@@ -1,4 +1,4 @@
-# Predix v2.0.0 Release Notes
+# NexQuant v2.0.0 Release Notes
 
 **Release Date:** 2026-04-10
 
@@ -8,7 +8,7 @@
 
 ## 🎉 Overview
 
-Major update adding AI-powered strategy generation, realistic backtesting, and comprehensive CLI tooling. Predix now autonomously generates, evaluates, and optimizes trading strategies using local LLMs.
+Major update adding AI-powered strategy generation, realistic backtesting, and comprehensive CLI tooling. NexQuant now autonomously generates, evaluates, and optimizes trading strategies using local LLMs.
 
 ---
 
@@ -28,7 +28,7 @@ Major update adding AI-powered strategy generation, realistic backtesting, and c
 - **Proper Annualization**: sqrt(252*1440) for 1-min data
 
 ### CLI Commands
-- `rdagent predix` - Show beautiful welcome screen (perfect for screenshots!)
+- `rdagent nexquant` - Show beautiful welcome screen (perfect for screenshots!)
 - `rdagent start_llama` - Start llama.cpp server
 - `rdagent start_loop` - Start strategy generator loop with auto-restart
 - `rdagent generate_strategies` - Generate strategies from factors
@@ -65,8 +65,8 @@ Major update adding AI-powered strategy generation, realistic backtesting, and c
 ## 📦 Installation
 
 ```bash
-git clone https://github.com/TPTBusiness/Predix
-cd Predix
+git clone https://github.com/TPTBusiness/NexQuant
+cd NexQuant
 pip install -e .
 ```
 
@@ -74,7 +74,7 @@ pip install -e .
 
 ```bash
 # Show welcome screen
-rdagent predix
+rdagent nexquant
 
 # Start LLM server
 rdagent start_llama

constraints/.bandit.yml

@@ -1,7 +1,7 @@
 # Bandit Security Scanner Configuration
 # Documentation: https://bandit.readthedocs.io/
 
-title: Bandit Security Scan for Predix
+title: Bandit Security Scan for NexQuant
 
 # Tests to skip (known false positives or acceptable risks)
 skips:

constraints/3.10.txt

@@ -1,5 +1,5 @@
 azure-identity==1.25.3
 dill==0.4.1
-pillow==10.4.0
+pillow==12.2.0
 psutil==6.1.1
 scipy==1.15.3

constraints/3.11.txt

@@ -1,5 +1,5 @@
 azure-identity==1.25.3
 dill==0.4.1
-pillow==10.4.0
+pillow==12.2.0
 psutil==6.1.1
 scipy==1.15.3

constraints/data_config.yaml

@@ -1,5 +1,5 @@
 # ============================================================
-#  Predix Data Configuration
+#  NexQuant Data Configuration
 #  Change instrument, frequency, and time periods here
 #  All other components read from this file
 # ============================================================

docs/ATTRIBUTION.md

@@ -1,6 +1,6 @@
 # Attribution Guidelines
 
-## Using Predix in Your Project
+## Using NexQuant in Your Project
 
 If you use code, concepts, or ideas from this project, you **must**:
 
@@ -11,8 +11,8 @@ Include the full MIT License text in your project's LICENSE file or documentatio
 ### 2. Include Copyright Notice
 
 ```
-Copyright (c) 2025 Predix Team
-Original Project: https://github.com/TPTBusiness/Predix
+Copyright (c) 2025 NexQuant Team
+Original Project: https://github.com/TPTBusiness/NexQuant
 ```
 
 ### 3. Provide Attribution
@@ -22,7 +22,7 @@ Add a notice in your documentation or README:
 ```markdown
 ## Acknowledgments
 
-This project uses code/concepts from [Predix](https://github.com/TPTBusiness/Predix), 
+This project uses code/concepts from [NexQuant](https://github.com/TPTBusiness/NexQuant), 
 licensed under the [MIT License](https://opensource.org/licenses/MIT).
 ```
 
@@ -33,7 +33,7 @@ If you modified the code:
 ```markdown
 ## Modifications
 
-Based on Predix (original by Predix Team).
+Based on NexQuant (original by NexQuant Team).
 Modified by [Your Name/Organization] on [Date].
 Changes: [Brief description of changes]
 ```
@@ -63,13 +63,13 @@ Changes: [Brief description of changes]
 ```markdown
 # My Trading Project
 
-This project uses factor generation concepts from [Predix](https://github.com/TPTBusiness/Predix).
+This project uses factor generation concepts from [NexQuant](https://github.com/TPTBusiness/NexQuant).
 
 ## License
 MIT License - see LICENSE file for details.
 
 ## Credits
-- Original Predix code by Predix Team (MIT License)
+- Original NexQuant code by NexQuant Team (MIT License)
 - Modified by John Doe, 2025
 ```
 

docs/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-All notable changes to Predix will be documented in this file.
+All notable changes to NexQuant will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

docs/architecture.svg

@@ -0,0 +1,158 @@
+<svg width="100%" viewBox="0 0 680 920" xmlns="http://www.w3.org/2000/svg" role="img">
+<title>NexQuant data flow architecture</title>
+<desc>Full pipeline from Qlib data source through R&D loop, factor and model tracks, strategy generation, portfolio optimization, to live trading.</desc>
+
+<defs>
+  <marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+    <path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  </marker>
+  <style>
+    text { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    .th { font-size: 14px; font-weight: 600; fill: #1a1a1a; }
+    .ts { font-size: 12px; font-weight: 400; fill: #555; }
+    .arr { stroke: #888; stroke-width: 1.2; fill: none; }
+    .box-blue   { fill: #E6F1FB; stroke: #185FA5; }
+    .box-purple { fill: #EEEDFE; stroke: #534AB7; }
+    .th-purple  { fill: #3C3489; }
+    .ts-purple  { fill: #534AB7; }
+    .box-teal   { fill: #E1F5EE; stroke: #0F6E56; }
+    .th-teal    { fill: #085041; }
+    .ts-teal    { fill: #0F6E56; }
+    .box-coral  { fill: #FAECE7; stroke: #993C1D; }
+    .th-coral   { fill: #712B13; }
+    .ts-coral   { fill: #993C1D; }
+    .box-amber  { fill: #FAEEDA; stroke: #854F0B; }
+    .th-amber   { fill: #633806; }
+    .ts-amber   { fill: #854F0B; }
+    .box-green  { fill: #EAF3DE; stroke: #3B6D11; }
+    .th-green   { fill: #27500A; }
+    .ts-green   { fill: #3B6D11; }
+    .box-gray   { fill: #F1EFE8; stroke: #5F5E5A; }
+    .th-gray    { fill: #2C2C2A; }
+    .ts-gray    { fill: #5F5E5A; }
+    .th-blue    { fill: #0C447C; }
+    .ts-blue    { fill: #185FA5; }
+    .container  { fill: none; stroke: #B4B2A9; stroke-width: 0.5; }
+    .label-muted { font-size: 12px; fill: #888780; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+  </style>
+</defs>
+
+<!-- DATA SOURCE -->
+<rect x="200" y="20" width="280" height="56" rx="8" stroke-width="0.5" class="box-blue"/>
+<text class="th th-blue" x="340" y="43" text-anchor="middle" dominant-baseline="central">Qlib data (1-min EUR/USD)</text>
+<text class="ts ts-blue" x="340" y="63" text-anchor="middle" dominant-baseline="central">2020–2026 · 96 bars/day</text>
+
+<line x1="340" y1="76" x2="340" y2="104" class="arr" marker-end="url(#arrow)"/>
+
+<!-- R&D LOOP container -->
+<rect x="40" y="104" width="600" height="190" rx="10" class="container"/>
+<text class="label-muted" x="56" y="121" dominant-baseline="central">R&D loop (rdagent fin_quant)</text>
+
+<rect x="56"  y="132" width="100" height="56" rx="6" stroke-width="0.5" class="box-purple"/>
+<text class="th th-purple" x="106" y="154" text-anchor="middle" dominant-baseline="central">Propose</text>
+<text class="ts ts-purple" x="106" y="172" text-anchor="middle" dominant-baseline="central">LLM</text>
+<line x1="156" y1="160" x2="170" y2="160" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="170" y="132" width="100" height="56" rx="6" stroke-width="0.5" class="box-purple"/>
+<text class="th th-purple" x="220" y="154" text-anchor="middle" dominant-baseline="central">Coding</text>
+<text class="ts ts-purple" x="220" y="172" text-anchor="middle" dominant-baseline="central">CoSTEER</text>
+<line x1="270" y1="160" x2="284" y2="160" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="284" y="132" width="100" height="56" rx="6" stroke-width="0.5" class="box-purple"/>
+<text class="th th-purple" x="334" y="154" text-anchor="middle" dominant-baseline="central">Running</text>
+<text class="ts ts-purple" x="334" y="172" text-anchor="middle" dominant-baseline="central">Docker</text>
+<line x1="384" y1="160" x2="398" y2="160" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="398" y="132" width="100" height="56" rx="6" stroke-width="0.5" class="box-purple"/>
+<text class="th th-purple" x="448" y="154" text-anchor="middle" dominant-baseline="central">Feedback</text>
+<text class="ts ts-purple" x="448" y="172" text-anchor="middle" dominant-baseline="central">LLM</text>
+<line x1="498" y1="160" x2="512" y2="160" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="512" y="132" width="100" height="56" rx="6" stroke-width="0.5" class="box-purple"/>
+<text class="th th-purple" x="562" y="154" text-anchor="middle" dominant-baseline="central">Record</text>
+<text class="ts ts-purple" x="562" y="172" text-anchor="middle" dominant-baseline="central">Pickle</text>
+
+<text class="label-muted" x="340" y="216" text-anchor="middle" dominant-baseline="central">Bandit selection → factor track or model track</text>
+
+<!-- Split to two tracks -->
+<path d="M210 294 L210 308 L470 308 L470 294" fill="none" stroke="#B4B2A9" stroke-width="0.5"/>
+<line x1="210" y1="308" x2="210" y2="322" class="arr" marker-end="url(#arrow)"/>
+<line x1="470" y1="308" x2="470" y2="322" class="arr" marker-end="url(#arrow)"/>
+<text class="label-muted" x="340" y="478" text-anchor="middle">every N factors · auto or CLI</text>
+
+<!-- FACTOR TRACK -->
+<rect x="40" y="322" width="260" height="130" rx="8" stroke-width="0.5" class="box-teal"/>
+<text class="th th-teal" x="170" y="344" text-anchor="middle" dominant-baseline="central">Factor track</text>
+<text class="ts ts-teal" x="170" y="364" text-anchor="middle" dominant-baseline="central">Hypothesis → FactorCoSTEER</text>
+<text class="ts ts-teal" x="170" y="382" text-anchor="middle" dominant-baseline="central">FactorRunner → FactorFeedback</text>
+<text class="ts ts-teal" x="170" y="402" text-anchor="middle" dominant-baseline="central">Output: result.h5</text>
+<text class="ts ts-teal" x="170" y="420" text-anchor="middle" dominant-baseline="central">MultiIndex DataFrame</text>
+<text class="ts ts-teal" x="170" y="438" text-anchor="middle" dominant-baseline="central">IC / Sharpe metrics</text>
+
+<!-- MODEL TRACK -->
+<rect x="380" y="322" width="260" height="130" rx="8" stroke-width="0.5" class="box-coral"/>
+<text class="th th-coral" x="510" y="344" text-anchor="middle" dominant-baseline="central">Model track</text>
+<text class="ts ts-coral" x="510" y="364" text-anchor="middle" dominant-baseline="central">Hypothesis → ModelCoSTEER</text>
+<text class="ts ts-coral" x="510" y="382" text-anchor="middle" dominant-baseline="central">ModelRunner → ModelFeedback</text>
+<text class="ts ts-coral" x="510" y="402" text-anchor="middle" dominant-baseline="central">Output: PyTorch preds</text>
+<text class="ts ts-coral" x="510" y="420" text-anchor="middle" dominant-baseline="central">+ mlflow logs</text>
+<text class="ts ts-coral" x="510" y="438" text-anchor="middle" dominant-baseline="central">LSTM / Transformer / CNN</text>
+
+<!-- Merge to strategy -->
+<path d="M170 452 L170 486 L340 486 L340 502" fill="none" stroke="#B4B2A9" stroke-width="0.5" marker-end="url(#arrow)"/>
+<path d="M510 452 L510 486 L340 486" fill="none" stroke="#B4B2A9" stroke-width="0.5"/>
+
+<!-- STRATEGY GENERATION -->
+<rect x="100" y="502" width="480" height="120" rx="8" stroke-width="0.5" class="box-amber"/>
+<text class="th th-amber" x="340" y="524" text-anchor="middle" dominant-baseline="central">Strategy generation pipeline</text>
+
+<rect x="116" y="536" width="120" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="176" y="554" text-anchor="middle" dominant-baseline="central">Load top factors</text>
+<text class="ts ts-gray" x="176" y="570" text-anchor="middle" dominant-baseline="central">by |IC|</text>
+<line x1="236" y1="558" x2="252" y2="558" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="252" y="536" width="120" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="312" y="554" text-anchor="middle" dominant-baseline="central">LLM strategy</text>
+<text class="ts ts-gray" x="312" y="570" text-anchor="middle" dominant-baseline="central">code gen</text>
+<line x1="372" y1="558" x2="388" y2="558" class="arr" marker-end="url(#arrow)"/>
+
+<rect x="388" y="536" width="120" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="448" y="554" text-anchor="middle" dominant-baseline="central">OHLCV backtest</text>
+<text class="ts ts-gray" x="448" y="570" text-anchor="middle" dominant-baseline="central">signals eval</text>
+
+<text class="label-muted" x="340" y="600" text-anchor="middle" dominant-baseline="central">Optuna: 10 → 15 → 5 trials · Sharpe ≥ 1.5 · DD ≥ −0.30 · WR ≥ 0.40</text>
+
+<line x1="340" y1="622" x2="340" y2="648" class="arr" marker-end="url(#arrow)"/>
+
+<!-- PORTFOLIO -->
+<rect x="160" y="648" width="360" height="56" rx="8" stroke-width="0.5" class="box-green"/>
+<text class="th th-green" x="340" y="670" text-anchor="middle" dominant-baseline="central">Portfolio optimization</text>
+<text class="ts ts-green" x="340" y="688" text-anchor="middle" dominant-baseline="central">Mean-variance · Risk parity · Black-Litterman</text>
+
+<line x1="340" y1="704" x2="340" y2="730" class="arr" marker-end="url(#arrow)"/>
+
+<!-- LIVE TRADING -->
+<rect x="160" y="730" width="360" height="56" rx="8" stroke-width="0.5" class="box-gray"/>
+<text class="th th-gray" x="340" y="752" text-anchor="middle" dominant-baseline="central">Live trading (closed-source)</text>
+<text class="ts ts-gray" x="340" y="770" text-anchor="middle" dominant-baseline="central">ftmo_live_trader.py · FTMO signals</text>
+
+<!-- EXTERNAL SERVICES -->
+<text class="label-muted" x="340" y="812" text-anchor="middle">External services</text>
+
+<rect x="40"  y="824" width="130" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="105" y="842" text-anchor="middle" dominant-baseline="central">llama.cpp</text>
+<text class="ts ts-gray" x="105" y="858" text-anchor="middle" dominant-baseline="central">LLM inference</text>
+
+<rect x="185" y="824" width="130" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="250" y="842" text-anchor="middle" dominant-baseline="central">Docker</text>
+<text class="ts ts-gray" x="250" y="858" text-anchor="middle" dominant-baseline="central">sandbox</text>
+
+<rect x="330" y="824" width="130" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="395" y="842" text-anchor="middle" dominant-baseline="central">Optuna</text>
+<text class="ts ts-gray" x="395" y="858" text-anchor="middle" dominant-baseline="central">Bayesian opt</text>
+
+<rect x="475" y="824" width="130" height="44" rx="6" stroke-width="0.5" class="box-gray"/>
+<text class="ts th-gray" x="540" y="842" text-anchor="middle" dominant-baseline="central">Qlib</text>
+<text class="ts ts-gray" x="540" y="858" text-anchor="middle" dominant-baseline="central">backtest engine</text>
+
+</svg>

docs/conf.py

@@ -10,9 +10,9 @@ import subprocess
 
 latest_tag = subprocess.check_output(["git", "describe", "--tags", "--abbrev=0"], text=True).strip()
 
-project = "Predix"
-copyright = "2025, Predix Team"
-author = "Predix Team"
+project = "NexQuant"
+copyright = "2025, NexQuant Team"
+author = "NexQuant Team"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
@@ -66,7 +66,7 @@ html_static_path = ["_static"]
 html_favicon = "_static/favicon.ico"
 
 html_theme_options = {
-    "source_repository": "https://github.com/PredixAI/predix",
+    "source_repository": "https://github.com/NexQuantAI/nexquant",
     "source_branch": "main",
     "source_directory": "docs/",
 }

docs/index.rst

@@ -1,13 +1,13 @@
-.. Predix documentation master file, created by
+.. NexQuant documentation master file, created by
    sphinx-quickstart on Mon Jul 15 04:27:50 2024.
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Welcome to Predix's documentation!
+Welcome to NexQuant's documentation!
 ===================================
 
 .. image:: _static/logo.png
-   :alt: Predix Logo
+   :alt: NexQuant Logo
 
 .. toctree::
    :maxdepth: 3
@@ -23,7 +23,7 @@ Welcome to Predix's documentation!
    api_reference
    policy
 
-   GitHub <https://github.com/PredixAI/predix>
+   GitHub <https://github.com/NexQuantAI/nexquant>
 
 
 Indices and tables

docs/parallel_runs.md

@@ -1,4 +1,4 @@
-# Predix Parallel Run System
+# NexQuant Parallel Run System
 
 ## Overview
 
@@ -10,8 +10,8 @@ The Parallel Run System enables concurrent execution of 5+ factor generation exp
 
 | File | Purpose |
 |------|---------|
-| `predix.py` | Extended with `--run-id` parameter for isolated single runs |
-| `predix_parallel.py` | Parallel runner manager with Rich live dashboard |
+| `nexquant.py` | Extended with `--run-id` parameter for isolated single runs |
+| `nexquant_parallel.py` | Parallel runner manager with Rich live dashboard |
 | `factor_runner.py` | Modified to use `PARALLEL_RUN_ID` for path isolation |
 | `CoSTEER/__init__.py` | Modified to use `PARALLEL_RUN_ID` for intermediate results |
 
@@ -57,26 +57,26 @@ RD-Agent_workspace_run2/         # Parallel run #2
 
 ```bash
 # Run with isolated results
-predix quant --run-id 1 -m openrouter
+nexquant quant --run-id 1 -m openrouter
 ```
 
 ### CLI - Parallel Runner (Direct)
 
 ```bash
 # Run 5 experiments with 2 API keys
-python predix_parallel.py --runs 5 --api-keys 2
+python nexquant_parallel.py --runs 5 --api-keys 2
 
 # Run 3 experiments with local model
-python predix_parallel.py --runs 3 --model local
+python nexquant_parallel.py --runs 3 --model local
 
 # Custom configuration
-python predix_parallel.py -n 10 -k 2 -m openrouter
+python nexquant_parallel.py -n 10 -k 2 -m openrouter
 ```
 
 ### Programmatic Usage
 
 ```python
-from predix_parallel import main
+from nexquant_parallel import main
 
 result = main(runs=5, api_keys=2, model="openrouter")
 print(f"Success: {result['success']}/{result['total']}")
@@ -132,7 +132,7 @@ The parallel runner shows a Rich-based live dashboard:
 
 ```
 ┌─────────────────────────────────────────────────────────┐
-│  🔀 Predix Parallel Run Dashboard                       │
+│  🔀 NexQuant Parallel Run Dashboard                       │
 ├──────┬──────────┬──────────┬─────────┬──────────┬───────┤
 │ Run  │ Status   │ Elapsed  │ API Key │ Model    │ Exit  │
 ├──────┼──────────┼──────────┼─────────┼──────────┼───────┤
@@ -222,10 +222,10 @@ if parallel_run_id != "0":
 pytest test/integration/test_all_features.py -v
 
 # Test parallel runner imports
-python -c "from predix_parallel import ParallelRunner, main; print('✅ OK')"
+python -c "from nexquant_parallel import ParallelRunner, main; print('✅ OK')"
 
 # Test CLI options
-predix quant --help  # Should show --run-id option
+nexquant quant --help  # Should show --run-id option
 ```
 
 ## Future Enhancements

docs/security/SECURITY_RUNBOOK.md

@@ -1,4 +1,4 @@
-# Security Runbook für Predix
+# Security Runbook für NexQuant
 
 ## Bandit Security Scanner
 

examples/README.md

@@ -127,8 +127,8 @@ jupyter notebook examples/notebooks/quickstart.ipynb
 
 - **Dokumentation:** `docs/` oder [README.md](../README.md)
 - **CLI Hilfe:** `rdagent COMMAND --help`
-- **Issues:** [GitHub Issues](https://github.com/nico/Predix/issues)
-- **Community:** [Discussions](https://github.com/nico/Predix/discussions)
+- **Issues:** [GitHub Issues](https://github.com/nico/NexQuant/issues)
+- **Community:** [Discussions](https://github.com/nico/NexQuant/discussions)
 
 ## ⚠️ Wichtige Hinweise
 

examples/notebooks/quickstart.ipynb

@@ -382,8 +382,8 @@
     "### Ressourcen:\n",
     "\n",
     "- 📚 [Dokumentation](../docs/)\n",
-    "- 💬 [GitHub Discussions](https://github.com/nico/Predix/discussions)\n",
-    "- 🐛 [Issues melden](https://github.com/nico/Predix/issues)"
+    "- 💬 [GitHub Discussions](https://github.com/nico/NexQuant/discussions)\n",
+    "- 🐛 [Issues melden](https://github.com/nico/NexQuant/issues)"
    ]
   }
  ],

models/README.md

@@ -1,6 +1,6 @@
-# Predix Models
+# NexQuant Models
 
-This directory contains all ML model definitions for Predix trading factors.
+This directory contains all ML model definitions for NexQuant trading factors.
 
 ---
 

prompts/INDEX.md

@@ -1,6 +1,6 @@
-# Predix Prompts Index
+# NexQuant Prompts Index
 
-Centralized location for all LLM prompts used in the Predix trading system.
+Centralized location for all LLM prompts used in the NexQuant trading system.
 
 ## Structure
 

prompts/README.md

@@ -1,6 +1,6 @@
-# Predix Prompts
+# NexQuant Prompts
 
-This directory contains all LLM prompts for the Predix trading agent.
+This directory contains all LLM prompts for the NexQuant trading agent.
 
 ---
 
@@ -174,13 +174,13 @@ prompt_v2 = load_yaml_file("prompts/local/factor_discovery_v2.yaml")
 
 ```bash
 # Backup to private repo
-cd ~/Predix
+cd ~/NexQuant
 git archive --format=tar prompts/local/ | gzip > ~/backups/prompts_local_$(date +%Y%m%d).tar.gz
 
 # Or sync to private GitHub repo
-git clone git@github.com:TPTBusiness/predix-prompts-private.git
-cp -r prompts/local/* predix-prompts-private/
-cd predix-prompts-private && git push
+git clone git@github.com:TPTBusiness/nexquant-prompts-private.git
+cp -r prompts/local/* nexquant-prompts-private/
+cd nexquant-prompts-private && git push
 ```
 
 ---

prompts/strategy_generation_v4.yaml

@@ -34,9 +34,9 @@ strategy_generation:
     5. signal.name must be 'signal'
 
     IC-Guided Factor Selection:
-    - Factors with |IC| > 0.10 are highly predictive - PRIORITIZE these
-    - Factors with |IC| > 0.05 are moderately predictive - USE these
-    - Factors with |IC| < 0.05 are weak - AVOID unless complementary
+    - Factors with |IC| > 0.15 are highly predictive - PRIORITIZE these
+    - Factors with |IC| > 0.08 are moderately predictive - USE these
+    - Factors with |IC| < 0.08 are weak - AVOID unless complementary
     - Combine factors with different signs of IC for diversification
     - Weight factors proportionally to their |IC| values
 
@@ -62,6 +62,7 @@ strategy_generation:
     TRADING STYLE: {{ trading_style }}
     TARGET SHARPE: > {{ min_sharpe }}
     MAX DRAWDOWN: {{ max_drawdown }}
+    TARGET MONTHLY RETURN: > {{ min_monthly_return }}%
 
     CRITICAL CODE RULES:
     1. DO NOT define functions - write direct executable code

pyproject.toml

@@ -7,7 +7,7 @@ requires = [
 
 [project]
 authors = [
-  {email = "nico@predix.io", name = "Predix Team"},
+  {email = "nico@nexquant.io", name = "NexQuant Team"},
 ]
 classifiers = [
   "Development Status :: 3 - Alpha",
@@ -16,7 +16,7 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
 ]
-description = "Predix - AI-gestützter Quantitative Trading Agent für EUR/USD"
+description = "NexQuant - AI-gestützter Quantitative Trading Agent für EUR/USD"
 dynamic = [
   "dependencies",
   "optional-dependencies",
@@ -29,7 +29,7 @@ keywords = [
   "EUR/USD",
   "Forex",
 ]
-name = "predix"
+name = "nexquant"
 readme = "README.md"
 requires-python = ">=3.10"
 
@@ -37,8 +37,8 @@ requires-python = ">=3.10"
 rdagent = "rdagent.app.cli:app"
 
 [project.urls]
-homepage = "https://github.com/PredixAI/predix/"
-issue = "https://github.com/PredixAI/predix/issues"
+homepage = "https://github.com/NexQuantAI/nexquant/"
+issue = "https://github.com/NexQuantAI/nexquant/issues"
 
 [tool.coverage.report]
 fail_under = 80

rdagent/app/cli.py

@@ -21,11 +21,10 @@ load_dotenv(".env")
 
 import subprocess
 from importlib.resources import path as rpath
-from typing import Dict, Optional
+from typing import Annotated
 
 import typer
 from rich.console import Console
-from typing_extensions import Annotated
 
 try:
     from rdagent.utils.env import logger
@@ -146,10 +145,10 @@ def ds_user_interact(port=19900):
 
 @app.command(name="fin_factor")
 def fin_factor_cli(
-    path: Optional[str] = None,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
-    all_duration: Optional[str] = None,
+    path: str | None = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
+    all_duration: str | None = None,
     checkout: CheckoutOption = True,
 ):
     fin_factor(path=path, step_n=step_n, loop_n=loop_n, all_duration=all_duration, checkout=checkout)
@@ -157,10 +156,10 @@ def fin_factor_cli(
 
 @app.command(name="fin_model")
 def fin_model_cli(
-    path: Optional[str] = None,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
-    all_duration: Optional[str] = None,
+    path: str | None = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
+    all_duration: str | None = None,
     checkout: CheckoutOption = True,
 ):
     fin_model(path=path, step_n=step_n, loop_n=loop_n, all_duration=all_duration, checkout=checkout)
@@ -168,10 +167,10 @@ def fin_model_cli(
 
 @app.command(name="fin_quant")
 def fin_quant_cli(
-    path: Optional[str] = None,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
-    all_duration: Optional[str] = None,
+    path: str | None = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
+    all_duration: str | None = None,
     checkout: CheckoutOption = True,
     with_dashboard: bool = typer.Option(False, "--with-dashboard/-d", help="Start web dashboard automatically"),
     with_cli_dashboard: bool = typer.Option(False, "--cli-dashboard/-c", help="Show beautiful CLI dashboard"),
@@ -231,7 +230,7 @@ def fin_quant_cli(
         if not api_key:
             console.print("\n[bold red]❌ OPENROUTER_API_KEY not set in .env[/bold red]")
             console.print("[yellow]Add your API key to .env and retry:[/yellow]")
-            console.print('  OPENROUTER_API_KEY=sk-or-your-key-here')
+            console.print("  OPENROUTER_API_KEY=sk-or-your-key-here")
             raise typer.Exit(code=1)
 
         os.environ["OPENAI_API_KEY"] = api_key
@@ -250,8 +249,8 @@ def fin_quant_cli(
         console.print(f"   [dim]Base URL: {os.environ['OPENAI_API_BASE']}[/dim]")
 
         # Wait until the llama.cpp server is fully loaded before starting the pipeline
-        import urllib.request
         import urllib.error
+        import urllib.request
 
         base_url = os.environ["OPENAI_API_BASE"].removesuffix("/v1").rstrip("/")
         health_url = f"{base_url}/health"
@@ -285,7 +284,7 @@ def fin_quant_cli(
             subprocess.run(
                 ["python", "web/dashboard_api.py"],
                 cwd=str(Path(__file__).parent.parent.parent),
-                env={**os.environ, "FLASK_ENV": "development"}
+                env={**os.environ, "FLASK_ENV": "development"},
             )
 
         dashboard_thread = threading.Thread(target=start_web_dashboard, daemon=True)
@@ -295,7 +294,7 @@ def fin_quant_cli(
     # Start CLI Dashboard wenn gewünscht
     if with_cli_dashboard:
         def start_cli_dash():
-            from rdagent.log.ui.predix_dashboard import run_dashboard
+            from rdagent.log.ui.nexquant_dashboard import run_dashboard
             run_dashboard(log_path="fin_quant.log", refresh_interval=3)
 
         cli_thread = threading.Thread(target=start_cli_dash, daemon=True)
@@ -327,9 +326,9 @@ def fin_quant_cli(
 
 @app.command(name="fin_factor_report")
 def fin_factor_report_cli(
-    report_folder: Optional[str] = None,
-    path: Optional[str] = None,
-    all_duration: Optional[str] = None,
+    report_folder: str | None = None,
+    path: str | None = None,
+    all_duration: str | None = None,
     checkout: CheckoutOption = True,
 ):
     fin_factor_report(report_folder=report_folder, path=path, all_duration=all_duration, checkout=checkout)
@@ -342,12 +341,12 @@ def general_model_cli(report_file_path: str):
 
 @app.command(name="data_science")
 def data_science_cli(
-    path: Optional[str] = None,
+    path: str | None = None,
     checkout: CheckoutOption = True,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
-    timeout: Optional[str] = None,
-    competition: Optional[str] = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
+    timeout: str | None = None,
+    competition: str | None = None,
 ):
     data_science(
         path=path,
@@ -361,16 +360,16 @@ def data_science_cli(
 
 @app.command(name="llm_finetune")
 def llm_finetune_cli(
-    path: Optional[str] = None,
+    path: str | None = None,
     checkout: CheckoutOption = True,
-    benchmark: Optional[str] = None,
-    benchmark_description: Optional[str] = None,
-    dataset: Optional[str] = None,
-    base_model: Optional[str] = None,
-    upper_data_size_limit: Optional[int] = None,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
-    timeout: Optional[str] = None,
+    benchmark: str | None = None,
+    benchmark_description: str | None = None,
+    dataset: str | None = None,
+    base_model: str | None = None,
+    upper_data_size_limit: int | None = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
+    timeout: str | None = None,
 ):
     llm_finetune(
         path=path,
@@ -436,6 +435,7 @@ def rl_trading_cli(
         rdagent rl_trading --mode backtest --no-with-protections
     """
     from pathlib import Path
+
     import yaml
 
     console = Console()
@@ -447,18 +447,18 @@ def rl_trading_cli(
         with open(config_path) as f:
             config = yaml.safe_load(f) or {}
 
-    console.print(f"\n[bold blue]🤖 RL Trading Agent[/bold blue]")
+    console.print("\n[bold blue]🤖 RL Trading Agent[/bold blue]")
     console.print(f"Mode: [cyan]{mode}[/cyan]")
     console.print(f"Algorithm: [cyan]{algorithm.upper()}[/cyan]")
     console.print(f"Protections: {'[green]Enabled[/green]' if with_protections else '[red]Disabled[/red]'}")
 
     try:
-        from rdagent.components.coder.rl import RLTradingAgent, RLCosteer, TradingEnv
+        from rdagent.components.coder.rl import RLCosteer, RLTradingAgent, TradingEnv
     except ImportError as e:
-        console.print(f"[bold red]Error: RL components not available.[/bold red]")
+        console.print("[bold red]Error: RL components not available.[/bold red]")
         console.print(f"Details: {e}")
-        console.print(f"\n[yellow]Install RL dependencies:[/yellow]")
-        console.print(f"  pip install stable-baselines3 gymnasium")
+        console.print("\n[yellow]Install RL dependencies:[/yellow]")
+        console.print("  pip install stable-baselines3 gymnasium")
         raise typer.Exit(code=1)
 
     if mode == "train":
@@ -474,8 +474,8 @@ def rl_trading_cli(
             console.print("[dim]Loading market data...[/dim]")
             # TODO: Load actual data from config
             # For now, create mock environment
-            import numpy as np
             import gymnasium as gym
+            import numpy as np
 
             # Create simple mock environment for demonstration
             class MockTradingEnv(gym.Env):
@@ -511,7 +511,7 @@ def rl_trading_cli(
             model_path_out.parent.mkdir(parents=True, exist_ok=True)
             agent.save(model_path_out)
 
-            console.print(f"\n[bold green]✅ Training complete![/bold green]")
+            console.print("\n[bold green]✅ Training complete![/bold green]")
             console.print(f"Model saved to: [cyan]{model_path_out}[/cyan]")
             console.print(f"Algorithm: {result['algorithm']}")
             console.print(f"Timesteps: {result['total_timesteps']:,}")
@@ -537,9 +537,9 @@ def rl_trading_cli(
                 agent = RLTradingAgent(algorithm=algorithm.upper())
 
             # Run backtest
-            from rdagent.components.backtesting import FactorBacktester
-            import pandas as pd
             import numpy as np
+            import pandas as pd
+            from rdagent.components.backtesting import FactorBacktester
 
             backtester = FactorBacktester()
 
@@ -548,8 +548,8 @@ def rl_trading_cli(
             n_steps = 500
             mock_prices = pd.Series(100 + np.cumsum(np.random.randn(n_steps) * 0.5))
             mock_indicators = pd.DataFrame({
-                'rsi': np.random.uniform(30, 70, n_steps),
-                'macd': np.random.randn(n_steps) * 0.1,
+                "rsi": np.random.uniform(30, 70, n_steps),
+                "macd": np.random.randn(n_steps) * 0.1,
             })
 
             console.print("[yellow]Running backtest...[/yellow]")
@@ -560,7 +560,7 @@ def rl_trading_cli(
                 enable_protections=with_protections,
             )
 
-            console.print(f"\n[bold green]✅ Backtest complete![/bold green]")
+            console.print("\n[bold green]✅ Backtest complete![/bold green]")
             console.print(f"  Final Equity: [green]${metrics.get('final_equity', 0):,.2f}[/green]")
             console.print(f"  Sharpe Ratio: {metrics.get('sharpe_ratio', 0):.3f}")
             console.print(f"  Max Drawdown: {metrics.get('max_drawdown', 0):.2%}")
@@ -617,6 +617,9 @@ def generate_strategies_cli(
     top_factors: int = typer.Option(20, "--top-factors", help="Number of top factors to consider"),
     continuous: bool = typer.Option(True, "--continuous/--single-pass", help="Optimize ALL strategies including rejected ones"),
     max_iterations: int = typer.Option(1, "--max-iterations", "-i", help="Number of generation-optimization cycles (1 = single pass, >1 = continuous)"),
+    min_sharpe: float = typer.Option(1.5, "--min-sharpe", help="Minimum Sharpe ratio for acceptance"),
+    max_drawdown: float = typer.Option(-0.30, "--max-dd", help="Maximum drawdown allowed"),
+    min_win_rate: float = typer.Option(0.40, "--min-winrate", help="Minimum win rate for acceptance"),
 ):
     """
     Generate trading strategies from evaluated factors.
@@ -634,7 +637,7 @@ def generate_strategies_cli(
         rdagent generate_strategies -n 3 -i 10 --optuna-trials 50  # Deep optimization
     """
     from rich.console import Console
-    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeRemainingColumn
+    from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeRemainingColumn
     from rich.table import Table
 
     console = Console()
@@ -653,7 +656,7 @@ def generate_strategies_cli(
         raise typer.Exit(code=1)
 
     console.print(f"\n[bold blue]{'='*60}[/bold blue]")
-    console.print(f"[bold blue]  PREDIX Strategy Generator[/bold blue]")
+    console.print("[bold blue]  PREDIX Strategy Generator[/bold blue]")
     console.print(f"[bold blue]{'='*60}[/bold blue]")
     console.print(f"  Strategies:  [cyan]{count}[/cyan]")
     console.print(f"  Workers:     [cyan]{workers}[/cyan]")
@@ -680,12 +683,12 @@ def generate_strategies_cli(
     _slog = _dlog.setup("strategies", **_strat_ctx)
 
     try:
-        from rdagent.components.coder.strategy_orchestrator import StrategyOrchestrator
         import pandas as pd
+        from rdagent.scenarios.qlib.local.strategy_orchestrator import StrategyOrchestrator
 
         all_results = []
         best_strategy = None
-        best_sharpe = float('-inf')
+        best_sharpe = float("-inf")
 
         # CONTINUOUS OPTIMIZATION LOOP
         for iteration in range(1, max_iterations + 1):
@@ -698,6 +701,9 @@ def generate_strategies_cli(
             orchestrator = StrategyOrchestrator(
                 top_factors=top_factors,
                 trading_style=style,
+                min_sharpe=min_sharpe,
+                max_drawdown=max_drawdown,
+                min_win_rate=min_win_rate,
                 use_optuna=optuna,
                 optuna_trials=optuna_trials,
                 continuous_optimization=continuous,
@@ -734,7 +740,7 @@ def generate_strategies_cli(
 
             # Track best strategy
             for r in results:
-                sharpe = r.get("sharpe_ratio", float('-inf'))
+                sharpe = r.get("sharpe_ratio", float("-inf"))
                 if sharpe > best_sharpe:
                     best_sharpe = sharpe
                     best_strategy = r
@@ -754,7 +760,7 @@ def generate_strategies_cli(
         rejected = [r for r in results if r.get("status") == "rejected"]
 
         console.print(f"\n[bold green]{'='*60}[/bold green]")
-        console.print(f"[bold green]  Strategy Generation Summary[/bold green]")
+        console.print("[bold green]  Strategy Generation Summary[/bold green]")
         console.print(f"[bold green]{'='*60}[/bold green]")
 
         table = Table(show_header=True, header_style="bold magenta", show_lines=True)
@@ -783,7 +789,7 @@ def generate_strategies_cli(
         # Show best strategy details
         if best_strategy:
             console.print(f"\n[bold gold1]{'='*60}[/bold gold1]")
-            console.print(f"[bold gold1]  BEST STRATEGY[/bold gold1]")
+            console.print("[bold gold1]  BEST STRATEGY[/bold gold1]")
             console.print(f"[bold gold1]{'='*60}[/bold gold1]")
             console.print(f"  Name:        [cyan]{best_strategy.get('strategy_name', 'Unknown')}[/cyan]")
             console.print(f"  Sharpe:      [green]{best_strategy.get('sharpe_ratio', 0):.4f}[/green]")
@@ -791,13 +797,13 @@ def generate_strategies_cli(
             console.print(f"  Max DD:      [yellow]{best_strategy.get('max_drawdown', 0):.2%}[/yellow]")
             console.print(f"  Win Rate:    [cyan]{best_strategy.get('win_rate', 0):.2%}[/cyan]")
             if best_strategy.get("best_params"):
-                console.print(f"\n  [bold]Optimized Parameters:[/bold]")
+                console.print("\n  [bold]Optimized Parameters:[/bold]")
                 for param, val in best_strategy["best_params"].items():
                     console.print(f"    {param}: [cyan]{val}[/cyan]")
             console.print(f"[bold gold1]{'='*60}[/bold gold1]")
 
         if accepted:
-            console.print(f"\n[bold]Accepted Strategies:[/bold]")
+            console.print("\n[bold]Accepted Strategies:[/bold]")
             acc_table = Table(show_header=True, header_style="bold cyan")
             acc_table.add_column("#", width=4)
             acc_table.add_column("Strategy", width=30)
@@ -820,13 +826,13 @@ def generate_strategies_cli(
                 )
             console.print(acc_table)
 
-        console.print(f"\n[bold green]Strategies saved to:[/bold green] [cyan]results/strategies_new/[/cyan]")
+        console.print("\n[bold green]Strategies saved to:[/bold green] [cyan]results/strategies_new/[/cyan]")
         console.print(f"[bold blue]{'='*60}[/bold blue]\n")
         _slog.success(f"Generated {len(all_results)} strategies ({len([r for r in all_results if r.get('status')=='accepted'])} accepted)")
 
     except ImportError as e:
         _slog.error(f"Strategy components not available: {e}")
-        console.print(f"[bold red]Error: Strategy components not available.[/bold red]")
+        console.print("[bold red]Error: Strategy components not available.[/bold red]")
         console.print(f"Details: {e}")
         raise typer.Exit(code=1)
     except Exception as e:
@@ -862,17 +868,18 @@ def optimize_portfolio_cli(
         raise typer.Exit(code=1)
 
     console.print(f"\n[bold blue]{'='*60}[/bold blue]")
-    console.print(f"[bold blue]  PREDIX Portfolio Optimizer[/bold blue]")
+    console.print("[bold blue]  PREDIX Portfolio Optimizer[/bold blue]")
     console.print(f"[bold blue]{'='*60}[/bold blue]")
     console.print(f"  Top N:    [cyan]{top_n}[/cyan]")
     console.print(f"  Method:   [cyan]{method}[/cyan]")
     console.print(f"[bold blue]{'='*60}[/bold blue]\n")
 
     try:
-        from rdagent.components.backtesting.risk_management import PortfolioOptimizer
         import json
         from pathlib import Path
 
+        from rdagent.components.backtesting.risk_management import PortfolioOptimizer
+
         project_root = Path(__file__).parent.parent.parent
         strategies_dir = project_root / "results" / "strategies_new"
 
@@ -1009,14 +1016,15 @@ def strategies_report_cli(
         rdagent strategies_report -s path/to/strategy.json  # Single strategy
         rdagent strategies_report -o custom/reports/      # Custom output dir
     """
+    from pathlib import Path
+
     from rich.console import Console
     from rich.progress import Progress, SpinnerColumn, TextColumn
-    from pathlib import Path
 
     console = Console()
 
     console.print(f"\n[bold blue]{'='*60}[/bold blue]")
-    console.print(f"[bold blue]  PREDIX Strategy Report Generator[/bold blue]")
+    console.print("[bold blue]  PREDIX Strategy Report Generator[/bold blue]")
     console.print(f"[bold blue]{'='*60}[/bold blue]\n")
 
     project_root = Path(__file__).parent.parent.parent
@@ -1068,20 +1076,20 @@ def strategies_report_cli(
                 progress.update(task, completed=1)
 
     console.print(f"\n[bold green]{'='*60}[/bold green]")
-    console.print(f"[bold green]  Report Generation Complete[/bold green]")
+    console.print("[bold green]  Report Generation Complete[/bold green]")
     console.print(f"[bold green]{'='*60}[/bold green]")
     console.print(f"  Reports generated: [cyan]{reports_generated}/{len(strategy_files)}[/cyan]")
     console.print(f"  Output directory:  [cyan]{output_dir_path}[/cyan]")
     console.print(f"[bold green]{'='*60}[/bold green]\n")
 
 
-def _generate_single_strategy_report(strategy_file: Path, output_dir: Path) -> Dict:
+def _generate_single_strategy_report(strategy_file: Path, output_dir: Path) -> dict:
     """Generate a report for a single strategy."""
     import json
+
     import matplotlib
     matplotlib.use("Agg")  # Non-interactive backend
     import matplotlib.pyplot as plt
-    import seaborn as sns
 
     with open(strategy_file, encoding="utf-8") as f:
         strategy = json.load(f)
@@ -1156,7 +1164,7 @@ if __name__ == "__main__":
 @app.command(name="start_llama")
 def start_llama_cli(
     model: str = typer.Option(
-        None, "--model", "-m", help="Path to model file"
+        None, "--model", "-m", help="Path to model file",
     ),
     port: int = typer.Option(8081, "--port", "-p", help="Server port"),
     gpu_layers: int = typer.Option(30, "--gpu-layers", "-g", help="GPU layers"),
@@ -1178,8 +1186,6 @@ def start_llama_cli(
       rdagent start_llama --gpu-layers 40 --ctx-size 4096
       rdagent start_llama --reasoning
     """
-    import subprocess
-    import sys
     import os
 
     model_path = model or os.getenv(
@@ -1216,7 +1222,7 @@ def start_llama_cli(
     if not reasoning:
         cmd.extend(["--reasoning", "off"])
 
-    print(f"🚀 Starting llama.cpp server...")
+    print("🚀 Starting llama.cpp server...")
     print(f"   Model: {Path(model_path).name}")
     print(f"   Port: {port}")
     print(f"   GPU Layers: {gpu_layers}")
@@ -1249,17 +1255,16 @@ def start_loop_cli(
       rdagent start_loop
       rdagent start_loop --target 5 --max-wait 3600
     """
-    import subprocess
-    import signal
-    import sys
     import os
-    from datetime import datetime
+    import signal
+    import subprocess
     import time
+    from datetime import datetime
 
-    script_dir = str(Path(__file__).parent.parent.parent.parent)
-    generator = f"python {script_dir}/scripts/predix_smart_strategy_gen.py"
+    script_dir = str(Path(__file__).parent.parent.parent)
+    generator = [sys.executable, f"{script_dir}/scripts/nexquant_smart_strategy_gen.py"]
     logfile = f"{script_dir}/results/logs/generator_loop.log"
-    pidfile = "/tmp/predix_loop.pid"  # nosec B108 — administrative PID file, single-process daemon
+    pidfile = "/tmp/nexquant_loop.pid"  # nosec B108 — administrative PID file, single-process daemon
 
     os.makedirs(f"{script_dir}/results/logs", exist_ok=True)
 
@@ -1270,12 +1275,19 @@ def start_loop_cli(
         with open(logfile, "a") as f:
             f.write(line + "\n")
 
+    child_proc = None  # track current child PID for targeted cleanup
+
     def cleanup(signum=None, frame=None):
         log("Received termination signal. Cleaning up...")
-        try:
-            subprocess.run(["pkill", "-f", "predix_smart_strategy_gen.py"], capture_output=True)
-        except Exception:
-            pass
+        if child_proc is not None:
+            try:
+                child_proc.terminate()
+                child_proc.wait(timeout=10)
+            except Exception:
+                try:
+                    child_proc.kill()
+                except Exception:
+                    pass
         try:
             os.remove(pidfile)
         except FileNotFoundError:
@@ -1321,26 +1333,32 @@ def start_loop_cli(
         strat_count = len(list(strat_dir.glob("*.json"))) if strat_dir.exists() else 0
         log(f"📁 Existing strategies: {strat_count}")
 
-        # Kill stale processes
-        try:
-            subprocess.run(["pkill", "-9", "-f", "predix_smart_strategy_gen.py"], capture_output=True)
-        except Exception:
-            pass
-        time.sleep(2)
+        # Kill stale child from previous iteration
+        if child_proc is not None:
+            try:
+                child_proc.terminate()
+                child_proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                child_proc.kill()
+                child_proc.wait()
+            except Exception:
+                pass
+            child_proc = None
+            time.sleep(2)
 
         # Start generator
         log("🤖 Starting generator...")
-        proc = subprocess.Popen(
-            generator.split(),
+        child_proc = subprocess.Popen(
+            generator,
             cwd=script_dir,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
         )
-        log(f"   PID: {proc.pid}")
+        log(f"   PID: {child_proc.pid}")
 
         # Monitor progress
         elapsed = 0
-        while proc.poll() is None:
+        while child_proc.poll() is None:
             time.sleep(30)
             elapsed += 30
 
@@ -1349,11 +1367,12 @@ def start_loop_cli(
 
             if elapsed >= max_wait:
                 log(f"   ⏰ Timeout after {elapsed}s. Killing...")
-                proc.kill()
+                child_proc.kill()
                 break
 
         # Check results
-        exit_code = proc.wait()
+        exit_code = child_proc.wait()
+        child_proc = None
         if exit_code == 0:
             log("✅ Generator completed successfully")
         elif exit_code == -9:
@@ -1394,24 +1413,24 @@ def parallel_cli(
       rdagent parallel -n 10 -k 2
     """
     import subprocess
-    import sys
     from pathlib import Path
+
     from rdagent.log import daily_log as _dlog
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_parallel.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_parallel.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
         raise typer.Exit(code=1)
 
-    cmd = [sys.executable, str(script), "--runs", str(runs), "--api-keys", str(api_keys), "-m", "local"]
+    cmd = [sys.executable, str(script), "--runs", str(runs), "--api-keys", str(api_keys)]
 
     _plog = _dlog.setup("parallel", runs=runs, api_keys=api_keys, model="local")
     typer.echo(f"🚀 Starting {runs} parallel runs...")
     typer.echo(f"   Script: {script}")
     typer.echo(f"   API Keys: {api_keys}")
-    typer.echo(f"   Model: local (llama.cpp)")
+    typer.echo("   Model: local (llama.cpp)")
 
     try:
         result = subprocess.run(cmd, cwd=str(project_root))
@@ -1445,12 +1464,12 @@ def eval_all_cli(
       rdagent eval_all -n 500 -p 8
     """
     import subprocess
-    import sys
     from pathlib import Path
+
     from rdagent.log import daily_log as _dlog
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_full_eval.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_full_eval.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
@@ -1500,11 +1519,10 @@ def batch_backtest_cli(
       rdagent batch_backtest --all
     """
     import subprocess
-    import sys
     from pathlib import Path
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_batch_backtest.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_batch_backtest.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
@@ -1553,11 +1571,10 @@ def simple_eval_cli(
       rdagent simple_eval --all
     """
     import subprocess
-    import sys
     from pathlib import Path
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_simple_eval.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_simple_eval.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
@@ -1586,7 +1603,7 @@ def simple_eval_cli(
 @app.command(name="rebacktest")
 def rebacktest_cli(
     strategies_dir: str = typer.Option(
-        None, "--strategies-dir", "-d", help="Directory containing strategy JSON files"
+        None, "--strategies-dir", "-d", help="Directory containing strategy JSON files",
     ),
 ):
     """
@@ -1600,11 +1617,10 @@ def rebacktest_cli(
       rdagent rebacktest -d results/strategies_new/
     """
     import subprocess
-    import sys
     from pathlib import Path
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_rebacktest_strategies.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_rebacktest_strategies.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
@@ -1628,10 +1644,10 @@ def rebacktest_cli(
 @app.command(name="report")
 def report_cli(
     strategy_path: str = typer.Option(
-        None, "--strategy", "-s", help="Path to single strategy JSON (default: all strategies)"
+        None, "--strategy", "-s", help="Path to single strategy JSON (default: all strategies)",
     ),
     output: str = typer.Option(
-        None, "--output", "-o", help="Output directory (default: results/strategy_reports/)"
+        None, "--output", "-o", help="Output directory (default: results/strategy_reports/)",
     ),
 ):
     """
@@ -1654,11 +1670,10 @@ def report_cli(
       rdagent report -o custom/reports/
     """
     import subprocess
-    import sys
     from pathlib import Path
 
-    project_root = Path(__file__).parent.parent.parent.parent
-    script = project_root / "scripts" / "predix_strategy_report.py"
+    project_root = Path(__file__).parent.parent.parent
+    script = project_root / "scripts" / "nexquant_strategy_report.py"
 
     if not script.exists():
         typer.echo(f"❌ Script not found: {script}")
@@ -1682,10 +1697,10 @@ def report_cli(
 
 
 
-@app.command(name="predix")
-def predix_welcome():
+@app.command(name="nexquant")
+def nexquant_welcome():
     """
-    Show Predix welcome screen with system overview.
+    Show NexQuant welcome screen with system overview.
     
     This command displays a beautiful dashboard showing:
     - System status (factors, strategies, security)
@@ -1695,7 +1710,7 @@ def predix_welcome():
     Perfect for GitHub README screenshots!
     
     Examples:
-      rdagent predix
+      rdagent nexquant
     """
     from rdagent.app.cli_welcome import show_welcome
     show_welcome()

rdagent/app/cli_welcome.py

@@ -1,5 +1,5 @@
 """
-Predix CLI Welcome Screen - Beautiful dashboard for GitHub README screenshot.
+NexQuant CLI Welcome Screen - Beautiful dashboard for GitHub README screenshot.
 """
 
 import os
@@ -16,7 +16,7 @@ from datetime import datetime
 console = Console()
 
 def show_welcome():
-    """Show beautiful Predix welcome screen."""
+    """Show beautiful NexQuant welcome screen."""
     
     # Header
     console.print()
@@ -89,7 +89,7 @@ def show_welcome():
     console.print()
     
     # Footer
-    footer = Text("📄 github.com/TPTBusiness/Predix  •  🔒 MIT License  •  📖 docs/", style="dim white")
+    footer = Text("📄 github.com/TPTBusiness/NexQuant  •  🔒 MIT License  •  📖 docs/", style="dim white")
     console.print(Align.center(footer))
     console.print()
 
@@ -98,5 +98,5 @@ if __name__ == "__main__":
 
 
 def main():
-    """Entry point for 'predix' CLI command."""
+    """Entry point for 'nexquant' CLI command."""
     show_welcome()

rdagent/app/qlib_rd_loop/factor.py

@@ -4,10 +4,9 @@ Factor workflow with session control
 
 import asyncio
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import fire
-
 from rdagent.app.qlib_rd_loop.conf import FACTOR_PROP_SETTING
 from rdagent.components.workflow.rd_loop import RDLoop
 from rdagent.core.exception import CoderError, FactorEmptyError
@@ -21,20 +20,20 @@ class FactorRDLoop(RDLoop):
     def running(self, prev_out: dict[str, Any]):
         exp = self.runner.develop(prev_out["coding"])
         if exp is None:
-            logger.error(f"Factor extraction failed.")
+            logger.error("Factor extraction failed.")
             raise FactorEmptyError("Factor extraction failed.")
         logger.log_object(exp, tag="runner result")
         return exp
 
 
 def main(
-    path: Optional[str] = None,
-    step_n: Optional[int] = None,
-    loop_n: Optional[int] = None,
+    path: str | None = None,
+    step_n: int | None = None,
+    loop_n: int | None = None,
     all_duration: str | None = None,
     checkout: bool = True,
-    checkout_path: Optional[str] = None,
-    base_features_path: Optional[str] = None,
+    checkout_path: str | None = None,
+    base_features_path: str | None = None,
     **kwargs,
 ):
     """
@@ -47,7 +46,7 @@ def main(
         dotenv run -- python rdagent/app/qlib_rd_loop/factor.py $LOG_PATH/__session__/1/0_propose  --step_n 1   # `step_n` is a optional paramter
 
     """
-    if not checkout_path is None:
+    if checkout_path is not None:
         checkout = Path(checkout_path)
 
     if path is None:

rdagent/app/qlib_rd_loop/factor_from_report.py

@@ -1,10 +1,9 @@
 import asyncio
 import json
 from pathlib import Path
-from typing import Any, Dict, Tuple
+from typing import Any
 
 import fire
-
 from rdagent.app.qlib_rd_loop.conf import FACTOR_FROM_REPORT_PROP_SETTING
 from rdagent.app.qlib_rd_loop.factor import FactorRDLoop
 from rdagent.components.document_reader.document_reader import (
@@ -12,7 +11,7 @@ from rdagent.components.document_reader.document_reader import (
     load_and_process_pdfs_by_langchain,
 )
 from rdagent.core.conf import RD_AGENT_SETTINGS
-from rdagent.core.proposal import Hypothesis, HypothesisFeedback
+from rdagent.core.proposal import Hypothesis
 from rdagent.log import rdagent_logger as logger
 from rdagent.oai.llm_utils import APIBackend
 from rdagent.scenarios.qlib.experiment.factor_experiment import QlibFactorExperiment
@@ -36,14 +35,14 @@ def generate_hypothesis(factor_result: dict, report_content: str) -> str:
     """
     system_prompt = T(".prompts:hypothesis_generation.system").r()
     user_prompt = T(".prompts:hypothesis_generation.user").r(
-        factor_descriptions=json.dumps(factor_result), report_content=report_content
+        factor_descriptions=json.dumps(factor_result), report_content=report_content,
     )
 
     response = APIBackend().build_messages_and_create_chat_completion(
         user_prompt=user_prompt,
         system_prompt=system_prompt,
         json_mode=True,
-        json_target_type=Dict[str, str],
+        json_target_type=dict[str, str],
     )
 
     response_json = json.loads(response)
@@ -99,7 +98,7 @@ class FactorReportLoop(FactorRDLoop, metaclass=LoopMeta):
         super().__init__(PROP_SETTING=FACTOR_FROM_REPORT_PROP_SETTING)
         if report_folder is None:
             self.judge_pdf_data_items = json.load(
-                open(FACTOR_FROM_REPORT_PROP_SETTING.report_result_json_file_path, "r")
+                open(FACTOR_FROM_REPORT_PROP_SETTING.report_result_json_file_path),
             )
         else:
             self.judge_pdf_data_items = [i for i in Path(report_folder).rglob("*.pdf")]
@@ -118,7 +117,7 @@ class FactorReportLoop(FactorRDLoop, metaclass=LoopMeta):
                 if exp is None:
                     self.shift_report += 1
                     self.loop_n -= 1
-                    if self.loop_n < 0:  # NOTE: on every step, we self.loop_n -= 1 at first.
+                    if self.loop_n < 0:  # loop_n is decremented above when reports are empty; prevents infinite skipping
                         raise self.LoopTerminationError("Reach stop criterion and stop loop")
                     continue
                 exp.based_experiments = [QlibFactorExperiment(sub_tasks=[], hypothesis=exp.hypothesis)] + [

rdagent/app/qlib_rd_loop/quant.py

@@ -8,7 +8,6 @@ from pathlib import Path
 from typing import Any
 
 import fire
-
 from rdagent.app.qlib_rd_loop.conf import QUANT_PROP_SETTING
 from rdagent.components.workflow.conf import BasePropSetting
 from rdagent.components.workflow.rd_loop import RDLoop
@@ -44,11 +43,11 @@ class QuantRDLoop(RDLoop):
         logger.log_object(self.hypothesis_gen, tag="quant hypothesis generator")
 
         self.factor_hypothesis2experiment: Hypothesis2Experiment = import_class(
-            PROP_SETTING.factor_hypothesis2experiment
+            PROP_SETTING.factor_hypothesis2experiment,
         )()
         logger.log_object(self.factor_hypothesis2experiment, tag="factor hypothesis2experiment")
         self.model_hypothesis2experiment: Hypothesis2Experiment = import_class(
-            PROP_SETTING.model_hypothesis2experiment
+            PROP_SETTING.model_hypothesis2experiment,
         )()
         logger.log_object(self.model_hypothesis2experiment, tag="model hypothesis2experiment")
 
@@ -74,6 +73,94 @@ class QuantRDLoop(RDLoop):
         self.trace = QuantTrace(scen=scen)
         super(RDLoop, self).__init__()
 
+    def _ensure_kronos_factors_in_pool(self) -> None:
+        """Generate Kronos foundation model factors with varying prediction horizons.
+
+        Generates KronosPredReturn_p24, KronosPredReturn_p48, KronosPredReturn_p96
+        if they don't already exist in results/factors/.  Uses CPU inference so it
+        co-exists peacefully with the llama-server GPU process.
+        """
+        import json as _json
+        from datetime import datetime as _dt
+        from pathlib import Path as _Path
+
+        data_path = _Path("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5")
+        if not data_path.exists():
+            logger.warning("Kronos: intraday_pv.h5 missing, skipping factor generation")
+            return
+
+        factors_dir = _Path("results/factors")
+        values_dir = factors_dir / "values"
+
+        for pred_bars in (24, 48, 96):
+            factor_name = f"KronosPredReturn_p{pred_bars}"
+            json_path = factors_dir / f"{factor_name}.json"
+            parquet_path = values_dir / f"{factor_name}.parquet"
+
+            if json_path.exists() and parquet_path.exists():
+                try:
+                    existing = _json.loads(json_path.read_text())
+                    if existing.get("ic") is not None and existing.get("model_size") == "small":
+                        logger.info(f"Kronos: {factor_name} exists (IC={existing['ic']:.4f}), skip")
+                        continue
+                except Exception:
+                    pass
+
+            try:
+                from rdagent.components.coder.kronos_adapter import build_kronos_factor, evaluate_kronos_model
+
+                has_cuda = False
+                try:
+                    import torch
+                    has_cuda = torch.cuda.is_available()
+                except Exception:
+                    pass
+                device = "cuda" if has_cuda else "cpu"
+
+                logger.info(f"Kronos-small: generating {factor_name} (pred={pred_bars}, stride=500, {device})...")
+                factor_df = build_kronos_factor(
+                    hdf5_path=data_path,
+                    context_bars=100,
+                    pred_bars=pred_bars,
+                    stride_bars=500,
+                    device=device,
+                    batch_size=32,
+                    model_size="small",
+                )
+
+                values_dir.mkdir(parents=True, exist_ok=True)
+                factor_df.to_parquet(parquet_path)
+
+                logger.info(f"Kronos: computing IC for {factor_name}...")
+                metrics = evaluate_kronos_model(
+                    hdf5_path=data_path,
+                    context_bars=100,
+                    pred_bars=pred_bars,
+                    stride_bars=2000,
+                    device=device,
+                    batch_size=32,
+                    model_size="small",
+                )
+                ic = metrics.get("IC_mean", 0.0) or 0.0
+
+                factors_dir.mkdir(parents=True, exist_ok=True)
+                meta = {
+                    "factor_name": factor_name,
+                    "status": "success",
+                    "ic": ic,
+                    "model_size": "small",
+                    "model": "NeoQuasar/Kronos-mini",
+                    "context_bars": 100,
+                    "pred_bars": pred_bars,
+                    "device": "cpu",
+                    "generated_at": _dt.now().isoformat(),
+                }
+                json_path.write_text(_json.dumps(meta, indent=2))
+                logger.info(f"Kronos: {factor_name} ready — IC={ic:.4f}")
+
+            except Exception as e:
+                logger.warning(f"Kronos: {factor_name} failed — {e}")
+
     async def direct_exp_gen(self, prev_out: dict[str, Any]):
         while True:
             if self.get_unfinished_loop_cnt(self.loop_idx) < RD_AGENT_SETTINGS.get_max_parallel():
@@ -133,7 +220,6 @@ class QuantRDLoop(RDLoop):
         """
         import json
         from datetime import datetime
-        from pathlib import Path
 
         try:
             project_root = Path(__file__).parent.parent.parent.parent
@@ -196,11 +282,11 @@ class QuantRDLoop(RDLoop):
         if prev_out["direct_exp_gen"]["propose"].action == "factor":
             exp = self.factor_runner.develop(prev_out["coding"])
             if exp is None:
-                logger.error(f"Factor extraction failed.")
+                logger.error("Factor extraction failed.")
                 raise FactorEmptyError("Factor extraction failed.")
 
             # Increment factor count for tracking
-            if hasattr(self, 'trace') and hasattr(self.trace, 'increment_factor_count'):
+            if hasattr(self, "trace") and hasattr(self.trace, "increment_factor_count"):
                 self.trace.increment_factor_count()
 
             # Handle failed experiments gracefully (don't break the loop)
@@ -211,7 +297,7 @@ class QuantRDLoop(RDLoop):
                     factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
                 logger.warning(
                     f"Factor '{factor_name}' failed evaluation: {reason}. "
-                    f"Continuing with next factor."
+                    f"Continuing with next factor.",
                 )
                 # Return exp anyway - loop will continue
         elif prev_out["direct_exp_gen"]["propose"].action == "model":
@@ -220,7 +306,7 @@ class QuantRDLoop(RDLoop):
         return exp
 
     def feedback(self, prev_out: dict[str, Any]):
-        e = prev_out.get(self.EXCEPTION_KEY, None)
+        e = prev_out.get(self.EXCEPTION_KEY)
         if e is not None:
             feedback = HypothesisFeedback(
                 observations=str(e),
@@ -246,11 +332,10 @@ class QuantRDLoop(RDLoop):
                     reason=reason,
                     decision=False,
                 )
-            else:
-                if prev_out["direct_exp_gen"]["propose"].action == "factor":
-                    feedback = self.factor_summarizer.generate_feedback(prev_out["running"], self.trace)
-                elif prev_out["direct_exp_gen"]["propose"].action == "model":
-                    feedback = self.model_summarizer.generate_feedback(prev_out["running"], self.trace)
+            elif prev_out["direct_exp_gen"]["propose"].action == "factor":
+                feedback = self.factor_summarizer.generate_feedback(prev_out["running"], self.trace)
+            elif prev_out["direct_exp_gen"]["propose"].action == "model":
+                feedback = self.model_summarizer.generate_feedback(prev_out["running"], self.trace)
 
             # NOTE: DB save is handled by factor_runner.py _save_result_to_database()
             # which runs immediately after Docker execution. No duplicate save needed here.
@@ -259,20 +344,20 @@ class QuantRDLoop(RDLoop):
         factor_count = self.trace.get_factor_count()
 
         # Check for auto-strategies trigger
-        auto_strategies = getattr(self, '_auto_strategies', False)
-        auto_threshold = getattr(self, '_auto_strategies_threshold', 500)
+        auto_strategies = getattr(self, "_auto_strategies", False)
+        auto_threshold = getattr(self, "_auto_strategies_threshold", 500)
 
         if auto_strategies and factor_count > 0 and factor_count % auto_threshold == 0:
             logger.info(
                 f"Auto-strategy trigger: {factor_count} factors evaluated. "
-                f"Suggesting strategy generation now..."
+                f"Suggesting strategy generation now...",
             )
             self._build_strategies_with_ai()
         elif factor_count > 0 and factor_count % 50 == 0 and not auto_strategies:
             # Standard periodic suggestion (every 50 factors)
             logger.info(
                 f"Periodic check: {factor_count} factors evaluated. "
-                f"Consider running 'rdagent generate_strategies' for AI strategy generation."
+                f"Consider running 'rdagent generate_strategies' for AI strategy generation.",
             )
 
         feedback = self._interact_feedback(feedback)
@@ -293,10 +378,11 @@ class QuantRDLoop(RDLoop):
         - Optuna hyperparameter optimization
         """
         try:
-            from rdagent.components.coder.strategy_orchestrator import StrategyOrchestrator
             from pathlib import Path
+
             import yaml
-            
+            from rdagent.scenarios.qlib.local.strategy_orchestrator import StrategyOrchestrator
+
             # Load improved prompt
             project_root = Path(__file__).parent.parent.parent.parent
             prompt_path = project_root / "prompts" / "strategy_generation_v2.yaml"
@@ -336,44 +422,47 @@ class QuantRDLoop(RDLoop):
 
             logger.info(f"StrategyOrchestrator: Building strategies from {len(top_factors)} top factors...")
             logger.info(f"  - Using improved prompt: {improved_prompt is not None}")
-            logger.info(f"  - Optuna optimization: enabled (20 trials)")
-            logger.info(f"  - Real OHLCV backtest: enabled")
+            logger.info("  - Optuna optimization: enabled (20 trials)")
+            logger.info("  - Real OHLCV backtest: enabled")
 
             # Initialize orchestrator with Optuna
             orchestrator = StrategyOrchestrator(
                 top_factors=20,
-                trading_style='swing',
-                min_sharpe=0.5,
+                trading_style="swing",
+                min_sharpe=1.5,
                 max_drawdown=-0.20,
                 min_win_rate=0.40,
                 use_optuna=True,
                 optuna_trials=20,
             )
-            
+
             # Override with improved prompt if available
             if improved_prompt:
-                orchestrator.strategy_prompt = improved_prompt.get('strategy_generation', {})
+                orchestrator.strategy_prompt = improved_prompt.get("strategy_generation", {})
 
             # Generate 3 strategies per cycle
             n_strategies = 3
             logger.info(f"Generating {n_strategies} strategies...")
-            
+
             # Load top factors for generation
             orch_factors = orchestrator.load_top_factors()
-            
+            if len(orch_factors) < 2:
+                logger.warning(f"Not enough factors for strategy generation (need >= 2, got {len(orch_factors)}). Skipping.")
+                return
+
             for i in range(n_strategies):
+                strategy_name = f"auto_gen_v{i+1}"
                 try:
                     # Select random factor combination
                     import random
                     n_factors = random.randint(2, min(5, len(orch_factors)))
                     factor_subset = random.sample(orch_factors, n_factors)
-                    
-                    strategy_name = f"auto_gen_v{i+1}"
+
                     code = orchestrator.generate_strategy_code(factor_subset, strategy_name)
-                    
+
                     if code:
                         result = orchestrator.evaluate_strategy(code, strategy_name, factor_subset)
-                        
+
                         if result.get("status") == "accepted":
                             logger.info(f"✅ Strategy {strategy_name} accepted!")
                             logger.info(f"   Sharpe: {result.get('sharpe_ratio', 0):.2f}")
@@ -422,6 +511,7 @@ def main(
     else:
         quant_loop = QuantRDLoop.load(path, checkout=checkout)
     quant_loop._init_base_features(base_features_path)
+    quant_loop._ensure_kronos_factors_in_pool()
     if "user_interaction_queues" in kwargs and kwargs["user_interaction_queues"] is not None:
         quant_loop._set_interactor(*kwargs["user_interaction_queues"])
         quant_loop._interact_init_params()
@@ -431,7 +521,7 @@ def main(
         quant_loop._auto_strategies = True
         quant_loop._auto_strategies_threshold = auto_strategies_threshold
         logger.info(
-            f"Auto-strategies enabled. Will trigger after {auto_strategies_threshold} factors."
+            f"Auto-strategies enabled. Will trigger after {auto_strategies_threshold} factors.",
         )
     else:
         quant_loop._auto_strategies = False

rdagent/components/backtesting/__init__.py

@@ -1,22 +1,22 @@
-"""Predix Backtesting Package"""
+"""NexQuant Backtesting Package"""
 from .backtest_engine import BacktestMetrics, FactorBacktester
 from .results_db import ResultsDatabase
 from .risk_management import CorrelationAnalyzer, PortfolioOptimizer, AdvancedRiskManager
 from .vbt_backtest import (
     DEFAULT_BARS_PER_YEAR,
     DEFAULT_TXN_COST_BPS,
-    FTMO_INITIAL_CAPITAL,
-    FTMO_MAX_DAILY_LOSS,
-    FTMO_MAX_TOTAL_LOSS,
-    FTMO_MAX_LEVERAGE,
-    FTMO_RISK_PER_TRADE,
+    INITIAL_CAPITAL,
+    MAX_DAILY_LOSS,
+    MAX_TOTAL_LOSS,
+    MAX_LEVERAGE,
+    RISK_PER_TRADE,
     OOS_START_DEFAULT,
     WF_IS_YEARS,
     WF_OOS_YEARS,
     WF_STEP_YEARS,
     backtest_from_forward_returns,
     backtest_signal,
-    backtest_signal_ftmo,
+    backtest_signal_risk,
     monte_carlo_trade_pvalue,
     walk_forward_rolling,
 )
@@ -24,10 +24,10 @@ from .vbt_backtest import (
 __all__ = [
     'BacktestMetrics', 'FactorBacktester', 'ResultsDatabase',
     'CorrelationAnalyzer', 'PortfolioOptimizer', 'AdvancedRiskManager',
-    'backtest_signal', 'backtest_signal_ftmo', 'backtest_from_forward_returns',
+    'backtest_signal', 'backtest_signal_risk', 'backtest_from_forward_returns',
     'monte_carlo_trade_pvalue', 'walk_forward_rolling',
     'DEFAULT_BARS_PER_YEAR', 'DEFAULT_TXN_COST_BPS',
-    'FTMO_INITIAL_CAPITAL', 'FTMO_MAX_DAILY_LOSS', 'FTMO_MAX_TOTAL_LOSS',
-    'FTMO_MAX_LEVERAGE', 'FTMO_RISK_PER_TRADE', 'OOS_START_DEFAULT',
+    'INITIAL_CAPITAL', 'MAX_DAILY_LOSS', 'MAX_TOTAL_LOSS',
+    'MAX_LEVERAGE', 'RISK_PER_TRADE', 'OOS_START_DEFAULT',
     'WF_IS_YEARS', 'WF_OOS_YEARS', 'WF_STEP_YEARS',
 ]

rdagent/components/backtesting/backtest_engine.py

@@ -1,5 +1,5 @@
 """
-Predix Backtesting Engine - IC, Sharpe, Drawdown
+NexQuant Backtesting Engine - IC, Sharpe, Drawdown
 
 Thin wrapper around the unified ``vbt_backtest.backtest_signal`` engine.
 All metric formulas live in ``vbt_backtest``; this module exists for
@@ -72,7 +72,7 @@ class BacktestMetrics:
 class FactorBacktester:
     def __init__(self):
         self.metrics = BacktestMetrics()
-        self.results_path = Path(__file__).parent.parent.parent / "results" / "backtests"
+        self.results_path = Path(__file__).parent.parent.parent.parent / "results" / "backtests"
         self.results_path.mkdir(parents=True, exist_ok=True)
 
     def run_backtest(
@@ -222,7 +222,7 @@ class FactorBacktester:
 
             # Calculate return for this step
             if step > 0:
-                prev_price = float(price_values[step - 1]) if step > 0 else current_price
+                prev_price = float(price_values[step - 1])
                 if prev_price > 0:
                     step_return = (current_price - prev_price) / prev_price * position
                     returns_history.append(step_return)

rdagent/components/backtesting/protections/__init__.py

@@ -1,5 +1,5 @@
 """
-Trading Protection System for Predix.
+Trading Protection System for NexQuant.
 
 Prevents excessive losses by automatically pausing trading
 when risk thresholds are exceeded.

rdagent/components/backtesting/protections/base.py

@@ -3,7 +3,7 @@ Trading Protection System
 
 Prevents excessive losses by automatically pausing trading when risk thresholds are exceeded.
 
-Inspired by common trading protection patterns, implemented from scratch for Predix.
+Inspired by common trading protection patterns, implemented from scratch for NexQuant.
 """
 
 from abc import ABC, abstractmethod

rdagent/components/backtesting/results_db.py

@@ -1,5 +1,5 @@
 """
-Predix Results Database - SQLite für Backtest-Ergebnisse
+NexQuant Results Database - SQLite für Backtest-Ergebnisse
 
 Stores backtest metrics from Qlib/MLflow runs for querying and dashboard display.
 """
@@ -97,7 +97,7 @@ class ResultsDatabase:
         c = self.conn.cursor()
         c.execute("SELECT name FROM pragma_table_info(?)", (table,))
         existing = {row[0] for row in c.fetchall()}
-        if column not in existing:
+        if column.lower() not in {name.lower() for name in existing}:
             c.execute(f"ALTER TABLE {table} ADD COLUMN {column} {col_type}")
     
     def add_factor(self, name: str, type: str = "unknown") -> int:
@@ -166,7 +166,7 @@ class ResultsDatabase:
         self.conn.commit()
         return c.lastrowid
     
-    def add_loop(self, loop_idx: int, success: int, fail: int, best_ic: float = None, status: str = "completed") -> int:
+    def add_loop(self, loop_idx: int, success: int, fail: int, best_ic: float | None = None, status: str = "completed") -> int:
         c = self.conn.cursor()
         rate = success / (success + fail) if (success + fail) > 0 else 0
         c.execute("""INSERT INTO loop_results (loop_index, factors_success, factors_fail, success_rate, best_ic, status)
@@ -330,13 +330,13 @@ class ResultsDatabase:
         worst_drawdown = all_results['max_drawdown'].min() if total_runs > 0 and all_results['max_drawdown'].notna().any() else None
 
         # Scan factors directory for JSON files
-        factors_dir = Path(__file__).parent.parent.parent / "results" / "factors"
+        factors_dir = Path(__file__).parent.parent.parent.parent / "results" / "factors"
         json_factor_files = 0
         if factors_dir.exists():
             json_factor_files = len(list(factors_dir.glob("*.json")))
 
         # Scan failed runs
-        failed_dir = Path(__file__).parent.parent.parent / "results" / "failed_runs"
+        failed_dir = Path(__file__).parent.parent.parent.parent / "results" / "failed_runs"
         failed_runs_file = failed_dir / "failed_runs.json"
         failed_runs_count = 0
         failed_runs_data = []
@@ -409,7 +409,7 @@ class ResultsDatabase:
         worst_dd_str = self._fmt_float(best['worst_drawdown'], ".4f")
 
         md_lines = [
-            "# Predix Results Summary",
+            "# NexQuant Results Summary",
             "",
             f"**Generated:** {summary['generated_at']}",
             f"**Database:** `{summary['database_path']}`",

rdagent/components/backtesting/risk_management.py

@@ -1,21 +1,19 @@
 """
-Predix Risk Management - Korrelation, Portfolio-Optimierung
+NexQuant Risk Management - Korrelation, Portfolio-Optimierung
 """
+
 import numpy as np
 import pandas as pd
-from pathlib import Path
-from typing import Dict, List, Optional
-from datetime import datetime
-import json
+
 
 class CorrelationAnalyzer:
     def __init__(self, lookback: int = 60):
         self.lookback = lookback
-    
+
     def calculate_matrix(self, returns: pd.DataFrame) -> pd.DataFrame:
         return returns.dropna().corr()
-    
-    def find_uncorrelated(self, corr: pd.DataFrame, threshold: float = 0.3) -> List[str]:
+
+    def find_uncorrelated(self, corr: pd.DataFrame, threshold: float = 0.3) -> list[str]:
         result = []
         for f in corr.columns:
             others = [x for x in corr.columns if x != f]
@@ -28,9 +26,9 @@ class PortfolioOptimizer:
         try:
             w = np.linalg.inv(cov.values) @ exp_ret.values
             return w / np.sum(w)
-        except:
+        except (np.linalg.LinAlgError, ValueError):
             return np.ones(len(exp_ret)) / len(exp_ret)
-    
+
     def risk_parity(self, cov: pd.DataFrame, max_iter: int = 100) -> np.ndarray:
         n = cov.shape[0]
         w = np.ones(n) / n
@@ -53,36 +51,36 @@ class AdvancedRiskManager:
         self.max_dd = max_dd
         self.corr_analyzer = CorrelationAnalyzer()
         self.optimizer = PortfolioOptimizer()
-    
-    def check_limits(self, weights: np.ndarray, vol: float, dd: float) -> Dict[str, bool]:
+
+    def check_limits(self, weights: np.ndarray, vol: float, dd: float) -> dict[str, bool]:
         return {
-            'position_limit': np.max(np.abs(weights)) <= self.max_pos,
-            'leverage_limit': np.sum(np.abs(weights)) <= self.max_lev,
-            'drawdown_limit': abs(dd) <= self.max_dd,
+            "position_limit": np.max(np.abs(weights)) <= self.max_pos,
+            "leverage_limit": np.sum(np.abs(weights)) <= self.max_lev,
+            "drawdown_limit": abs(dd) <= self.max_dd,
         }
 
 if __name__ == "__main__":
     print("=== Risk Test ===")
     np.random.seed(42)
-    n, names = 252, ['Mom', 'MeanRev', 'Vol', 'Volu', 'ML']
+    n, names = 252, ["Mom", "MeanRev", "Vol", "Volu", "ML"]
     ret = pd.DataFrame(np.random.randn(n, 5), columns=names)
-    
+
     corr = CorrelationAnalyzer().calculate_matrix(ret)
     print("Korrelationsmatrix:")
     print(corr.round(2))
-    
+
     opt = PortfolioOptimizer()
     exp_ret = pd.Series([0.1, 0.08, 0.06, 0.07, 0.12], index=names)
     cov = ret.cov() * 252
-    
+
     mv = opt.mean_variance(exp_ret, cov)
     print("\nMean-Variance:")
     for n, w in zip(names, mv): print(f"  {n}: {w:.2%}")
-    
+
     rp = opt.risk_parity(cov)
     print("\nRisk Parity:")
     for n, w in zip(names, rp): print(f"  {n}: {w:.2%}")
-    
+
     rm = AdvancedRiskManager()
     checks = rm.check_limits(mv, 0.15, -0.08)
     print(f"\nLimits OK: {all(checks.values())}")

rdagent/components/backtesting/vbt_backtest.py

@@ -2,9 +2,9 @@
 Unified, verifiable backtesting engine.
 
 Single entry point (`backtest_signal`) used by:
-  - scripts/predix_gen_strategies_real_bt.py
-  - rdagent/components/coder/strategy_orchestrator.py
-  - rdagent/components/coder/optuna_optimizer.py
+  - scripts/nexquant_gen_strategies_real_bt.py
+  - rdagent/scenarios/qlib/local/strategy_orchestrator.py
+  - rdagent/scenarios/qlib/local/optuna_optimizer.py
   - rdagent/components/backtesting/backtest_engine.py
 
 Design goals
@@ -19,7 +19,7 @@ Design goals
 """
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -38,15 +38,15 @@ DEFAULT_TXN_COST_BPS = 2.14
 DEFAULT_BARS_PER_YEAR = 252 * 1440  # 252 trading days * 1440 min/day = 362,880
 EXTREME_BAR_THRESHOLD = 0.05  # |ret| > 5% on a single 1-min bar → suspicious
 
-# FTMO 100k account rules (enforced in backtest_signal when ftmo=True)
-FTMO_INITIAL_CAPITAL   = 100_000.0
-FTMO_MAX_DAILY_LOSS    = 0.05   # 5%  of initial → block new trades rest of day
-FTMO_MAX_TOTAL_LOSS    = 0.10   # 10% of initial → simulation ends
-# Risk-based position sizing: 0.5% equity risk per trade, 10-pip stop, max 1:30 leverage
-FTMO_RISK_PER_TRADE    = 0.005
-FTMO_STOP_PIPS         = 10
-FTMO_PIP               = 0.0001
-FTMO_MAX_LEVERAGE      = 30
+# RiskMgmt 100k account rules (enforced in backtest_signal when riskmgmt=True)
+INITIAL_CAPITAL   = 100_000.0
+MAX_DAILY_LOSS    = 0.05   # 5%  of initial → block new trades rest of day
+MAX_TOTAL_LOSS    = 0.10   # 10% of initial → simulation ends
+# Risk-based position sizing: 1.5% equity risk per trade, 10-pip stop, max 1:30 leverage
+RISK_PER_TRADE    = 0.015
+STOP_PIPS         = 10
+PIP_SIZE               = 0.0001
+MAX_LEVERAGE      = 30
 
 
 def _compute_trade_pnl(position: pd.Series, strategy_returns: pd.Series) -> pd.Series:
@@ -67,9 +67,8 @@ def _cross_check_with_vbt(
     close: pd.Series,
     position: pd.Series,
     txn_cost: float,
-    manual_total_return: float,
     freq: str,
-) -> Optional[float]:
+) -> float | None:
     """Run a vectorbt simulation and return its total_return for comparison."""
     if not VBT_AVAILABLE:
         return None
@@ -84,7 +83,8 @@ def _cross_check_with_vbt(
             init_cash=10_000.0,
             freq=freq,
         )
-        return float(pf.total_return())
+        tr = float(pf.total_return())
+        return tr if np.isfinite(tr) else None
     except Exception:
         return None
 
@@ -95,9 +95,9 @@ def backtest_signal(
     txn_cost_bps: float = DEFAULT_TXN_COST_BPS,
     freq: str = "1min",
     bars_per_year: int = DEFAULT_BARS_PER_YEAR,
-    forward_returns: Optional[pd.Series] = None,
+    forward_returns: pd.Series | None = None,
     cross_check: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Run a single-asset backtest from a position signal.
 
@@ -204,7 +204,7 @@ def backtest_signal(
     calmar = ann_return_arith / abs(max_dd) if max_dd < 0 else 0.0
 
     trade_pnl = _compute_trade_pnl(position, strategy_returns)
-    n_trades = int(len(trade_pnl))
+    n_trades = len(trade_pnl)
     n_position_changes = int((position.diff().fillna(0) != 0).sum())
 
     if n_trades > 0:
@@ -216,7 +216,7 @@ def backtest_signal(
         win_rate = 0.0
         profit_factor = 0.0
 
-    ic: Optional[float] = None
+    ic: float | None = None
     if forward_returns is not None:
         fwd = pd.to_numeric(forward_returns, errors="coerce")
         common = signal.index.intersection(fwd.dropna().index)
@@ -227,7 +227,7 @@ def backtest_signal(
                 ic_val = float(s.corr(f))
                 ic = ic_val if np.isfinite(ic_val) else None
 
-    result: Dict[str, Any] = {
+    result: dict[str, Any] = {
         "status": "success",
         "sharpe": sharpe,
         "sortino": sortino,
@@ -244,7 +244,7 @@ def backtest_signal(
         "volatility": volatility,
         "n_trades": n_trades,
         "n_position_changes": n_position_changes,
-        "n_bars": int(len(strategy_returns)),
+        "n_bars": len(strategy_returns),
         "n_months": float(n_months),
         "signal_long": int((signal > 0).sum()),
         "signal_short": int((signal < 0).sum()),
@@ -264,38 +264,41 @@ def backtest_signal(
             close=close,
             position=position,
             txn_cost=txn_cost,
-            manual_total_return=total_return,
             freq=freq,
         )
 
+    from rdagent.components.backtesting.verify import verify_and_log
+
+    verify_and_log(result, factor_name="backtest_signal")
+
     return result
 
 
-def _apply_ftmo_mask(
+def _apply_risk_mask(
     signal: pd.Series,
     close: pd.Series,
     leverage: float,
     txn_cost_bps: float,
 ) -> tuple[pd.Series, dict]:
     """
-    Apply FTMO daily/total loss rules to a signal series.
+    Apply RiskMgmt daily/total loss rules to a signal series.
 
     Returns a masked signal (positions zeroed after each limit breach) and
-    a dict of FTMO compliance metrics.
+    a dict of RiskMgmt compliance metrics.
     """
     txn_cost = txn_cost_bps / 10_000.0
     position = signal.shift(1).fillna(0) * leverage
     bar_ret  = close.pct_change().fillna(0)
 
-    equity   = FTMO_INITIAL_CAPITAL
-    peak_day = FTMO_INITIAL_CAPITAL
+    equity   = INITIAL_CAPITAL
+    peak_day = INITIAL_CAPITAL
     masked   = signal.copy()
 
     daily_breaches = 0
     total_breached = False
-    total_breach_ts: Optional[pd.Timestamp] = None
+    total_breach_ts: pd.Timestamp | None = None
     current_day    = None
-    day_start_eq   = FTMO_INITIAL_CAPITAL
+    day_start_eq   = INITIAL_CAPITAL
 
     pos_prev = 0.0
     for ts, sig_i in signal.items():
@@ -308,42 +311,39 @@ def _apply_ftmo_mask(
         pos_i  = float(signal.at[ts]) * leverage
         ret_i  = float(bar_ret.get(ts, 0.0))
         cost_i = abs(pos_i - pos_prev) * txn_cost
-        ret_net = pos_prev * ret_i - cost_i
-        equity  = equity * (1.0 + ret_net / FTMO_INITIAL_CAPITAL * FTMO_INITIAL_CAPITAL / equity
-                            if equity > 0 else 1.0)
-        # Simpler: track as fraction
-        equity += FTMO_INITIAL_CAPITAL * ret_net
+        ret_frac = pos_prev * ret_i - cost_i
+        equity *= 1.0 + ret_frac if equity > 0 else 1.0
         pos_prev = pos_i
 
         if total_breached:
             masked.at[ts] = 0
             continue
 
-        daily_loss = (equity - day_start_eq) / FTMO_INITIAL_CAPITAL
-        total_loss = (equity - FTMO_INITIAL_CAPITAL) / FTMO_INITIAL_CAPITAL
+        daily_loss = (equity - day_start_eq) / INITIAL_CAPITAL
+        total_loss = (equity - INITIAL_CAPITAL) / INITIAL_CAPITAL
 
-        if daily_loss < -FTMO_MAX_DAILY_LOSS:
+        if daily_loss < -MAX_DAILY_LOSS:
             daily_breaches += 1
             day_start_eq = -999  # block rest of day
             masked.at[ts] = 0
 
-        if total_loss < -FTMO_MAX_TOTAL_LOSS:
+        if total_loss < -MAX_TOTAL_LOSS:
             total_breached = True
             total_breach_ts = ts
             masked.at[ts] = 0
 
     return masked, {
-        "ftmo_daily_breaches": daily_breaches,
-        "ftmo_total_breached": total_breached,
-        "ftmo_total_breach_ts": str(total_breach_ts) if total_breach_ts else None,
-        "ftmo_compliant": not total_breached and daily_breaches == 0,
+        "riskmgmt_daily_breaches": daily_breaches,
+        "riskmgmt_total_breached": total_breached,
+        "riskmgmt_total_breach_ts": str(total_breach_ts) if total_breach_ts else None,
+        "riskmgmt_compliant": not total_breached and daily_breaches == 0,
     }
 
 
 OOS_START_DEFAULT = "2024-01-01"
 
 # Rolling walk-forward default windows (IS years, OOS years, step years)
-WF_IS_YEARS  = 3
+WF_IS_YEARS  = 1
 WF_OOS_YEARS = 1
 WF_STEP_YEARS = 1
 
@@ -399,11 +399,11 @@ def walk_forward_rolling(
     is_years: int = WF_IS_YEARS,
     oos_years: int = WF_OOS_YEARS,
     step_years: int = WF_STEP_YEARS,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Rolling walk-forward validation: multiple IS/OOS windows shifted by ``step_years``.
 
-    Each window runs an independent FTMO simulation on the IS and OOS slices.
+    Each window runs an independent RiskMgmt simulation on the IS and OOS slices.
     Produces aggregate OOS statistics to measure cross-time consistency.
 
     Returns
@@ -433,7 +433,7 @@ def walk_forward_rolling(
             yr += step_years
             continue
 
-        window: Dict[str, Any] = {
+        window: dict[str, Any] = {
             "is_start":  str(is_start.date()),
             "is_end":    str(is_end.date()),
             "oos_start": str(is_end.date()),
@@ -442,7 +442,7 @@ def walk_forward_rolling(
         for mask, prefix in [(is_mask, "is"), (oos_mask, "oos")]:
             close_s  = close.loc[mask]
             signal_s = signal.loc[mask]
-            masked_s, _ = _apply_ftmo_mask(signal_s, close_s, leverage, txn_cost_bps)
+            masked_s, _ = _apply_risk_mask(signal_s, close_s, leverage, txn_cost_bps)
             r = backtest_signal(close=close_s, signal=masked_s,
                                 txn_cost_bps=txn_cost_bps, bars_per_year=bars_per_year)
             window[f"{prefix}_sharpe"]       = r.get("sharpe", 0.0)
@@ -466,30 +466,30 @@ def walk_forward_rolling(
     }
 
 
-def backtest_signal_ftmo(
+def backtest_signal_risk(
     close: pd.Series,
     signal: pd.Series,
     txn_cost_bps: float = DEFAULT_TXN_COST_BPS,
     eurusd_price: float = 1.10,
-    risk_pct: float = FTMO_RISK_PER_TRADE,
-    stop_pips: float = FTMO_STOP_PIPS,
-    max_leverage: float = FTMO_MAX_LEVERAGE,
+    risk_pct: float = RISK_PER_TRADE,
+    stop_pips: float = STOP_PIPS,
+    max_leverage: float = MAX_LEVERAGE,
     bars_per_year: int = DEFAULT_BARS_PER_YEAR,
-    forward_returns: Optional[pd.Series] = None,
-    oos_start: Optional[str] = OOS_START_DEFAULT,
-    wf_rolling: bool = False,
+    forward_returns: pd.Series | None = None,
+    oos_start: str | None = OOS_START_DEFAULT,
+    wf_rolling: bool = True,
     mc_n_permutations: int = 0,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
-    FTMO-compliant backtest of a strategy signal on EUR/USD.
+    RiskMgmt-compliant backtest of a strategy signal on EUR/USD.
 
     Applies on top of ``backtest_signal``:
       - Realistic costs: default 2.14 bps (≈ 2.35 pip spread+slippage+commission)
       - Risk-based position sizing: risk_pct equity per trade, stop_pips hard stop
-      - Max leverage cap: max_leverage (default 1:30, FTMO standard)
-      - FTMO daily loss limit (5%): positions zeroed rest of day after breach
-      - FTMO total loss limit (10%): all positions zeroed after breach
-      - FTMO-specific metrics added to result dict
+      - Max leverage cap: max_leverage (default 1:30, RiskMgmt standard)
+      - RiskMgmt daily loss limit (5%): positions zeroed rest of day after breach
+      - RiskMgmt total loss limit (10%): all positions zeroed after breach
+      - RiskMgmt-specific metrics added to result dict
       - Walk-forward OOS split: IS metrics (before oos_start) + OOS metrics (after)
 
     Parameters
@@ -507,7 +507,7 @@ def backtest_signal_ftmo(
     stop_pips : float
         Hard stop-loss distance in pips (default 10).
     max_leverage : float
-        Maximum leverage (default 30 = FTMO 1:30).
+        Maximum leverage (default 30 = RiskMgmt 1:30).
     oos_start : str or None
         Start of out-of-sample period (ISO date). None disables OOS split.
     wf_rolling : bool
@@ -518,11 +518,11 @@ def backtest_signal_ftmo(
         When > 0, computes ``mc_pvalue``: fraction of permuted sequences whose
         total return >= real total return. p < 0.05 indicates a genuine edge.
     """
-    stop_price = stop_pips * FTMO_PIP
+    stop_price = stop_pips * PIP_SIZE
     leverage_by_risk = risk_pct / (stop_price / eurusd_price)
     leverage = min(leverage_by_risk, max_leverage)
 
-    masked_signal, ftmo_metrics = _apply_ftmo_mask(signal, close, leverage, txn_cost_bps)
+    masked_signal, risk_metrics = _apply_risk_mask(signal, close, leverage, txn_cost_bps)
 
     result = backtest_signal(
         close=close,
@@ -532,14 +532,14 @@ def backtest_signal_ftmo(
         forward_returns=forward_returns,
     )
 
-    result.update(ftmo_metrics)
-    result["ftmo_leverage"] = round(leverage, 2)
-    result["ftmo_risk_pct"] = risk_pct
-    result["ftmo_stop_pips"] = stop_pips
+    result.update(risk_metrics)
+    result["riskmgmt_leverage"] = round(leverage, 2)
+    result["riskmgmt_risk_pct"] = risk_pct
+    result["riskmgmt_stop_pips"] = stop_pips
 
-    # Re-scale reported equity metrics to FTMO_INITIAL_CAPITAL
-    result["ftmo_end_equity"] = FTMO_INITIAL_CAPITAL * (1 + result.get("total_return", 0))
-    result["ftmo_monthly_profit"] = FTMO_INITIAL_CAPITAL * result.get("monthly_return", 0)
+    # Re-scale reported equity metrics to INITIAL_CAPITAL
+    result["riskmgmt_end_equity"] = INITIAL_CAPITAL * (1 + result.get("total_return", 0))
+    result["riskmgmt_monthly_profit"] = INITIAL_CAPITAL * result.get("monthly_return", 0)
 
     # Walk-forward OOS split
     if oos_start is not None:
@@ -547,13 +547,13 @@ def backtest_signal_ftmo(
         is_mask  = close.index < oos_ts
         oos_mask = close.index >= oos_ts
 
-        def _split_bt(mask: "pd.Series[bool]", prefix: str) -> None:
+        def _split_bt(mask: pd.Series[bool], prefix: str) -> None:
             if mask.sum() < 100:
                 return
             close_s  = close.loc[mask]
-            signal_s = signal.loc[mask]  # raw signal, not masked — fresh FTMO sim per period
+            signal_s = signal.loc[mask]  # raw signal, not masked — fresh RiskMgmt sim per period
             fwd_split = forward_returns.loc[mask] if forward_returns is not None else None
-            masked_s, _ = _apply_ftmo_mask(signal_s, close_s, leverage, txn_cost_bps)
+            masked_s, _ = _apply_risk_mask(signal_s, close_s, leverage, txn_cost_bps)
             split_result = backtest_signal(
                 close=close_s,
                 signal=masked_s,
@@ -594,6 +594,10 @@ def backtest_signal_ftmo(
         result["mc_pvalue"]        = monte_carlo_trade_pvalue(trade_pnl, mc_n_permutations)
         result["mc_n_permutations"] = mc_n_permutations
 
+    from rdagent.components.backtesting.verify import verify_and_log
+
+    verify_and_log(result, factor_name="backtest_from_forward_returns")
+
     return result
 
 
@@ -602,7 +606,7 @@ def backtest_from_forward_returns(
     forward_returns: pd.Series,
     txn_cost_bps: float = DEFAULT_TXN_COST_BPS,
     bars_per_year: int = DEFAULT_BARS_PER_YEAR,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Backtest a factor using sign(factor) as signal against forward returns.
 
@@ -640,7 +644,7 @@ def backtest_from_forward_returns(
     ic = ic_val if np.isfinite(ic_val) else 0.0
 
     trade_pnl = _compute_trade_pnl(position, strategy_returns)
-    n_trades = int(len(trade_pnl))
+    n_trades = len(trade_pnl)
     win_rate = float((trade_pnl > 0).mean()) if n_trades > 0 else 0.0
 
     ann_return = float(strategy_returns.mean() * bars_per_year)
@@ -656,7 +660,7 @@ def backtest_from_forward_returns(
         "win_rate": win_rate,
         "n_trades": n_trades,
         "ic": ic,
-        "n_bars": int(len(strategy_returns)),
+        "n_bars": len(strategy_returns),
         "txn_cost_bps": txn_cost_bps,
         "bars_per_year": bars_per_year,
     }

rdagent/components/backtesting/verify.py

@@ -0,0 +1,112 @@
+"""Runtime backtest verification — fast sanity checks for every backtest result.
+
+These checks run in <1ms and catch corrupted/flipped/missing metrics before they
+propagate into the factor database.  Called automatically by backtest_signal()
+and backtest_from_forward_returns().
+
+The same invariants are covered by 477 unit tests in test/qlib/.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+REQUIRED_KEYS = [
+    "sharpe",
+    "max_drawdown",
+    "win_rate",
+    "total_return",
+    "annual_return_pct",
+    "monthly_return_pct",
+    "n_trades",
+    "status",
+]
+
+
+def verify_backtest_result(result: dict) -> list[str]:
+    """Run fast mathematical-invariant checks on a backtest result dict.
+
+    Returns a list of warning strings (empty = all good).
+
+    Parameters
+    ----------
+    result : dict
+        Output of ``backtest_signal()`` or ``backtest_from_forward_returns()``.
+
+    Returns
+    -------
+    list[str]
+        Warning messages for any failed check.
+    """
+    warnings: list[str] = []
+
+    # ── 1. Required keys present ──
+    for key in REQUIRED_KEYS:
+        if key not in result:
+            warnings.append(f"Missing key: {key}")
+            return warnings  # can't check further
+
+    # ── 2. MaxDD must be in [-1, 0] ──
+    mdd = result["max_drawdown"]
+    if not (-1.0 <= mdd <= 0.0):
+        warnings.append(f"max_drawdown {mdd:.4f} outside valid range [-1, 0]")
+
+    # ── 3. Win rate in [0, 1] ──
+    wr = result["win_rate"]
+    if not (0.0 <= wr <= 1.0):
+        warnings.append(f"win_rate {wr:.4f} outside valid range [0, 1]")
+
+    # ── 4. Sharpe must be finite ──
+    sharpe = result["sharpe"]
+    if not np.isfinite(sharpe):
+        warnings.append(f"sharpe is not finite: {sharpe}")
+
+    # ── 5. total_return finite ──
+    tr = result["total_return"]
+    if not np.isfinite(tr):
+        warnings.append(f"total_return is not finite: {tr}")
+
+    # ── 6. n_trades >= 0 ──
+    nt = result["n_trades"]
+    if nt < 0:
+        warnings.append(f"n_trades is negative: {nt}")
+
+    # ── 7. Annual return consistent with total return ──
+    ar = result["annual_return_pct"]
+    if not np.isfinite(ar):
+        warnings.append(f"annual_return_pct is not finite: {ar}")
+
+    # ── 8. Monthly return consistent with total return ──
+    mr = result["monthly_return_pct"]
+    if mr is not None and not np.isfinite(mr):
+        warnings.append(f"monthly_return_pct is not finite: {mr}")
+
+    # ── 9. Sharpe sign matches annual return sign (with 0-cost approximation) ──
+    if abs(sharpe) > 0.01 and abs(ar) > 0.01:
+        if np.sign(sharpe) != np.sign(ar):
+            warnings.append(
+                f"Sharpe ({sharpe:.4f}) and annual_return_pct ({ar:.4f}) have opposite signs"
+            )
+
+    # ── 10. status must be 'success' or 'failed' ──
+    if result["status"] not in ("success", "failed"):
+        warnings.append(f"status is not 'success' or 'failed': {result['status']}")
+
+    return warnings
+
+
+def verify_and_log(result: dict, factor_name: str = "unknown") -> bool:
+    """Verify backtest result and log any warnings.
+
+    Returns True if all checks passed.
+    """
+    warnings = verify_backtest_result(result)
+    if warnings:
+        for w in warnings:
+            logger.warning(f"[BacktestVerify] [{factor_name[:60]}] {w}")
+        return False
+    return True

rdagent/components/coder/factor_coder/auto_fixer.py

@@ -1,5 +1,5 @@
 """
-Predix Factor Auto-Fixer - Automatically patches common factor code issues.
+NexQuant Factor Auto-Fixer - Automatically patches common factor code issues.
 
 This module intercepts LLM-generated factor code and automatically fixes known problems:
 1. min_periods mismatch in rolling window calculations
@@ -68,6 +68,7 @@ class FactorAutoFixer:
             self._fix_inf_nan_handling,             # Tenth: add inf/nan handling
             self._fix_data_range_processing,        # Eleventh: ensure full data range
             self._fix_multiindex_groupby,           # Twelfth: ensure groupby on MultiIndex
+            self._fix_composite_normalization,      # Thirteenth: normalize thresholds + composite variance
         ]
 
         for fix_method in fix_methods:
@@ -85,6 +86,24 @@ class FactorAutoFixer:
 
         return fixed_code
 
+    def _fix_composite_normalization(self, code: str) -> str:
+        """Normalize strategy code: cap thresholds, limit windows, normalize composite."""
+        code = re.sub(r'\bentry_thresh\s*=\s*([0-9.]+)',
+                      lambda m: f'entry_thresh = {min(float(m.group(1)), 0.7):.1f}', code)
+        code = re.sub(r'\bexit_thresh\s*=\s*([0-9.]+)',
+                      lambda m: f'exit_thresh = {min(float(m.group(1)), 0.3):.1f}', code)
+        code = re.sub(r'\bwindow\s*=\s*(\d+)',
+                      lambda m: f'window = {min(int(m.group(1)), 20)}', code)
+        code = re.sub(r'(signal\s*=\s*signal\s*\.\s*rolling\s*\()(\d+)',
+                      lambda m: f'{m.group(1)}{min(int(m.group(2)), 2)}', code)
+        if 'composite' in code and 'composite = (composite' not in code:
+            code = re.sub(
+                r'\n(signal\s*=\s*pd\.Series)',
+                r'\ncomposite = (composite - composite.rolling(20).mean()) / (composite.rolling(20).std() + 1e-8)\n\n\1',
+                code, count=1,
+            )
+        return code
+
     def _fix_instrument_column_access(self, code: str) -> str:
         """
         Fix: df['instrument'] raises KeyError on a MultiIndex DataFrame because

rdagent/components/coder/factor_coder/eva_utils.py

@@ -328,12 +328,13 @@ class FactorEqualValueRatioEvaluator(FactorEvaluator):
                 "The source dataframe is None. Please check the implementation.",
                 -1,
             )
+        acc_rate = -1
         try:
             close_values = gen_df.sub(gt_df).abs().lt(1e-6)
             result_int = close_values.astype(int)
             pos_num = result_int.sum().sum()
             acc_rate = pos_num / close_values.size
-        except:
+        except Exception:
             close_values = gen_df
         if close_values.all().iloc[0]:
             return (

rdagent/components/coder/kronos_adapter.py

@@ -1,5 +1,5 @@
 """
-Kronos Foundation Model Adapter for Predix.
+Kronos Foundation Model Adapter for NexQuant.
 
 Wraps the Kronos-mini OHLCV foundation model (4.1M params, AAAI 2026, MIT)
 for use as:
@@ -55,8 +55,8 @@ def _ensure_kronos() -> bool:
     return _KRONOS_AVAILABLE
 
 
-def _ohlcv_from_predix(df: pd.DataFrame) -> pd.DataFrame:
-    """Convert Predix HDF5 format ($open/$close/...) to Kronos format (open/close/...)."""
+def _ohlcv_from_nexquant(df: pd.DataFrame) -> pd.DataFrame:
+    """Convert NexQuant HDF5 format ($open/$close/...) to Kronos format (open/close/...)."""
     col_map = {"$open": "open", "$high": "high", "$low": "low", "$close": "close", "$volume": "volume"}
     renamed = df.rename(columns=col_map)
     cols = [c for c in ["open", "high", "low", "close", "volume"] if c in renamed.columns]
@@ -90,9 +90,19 @@ class KronosAdapter:
     MODEL_ID = "NeoQuasar/Kronos-mini"
     TOKENIZER_ID = "NeoQuasar/Kronos-Tokenizer-2k"
 
-    def __init__(self, device: Optional[str] = None, max_context: int = 512):
-        self.device = device or ("cuda" if _cuda_available() else "cpu")
+    # Mapping for larger Kronos variants
+    _MODEL_MAP = {
+        "mini": ("NeoQuasar/Kronos-mini", "NeoQuasar/Kronos-Tokenizer-2k"),
+        "small": ("NeoQuasar/Kronos-small", "NeoQuasar/Kronos-Tokenizer-base"),
+        "base": ("NeoQuasar/Kronos-base", "NeoQuasar/Kronos-Tokenizer-base"),
+    }
+
+    def __init__(self, device: Optional[str] = None, max_context: int = 512, model_size: str = "mini"):
+        self.device = device or "cpu"
         self.max_context = max_context
+        self.model_size = model_size
+        if model_size in self._MODEL_MAP:
+            self.MODEL_ID, self.TOKENIZER_ID = self._MODEL_MAP[model_size]
         self._predictor = None
 
     def load(self) -> "KronosAdapter":
@@ -102,11 +112,11 @@ class KronosAdapter:
             raise RuntimeError("Kronos not available — see warning above.")
         from model import Kronos, KronosTokenizer, KronosPredictor  # type: ignore
 
-        logger.info(f"Loading Kronos-mini from HuggingFace ({self.MODEL_ID})...")
+        logger.info(f"Loading Kronos-{self.model_size} from HuggingFace ({self.MODEL_ID})...")
         tokenizer = KronosTokenizer.from_pretrained(self.TOKENIZER_ID)
         model = Kronos.from_pretrained(self.MODEL_ID)
+        logger.info(f"Kronos-{self.model_size} loaded.")
         self._predictor = KronosPredictor(model, tokenizer, device=self.device, max_context=self.max_context)
-        logger.info("Kronos-mini loaded.")
         return self
 
     def predict_next_bars(
@@ -223,6 +233,7 @@ def build_kronos_factor(
     stride_bars: int = 96,
     device: Optional[str] = None,
     batch_size: int = 32,
+    model_size: str = "mini",
 ) -> pd.DataFrame:
     """
     Generate the Kronos predicted-return factor for all EUR/USD 1-min bars.
@@ -236,15 +247,15 @@ def build_kronos_factor(
     Returns:
         MultiIndex (datetime, instrument) DataFrame with column "KronosPredReturn".
     """
-    device = device or ("cuda" if _cuda_available() else "cpu")
+    device = device or "cpu"
     logger.info(f"Loading data from {hdf5_path}...")
     raw = pd.read_hdf(hdf5_path, key="data")
 
     instrument = raw.index.get_level_values("instrument").unique()[0]
     df = raw.xs(instrument, level="instrument")
-    ohlcv = _ohlcv_from_predix(df)
+    ohlcv = _ohlcv_from_nexquant(df)
 
-    adapter = KronosAdapter(device=device, max_context=min(context_bars, 512))
+    adapter = KronosAdapter(device=device, max_context=min(context_bars, 512), model_size=model_size)
     adapter.load()
 
     bar_indices = list(range(context_bars, len(ohlcv), stride_bars))
@@ -302,6 +313,7 @@ def evaluate_kronos_model(
     stride_bars: int = 30,
     device: Optional[str] = None,
     batch_size: int = 32,
+    model_size: str = "mini",
 ) -> dict:
     """
     Evaluate Kronos as a standalone model (Option B, alongside LightGBM).
@@ -312,13 +324,13 @@ def evaluate_kronos_model(
     Returns:
         dict with keys: IC_mean, IC_std, IC_IR (IC / std), hit_rate, n_predictions
     """
-    device = device or ("cuda" if _cuda_available() else "cpu")
+    device = device or "cpu"
     raw = pd.read_hdf(hdf5_path, key="data")
     instrument = raw.index.get_level_values("instrument").unique()[0]
     df = raw.xs(instrument, level="instrument")
-    ohlcv = _ohlcv_from_predix(df)
+    ohlcv = _ohlcv_from_nexquant(df)
 
-    adapter = KronosAdapter(device=device, max_context=min(context_bars, 512))
+    adapter = KronosAdapter(device=device, max_context=min(context_bars, 512), model_size=model_size)
     adapter.load()
 
     n = len(ohlcv)

rdagent/components/coder/optuna_optimizer.py

@@ -1,699 +0,0 @@
-"""
-Predix Optuna Optimizer - Hyperparameter optimization for trading strategies.
-
-This module:
-1. Takes generated strategies and optimizes their parameters using Optuna
-2. Searches for optimal entry/exit thresholds, position sizing, etc.
-3. Validates optimized strategies to prevent overfitting
-4. Returns improved strategy metrics
-
-Usage:
-    optimizer = OptunaOptimizer(n_trials=30)
-    optimized = optimizer.optimize_strategy(strategy_result, factor_values)
-"""
-
-import logging
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-import numpy as np
-import pandas as pd
-
-from rdagent.log import rdagent_logger as logger
-
-logger = logging.getLogger(__name__)
-
-try:
-    import optuna
-    OPTUNA_AVAILABLE = True
-except ImportError:
-    OPTUNA_AVAILABLE = False
-    logger.warning("Optuna not installed. Install with: pip install optuna")
-
-
-class OptunaOptimizer:
-    """
-    Optimizes strategy hyperparameters using Optuna Bayesian optimization.
-
-    Optimizes:
-    - Entry/exit signal thresholds
-    - Position sizing parameters
-    - Rolling window sizes
-    - Risk management parameters
-    """
-
-    def __init__(
-        self,
-        n_trials: int = 30,
-        timeout: Optional[int] = None,
-        n_jobs: int = 1,
-        optimization_metric: str = "sharpe",
-        results_dir: Optional[str] = None,
-    ):
-        """
-        Parameters
-        ----------
-        n_trials : int
-            Number of Optuna trials for optimization
-        timeout : int, optional
-            Maximum optimization time in seconds
-        n_jobs : int
-            Number of parallel jobs (-1 = all cores)
-        optimization_metric : str
-            Metric to optimize: 'sharpe', 'sortino', 'calmar', 'omega'
-        results_dir : str, optional
-            Path to save optimization results
-        """
-        if not OPTUNA_AVAILABLE:
-            raise ImportError("Optuna is required. Install with: pip install optuna")
-
-        self.n_trials = n_trials
-        self.timeout = timeout
-        self.n_jobs = n_jobs
-        self.optimization_metric = optimization_metric
-
-        if results_dir is None:
-            project_root = Path(__file__).parent.parent.parent.parent
-            self.results_dir = project_root / "results"
-        else:
-            self.results_dir = Path(results_dir)
-
-        self.optimization_dir = self.results_dir / "optimization"
-        self.optimization_dir.mkdir(parents=True, exist_ok=True)
-
-        logger.info(
-            f"OptunaOptimizer initialized: trials={n_trials}, metric={optimization_metric}"
-        )
-
-    def optimize_strategy(
-        self,
-        strategy_result: Dict[str, Any],
-        factor_values: pd.DataFrame,
-        forward_returns: Optional[pd.Series] = None,
-    ) -> Dict[str, Any]:
-        """
-        Optimiere eine einzelne Strategie mit mehrstufiger Suche (grob → fein).
-
-        STAGE 1: Grobe Suche mit weiten Bereichen (10 Trials)
-        STAGE 2: Feine Suche um die besten Stage-1-Parameter (15 Trials)
-        STAGE 3: Sehr feine lokale Suche (5 Trials)
-
-        Parameters
-        ----------
-        strategy_result : Dict[str, Any]
-            Strategy result from StrategyOrchestrator
-        factor_values : pd.DataFrame
-            DataFrame with factor values over time
-        forward_returns : pd.Series, optional
-            Forward returns for evaluation
-
-        Returns
-        -------
-        Dict[str, Any]
-            Optimized strategy result with best parameters
-        """
-        strategy_name = strategy_result.get("strategy_name", "Unknown")
-        logger.info(f"Starting multi-stage optimization for strategy: {strategy_name}")
-
-        # Speichere Referenzen für Objective-Methoden
-        self._current_strategy = strategy_result
-        self._current_factors = factor_values
-        self._current_forward_returns = forward_returns
-
-        # STAGE 1: Grobe Suche mit weiten Bereichen (10 Trials)
-        logger.info(f"Stage 1: Coarse search for {strategy_name}")
-        stage1_study = optuna.create_study(
-            direction="maximize",
-            sampler=optuna.samplers.TPESampler(seed=42),
-            pruner=optuna.pruners.MedianPruner(n_startup_trials=3, n_warmup_steps=5),
-        )
-        stage1_study.optimize(self._objective_coarse, n_trials=10, gc_after_trial=True)
-
-        best_stage1 = stage1_study.best_trial.params
-        best_stage1_value = stage1_study.best_trial.value
-        logger.info(
-            f"Stage 1 complete: best_value={best_stage1_value:.4f}, "
-            f"params={best_stage1}"
-        )
-
-        # STAGE 2: Feine Suche um die besten Stage-1-Parameter (15 Trials)
-        logger.info(f"Stage 2: Fine search around best params")
-        stage2_study = optuna.create_study(
-            direction="maximize",
-            sampler=optuna.samplers.TPESampler(seed=43),
-            pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=5),
-        )
-        # Verwende beste Stage-1-Parameter als Zentrum für feine Suche
-        self._fine_search_center = best_stage1
-        stage2_study.optimize(self._objective_fine, n_trials=15, gc_after_trial=True)
-
-        best_stage2 = stage2_study.best_trial.params
-        best_stage2_value = stage2_study.best_trial.value
-        logger.info(
-            f"Stage 2 complete: best_value={best_stage2_value:.4f}, "
-            f"params={best_stage2}"
-        )
-
-        # STAGE 3: Sehr feine lokale Suche (5 Trials) - nur wenn Stage 2 besser war
-        if best_stage2_value > best_stage1_value:
-            logger.info(f"Stage 3: Very fine local search")
-            stage3_study = optuna.create_study(
-                direction="maximize",
-                sampler=optuna.samplers.TPESampler(seed=44),
-            )
-            self._very_fine_center = best_stage2
-            stage3_study.optimize(self._objective_very_fine, n_trials=5, gc_after_trial=True)
-
-            best_stage3_value = stage3_study.best_trial.value
-            logger.info(f"Stage 3 complete: best_value={best_stage3_value:.4f}")
-
-            # Bestes Trial über alle Stufen wählen
-            if best_stage3_value > best_stage2_value:
-                best_trial = stage3_study.best_trial
-            else:
-                best_trial = stage2_study.best_trial
-        else:
-            best_trial = stage1_study.best_trial
-
-        # Re-evaluate with best params
-        best_params = best_trial.params
-        best_metrics = self._evaluate_with_params(
-            strategy_result, factor_values, best_params, forward_returns
-        )
-
-        # Baue optimiertes Ergebnis
-        optimized_result = {
-            **strategy_result,
-            "status": "accepted" if self._is_acceptable(best_metrics) else "rejected",
-            "sharpe_ratio": best_metrics.get("sharpe_ratio", 0),
-            "annualized_return": best_metrics.get("annualized_return", 0),
-            "max_drawdown": best_metrics.get("max_drawdown", 0),
-            "win_rate": best_metrics.get("win_rate", 0),
-            "optimization_status": "success",
-            "best_params": best_params,
-            "optimization_stages": {
-                "stage1_best": best_stage1_value,
-                "stage2_best": best_stage2_value,
-                "stage3_best": best_stage3_value if best_stage2_value > best_stage1_value else None,
-            },
-            "optimization_trials": len(stage1_study.trials) + len(stage2_study.trials) + (
-                len(stage3_study.trials) if best_stage2_value > best_stage1_value else 0
-            ),
-            "optimization_history": {
-                "stage1": [t.value for t in stage1_study.trials if t.value is not None],
-                "stage2": [t.value for t in stage2_study.trials if t.value is not None],
-                "stage3": (
-                    [t.value for t in stage3_study.trials if t.value is not None]
-                    if best_stage2_value > best_stage1_value else []
-                ),
-            },
-            "optimized_at": datetime.now().isoformat(),
-        }
-
-        # Speichere Optimierungsergebnisse
-        self._save_optimization_results(optimized_result, strategy_name)
-
-        logger.info(
-            f"Multi-stage optimization complete for {strategy_name}: "
-            f"best_metric={best_trial.value:.4f}, status={optimized_result['status']}"
-        )
-
-        return optimized_result
-
-    def optimize_batch(
-        self,
-        strategies: List[Dict[str, Any]],
-        factor_values: pd.DataFrame,
-        forward_returns: Optional[pd.Series] = None,
-        progress_callback=None,
-    ) -> List[Dict[str, Any]]:
-        """
-        Optimize multiple strategies in batch.
-
-        Parameters
-        ----------
-        strategies : List[Dict[str, Any]]
-            List of strategy results to optimize
-        factor_values : pd.DataFrame
-            Factor values for all strategies
-        forward_returns : pd.Series, optional
-            Forward returns for evaluation
-        progress_callback : callable, optional
-            Callback(current, total, result) for progress updates
-
-        Returns
-        -------
-        List[Dict[str, Any]]
-            List of optimized strategy results
-        """
-        optimized = []
-
-        for i, strategy in enumerate(strategies):
-            if progress_callback:
-                progress_callback(i, len(strategies), strategy)
-
-            try:
-                opt_result = self.optimize_strategy(strategy, factor_values, forward_returns)
-                optimized.append(opt_result)
-            except Exception as e:
-                logger.error(f"Failed to optimize strategy {strategy.get('strategy_name', i)}: {e}")
-                optimized.append({
-                    **strategy,
-                    "optimization_status": "failed",
-                    "error": str(e),
-                })
-
-        return optimized
-
-    def _sample_coarse_params(self, trial: optuna.Trial) -> Dict[str, Any]:
-        """
-        Weite Bereiche für initiale Exploration (Stage 1).
-
-        Parameters
-        ----------
-        trial : optuna.Trial
-            Current Optuna trial
-
-        Returns
-        -------
-        Dict[str, Any]
-            Sampled hyperparameters with wide ranges
-        """
-        return {
-            "entry_threshold": trial.suggest_float("entry_threshold", 0.1, 3.0, step=0.1),
-            "exit_threshold": trial.suggest_float("exit_threshold", 0.0, 1.5, step=0.1),
-            "zscore_window": trial.suggest_int("zscore_window", 5, 500, step=5),
-            "signal_window": trial.suggest_int("signal_window", 1, 30, step=1),
-            "position_size_pct": trial.suggest_float("position_size_pct", 0.05, 1.0, step=0.05),
-            "stop_loss_mult": trial.suggest_float("stop_loss_mult", 0.5, 15.0, step=0.5),
-            "take_profit_mult": trial.suggest_float("take_profit_mult", 1.0, 20.0, step=0.5),
-            "volatility_lookback": trial.suggest_int("volatility_lookback", 5, 500, step=5),
-            "signal_bias": trial.suggest_float("signal_bias", -1.0, 1.0, step=0.05),
-            "max_hold_bars": trial.suggest_int("max_hold_bars", 5, 1000, step=5),
-        }
-
-    # Parameters that are allowed to be negative (not clamped to 0).
-    _SIGNED_PARAMS = {"signal_bias"}
-    # Absolute lower bounds per parameter (applied after the center-half_width calc).
-    _PARAM_FLOOR: Dict[str, float] = {
-        "entry_threshold": 0.0,
-        "exit_threshold": 0.0,
-        "zscore_window": 1.0,
-        "signal_window": 1.0,
-        "position_size_pct": 0.01,
-        "stop_loss_mult": 0.1,
-        "take_profit_mult": 0.1,
-        "volatility_lookback": 1.0,
-        "signal_bias": -1.0,
-        "max_hold_bars": 1.0,
-    }
-
-    def _suggest_bounded(
-        self,
-        trial: optuna.Trial,
-        key: str,
-        center_val: float,
-        half_width: float,
-    ) -> Any:
-        """Suggest a parameter value with safe bounds that never invert."""
-        floor = self._PARAM_FLOOR.get(key, -float("inf"))
-        is_int = "window" in key or "lookback" in key or "bars" in key
-        if is_int:
-            low = max(int(floor), int(center_val - half_width))
-            high = max(low + 1, int(center_val + half_width))
-            return trial.suggest_int(key, low, high)
-        else:
-            low = max(floor, center_val - half_width)
-            high = center_val + half_width
-            if high <= low:
-                high = low + max(1e-4, half_width * 0.1)
-            return trial.suggest_float(key, low, high)
-
-    def _sample_fine_params(self, trial: optuna.Trial) -> Dict[str, Any]:
-        """
-        Enge Bereiche zentriert um die besten Stage-1-Parameter (Stage 2).
-
-        Parameters
-        ----------
-        trial : optuna.Trial
-            Current Optuna trial
-
-        Returns
-        -------
-        Dict[str, Any]
-            Sampled hyperparameters with narrow ranges around Stage 1 best
-        """
-        center = getattr(self, "_fine_search_center", {})
-        ranges: Dict[str, Tuple[float, float]] = {
-            "entry_threshold": (center.get("entry_threshold", 1.0), 0.3),
-            "exit_threshold": (center.get("exit_threshold", 0.3), 0.2),
-            "zscore_window": (center.get("zscore_window", 50), 20),
-            "signal_window": (center.get("signal_window", 3), 5),
-            "position_size_pct": (center.get("position_size_pct", 0.5), 0.15),
-            "stop_loss_mult": (center.get("stop_loss_mult", 5.0), 2.0),
-            "take_profit_mult": (center.get("take_profit_mult", 5.0), 2.0),
-            "volatility_lookback": (center.get("volatility_lookback", 100), 30),
-            "signal_bias": (center.get("signal_bias", 0.0), 0.2),
-            "max_hold_bars": (center.get("max_hold_bars", 100), 50),
-        }
-        return {key: self._suggest_bounded(trial, key, c, hw) for key, (c, hw) in ranges.items()}
-
-    def _sample_very_fine_params(self, trial: optuna.Trial) -> Dict[str, Any]:
-        """
-        Sehr enge Bereiche für finale Verfeinerung (Stage 3).
-
-        Parameters
-        ----------
-        trial : optuna.Trial
-            Current Optuna trial
-
-        Returns
-        -------
-        Dict[str, Any]
-            Sampled hyperparameters with very narrow ranges around Stage 2 best
-        """
-        center = getattr(
-            self, "_very_fine_center", getattr(self, "_fine_search_center", {})
-        )
-        ranges: Dict[str, Tuple[float, float]] = {
-            "entry_threshold": (center.get("entry_threshold", 1.0), 0.1),
-            "exit_threshold": (center.get("exit_threshold", 0.3), 0.07),
-            "zscore_window": (center.get("zscore_window", 50), 7),
-            "signal_window": (center.get("signal_window", 3), 2),
-            "position_size_pct": (center.get("position_size_pct", 0.5), 0.05),
-            "stop_loss_mult": (center.get("stop_loss_mult", 5.0), 0.7),
-            "take_profit_mult": (center.get("take_profit_mult", 5.0), 0.7),
-            "volatility_lookback": (center.get("volatility_lookback", 100), 10),
-            "signal_bias": (center.get("signal_bias", 0.0), 0.07),
-            "max_hold_bars": (center.get("max_hold_bars", 100), 17),
-        }
-        return {key: self._suggest_bounded(trial, key, c, hw) for key, (c, hw) in ranges.items()}
-
-    def _objective_coarse(self, trial: optuna.Trial) -> float:
-        """Objective-Funktion für Stage 1 (grobe Suche)."""
-        try:
-            params = self._sample_coarse_params(trial)
-            metrics = self._evaluate_with_params(
-                self._current_strategy, self._current_factors, params, self._current_forward_returns
-            )
-            return self._extract_metric(metrics, self.optimization_metric)
-        except Exception as e:
-            logger.warning(f"Stage 1 trial {trial.number} failed: {e}")
-            return float("-inf")
-
-    def _objective_fine(self, trial: optuna.Trial) -> float:
-        """Objective-Funktion für Stage 2 (feine Suche)."""
-        try:
-            params = self._sample_fine_params(trial)
-            metrics = self._evaluate_with_params(
-                self._current_strategy, self._current_factors, params, self._current_forward_returns
-            )
-            return self._extract_metric(metrics, self.optimization_metric)
-        except Exception as e:
-            logger.warning(f"Stage 2 trial {trial.number} failed: {e}")
-            return float("-inf")
-
-    def _objective_very_fine(self, trial: optuna.Trial) -> float:
-        """Objective-Funktion für Stage 3 (sehr feine Suche)."""
-        try:
-            params = self._sample_very_fine_params(trial)
-            metrics = self._evaluate_with_params(
-                self._current_strategy, self._current_factors, params, self._current_forward_returns
-            )
-            return self._extract_metric(metrics, self.optimization_metric)
-        except Exception as e:
-            logger.warning(f"Stage 3 trial {trial.number} failed: {e}")
-            return float("-inf")
-
-    def _sample_hyperparameters(self, trial: optuna.Trial) -> Dict[str, Any]:
-        """
-        Sample hyperparameters for a trial.
-
-        Parameters
-        ----------
-        trial : optuna.Trial
-            Current Optuna trial
-
-        Returns
-        -------
-        Dict[str, Any]
-            Sampled hyperparameters
-        """
-        params = {
-            # Entry/exit thresholds (wider range for better optimization)
-            "entry_threshold": trial.suggest_float("entry_threshold", 0.3, 2.0, step=0.1),
-            "exit_threshold": trial.suggest_float("exit_threshold", 0.0, 1.0, step=0.1),
-
-            # Rolling window for z-score normalization
-            "zscore_window": trial.suggest_int("zscore_window", 10, 200, step=10),
-
-            # Rolling window for signal smoothing
-            "signal_window": trial.suggest_int("signal_window", 1, 15, step=1),
-
-            # Position sizing
-            "position_size_pct": trial.suggest_float("position_size_pct", 0.1, 1.0, step=0.1),
-
-            # Stop loss / take profit (in terms of factor std)
-            "stop_loss_mult": trial.suggest_float("stop_loss_mult", 1.0, 10.0, step=0.5),
-            "take_profit_mult": trial.suggest_float("take_profit_mult", 1.5, 15.0, step=0.5),
-
-            # Volatility adjustment
-            "volatility_lookback": trial.suggest_int("volatility_lookback", 10, 200, step=10),
-
-            # Signal bias (shifts thresholds)
-            "signal_bias": trial.suggest_float("signal_bias", -0.5, 0.5, step=0.1),
-
-            # Max holding periods (in bars)
-            "max_hold_bars": trial.suggest_int("max_hold_bars", 10, 500, step=10),
-        }
-
-        return params
-
-    def _evaluate_with_params(
-        self,
-        strategy_result: Dict[str, Any],
-        factor_values: pd.DataFrame,
-        params: Dict[str, Any],
-        forward_returns: Optional[pd.Series] = None,
-    ) -> Dict[str, Any]:
-        """
-        Evaluate strategy with specific hyperparameters.
-
-        This method:
-        1. Uses the ORIGINAL strategy code from the LLM
-        2. Overrides key parameters (thresholds, windows) via exec
-        3. Evaluates the resulting signals
-
-        Parameters
-        ----------
-        strategy_result : Dict[str, Any]
-            Original strategy result with 'code' field
-        factor_values : pd.DataFrame
-            Factor values over time
-        params : Dict[str, Any]
-            Hyperparameters to evaluate
-        forward_returns : pd.Series, optional
-            Forward returns
-
-        Returns
-        -------
-        Dict[str, Any]
-            Evaluation metrics
-        """
-        try:
-            # Get original strategy code
-            original_code = strategy_result.get("code", "")
-
-            # Get factor weights if available
-            factors_used = strategy_result.get("factors_used", list(factor_values.columns))
-            available_factors = [f for f in factors_used if f in factor_values.columns]
-
-            if not available_factors:
-                return self._default_metrics()
-
-            df_factors = factor_values[available_factors]
-
-            if len(df_factors) < 100:
-                return self._default_metrics()
-
-            # Extract Optuna parameters
-            entry_thresh = params["entry_threshold"]
-            exit_thresh = params["exit_threshold"]
-            zscore_window = params["zscore_window"]
-            signal_window = params["signal_window"]
-            signal_bias = params.get("signal_bias", 0.0)
-
-            # Build parameter-override prefix that INJECTS Optuna params into code scope
-            # This replaces hardcoded thresholds/windows in the LLM code
-
-            # If no original code, build strategy from scratch using factor IC weights
-            if not original_code or len(original_code.strip()) < 20:
-                df_norm = (df_factors - df_factors.rolling(zscore_window).mean()) / (df_factors.rolling(zscore_window).std() + 1e-8)
-
-                ic_weights = strategy_result.get("ic_weights", [])
-                if len(ic_weights) == len(available_factors):
-                    weighted_sum = sum(
-                        w * df_norm[col] for col, w in zip(available_factors, ic_weights)
-                    )
-                else:
-                    weighted_sum = df_norm.mean(axis=1)
-
-                signal = pd.Series(0.0, index=df_factors.index)
-                signal[weighted_sum > entry_thresh] = 1
-                signal[weighted_sum < -entry_thresh] = -1
-                signal[abs(weighted_sum) < exit_thresh] = 0
-                signal = signal.rolling(window=signal_window, min_periods=1).mean().round().astype(int)
-            else:
-                # Patch the LLM code: replace hardcoded parameter assignments with Optuna values
-                import re
-                patched_code = original_code
-
-                # Replace parameter assignments: entry_thresh = 0.8 → entry_thresh = 1.2
-                param_patterns = [
-                    (r'entry_thresh\s*=\s*[\d.]+', f'entry_thresh = {entry_thresh}'),
-                    (r'exit_thresh\s*=\s*[\d.]+', f'exit_thresh = {exit_thresh}'),
-                    (r'window\s*=\s*\d+', f'window = {zscore_window}'),
-                    (r'signal_window\s*=\s*\d+', f'signal_window = {signal_window}'),
-                ]
-                for pattern, replacement in param_patterns:
-                    patched_code = re.sub(pattern, replacement, patched_code)
-
-                # Also handle inline .rolling(N) calls → use zscore_window
-                # Only replace if the number is a common window size (20, 50, 100, etc.)
-                rolling_pattern = r'\.rolling\((\d+)\)'
-                def replace_rolling(match):
-                    val = int(match.group(1))
-                    if val in (20, 30, 50, 100, 200):
-                        return f'.rolling({zscore_window})'
-                    return match.group(0)
-                patched_code = re.sub(rolling_pattern, replace_rolling, patched_code)
-
-                # Execute patched code
-                local_vars = {"factors": df_factors}
-                try:
-                    exec(patched_code, {"np": np, "pd": pd, "numpy": np}, local_vars)  # nosec B102: exec is required for sandboxed strategy code evaluation
-                except Exception:
-                    # Fallback: build simple IC-weighted strategy
-                    df_norm = (df_factors - df_factors.rolling(zscore_window).mean()) / (df_factors.rolling(zscore_window).std() + 1e-8)
-                    combined = df_norm.mean(axis=1)
-                    signal = pd.Series(0, index=combined.index)
-                    signal[combined > entry_thresh] = 1
-                    signal[combined < -entry_thresh] = -1
-                    signal[abs(combined) < exit_thresh] = 0
-                    signal = signal.rolling(window=signal_window, min_periods=1).mean().round().astype(int)
-                    local_vars["signal"] = signal
-
-                signal = local_vars.get("signal")
-
-            if signal is None or len(signal) < 10:
-                return self._default_metrics()
-
-            # Ensure signal is aligned
-            signal = signal.reindex(df_factors.index).fillna(0).astype(int)
-
-            # Apply signal bias (shifts signal values before thresholding)
-            if signal_bias != 0.0:
-                signal = (signal.astype(float) + signal_bias).round().astype(int).clip(-1, 1)
-
-            # Build a synthetic close from the factor-mean so we can route
-            # through the same unified engine as every other backtest path.
-            # Backtest formulas must match the orchestrator's real-OHLCV path.
-            combined = df_factors.mean(axis=1)
-            combined_ret = combined.pct_change().fillna(0)
-            synthetic_close = (1 + combined_ret).cumprod() * 100.0
-
-            from rdagent.components.backtesting.vbt_backtest import (
-                backtest_signal_ftmo,
-                DEFAULT_TXN_COST_BPS,
-            )
-            import os as _os
-
-            bt = backtest_signal_ftmo(
-                close=synthetic_close,
-                signal=signal,
-                txn_cost_bps=float(_os.getenv("TXN_COST_BPS", DEFAULT_TXN_COST_BPS)),
-            )
-            if bt.get("status") != "success":
-                return self._default_metrics()
-
-            return {
-                "sharpe_ratio": bt["sharpe"],
-                "annualized_return": bt["annualized_return"],
-                "max_drawdown": bt["max_drawdown"],
-                "win_rate": bt["win_rate"],
-                "volatility": bt["volatility"],
-                "total_return": bt["total_return"],
-                "num_trades": bt["n_trades"],
-            }
-
-        except Exception as e:
-            logger.debug(f"Evaluation failed with params {params}: {e}")
-            return self._default_metrics()
-
-    def _default_metrics(self) -> Dict[str, float]:
-        """Return default/failure metrics."""
-        return {
-            "sharpe_ratio": float("-inf"),
-            "annualized_return": 0.0,
-            "max_drawdown": 0.0,
-            "win_rate": 0.0,
-            "volatility": 0.0,
-            "total_return": 0.0,
-            "num_trades": 0,
-        }
-
-    def _extract_metric(self, metrics: Dict[str, Any], metric_name: str) -> float:
-        """Extract specific metric from metrics dict."""
-        metric_map = {
-            "sharpe": metrics.get("sharpe_ratio", float("-inf")),
-            "sortino": self._calculate_sortino(metrics),
-            "calmar": self._calculate_calmar(metrics),
-            "omega": self._calculate_omega(metrics),
-        }
-        return metric_map.get(metric_name, metrics.get("sharpe_ratio", float("-inf")))
-
-    def _calculate_sortino(self, metrics: Dict[str, Any]) -> float:
-        """Calculate Sortino ratio (simplified)."""
-        sharpe = metrics.get("sharpe_ratio", 0)
-        # Sortino is typically higher than Sharpe (only penalizes downside)
-        return sharpe * 1.2 if sharpe > 0 else sharpe
-
-    def _calculate_calmar(self, metrics: Dict[str, Any]) -> float:
-        """Calculate Calmar ratio."""
-        ann_return = metrics.get("annualized_return", 0)
-        max_dd = abs(metrics.get("max_drawdown", 0.01))
-        return ann_return / max_dd if max_dd > 0 else 0.0
-
-    def _calculate_omega(self, metrics: Dict[str, Any]) -> float:
-        """Calculate Omega ratio (simplified)."""
-        win_rate = metrics.get("win_rate", 0.5)
-        return win_rate / (1 - win_rate) if win_rate < 1 else float("inf")
-
-    def _is_acceptable(self, metrics: Dict[str, Any]) -> bool:
-        """Check if optimized strategy is acceptable."""
-        sharpe = metrics.get("sharpe_ratio", 0)
-        max_dd = metrics.get("max_drawdown", 0)
-        win_rate = metrics.get("win_rate", 0)
-
-        return sharpe >= 0.3 and max_dd >= -0.30 and win_rate >= 0.40
-
-    def _save_optimization_results(
-        self, optimized_result: Dict[str, Any], strategy_name: str
-    ) -> None:
-        """Save optimization results to file."""
-        import json
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_name = strategy_name.replace("/", "_").replace(" ", "_")[:60]
-        filename = f"opt_{safe_name}_{timestamp}.json"
-        filepath = self.optimization_dir / filename
-
-        # Remove non-serializable fields
-        save_data = {k: v for k, v in optimized_result.items() if k != "code"}
-
-        with open(filepath, "w", encoding="utf-8") as f:
-            json.dump(save_data, f, indent=2, default=str, ensure_ascii=False)
-
-        logger.debug(f"Saved optimization results to {filepath}")

rdagent/components/coder/rl/__init__.py

@@ -1,4 +1,4 @@
-"""RL Trading Agent components for Predix.
+"""RL Trading Agent components for NexQuant.
 
 This package provides reinforcement learning trading capabilities.
 Works with or without stable-baselines3 (graceful fallback).

rdagent/components/coder/rl/agent.py

@@ -2,7 +2,7 @@
 RL Trading Agent wrapper for Stable Baselines3.
 
 Provides an easy-to-use interface for training, evaluating, and deploying
-RL trading agents within the Predix framework.
+RL trading agents within the NexQuant framework.
 
 Supported algorithms:
 - PPO: Proximal Policy Optimization (most stable, recommended for production)

rdagent/components/coder/rl/env.py

@@ -5,7 +5,7 @@ Gym-compatible environment for training RL trading agents.
 Supports single-asset (EUR/USD) trading with technical indicators
 and portfolio state as observations.
 
-Inspired by common RL trading environment patterns, implemented from scratch for Predix.
+Inspired by common RL trading environment patterns, implemented from scratch for NexQuant.
 """
 
 import gymnasium as gym

rdagent/components/coder/rl/fallback.py

@@ -2,7 +2,7 @@
 Fallback RL implementation for users without stable-baselines3.
 
 Provides simple rule-based trading when RL library is not available.
-This ensures the Predix system works for all GitHub users, even
+This ensures the NexQuant system works for all GitHub users, even
 without the optional stable-baselines3 dependency.
 
 The fallback implements a momentum-based strategy as a placeholder

rdagent/components/model_loader.py

@@ -1,5 +1,5 @@
 """
-Predix Model Loader
+NexQuant Model Loader
 
 Loads models from:
 1. models/local/*.py (your improved models - not in Git)
@@ -23,7 +23,7 @@ from typing import Optional, Any
 
 
 # Base paths
-BASE_DIR = Path(__file__).parent.parent.parent  # Predix/
+BASE_DIR = Path(__file__).parent.parent.parent  # NexQuant/
 MODELS_DIR = BASE_DIR / "models"
 LOCAL_MODELS_DIR = MODELS_DIR / "local"
 STANDARD_MODELS_DIR = MODELS_DIR / "standard"

rdagent/components/prompt_loader.py

@@ -1,5 +1,5 @@
 """
-Predix Prompt Loader
+NexQuant Prompt Loader
 
 Loads prompts from:
 1. prompts/local/*.yaml (your improved prompts - not in Git)
@@ -22,7 +22,7 @@ from typing import Optional, Dict, Any
 
 
 # Base paths
-BASE_DIR = Path(__file__).parent.parent.parent  # Predix/
+BASE_DIR = Path(__file__).parent.parent.parent  # NexQuant/
 PROMPTS_DIR = BASE_DIR / "prompts"
 LOCAL_PROMPTS_DIR = PROMPTS_DIR / "local"
 STANDARD_PROMPTS_FILE = PROMPTS_DIR / "standard_prompts.yaml"

rdagent/core/utils.py

@@ -83,10 +83,24 @@ def import_class(class_path: str) -> Any:
     Returns
     -------
         class of `class_path`
+
+    Raises
+    ------
+    ImportError
+        If module or class cannot be found.
     """
-    module_path, class_name = class_path.rsplit(".", 1)
-    module = importlib.import_module(module_path)
-    return getattr(module, class_name)
+    try:
+        module_path, class_name = class_path.rsplit(".", 1)
+    except ValueError:
+        raise ImportError(f"Invalid class path: {class_path!r}")
+    try:
+        module = importlib.import_module(module_path)
+    except ModuleNotFoundError as e:
+        raise ImportError(f"Module not found: {module_path!r}") from e
+    try:
+        return getattr(module, class_name)
+    except AttributeError as e:
+        raise ImportError(f"Class not found: {class_name!r} in {module_path!r}") from e
 
 
 class CacheSeedGen:
@@ -211,11 +225,27 @@ def cache_with_pickle(hash_func: Callable, post_process_func: Callable | None =
     return cache_decorator
 
 
-def safe_resolve_path(user_path: Path, safe_root: Path | None = None) -> Path:
+def safe_resolve_path(user_path: Path | str, safe_root: Path | str | None = None) -> Path:
+    """Resolve a user-provided path safely against an allowed root directory.
+
+    Args:
+        user_path: Path provided by user/LLM/config
+        safe_root: If provided, the resolved path must be within this directory
+
+    Raises:
+        ValueError: If path resolves outside safe_root
+        OSError: If path cannot be resolved
+    """
+    resolved = Path(user_path).expanduser().resolve()
+
     if safe_root is not None:
-        root_real = os.path.realpath(str(safe_root.expanduser()))
-        path_real = os.path.realpath(str(user_path.expanduser()))  # nosec B614 — validated against safe_root below
-        if not (path_real == root_real or path_real.startswith(root_real + os.sep)):
-            raise ValueError(f"Path {user_path} resolves to {path_real}, outside allowed root {safe_root}")
-        return Path(path_real)
-    return user_path.expanduser().resolve()
+        root_resolved = Path(safe_root).expanduser().resolve()
+        try:
+            resolved.relative_to(root_resolved)
+        except ValueError:
+            raise ValueError(
+                f"Path {user_path} resolves to {resolved}, "
+                f"outside allowed root {root_resolved}"
+            )
+
+    return resolved

rdagent/log/logger.py

@@ -160,6 +160,9 @@ class RDAgentLog(SingletonBaseClass):
         log_func = getattr(patched_logger, level)
         log_func(msg)
 
+    def debug(self, msg: str, *, tag: str = "", raw: bool = False) -> None:
+        self._log("debug", msg, tag=tag, raw=raw)
+
     def info(self, msg: str, *, tag: str = "", raw: bool = False) -> None:
         self._log("info", msg, tag=tag, raw=raw)
 

rdagent/oai/backend/base.py

@@ -585,6 +585,24 @@ class APIBackend(ABC):
                         f"Original error: {e}"
                     ) from e
 
+                # Handle llama.cpp 400: "Cannot have 2 or more assistant messages at the end of the list"
+                if (
+                    openai_imported
+                    and isinstance(e, openai.BadRequestError)
+                    and hasattr(e, "message")
+                    and "Cannot have 2 or more assistant messages" in e.message
+                ):
+                    if "messages" in kwargs:
+                        merged = []
+                        for msg in kwargs["messages"]:
+                            if merged and merged[-1]["role"] == "assistant" and msg["role"] == "assistant":
+                                merged[-1]["content"] += "\n" + msg["content"]
+                            else:
+                                merged.append(msg)
+                        kwargs["messages"] = merged
+                    logger.warning("Fixed consecutive assistant messages, retrying...")
+                    continue
+
                 if embedding and too_long_error_message:
                     if not embedding_truncated:
                         # Handle embedding text too long error - truncate once and retry
@@ -654,9 +672,11 @@ class APIBackend(ABC):
         add json related content in the prompt if add_json_in_prompt is True
         """
         for message in messages[::-1]:
-            message["content"] = message["content"] + "\nPlease respond in json format."
+            if message["role"] == "user":
+                message["content"] = message["content"] + "\nPlease respond in json format."
+                break
             if message["role"] == LLM_SETTINGS.system_prompt_role:
-                # NOTE: assumption: systemprompt is always the first message
+                message["content"] = message["content"] + "\nPlease respond in json format."
                 break
 
     def _create_chat_completion_auto_continue(

rdagent/scenarios/qlib/developer/factor_runner.py

@@ -1,7 +1,7 @@
-import sys
-import os
 import logging
+import os
 from pathlib import Path
+
 """
 Qlib Factor Runner - Executes factor backtests in Docker.
 
@@ -11,15 +11,8 @@ NOTE: The @cache_with_pickle decorator was REMOVED from develop() because:
 - Docker-level caching (QlibDockerConf.enable_cache=False) is sufficient
 - The pickle cache caused 240+ factor generations but ZERO Docker backtests
 """
-from pathlib import Path
-from typing import Optional
 
 import pandas as pd
-from pandarallel import pandarallel
-
-
-pandarallel.initialize(verbose=1)
-
 from rdagent.app.qlib_rd_loop.conf import FactorBasePropSetting
 from rdagent.components.runner import CachedRunner
 from rdagent.core.exception import FactorEmptyError
@@ -74,7 +67,7 @@ def _shift_daily_constant_factor_if_needed(factor_col: "pd.Series", factor_name:
 
         logger.warning(
             f"[LookAheadFix] Factor '{factor_name}' is daily-constant "
-            f"({fraction_constant:.0%} of days). Applying 1-day shift to remove look-ahead bias."
+            f"({fraction_constant:.0%} of days). Applying 1-day shift to remove look-ahead bias.",
         )
 
         # Shift: for each instrument, map daily values forward by 1 trading day
@@ -122,13 +115,13 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
     """
 
     def calculate_information_coefficient(
-        self, concat_feature: pd.DataFrame, SOTA_feature_column_size: int, new_feature_columns_size: int
+        self, concat_feature: pd.DataFrame, SOTA_feature_column_size: int, new_feature_columns_size: int,
     ) -> pd.DataFrame:
         res = pd.Series(index=range(SOTA_feature_column_size * new_feature_columns_size))
         for col1 in range(SOTA_feature_column_size):
             for col2 in range(SOTA_feature_column_size, SOTA_feature_column_size + new_feature_columns_size):
                 res.loc[col1 * new_feature_columns_size + col2 - SOTA_feature_column_size] = concat_feature.iloc[
-                    :, col1
+                    :, col1,
                 ].corr(concat_feature.iloc[:, col2])
         return res
 
@@ -137,16 +130,21 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         # if the IC is larger than a threshold, remove the new_feature column
         # return the new_feature
 
+        from pandarallel import pandarallel
+        pandarallel.initialize(verbose=1)
+
         concat_feature = pd.concat([SOTA_feature, new_feature], axis=1)
         IC_max = (
             concat_feature.groupby("datetime")
             .parallel_apply(
-                lambda x: self.calculate_information_coefficient(x, SOTA_feature.shape[1], new_feature.shape[1])
+                lambda x: self.calculate_information_coefficient(x, SOTA_feature.shape[1], new_feature.shape[1]),
             )
             .mean()
         )
         IC_max.index = pd.MultiIndex.from_product([range(SOTA_feature.shape[1]), range(new_feature.shape[1])])
         IC_max = IC_max.unstack().max(axis=0)
+        if not hasattr(IC_max, "index"):
+            return new_feature
         return new_feature.iloc[:, IC_max[IC_max < 0.99].index]
 
     def develop(self, exp: QlibFactorExperiment) -> QlibFactorExperiment:
@@ -161,7 +159,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         self._ensure_results_dirs()
 
         if exp.based_experiments and exp.based_experiments[-1].result is None:
-            logger.info(f"Baseline experiment execution ...")
+            logger.info("Baseline experiment execution ...")
             exp.based_experiments[-1] = self.develop(exp.based_experiments[-1])
 
         fbps = FactorBasePropSetting()
@@ -185,11 +183,11 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                 base_exp for base_exp in exp.based_experiments if isinstance(base_exp, QlibFactorExperiment)
             ]
             if len(sota_factor_experiments_list) > 1:
-                logger.info(f"SOTA factor processing ...")
+                logger.info("SOTA factor processing ...")
                 SOTA_factor = process_factor_data(sota_factor_experiments_list)
 
             # Process the new factors data
-            logger.info(f"New factor processing ...")
+            logger.info("New factor processing ...")
             new_factors = process_factor_data(exp)
 
             if new_factors.empty:
@@ -200,7 +198,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                 new_factors = self.deduplicate_new_factors(SOTA_factor, new_factors)
                 if new_factors.empty:
                     raise FactorEmptyError(
-                        "The factors generated in this round are highly similar to the previous factors. Please change the direction for creating new factors."
+                        "The factors generated in this round are highly similar to the previous factors. Please change the direction for creating new factors.",
                     )
                 combined_factors = pd.concat([SOTA_factor, new_factors], axis=1).dropna()
             else:
@@ -211,7 +209,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             combined_factors = combined_factors.loc[:, ~combined_factors.columns.duplicated(keep="last")]
             new_columns = pd.MultiIndex.from_product([["feature"], combined_factors.columns])
             combined_factors.columns = new_columns
-            logger.info(f"Factor data processing completed.")
+            logger.info("Factor data processing completed.")
 
             num_features = len(exp.base_features) + len(combined_factors.columns)
 
@@ -230,10 +228,10 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                     sota_model_exp = base_exp
                     exist_sota_model_exp = True
                     break
-            logger.info(f"Experiment execution ...")
+            logger.info("Experiment execution ...")
             if exist_sota_model_exp:
                 exp.experiment_workspace.inject_files(
-                    **{"model.py": sota_model_exp.sub_workspace_list[0].file_dict["model.py"]}
+                    **{"model.py": sota_model_exp.sub_workspace_list[0].file_dict["model.py"]},
                 )
                 sota_training_hyperparameters = sota_model_exp.sub_tasks[0].training_hyperparameters
                 if sota_training_hyperparameters:
@@ -244,19 +242,19 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                             "early_stop": str(sota_training_hyperparameters.get("early_stop", 10)),
                             "batch_size": str(sota_training_hyperparameters.get("batch_size", 256)),
                             "weight_decay": str(sota_training_hyperparameters.get("weight_decay", 0.0001)),
-                        }
+                        },
                     )
                 sota_model_type = sota_model_exp.sub_tasks[0].model_type
                 if sota_model_type == "TimeSeries":
                     env_to_use.update(
-                        {"dataset_cls": "TSDatasetH", "num_features": num_features, "step_len": 20, "num_timesteps": 20}
+                        {"dataset_cls": "TSDatasetH", "num_features": num_features, "step_len": 20, "num_timesteps": 20},
                     )
                 elif sota_model_type == "Tabular":
                     env_to_use.update({"dataset_cls": "DatasetH", "num_features": num_features})
 
                 # model + combined factors
                 result, stdout = exp.experiment_workspace.execute(
-                    qlib_config_name="conf_combined_factors_sota_model.yaml", run_env=env_to_use
+                    qlib_config_name="conf_combined_factors_sota_model.yaml", run_env=env_to_use,
                 )
             else:
                 # LGBM + combined factors
@@ -265,7 +263,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                     run_env=env_to_use,
                 )
         else:
-            logger.info(f"Experiment execution ...")
+            logger.info("Experiment execution ...")
             if exp.base_feature_codes:
                 factors = process_factor_data(exp)
                 factors = factors.sort_index()
@@ -275,7 +273,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                 target_path = exp.experiment_workspace.workspace_path / "combined_factors_df.parquet"
                 # Save the combined factors to the workspace
                 factors.to_parquet(target_path, engine="pyarrow")
-                logger.info(f"Factor data processing completed.")
+                logger.info("Factor data processing completed.")
                 result, stdout = exp.experiment_workspace.execute(
                     qlib_config_name="conf_combined_factors.yaml",
                     run_env=env_to_use,
@@ -288,10 +286,10 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
         # Handle Qlib Docker backtest failure gracefully
         if result is None:
-            factor_name = getattr(exp.hypothesis, 'hypothesis', 'unknown')
+            factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
             logger.warning(
                 f"Qlib Docker backtest returned None for '{factor_name}'. "
-                f"Attempting direct factor evaluation..."
+                f"Attempting direct factor evaluation...",
             )
 
             # Try to compute metrics directly from the factor's result.h5
@@ -303,7 +301,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             else:
                 logger.error(
                     f"Both Qlib Docker backtest and direct evaluation failed for '{factor_name}'. "
-                    f"Skipping this factor and continuing."
+                    f"Skipping this factor and continuing.",
                 )
                 # Save failed run info for debugging
                 self._save_failed_run(exp, stdout, error_type="result_none")
@@ -321,7 +319,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         if validation_result.get("has_issues"):
             logger.warning(
                 f"Result validation warnings for factor '{getattr(exp.hypothesis, 'hypothesis', 'unknown')}': "
-                f"{validation_result['warnings']}"
+                f"{validation_result['warnings']}",
             )
             # Save warning info for debugging
             self._save_failed_run(exp, stdout, error_type="validation_warnings", validation=validation_result)
@@ -372,43 +370,47 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         details = {}
 
         factor_name = "unknown"
-        if hasattr(exp, 'hypothesis') and exp.hypothesis is not None:
-            factor_name = getattr(exp.hypothesis, 'hypothesis', 'unknown')
+        if hasattr(exp, "hypothesis") and exp.hypothesis is not None:
+            factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
 
         if isinstance(result, pd.Series):
             # Check IC
-            ic_value = result.get('IC', None)
-            details['ic_raw'] = ic_value
+            ic_value = result.get("IC", None)
+            details["ic_raw"] = ic_value
             if ic_value is None or (isinstance(ic_value, float) and (ic_value != ic_value)):  # NaN check
                 warnings.append("IC is None/NaN — factor has no predictive power")
             else:
                 try:
                     ic_float = float(ic_value)
-                    details['ic'] = ic_float
+                    details["ic"] = ic_float
                     if abs(ic_float) < 0.001:
                         warnings.append(
-                            f"IC is near zero ({ic_float:.6f}) — factor may not predict returns"
+                            f"IC is near zero ({ic_float:.6f}) — factor may not predict returns",
+                        )
+                    if abs(ic_float) < 0.04:
+                        warnings.append(
+                            f"IC below target ({ic_float:.4f}) — factor will be excluded from strategy building (min IC=0.04)",
                         )
                 except (ValueError, TypeError):
                     warnings.append(f"IC value is not numeric: {ic_value}")
 
             # Check positions (1day.pos)
-            pos_value = result.get('1day.pos', None)
-            details['positions_raw'] = pos_value
+            pos_value = result.get("1day.pos", None)
+            details["positions_raw"] = pos_value
             if pos_value is not None:
                 try:
                     pos_float = float(pos_value)
-                    details['positions'] = pos_float
+                    details["positions"] = pos_float
                     if pos_float == 0:
                         warnings.append(
                             "1day.pos == 0 — model opened ZERO positions (stayed neutral). "
                             "Possible causes: (1) topk too high for single-asset, "
-                            "(2) signal threshold too restrictive, (3) no valid predictions"
+                            "(2) signal threshold too restrictive, (3) no valid predictions",
                         )
                     elif pos_float < 10:
                         warnings.append(
                             f"1day.pos = {pos_float:.0f} — very few positions opened. "
-                            f"Check signal threshold and topk settings"
+                            f"Check signal threshold and topk settings",
                         )
                 except (ValueError, TypeError):
                     pass  # pos might be a string
@@ -416,24 +418,24 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             # Check if result is essentially empty (all values None or NaN)
             non_null_count = result.notna().sum()
             total_count = len(result)
-            details['non_null_metrics'] = int(non_null_count)
-            details['total_metrics'] = int(total_count)
+            details["non_null_metrics"] = int(non_null_count)
+            details["total_metrics"] = int(total_count)
             if non_null_count < 3:
                 warnings.append(
                     f"Result has only {non_null_count}/{total_count} non-null metrics — "
-                    f"backtest likely produced empty results"
+                    f"backtest likely produced empty results",
                 )
 
             # Check for key metrics
-            required_metrics = ['IC', '1day.excess_return_with_cost.shar', '1day.pos']
+            required_metrics = ["IC", "1day.excess_return_with_cost.shar", "1day.pos"]
             for metric_name in required_metrics:
                 val = result.get(metric_name, None)
-                details[f'has_{metric_name}'] = val is not None
+                details[f"has_{metric_name}"] = val is not None
 
         elif isinstance(result, dict):
             # Dict-based result validation
-            ic_value = result.get('IC', result.get('ic', None))
-            details['ic_raw'] = ic_value
+            ic_value = result.get("IC", result.get("ic", None))
+            details["ic_raw"] = ic_value
             if ic_value is None:
                 warnings.append("IC is None — factor has no predictive power")
 
@@ -443,7 +445,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             "details": details,
         }
 
-    def _evaluate_factor_directly(self, exp, stdout: str) -> Optional[pd.Series]:
+    def _evaluate_factor_directly(self, exp, stdout: str) -> pd.Series | None:
         """
         Evaluate factor directly from its result.h5 file when Qlib Docker fails.
 
@@ -475,7 +477,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             workspace_path = None
             if exp.sub_workspace_list:
                 for ws in exp.sub_workspace_list:
-                    if ws is not None and hasattr(ws, 'workspace_path'):
+                    if ws is not None and hasattr(ws, "workspace_path"):
                         candidate = ws.workspace_path / "result.h5"
                         if candidate.exists():
                             workspace_path = ws.workspace_path
@@ -546,23 +548,32 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             except Exception:
                 rank_ic = ic
 
-            # Compute Sharpe-like metric
-            factor_mean = factor_col.loc[valid_idx].mean()
-            factor_std = factor_col.loc[valid_idx].std()
-            sharpe = factor_mean / factor_std if factor_std > 0 else 0
+            # Compute strategy returns from factor signal + forward returns
+            # signal: long(1) when factor > 0, short(-1) when factor <= 0
+            signal = np.where(factor_col.loc[valid_idx] > 0, 1.0, -1.0)
+            strategy_ret = signal * forward_ret.loc[valid_idx]
 
-            # Annualized return (approximate)
-            ann_factor = np.sqrt(252 * 1440 / 96)
-            annualized_return = factor_mean * ann_factor * 100
+            # Annualization factor for 1-minute bars
+            bars_per_year = 252 * 1440  # ~362880
+            bars_per_forward = 96
+            ann_factor = np.sqrt(bars_per_year / bars_per_forward)
 
-            # Max drawdown (approximate)
-            cum_perf = factor_col.loc[valid_idx].cumsum()
-            running_max = cum_perf.expanding().max()
-            drawdown = (cum_perf - running_max) / running_max.replace(0, np.nan)
-            max_drawdown = drawdown.min() if len(drawdown) > 0 else 0
+            # Sharpe: annualized mean/vol of strategy returns
+            ret_mean = strategy_ret.mean()
+            ret_std = strategy_ret.std()
+            sharpe = (ret_mean / ret_std * ann_factor) if ret_std > 0 else 0.0
 
-            # Win rate
-            win_rate = (factor_col.loc[valid_idx] > 0).sum() / len(valid_idx)
+            # Annualized return
+            annualized_return = float(ret_mean * bars_per_year / bars_per_forward * 100)
+
+            # Max drawdown on equity curve
+            equity = (1.0 + strategy_ret).cumprod()
+            running_max = equity.expanding().max()
+            drawdown = (equity - running_max) / running_max.replace(0, np.nan)
+            max_drawdown = float(drawdown.min()) if len(drawdown) > 0 else 0.0
+
+            # Win rate: fraction of positive strategy returns
+            win_rate = float((strategy_ret > 0).sum()) / len(strategy_ret) if len(strategy_ret) > 0 else 0.0
 
             # Create result series compatible with Qlib backtest result format
             result = pd.Series({
@@ -572,14 +583,14 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                 "1day.excess_return_with_cost.max_drawdown": max_drawdown,
                 "win_rate": win_rate,
                 "1day.excess_return_with_cost.information_ratio": rank_ic,
-                "1day.excess_return_with_cost.std": factor_std,
+                "1day.excess_return_with_cost.std": float(ret_std),
                 "1day.pos": len(valid_idx),
                 "factor_name": factor_name,
             })
 
             logger.info(
                 f"Direct evaluation: IC={ic:.6f}, Sharpe={sharpe:.4f}, "
-                f"AnnRet={annualized_return:.4f}%, WR={win_rate:.2%}"
+                f"AnnRet={annualized_return:.4f}%, WR={win_rate:.2%}",
             )
             return result
 
@@ -588,7 +599,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             return None
 
     def _save_failed_run(self, exp, stdout: str, error_type: str = "unknown",
-                         validation: Optional[dict] = None) -> None:
+                         validation: dict | None = None) -> None:
         """
         Save failed run information to results/failed_runs.json for debugging.
 
@@ -615,20 +626,20 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
             # Get factor name
             factor_name = "unknown"
-            if hasattr(exp, 'hypothesis') and exp.hypothesis is not None:
-                factor_name = getattr(exp.hypothesis, 'hypothesis', 'unknown')
+            if hasattr(exp, "hypothesis") and exp.hypothesis is not None:
+                factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
 
             # Build failed run record
             failed_record = {
                 "timestamp": datetime.now().isoformat(),
                 "factor_name": factor_name,
                 "error_type": error_type,
-                "stdout": stdout if stdout else "(empty)",
+                "stdout": stdout or "(empty)",
                 "validation": validation,
                 "experiment_details": {
-                    "base_features": list(getattr(exp, 'base_features', {}).keys()) if hasattr(exp, 'base_features') else [],
-                    "hypothesis": getattr(exp.hypothesis, 'hypothesis', str(getattr(exp, 'hypothesis', 'N/A')))
-                                  if hasattr(exp, 'hypothesis') else "N/A",
+                    "base_features": list(getattr(exp, "base_features", {}).keys()) if hasattr(exp, "base_features") else [],
+                    "hypothesis": getattr(exp.hypothesis, "hypothesis", str(getattr(exp, "hypothesis", "N/A")))
+                                  if hasattr(exp, "hypothesis") else "N/A",
                 },
             }
 
@@ -651,11 +662,11 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
             failed_file.write_text(
                 json.dumps(existing_records, indent=2, default=str, ensure_ascii=False),
-                encoding="utf-8"
+                encoding="utf-8",
             )
             logger.info(
                 f"Failed run saved: {factor_name} (type={error_type}) "
-                f"→ {failed_file}"
+                f"→ {failed_file}",
             )
 
         except Exception as e:
@@ -678,23 +689,23 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             containing metric names like 'IC', '1day.excess_return_with_cost.shar', etc.
         """
         try:
-            import json
-            import pandas as pd
             from pathlib import Path
+
+            import pandas as pd
             from rdagent.components.backtesting import ResultsDatabase
 
             # Get factor name: prefer hypothesis, fallback to result Series 'factor_name' key
             factor_name = "unknown"
-            if hasattr(exp, 'hypothesis') and exp.hypothesis is not None:
-                factor_name = getattr(exp.hypothesis, 'hypothesis', 'unknown')
-            if factor_name == 'unknown' and isinstance(result, pd.Series) and 'factor_name' in result.index:
-                factor_name = str(result['factor_name'])
+            if hasattr(exp, "hypothesis") and exp.hypothesis is not None:
+                factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
+            if factor_name == "unknown" and isinstance(result, pd.Series) and "factor_name" in result.index:
+                factor_name = str(result["factor_name"])
 
             # Check if already rejected by protection
-            if getattr(exp, 'rejected_by_protection', False):
+            if getattr(exp, "rejected_by_protection", False):
                 logger.info(
                     f"Factor rejected by protection, skipping DB save: "
-                    f"{getattr(exp, 'protection_reason', 'unknown')}"
+                    f"{getattr(exp, 'protection_reason', 'unknown')}",
                 )
                 return
 
@@ -710,47 +721,47 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             # Extract metrics from result (pd.Series from qlib_res.csv)
             metrics = {}
             if isinstance(result, pd.Series):
-                metrics['ic'] = self._safe_float(result.get('IC', None))
-                metrics['sharpe_ratio'] = self._safe_float(
-                    result.get('1day.excess_return_with_cost.shar',
-                    result.get('1day.excess_return_with_cost.sharpe', None))
+                metrics["ic"] = self._safe_float(result.get("IC", None))
+                metrics["sharpe_ratio"] = self._safe_float(
+                    result.get("1day.excess_return_with_cost.shar",
+                    result.get("1day.excess_return_with_cost.sharpe", None)),
                 )
-                metrics['annualized_return'] = self._safe_float(
-                    result.get('1day.excess_return_with_cost.annualized_return', None)
+                metrics["annualized_return"] = self._safe_float(
+                    result.get("1day.excess_return_with_cost.annualized_return", None),
                 )
-                metrics['max_drawdown'] = self._safe_float(
-                    result.get('1day.excess_return_with_cost.max_drawdown', None)
+                metrics["max_drawdown"] = self._safe_float(
+                    result.get("1day.excess_return_with_cost.max_drawdown", None),
                 )
-                metrics['win_rate'] = self._safe_float(result.get('win_rate', None))
-                metrics['information_ratio'] = self._safe_float(
-                    result.get('1day.excess_return_with_cost.information_ratio', None)
+                metrics["win_rate"] = self._safe_float(result.get("win_rate", None))
+                metrics["information_ratio"] = self._safe_float(
+                    result.get("1day.excess_return_with_cost.information_ratio", None),
                 )
-                metrics['volatility'] = self._safe_float(
-                    result.get('1day.excess_return_with_cost.std',
-                    result.get('1day.excess_return_with_cost.volatility', None))
+                metrics["volatility"] = self._safe_float(
+                    result.get("1day.excess_return_with_cost.std",
+                    result.get("1day.excess_return_with_cost.volatility", None)),
                 )
                 # Store raw metrics for JSON export
-                metrics['raw_metrics'] = result.to_dict()
+                metrics["raw_metrics"] = result.to_dict()
             elif isinstance(result, dict):
-                metrics['ic'] = self._safe_float(result.get('IC', result.get('ic', None)))
-                metrics['sharpe_ratio'] = self._safe_float(
-                    result.get('sharpe', result.get('sharpe_ratio', None))
+                metrics["ic"] = self._safe_float(result.get("IC", result.get("ic", None)))
+                metrics["sharpe_ratio"] = self._safe_float(
+                    result.get("sharpe", result.get("sharpe_ratio", None)),
                 )
-                metrics['annualized_return'] = self._safe_float(result.get('annualized_return', None))
-                metrics['max_drawdown'] = self._safe_float(result.get('max_drawdown', None))
-                metrics['win_rate'] = self._safe_float(result.get('win_rate', None))
-                metrics['information_ratio'] = None
-                metrics['volatility'] = None
-                metrics['raw_metrics'] = result
+                metrics["annualized_return"] = self._safe_float(result.get("annualized_return", None))
+                metrics["max_drawdown"] = self._safe_float(result.get("max_drawdown", None))
+                metrics["win_rate"] = self._safe_float(result.get("win_rate", None))
+                metrics["information_ratio"] = None
+                metrics["volatility"] = None
+                metrics["raw_metrics"] = result
 
             # Result validation before saving (warnings, not blocking)
             self._log_result_warnings(factor_name, result, metrics)
 
             # Only save if we have at least IC or Sharpe
-            if metrics.get('ic') is None and metrics.get('sharpe_ratio') is None:
+            if metrics.get("ic") is None and metrics.get("sharpe_ratio") is None:
                 logger.warning(
                     f"No valid IC/Sharpe for factor '{factor_name}', skipping DB save. "
-                    f"IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}"
+                    f"IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}",
                 )
                 return
 
@@ -761,19 +772,19 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             db_file = db_path / "backtest_results.db"
 
             # Parallel run isolation: use run-specific subdirectory if PARALLEL_RUN_ID is set
-            run_id = os.getenv("PARALLEL_RUN_ID", "0")
-            if run_id != "0":
+            parallel_run_id = os.getenv("PARALLEL_RUN_ID", "0")
+            if parallel_run_id != "0":
                 # For parallel runs, save to isolated results directory
-                isolated_db_path = project_root / "results" / "runs" / f"run{run_id}" / "db"
+                isolated_db_path = project_root / "results" / "runs" / f"run{parallel_run_id}" / "db"
                 isolated_db_path.mkdir(parents=True, exist_ok=True)
                 db_file = isolated_db_path / "backtest_results.db"
 
             # Save to database
             db = ResultsDatabase(db_path=str(db_file))
-            run_id = db.add_backtest(factor_name=factor_name[:100], metrics=metrics)
+            db_run_id = db.add_backtest(factor_name=factor_name[:100], metrics=metrics)
             logger.info(
                 f"Factor result saved to DB: {factor_name[:60]} "
-                f"(IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}, run_id={run_id})"
+                f"(IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}, run_id={db_run_id})"
             )
 
             # Extract factor code and description from experiment
@@ -781,10 +792,10 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
             # Also write a JSON summary to results/factors/ for file-based access
             self._save_factor_json(
-                factor_name, metrics, run_id,
+                factor_name, metrics, db_run_id,
                 factor_code=factor_code,
                 factor_description=factor_description,
-                exp=exp
+                exp=exp,
             )
 
             # Save factor values as parquet for strategy building
@@ -796,7 +807,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             import traceback
             logger.error(
                 f"Database save failed for factor '{getattr(exp.hypothesis, 'hypothesis', 'unknown')}': {e}\n"
-                f"Traceback: {traceback.format_exc()}"
+                f"Traceback: {traceback.format_exc()}",
             )
 
     def _save_factor_json(self, factor_name: str, metrics: dict, run_id: int,
@@ -907,14 +918,14 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                 factor_description = match.group(1).strip()[:500]
             else:
                 # Try comments
-                lines = factor_code.split('\n')
+                lines = factor_code.split("\n")
                 desc_lines = []
                 for line in lines[:20]:
                     stripped = line.strip()
-                    if stripped.startswith('#') and not stripped.startswith('#!'):
+                    if stripped.startswith("#") and not stripped.startswith("#!"):
                         desc_lines.append(stripped[1:].strip())
                 if desc_lines:
-                    factor_description = ' '.join(desc_lines)[:500]
+                    factor_description = " ".join(desc_lines)[:500]
 
         return factor_code, factor_description
 
@@ -926,8 +937,9 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         the complete backtest range (not just the debug 2024 subset).
         """
         import os as _os
-        import subprocess
         import shutil
+        import subprocess
+        import sys
         import tempfile
 
         try:
@@ -935,7 +947,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             workspace_path = None
             if exp.sub_workspace_list:
                 for ws in exp.sub_workspace_list:
-                    if ws is not None and hasattr(ws, 'workspace_path'):
+                    if ws is not None and hasattr(ws, "workspace_path"):
                         fp = ws.workspace_path / "factor.py"
                         if fp.exists():
                             workspace_path = ws.workspace_path
@@ -961,18 +973,23 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
             # Run factor code on full data in a temp workspace
             import pandas as pd
-            with tempfile.TemporaryDirectory(prefix="predix_fullval_") as tmp_dir:
+            with tempfile.TemporaryDirectory(prefix="nexquant_fullval_") as tmp_dir:
                 tmp = Path(tmp_dir)
                 shutil.copy(str(factor_py), str(tmp / "factor.py"))
                 shutil.copy(str(full_data), str(tmp / "intraday_pv.h5"))
 
                 ret = subprocess.run(
-                    ["sys.executable", "factor.py"],
+                    [sys.executable, "factor.py"],
                     cwd=str(tmp),
                     capture_output=True,
                     timeout=300,
+                    check=False,
                 )
                 if ret.returncode != 0:
+                    logger.warning(
+                        f"Full-data factor run failed (exit {ret.returncode}): "
+                        f"{ret.stderr[:500] if ret.stderr else '(no stderr)'}"
+                    )
                     # Fall back to debug-data result if full-data run fails
                     result_h5 = workspace_path / "result.h5"
                     if not result_h5.exists():
@@ -1023,7 +1040,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         warnings_list = []
 
         # Check IC
-        ic = metrics.get('ic')
+        ic = metrics.get("ic")
         if ic is None:
             warnings_list.append("IC is None — factor has no predictive power")
         elif abs(ic) < 0.001:
@@ -1031,7 +1048,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
         # Check positions (1day.pos) — CRITICAL for EURUSD
         if isinstance(result, pd.Series):
-            pos_value = result.get('1day.pos', None)
+            pos_value = result.get("1day.pos", None)
             if pos_value is not None:
                 try:
                     pos_float = float(pos_value)
@@ -1039,23 +1056,23 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
                         warnings_list.append(
                             "WARNING: 1day.pos == 0 — ZERO positions opened! "
                             "Model stayed completely neutral. Check Qlib config: "
-                            "ensure topk=1 and market=eurusd for single-asset trading."
+                            "ensure topk=1 and market=eurusd for single-asset trading.",
                         )
                     elif pos_float < 10:
                         warnings_list.append(
                             f"Low position count: 1day.pos = {pos_float:.0f} — "
-                            f"model traded very rarely"
+                            f"model traded very rarely",
                         )
                 except (ValueError, TypeError):
                     pass
 
         # Check Sharpe
-        sharpe = metrics.get('sharpe_ratio')
+        sharpe = metrics.get("sharpe_ratio")
         if sharpe is not None and abs(sharpe) < 0.1:
             warnings_list.append(f"Sharpe near zero ({sharpe:.4f}) — no risk-adjusted edge")
 
         # Check max drawdown
-        mdd = metrics.get('max_drawdown')
+        mdd = metrics.get("max_drawdown")
         if mdd is not None and mdd < -0.5:
             warnings_list.append(f"Extreme drawdown: {mdd:.2%} — high risk factor")
 
@@ -1070,7 +1087,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             return None
         try:
             f = float(value)
-            if pd.isna(f) or f == float('inf') or f == float('-inf'):
+            if pd.isna(f) or f == float("inf") or f == float("-inf"):
                 return None
             return f
         except (ValueError, TypeError):
@@ -1113,7 +1130,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
         if protection_result.should_block:
             logger.warning(
-                f"Factor {factor_name} rejected by protection manager: {protection_result.reason}"
+                f"Factor {factor_name} rejected by protection manager: {protection_result.reason}",
             )
             # Mark factor as rejected by protection
             exp.rejected_by_protection = True
@@ -1138,8 +1155,8 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
         from pathlib import Path
 
         factor_name = "unknown"
-        if hasattr(exp, 'hypothesis') and exp.hypothesis is not None:
-            factor_name = getattr(exp.hypothesis, 'hypothesis', 'unknown')
+        if hasattr(exp, "hypothesis") and exp.hypothesis is not None:
+            factor_name = getattr(exp.hypothesis, "hypothesis", "unknown")
 
         # Build log entry
         log_entry = {
@@ -1151,42 +1168,42 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
             "annualized_return": None,
             "max_drawdown": None,
             "win_rate": None,
-            "rejected_by_protection": getattr(exp, 'rejected_by_protection', False),
-            "protection_reason": getattr(exp, 'protection_reason', None),
+            "rejected_by_protection": getattr(exp, "rejected_by_protection", False),
+            "protection_reason": getattr(exp, "protection_reason", None),
         }
 
         # Extract metrics if available
         if result is not None:
-            if hasattr(result, 'get'):  # pd.Series or dict
-                ic_val = result.get('IC', result.get('ic', None))
-                log_entry['ic'] = self._safe_float(ic_val) if ic_val is not None else None
+            if hasattr(result, "get"):  # pd.Series or dict
+                ic_val = result.get("IC", result.get("ic", None))
+                log_entry["ic"] = self._safe_float(ic_val) if ic_val is not None else None
 
-                sharpe_val = result.get('1day.excess_return_with_cost.shar',
-                                        result.get('1day.excess_return_with_cost.sharpe',
-                                        result.get('sharpe', None)))
-                log_entry['sharpe'] = self._safe_float(sharpe_val) if sharpe_val is not None else None
+                sharpe_val = result.get("1day.excess_return_with_cost.shar",
+                                        result.get("1day.excess_return_with_cost.sharpe",
+                                        result.get("sharpe", None)))
+                log_entry["sharpe"] = self._safe_float(sharpe_val) if sharpe_val is not None else None
 
-                ann_ret = result.get('1day.excess_return_with_cost.annualized_return',
-                                     result.get('annualized_return', None))
-                log_entry['annualized_return'] = self._safe_float(ann_ret) if ann_ret is not None else None
+                ann_ret = result.get("1day.excess_return_with_cost.annualized_return",
+                                     result.get("annualized_return", None))
+                log_entry["annualized_return"] = self._safe_float(ann_ret) if ann_ret is not None else None
 
-                mdd = result.get('1day.excess_return_with_cost.max_drawdown',
-                                 result.get('max_drawdown', None))
-                log_entry['max_drawdown'] = self._safe_float(mdd) if mdd is not None else None
+                mdd = result.get("1day.excess_return_with_cost.max_drawdown",
+                                 result.get("max_drawdown", None))
+                log_entry["max_drawdown"] = self._safe_float(mdd) if mdd is not None else None
 
-                wr = result.get('win_rate', None)
-                log_entry['win_rate'] = self._safe_float(wr) if wr is not None else None
+                wr = result.get("win_rate", None)
+                log_entry["win_rate"] = self._safe_float(wr) if wr is not None else None
 
             # Determine status
-            if log_entry['ic'] is not None or log_entry['sharpe'] is not None:
-                log_entry['status'] = "success"
-            elif getattr(exp, 'rejected_by_protection', False):
-                log_entry['status'] = "rejected_protection"
+            if log_entry["ic"] is not None or log_entry["sharpe"] is not None:
+                log_entry["status"] = "success"
+            elif getattr(exp, "rejected_by_protection", False):
+                log_entry["status"] = "rejected_protection"
             else:
-                log_entry['status'] = "no_valid_metrics"
+                log_entry["status"] = "no_valid_metrics"
         else:
-            log_entry['status'] = "execution_failed"
-            log_entry['reason'] = "Result was None"
+            log_entry["status"] = "execution_failed"
+            log_entry["reason"] = "Result was None"
 
         # Write to results/logs/
         try:
@@ -1209,7 +1226,7 @@ class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
 
             logger.info(
                 f"Run log written for '{factor_name[:50]}': "
-                f"status={log_entry['status']}, IC={log_entry['ic']}, Sharpe={log_entry['sharpe']}"
+                f"status={log_entry['status']}, IC={log_entry['ic']}, Sharpe={log_entry['sharpe']}",
             )
         except Exception as e:
             logger.error(f"Failed to write run log: {e}")

rdagent/scenarios/qlib/developer/model_runner.py

@@ -203,12 +203,14 @@ class QlibModelRunner(CachedRunner[QlibModelExperiment]):
 
             # Save to database
             db = ResultsDatabase()
-            run_id = db.add_backtest(factor_name=factor_name[:100], metrics=metrics)
-            logger.info(
-                f"Model result saved to DB: {factor_name[:50]} "
-                f"(IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}, run_id={run_id})"
-            )
-            db.close()
+            try:
+                run_id = db.add_backtest(factor_name=factor_name[:100], metrics=metrics)
+                logger.info(
+                    f"Model result saved to DB: {factor_name[:50]} "
+                    f"(IC={metrics.get('ic')}, Sharpe={metrics.get('sharpe_ratio')}, run_id={run_id})"
+                )
+            finally:
+                db.close()
 
         except Exception as e:
             logger.warning(f"Database save failed for model {getattr(exp.hypothesis, 'hypothesis', 'unknown')}: {e}")

rdagent/scenarios/qlib/developer/strategy_builder.py

@@ -1,5 +1,5 @@
 """
-Predix Strategy Builder - Systematically combine factors into trading strategies.
+NexQuant Strategy Builder - Systematically combine factors into trading strategies.
 
 This module:
 1. Loads evaluated factors with time-series values
@@ -8,9 +8,9 @@ This module:
 4. Ranks and saves best strategies
 
 Usage:
-    predix build-strategies              # Build strategies from top factors
-    predix build-strategies --top 50     # Use top 50 factors
-    predix build-strategies --max-combo 3  # Allow up to 3-factor combinations
+    nexquant build-strategies              # Build strategies from top factors
+    nexquant build-strategies --top 50     # Use top 50 factors
+    nexquant build-strategies --max-combo 3  # Allow up to 3-factor combinations
 """
 
 import json
@@ -173,8 +173,10 @@ class StrategyEvaluator:
         df_norm = (df - df.mean()) / df.std()
         signal = df_norm.mean(axis=1)
 
-        # Calculate returns (forward returns approximation)
-        # Use factor values as proxy for returns
+        # Strategy returns: signal direction * forward returns
+        # Approximate forward returns from signal changes (no OHLCV in this context)
+        # Fall back to qlib-style: use signal sign as position, diff as P&L proxy
+        # This is approximate — real evaluation needs OHLCV data
         returns = signal.diff().fillna(0)
 
         # Apply transaction costs
@@ -184,15 +186,16 @@ class StrategyEvaluator:
 
         # Calculate metrics
         total_return = returns.sum()
-        ann_factor = np.sqrt(252 * 1440 / 96)  # Annualization for 1min data
+        bars_per_year = 252 * 1440
+        ann_factor = np.sqrt(bars_per_year / 96)  # Annualization for 1min data
         ann_return = total_return * ann_factor
-        volatility = returns.std() * np.sqrt(252 * 1440 / 96)
+        volatility = returns.std() * ann_factor
         sharpe = ann_return / volatility if volatility > 0 else 0
 
-        # Max drawdown
-        cum = returns.cumsum()
-        running_max = cum.expanding().max()
-        drawdown = (cum - running_max) / running_max.replace(0, np.nan)
+        # Max drawdown on equity curve
+        equity = (1.0 + returns).cumprod()
+        running_max = equity.expanding().max()
+        drawdown = (equity - running_max) / running_max.replace(0, np.nan)
         max_dd = drawdown.min() if len(drawdown) > 0 else 0
 
         # Win rate

rdagent/scenarios/qlib/fx_validator/agents/analysts/macro_analyst.py

@@ -56,7 +56,7 @@ Current Date: {current_date}
 Live Macro Data:
 {macro_data}
 
-Factor Report from Predix RD-Agent:
+Factor Report from NexQuant RD-Agent:
 {factor_report}
 
 Analyze the macro environment and its impact on the proposed factor:

rdagent/scenarios/qlib/fx_validator/agents/analysts/session_analyst.py

@@ -47,7 +47,7 @@ Active Session: {session}
 Expected Regime: {regime}
 Session Notes: {session_note}
 
-Factor Report from Predix RD-Agent:
+Factor Report from NexQuant RD-Agent:
 {factor_report}
 
 Analyze whether the proposed factor is suitable for the current session regime.

rdagent/scenarios/qlib/fx_validator/agents/trader/fx_trader.py

@@ -17,7 +17,7 @@ def create_fx_trader(llm):
 
 You have received reports from your team:
 
-FACTOR ANALYSIS (Predix RD-Agent):
+FACTOR ANALYSIS (NexQuant RD-Agent):
 {factor_report}
 
 SESSION ANALYSIS:

rdagent/scenarios/qlib/fx_validator/fx_graph.py

@@ -1,5 +1,5 @@
 """
-FX Validator Graph — Multi-Agent Validierung für Predix Faktoren
+FX Validator Graph — Multi-Agent Validierung für NexQuant Faktoren
 
 Implementiert Multi-Agenten-System für Trading-Entscheidungen:
 - Session Analyst: Analysiert aktuelle FX-Session
@@ -88,10 +88,10 @@ def create_fx_validator(config: dict = None):
 
 def validate_factor(factor_report: str, trade_date: str = None) -> dict:
     """
-    Hauptfunktion — validiert einen Predix-Faktor durch Multi-Agent Debatte
+    Hauptfunktion — validiert einen NexQuant-Faktor durch Multi-Agent Debatte
 
     Args:
-        factor_report: Der Faktor-Report von Predix RD-Agent
+        factor_report: Der Faktor-Report von NexQuant RD-Agent
         trade_date: Datum/Zeit in ISO Format (default: jetzt)
 
     Returns:

rdagent/scenarios/qlib/proposal/bandit.py

@@ -53,7 +53,8 @@ def extract_metrics_from_experiment(experiment) -> Metrics:
 
 
 class LinearThompsonTwoArm:
-    def __init__(self, dim: int, prior_var: float = 1.0, noise_var: float = 1.0):
+    def __init__(self, dim: int, prior_var: float = 1.0, noise_var: float = 1.0,
+                 model_prior_bias: float = 0.5):
         self.dim = dim
         self.noise_var = noise_var
         # Each arm has its own posterior: mean & inverse of covariance (precision matrix)
@@ -61,6 +62,8 @@ class LinearThompsonTwoArm:
             "factor": np.zeros(dim),
             "model": np.zeros(dim),
         }
+        # Give model arm an initial positive bias toward all metrics
+        self.mean["model"][:] = model_prior_bias
         self.precision = {
             "factor": np.eye(dim) / prior_var,
             "model": np.eye(dim) / prior_var,
@@ -94,8 +97,8 @@ class LinearThompsonTwoArm:
 
 class EnvController:
     def __init__(self, weights: Tuple[float, ...] = None) -> None:
-        self.weights = np.asarray(weights or (0.1, 0.1, 0.05, 0.05, 0.25, 0.15, 0.1, 0.2))
-        self.bandit = LinearThompsonTwoArm(dim=8, prior_var=10.0, noise_var=0.5)
+        self.weights = np.asarray(weights or (0.2, 0.1, 0.05, 0.05, 0.25, 0.1, 0.1, 0.15))
+        self.bandit = LinearThompsonTwoArm(dim=8, prior_var=5.0, noise_var=0.5, model_prior_bias=2.0)
 
     def reward(self, m: Metrics) -> float:
         return float(np.dot(self.weights, m.as_vector()))

rdagent/scenarios/qlib/proposal/quant_proposal.py

@@ -1,8 +1,7 @@
-import logging
 import json
+import logging
 import os
 import random
-from typing import Tuple
 
 from rdagent.app.qlib_rd_loop.conf import QUANT_PROP_SETTING
 from rdagent.components.proposal import FactorAndModelHypothesisGen
@@ -42,7 +41,7 @@ class QlibQuantHypothesis(Hypothesis):
         action: str,
     ) -> None:
         super().__init__(
-            hypothesis, reason, concise_reason, concise_observation, concise_justification, concise_knowledge
+            hypothesis, reason, concise_reason, concise_observation, concise_justification, concise_knowledge,
         )
         self.action = action
 
@@ -54,10 +53,10 @@ Reason: {self.reason}
 
 
 class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
-    def __init__(self, scen: Scenario) -> Tuple[dict, bool]:
+    def __init__(self, scen: Scenario) -> None:
         super().__init__(scen)
 
-    def prepare_context(self, trace: Trace) -> Tuple[dict, bool]:
+    def prepare_context(self, trace: Trace) -> tuple[dict, bool]:
 
         # ========= Bandit ==========
         if QUANT_PROP_SETTING.action_selection == "bandit":
@@ -74,7 +73,7 @@ class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
                 trace.controller.record(metric, prev_action)
                 action = trace.controller.decide(metric)
             else:
-                action = "factor"
+                action = "model"
         # ========= LLM ==========
         elif QUANT_PROP_SETTING.action_selection == "llm":
             hypothesis_and_feedback = (
@@ -85,7 +84,7 @@ class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
 
             last_hypothesis_and_feedback = (
                 T("scenarios.qlib.prompts:last_hypothesis_and_feedback").r(
-                    experiment=trace.hist[-1][0], feedback=trace.hist[-1][1]
+                    experiment=trace.hist[-1][0], feedback=trace.hist[-1][1],
                 )
                 if len(trace.hist) > 0
                 else "No previous hypothesis and feedback available since it's the first round."
@@ -109,7 +108,7 @@ class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
             if len(trace.hist) < 6:
                 qaunt_rag = "Try the easiest and fastest factors to experiment with from various perspectives first."
             else:
-                qaunt_rag = "Now, you need to try factors that can achieve high IC (e.g., machine learning-based factors)! Do not include factors that are similar to those in the SOTA factor library!"
+                qaunt_rag = "Now, you need to try factors that can achieve high IC (target |IC| > 0.04, e.g., machine learning-based factors)! Do not include factors that are similar to those in the SOTA factor library!"
         elif action == "model":
             qaunt_rag = "1. In Quantitative Finance, market data could be time-series, and GRU model/LSTM model are suitable for them. Do not generate GNN model as for now.\n2. The training data consists of approximately 478,000 samples for the training set and about 128,000 samples for the validation set. Please design the hyperparameters accordingly and control the model size. This has a significant impact on the training results. If you believe that the previous model itself is good but the training hyperparameters or model hyperparameters are not optimal, you can return the same model and adjust these parameters instead.\n"
 
@@ -195,7 +194,7 @@ class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
         for i in range(len(trace.hist) - 1, -1, -1):
             if trace.hist[i][0].hypothesis.action == action:
                 last_hypothesis_and_feedback = T("scenarios.qlib.prompts:last_hypothesis_and_feedback").r(
-                    experiment=trace.hist[i][0], feedback=trace.hist[i][1]
+                    experiment=trace.hist[i][0], feedback=trace.hist[i][1],
                 )
                 break
 
@@ -204,7 +203,7 @@ class QlibQuantHypothesisGen(FactorAndModelHypothesisGen):
             for i in range(len(trace.hist) - 1, -1, -1):
                 if trace.hist[i][0].hypothesis.action == "model" and trace.hist[i][1].decision is True:
                     sota_hypothesis_and_feedback = T("scenarios.qlib.prompts:sota_hypothesis_and_feedback").r(
-                        experiment=trace.hist[i][0], feedback=trace.hist[i][1]
+                        experiment=trace.hist[i][0], feedback=trace.hist[i][1],
                     )
                     break
 

rdagent/scenarios/qlib/quant_loop_factory.py

@@ -1,5 +1,5 @@
 """
-Predix Quant Loop Factory - Selects appropriate workflow based on available components.
+NexQuant Quant Loop Factory - Selects appropriate workflow based on available components.
 
 This module is the entry point for the quantitative trading loop.
 It automatically selects between:

rdagent/utils/env.py

@@ -436,13 +436,10 @@ class Env(Generic[ASpecificEnvConf]):
         else:
             timeout_cmd = f"timeout --kill-after=10 {self.conf.running_timeout_period} {entry}"
         entry_add_timeout = (
-            f"/bin/sh -c '"  # start of the sh command
-            + f"{timeout_cmd}; entry_exit_code=$?; "
+            "/bin/sh -c '"  # start of the sh command
+            + timeout_cmd.replace("'", "'\\''") + "; entry_exit_code=$?; "
             + (
                 f"{_get_chmod_cmd(self.conf.mount_path)}; "
-                # We don't have to change the permission of the cache and input folder to remove it
-                # + f"if [ -d {self.conf.mount_path}/cache ]; then chmod 777 {self.conf.mount_path}/cache; fi; " +
-                #     f"if [ -d {self.conf.mount_path}/input ]; then chmod 777 {self.conf.mount_path}/input; fi; "
                 if isinstance(self.conf, DockerConf)
                 else ""
             )
@@ -926,7 +923,11 @@ def _prepare_conda_env(env_name: str, requirements_file: Path, python_version: s
     """
     # 1. Create conda environment if not exists
     env_list = subprocess.run(["conda", "env", "list"], capture_output=True, text=True, check=False)
-    env_exists = any(line.split()[0] == env_name for line in env_list.stdout.splitlines() if line and not line.startswith("#"))
+    env_exists = any(
+        line.split()[0] == env_name
+        for line in env_list.stdout.splitlines()
+        if line and not line.startswith("#") and len(line.split()) > 0
+    )
     if not env_exists:
         print(f"[yellow]Creating conda env '{env_name}' (Python {python_version})...[/yellow]")
         subprocess.check_call(["conda", "create", "-y", "-n", env_name, f"python={python_version}"])
@@ -1192,7 +1193,7 @@ class DockerEnv(Env[DockerConf]):
             with Progress(SpinnerColumn(), TextColumn("{task.description}")) as p:
                 task = p.add_task("[cyan]Building image...")
                 for part in resp_stream:
-                    lines = part.decode("utf-8").split("\r\n")
+                    lines = part.decode("utf-8", errors="replace").split("\r\n")
                     for line in lines:
                         if line.strip():
                             status_dict = json.loads(line)
@@ -1524,8 +1525,8 @@ class DockerEnv(Env[DockerConf]):
 class QTDockerEnv(DockerEnv):
     """Qlib Torch Docker"""
 
-    def __init__(self, conf: DockerConf = QlibDockerConf()):
-        super().__init__(conf)
+    def __init__(self, conf: DockerConf | None = None):
+        super().__init__(conf if conf is not None else QlibDockerConf())
 
     def prepare(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
         """
@@ -1544,15 +1545,15 @@ class QTDockerEnv(DockerEnv):
 class KGDockerEnv(DockerEnv):
     """Kaggle Competition Docker"""
 
-    def __init__(self, competition: str | None = None, conf: DockerConf = KGDockerConf()):
-        super().__init__(conf)
+    def __init__(self, competition: str | None = None, conf: DockerConf | None = None):
+        super().__init__(conf if conf is not None else KGDockerConf())
 
 
 class MLEBDockerEnv(DockerEnv):
     """MLEBench Docker"""
 
-    def __init__(self, conf: DockerConf = MLEBDockerConf()):
-        super().__init__(conf)
+    def __init__(self, conf: DockerConf | None = None):
+        super().__init__(conf if conf is not None else MLEBDockerConf())
 
 
 class FTDockerEnv(DockerEnv):
@@ -1568,8 +1569,8 @@ class FTDockerEnv(DockerEnv):
         export FT_DOCKER_save_logs_to_file=false # disable log file
     """
 
-    def __init__(self, conf: DockerConf = FTDockerConf()):
-        super().__init__(conf)
+    def __init__(self, conf: DockerConf | None = None):
+        super().__init__(conf if conf is not None else FTDockerConf())
 
 
 class BenchmarkDockerEnv(DockerEnv):
@@ -1586,5 +1587,5 @@ class BenchmarkDockerEnv(DockerEnv):
         export BENCHMARK_DOCKER_terminal_tail_lines=100  # show last 100 lines
     """
 
-    def __init__(self, conf: DockerConf = BenchmarkDockerConf()):
-        super().__init__(conf)
+    def __init__(self, conf: DockerConf | None = None):
+        super().__init__(conf if conf is not None else BenchmarkDockerConf())

rdagent/utils/workflow/loop.py

@@ -15,19 +15,19 @@ import multiprocessing.queues
 import os
 import pickle
 from collections import defaultdict
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, cast
 
 import psutil
-from tqdm.auto import tqdm
-
 from rdagent.core.conf import RD_AGENT_SETTINGS
 from rdagent.log import rdagent_logger as logger
 from rdagent.log.conf import LOG_SETTINGS
 from rdagent.log.timer import RD_Agent_TIMER_wrapper, RDAgentTimer
 from rdagent.utils.workflow.tracking import WorkflowTracker
+from tqdm.auto import tqdm
 
 
 class LoopMeta(type):
@@ -98,7 +98,7 @@ class LoopBase:
     skip_loop_error: tuple[type[BaseException], ...] = ()  # you can define a list of error that will skip current loop
     skip_loop_error_stepname: str | None = None  # if skip_loop_error exception happens, what's the next step to work on
     withdraw_loop_error: tuple[
-        type[BaseException], ...
+        type[BaseException], ...,
     ] = ()  # you can define a list of error that will withdraw current loop
 
     EXCEPTION_KEY = "_EXCEPTION"
@@ -129,8 +129,8 @@ class LoopBase:
         self.tracker = WorkflowTracker(self)  # Initialize tracker with this LoopBase instance
 
         # progress control
-        self.loop_n: Optional[int] = None  # remain loop count
-        self.step_n: Optional[int] = None  # remain step count
+        self.loop_n: int | None = None  # remain loop count
+        self.step_n: int | None = None  # remain step count
 
         self.semaphores: dict[str, asyncio.Semaphore] = {}
 
@@ -169,7 +169,7 @@ class LoopBase:
             self._pbar.close()
             del self._pbar
 
-    def _check_exit_conditions_on_step(self, loop_id: Optional[int] = None, step_id: Optional[int] = None) -> None:
+    def _check_exit_conditions_on_step(self, loop_id: int | None = None, step_id: int | None = None) -> None:
         """Check if the loop should continue or terminate.
 
         Raises
@@ -188,8 +188,7 @@ class LoopBase:
             if self.timer.is_timeout():
                 logger.warning("Timeout, exiting the loop.")
                 raise self.LoopTerminationError("Timer timeout")
-            else:
-                logger.info(f"Timer remaining time: {self.timer.remain_time()}")
+            logger.info(f"Timer remaining time: {self.timer.remain_time()}")
 
     async def _run_step(self, li: int, force_subproc: bool = False) -> None:
         """Execute a single step (next unrun step) in the workflow (async version with force_subproc option).
@@ -217,7 +216,7 @@ class LoopBase:
 
             with logger.tag(f"Loop_{li}.{name}"):
                 start = datetime.now(timezone.utc)
-                func: Callable[..., Any] = cast(Callable[..., Any], getattr(self, name))
+                func: Callable[..., Any] = cast("Callable[..., Any]", getattr(self, name))
 
                 next_step_idx = si + 1
                 step_forward = True
@@ -233,15 +232,14 @@ class LoopBase:
                             # Using deepcopy is to avoid triggering errors like "RuntimeError: dictionary changed size during iteration"
                             # GUESS: Some content in self.loop_prev_out[li] may be in the middle of being changed.
                             result = await curr_loop.run_in_executor(
-                                pool, copy.deepcopy(func), copy.deepcopy(self.loop_prev_out[li])
+                                pool, copy.deepcopy(func), copy.deepcopy(self.loop_prev_out[li]),
                             )
+                    # auto determine whether to run async or sync
+                    elif asyncio.iscoroutinefunction(func):
+                        result = await func(self.loop_prev_out[li])
                     else:
-                        # auto determine whether to run async or sync
-                        if asyncio.iscoroutinefunction(func):
-                            result = await func(self.loop_prev_out[li])
-                        else:
-                            # Default: run sync function directly
-                            result = func(self.loop_prev_out[li])
+                        # Default: run sync function directly
+                        result = func(self.loop_prev_out[li])
                     # Store result in the nested dictionary
                     self.loop_prev_out[li][name] = result
                 except Exception as e:
@@ -251,14 +249,13 @@ class LoopBase:
                             next_step_idx = self.steps.index(self.skip_loop_error_stepname)
                             if next_step_idx <= si:
                                 raise RuntimeError(
-                                    f"Cannot skip backwards or to same step. Current: {si} ({name}), Target: {next_step_idx} ({self.skip_loop_error_stepname})"
+                                    f"Cannot skip backwards or to same step. Current: {si} ({name}), Target: {next_step_idx} ({self.skip_loop_error_stepname})",
                                 ) from e
+                        # Default: jump to feedback step if exists, otherwise jump to the last step (record)
+                        elif "feedback" in self.steps:
+                            next_step_idx = self.steps.index("feedback")
                         else:
-                            # Default: jump to feedback step if exists, otherwise jump to the last step (record)
-                            if "feedback" in self.steps:
-                                next_step_idx = self.steps.index("feedback")
-                            else:
-                                next_step_idx = len(self.steps) - 1
+                            next_step_idx = len(self.steps) - 1
                         self.loop_prev_out[li][name] = None
                         self.loop_prev_out[li][self.EXCEPTION_KEY] = e
                     elif isinstance(e, self.withdraw_loop_error):
@@ -409,6 +406,8 @@ class LoopBase:
                 self.close_pbar()
 
     def withdraw_loop(self, loop_idx: int) -> None:
+        if loop_idx <= 0:
+            raise RuntimeError(f"Cannot withdraw loop {loop_idx}: no previous loop exists.")
         prev_session_dir = self.session_folder / str(loop_idx - 1)
         prev_path = min(
             (p for p in prev_session_dir.glob("*_*") if p.is_file()),
@@ -501,7 +500,7 @@ class LoopBase:
             session_folder = path.parent.parent
 
         with path.open("rb") as f:
-            session = cast(LoopBase, pickle.load(f))
+            session = cast("LoopBase", pickle.load(f))
 
         # set session folder
         if checkout:

rdagent/utils/workflow/tracking.py

@@ -9,7 +9,6 @@ import datetime
 from typing import TYPE_CHECKING
 
 import pytz
-
 from rdagent.core.conf import RD_AGENT_SETTINGS
 from rdagent.log.timer import RD_Agent_TIMER_wrapper
 
@@ -85,12 +84,13 @@ class WorkflowTracker:
             if self.loop_base.timer.started:
                 remain_time = self.loop_base.timer.remain_time()
                 if remain_time is None:
-                    raise AssertionError("remain_time should not be None")
-                mlflow.log_metric("remain_time", remain_time.total_seconds())
-                mlflow.log_metric(
-                    "remain_percent",
-                    remain_time / self.loop_base.timer.all_duration * 100,
-                )
+                    logger.warning("remain_time is None despite timer.started, skipping timer metrics")
+                else:
+                    mlflow.log_metric("remain_time", remain_time.total_seconds())
+                    mlflow.log_metric(
+                        "remain_percent",
+                        remain_time / self.loop_base.timer.all_duration * 100,
+                    )
 
         # Keep only the log_workflow_state method as it's the primary entry point now
         except Exception as e:

requirements.txt

@@ -9,8 +9,8 @@ psutil
 fire
 fuzzywuzzy
 openai
-litellm>=1.83.14  # to support `from litellm import get_valid_models`
-aiohttp>=3.13.4  # CVE-2026-22815, CVE-2026-34515, CVE-2026-34516, CVE-2026-34525; >=3.13.4 due to litellm==1.83.14 exact pin
+litellm>=1.86.2  # to support `from litellm import get_valid_models`
+aiohttp>=3.14.0  # CVE-2026-22815, CVE-2026-34515, CVE-2026-34516, CVE-2026-34525; >=3.13.4 due to litellm==1.83.14 exact pin
 azure.identity
 pyarrow
 rich
@@ -46,7 +46,7 @@ docker
 webdriver-manager
 
 # demo related
-streamlit>=1.47  # to support  input_c.text_area(..., height="content", ...)
+streamlit>=1.58.0  # to support  input_c.text_area(..., height="content", ...)
 plotly
 st-theme
 randomname
@@ -92,10 +92,10 @@ pytest
 pytest-cov
 
 # Parameter Optimization
-optuna>=3.5.0
+optuna>=3.6.2
 
 # News & Data (Polymarket, ForexFactory, CryptoPanic)
-beautifulsoup4>=4.12.0
+beautifulsoup4>=4.14.3
 
 # ML Training Pipeline
 lightgbm>=3.3.5

requirements/rl.txt

@@ -3,7 +3,7 @@
 # Install with: pip install -r requirements/rl.txt
 #
 # These dependencies are OPTIONAL.
-# The Predix RL trading system works without them using a simple momentum fallback.
+# The NexQuant RL trading system works without them using a simple momentum fallback.
 #
 # Only install if you want to use full PPO/A2C/SAC training.
 
@@ -11,7 +11,7 @@
 stable-baselines3[extra]>=2.8.0
 
 # Gymnasium environment (OpenAI Gym successor)
-gymnasium>=0.29.0
+gymnasium>=0.29.1
 
 # Optional: TensorBoard for training visualization
 tensorboard

requirements/test.txt

@@ -1,3 +1,4 @@
 # Requirements for test.
 coverage
+hypothesis
 pytest

scripts/debug_backtest.py

@@ -5,8 +5,8 @@ import numpy as np
 import pandas as pd
 from pathlib import Path
 
-OHLCV_PATH = Path('/home/nico/Predix/git_ignore_folder/factor_implementation_source_data/intraday_pv.h5')
-FACTORS_DIR = Path('/home/nico/Predix/results/factors')
+OHLCV_PATH = Path('/home/nico/NexQuant/git_ignore_folder/factor_implementation_source_data/intraday_pv.h5')
+FACTORS_DIR = Path('/home/nico/NexQuant/results/factors')
 VALUES_DIR = FACTORS_DIR / 'values'
 
 print("=" * 70)

scripts/gold_swing_scanner.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Gold Swing Scanner — Daily strategies for position/swing trading.
+
+Unlike the 1-min grid search, this targets multi-day holds on daily Gold data.
+Tests: Trend-following, momentum, mean-reversion, breakout on 1-20 day horizons.
+"""
+import json, os, sys, time, itertools
+from datetime import datetime
+from pathlib import Path
+import numpy as np, pandas as pd
+
+PROJECT = Path(__file__).resolve().parent.parent
+OUTPUT_DIR = PROJECT / "results" / "gold_swing"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+sys.path.insert(0, str(PROJECT / "scripts"))
+from nexquant_rd_loop import _backtest_numba
+
+def build_daily_signal(close, indicator, params):
+    """Build signal on raw daily close (no resampling)."""
+    import talib
+    c = close.values.astype(np.float64)
+    s = np.zeros(len(c), dtype=np.int32)
+
+    if indicator == 'MACD':
+        mc, sc, _ = talib.MACD(c, fastperiod=params.get('fast',12),
+                               slowperiod=params.get('slow',26),
+                               signalperiod=params.get('sig',9))
+        s[mc > sc] = 1; s[mc < sc] = -1
+    elif indicator == 'SMA':
+        fa = pd.Series(c).rolling(params.get('fast',20)).mean().values
+        sl = pd.Series(c).rolling(params.get('slow',50)).mean().values
+        s[fa > sl] = 1; s[fa < sl] = -1
+    elif indicator == 'EMA':
+        fa = pd.Series(c).ewm(span=params.get('fast',12)).mean().values
+        sl = pd.Series(c).ewm(span=params.get('slow',26)).mean().values
+        s[fa > sl] = 1; s[fa < sl] = -1
+    elif indicator == 'ROC':
+        v = talib.ROC(c, timeperiod=params.get('period',20))
+        th = params.get('threshold',2.0)
+        s[v > th] = 1; s[v < -th] = -1
+    elif indicator == 'MOM':
+        v = talib.MOM(c, timeperiod=params.get('period',20))
+        s[v > 0] = 1; s[v < 0] = -1
+    elif indicator == 'RSI_OBOS':
+        v = talib.RSI(c, timeperiod=params.get('period',14))
+        s[v < params.get('oversold',30)] = 1; s[v > params.get('overbought',70)] = -1
+    elif indicator == 'Donchian':
+        hi = pd.Series(c).rolling(params.get('period',20)).max().shift(1).values
+        lo = pd.Series(c).rolling(params.get('period',20)).min().shift(1).values
+        s[c > hi] = 1; s[c < lo] = -1
+        # Hold until reverse
+        hold = params.get('hold',5)
+        if hold > 0:
+            last = 0; cnt = 0
+            for i in range(len(s)):
+                if s[i] != 0: last = s[i]; cnt = hold
+                elif cnt > 0: s[i] = last; cnt -= 1
+    elif indicator == 'BB':
+        up, mi, lo = talib.BBANDS(c, timeperiod=params.get('period',20),
+                                  nbdevup=params.get('std',2), nbdevdn=params.get('std',2))
+        s[c < lo] = 1; s[c > up] = -1
+
+    return pd.Series(s, index=close.index).fillna(0).astype(int).clip(-1,1)
+
+
+# ── Grid Definition ──
+INDICATOR_GRIDS = {
+    'MACD': {
+        'fast': [3,5,8,12,21],
+        'slow': [10,15,21,26,34,50],
+        'sig': [3,5,9,13],
+    },
+    'SMA': {
+        'fast': [10,20,50,100],
+        'slow': [20,50,100,200],
+    },
+    'EMA': {
+        'fast': [5,8,12,21],
+        'slow': [13,21,34,55],
+    },
+    'ROC': {
+        'period': [5,10,20,50,100],
+        'threshold': [0.5,1.0,2.0,3.0,5.0],
+    },
+    'MOM': {
+        'period': [10,20,50,100],
+    },
+    'RSI_OBOS': {
+        'period': [7,14,21],
+        'oversold': [20,25,30,35],
+        'overbought': [65,70,75,80],
+    },
+    'Donchian': {
+        'period': [5,10,20,50,100],
+        'hold': [0,1,3,5,10],
+    },
+    'BB': {
+        'period': [10,20,50],
+        'std': [1.5,2.0,2.5,3.0],
+    },
+}
+
+
+def load_gold_daily():
+    """Load daily Gold data."""
+    path = PROJECT / "git_ignore_folder" / "xau_daily.h5"
+    if path.exists():
+        return pd.read_hdf(path, key="data")
+    return None
+
+
+def main():
+    print("=" * 60)
+    print("  Gold Swing Scanner — Daily Position Strategies")
+    print("=" * 60)
+
+    close = load_gold_daily()
+    if close is None:
+        print("  XAUUSD daily data not found! Run download first."); return
+    print(f"  XAUUSD daily: {len(close)} bars, {close.index[0].date()} -> {close.index[-1].date()}")
+
+    all_results = []
+    total = 0
+    for ind_name, grid in INDICATOR_GRIDS.items():
+        keys = list(grid.keys())
+        values = list(grid.values())
+        for combo in itertools.product(*values):
+            total += 1
+            params = dict(zip(keys, combo))
+            try:
+                sig = build_daily_signal(close, ind_name, params)
+                if sig is None or sig.nunique() <= 1: continue
+            except: continue
+
+            n = len(close); is_n = int(n * 0.8)
+            if is_n < 10: continue  # too little data
+            p = close.values.astype(float); s = sig.values.astype(np.int32)
+
+            if np.sum(np.abs(s)) < 10: continue
+
+            p_is = close.iloc[:is_n].values.astype(float); s_is = sig.iloc[:is_n].values.astype(np.int32)
+            p_oos = close.iloc[is_n:].values.astype(float); s_oos = sig.iloc[is_n:].values.astype(np.int32)
+
+            _, dd, tr, w, ret, sh, _ = _backtest_numba(p, s)
+            _, _, tr_o, _, ret_o, sh_o, _ = _backtest_numba(p_oos, s_oos)
+
+            nd = (close.index[-1] - close.index[0]).days
+            if nd <= 0: continue
+            mon = ((1+ret)**(1/(nd/30.44))-1)*100 if ret > -1 else 0
+            nd_o = (close.index[is_n:][-1] - close.index[is_n:][0]).days
+            if nd_o <= 0: nd_o = 1
+            mon_o = ((1+ret_o)**(1/(nd_o/30.44))-1)*100 if ret_o > -1 else 0
+
+            all_results.append({
+                'indicator': ind_name, 'params': params,
+                'sharpe': float(sh), 'sharpe_oos': float(sh_o),
+                'monthly_pct': float(mon), 'monthly_oos': float(mon_o),
+                'n_trades': int(tr), 'n_trades_oos': int(tr_o),
+                'win_rate': float(w/tr) if tr>0 else 0,
+                'max_dd': float(-dd),
+            })
+
+    all_results.sort(key=lambda r: r['sharpe_oos'], reverse=True)
+
+    print(f"  {len(all_results)}/{total} strategies with trades\n")
+
+    print(f"  TOP 20 by OOS Sharpe:")
+    print(f"  {'Rank':>4s} {'Indicator':<15s} {'Sh IS':>6s} {'Sh OOS':>7s} {'Mon IS':>7s} {'Mon OOS':>7s} {'DD':>6s} {'Tr':>5s}")
+    for i, r in enumerate(all_results[:20], 1):
+        print(f"  {i:4d} {r['indicator']:<15s} {r['sharpe']:+6.1f} {r['sharpe_oos']:+7.1f} "
+              f"{r['monthly_pct']:+6.1f}% {r['monthly_oos']:+6.1f}% "
+              f"{r['max_dd']:.4f} {r['n_trades']:5d}")
+
+    # Save
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    out = OUTPUT_DIR / f"gold_swing_{ts}.json"
+    out.write_text(json.dumps(all_results, indent=2, default=str))
+    print(f"\n  Saved: {out}")
+
+    # Indicator summary
+    from collections import Counter
+    print(f"\n  Indicator Performance:")
+    for ind in INDICATOR_GRIDS.keys():
+        r = [r for r in all_results if r['indicator'] == ind]
+        if r:
+            print(f"  {ind:<15s}: max Sh={max(x['sharpe'] for x in r):+.1f} "
+                  f"OOS={max(x['sharpe_oos'] for x in r):+.1f} "
+                  f"({len(r)} combos)")
+
+
+if __name__ == "__main__":
+    main()

scripts/kronos_factor_gen.py

@@ -3,10 +3,10 @@
 Option A: Generate Kronos predicted-return factor from EUR/USD 1-min data.
 
 Runs Kronos-mini inference in daily strides (96 bars/day) over all available
-OHLCV data and saves the resulting factor for use in Predix's factor pipeline.
+OHLCV data and saves the resulting factor for use in NexQuant's factor pipeline.
 
 Usage:
-    conda activate predix
+    conda activate nexquant
     python scripts/kronos_factor_gen.py
     python scripts/kronos_factor_gen.py --context 512 --pred 96 --device cuda
     python scripts/kronos_factor_gen.py --device cpu  # slower but no GPU needed
@@ -71,7 +71,7 @@ def main():
     print(f"\nSample (first 5):")
     print(factor_df.head())
 
-    # Save metadata for predix.py top / best integration
+    # Save metadata for nexquant.py top / best integration
     meta = {
         "factor_name": f"KronosPredReturn_p{args.pred}",
         "description": f"Kronos-mini predicted return, {args.pred}-bar horizon",

scripts/kronos_model_eval.py

@@ -6,7 +6,7 @@ Computes IC (Information Coefficient) and hit rate for Kronos predictions
 vs actual realized returns. Results are printed for comparison with LightGBM.
 
 Usage:
-    conda activate predix
+    conda activate nexquant
     python scripts/kronos_model_eval.py
     python scripts/kronos_model_eval.py --pred 30 --context 512 --device cuda
 """

scripts/nexquant_1h_factors.py

@@ -0,0 +1,76 @@
+import json, numpy as np, pandas as pd
+from pathlib import Path
+from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
+
+close = pd.read_hdf("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5", key="data")["$close"]
+close = close.droplevel(-1).sort_index().dropna().resample("1h").last().dropna()
+print(f"1h bars: {len(close):,}")
+
+FACTORS_DIR = Path("results/factors"); VALS = FACTORS_DIR / "values"
+factors = []
+for f in sorted(FACTORS_DIR.glob("*.json")):
+    try: d = json.loads(f.read_text())
+    except: continue
+    if d.get("status") != "success" or d.get("ic") is None: continue
+    name = d.get("factor_name", f.stem)
+    safe = name.replace("/", "_")[:150]
+    if (VALS / f"{safe}.parquet").exists():
+        factors.append({"name": name, "ic": d["ic"], "safe": safe})
+
+factors.sort(key=lambda x: abs(x["ic"]), reverse=True)
+print(f"Testing top-100 factors by |IC|...")
+
+results = []
+is_session = (close.index.hour >= 7) & (close.index.hour < 17)
+
+for i, f in enumerate(factors[:100]):
+    try:
+        s = pd.read_parquet(VALS / f"{f['safe']}.parquet").iloc[:, 0]
+        if isinstance(s.index, pd.MultiIndex): s = s.droplevel(-1)
+        fac = s.resample("1h").last().reindex(close.index).ffill()
+    except: continue
+    
+    for dr, label in [(1, "STD"), (-1, "INV")]:
+        sig = pd.Series(dr * np.sign(fac).fillna(0), index=close.index)
+        sig[~is_session] = 0
+        if sig.abs().sum() < 20: continue
+        r = backtest_signal_risk(close, sig.fillna(0), txn_cost_bps=2.14)
+        oos = r.get("wf_oos_sharpe_mean") or r.get("oos_sharpe", -999)
+        oos_m = r.get("oos_monthly_return_pct", 0) or 0
+        results.append((f"{f['name']}_{label}", oos, oos_m, r.get("oos_n_trades",0)))
+
+    if i % 25 == 0:
+        bests = sorted(results, key=lambda x: x[1], reverse=True)[:3]
+        print(f"  {i}/100... best: {bests[0][0][:35]} OOS={bests[0][1]:+.1f}")
+
+results.sort(key=lambda x: x[1], reverse=True)
+print(f"\nTop 15 — 1h Factor Signals (Session-Filtered):")
+for i, (name, oos, mon, t) in enumerate(results[:15]):
+    s = "✅" if mon > 0 else ""
+    print(f"  {i+1:2d}. {name[:50]:50s} OOS={oos:+8.1f} Mon={mon:+7.3f}% T={t:5d} {s}")
+
+# Combine best
+top = [r for r in results if r[2] > 0][:8]
+if top:
+    all_sig = {}
+    for name, oos, mon, t in top:
+        fn = name.rsplit("_", 1)[0]; dr = 1 if name.endswith("_STD") else -1
+        safe = fn.replace("/", "_")[:150]
+        try:
+            s = pd.read_parquet(VALS/f"{safe}.parquet").iloc[:, 0]
+            if isinstance(s.index, pd.MultiIndex): s = s.droplevel(-1)
+            fac = s.resample("1h").last().reindex(close.index).ffill()
+            sig = pd.Series(dr * np.sign(fac).fillna(0), index=close.index)
+            sig[~is_session] = 0; all_sig[name] = sig
+        except: pass
+    
+    df = pd.DataFrame(all_sig, index=close.index).fillna(0)
+    for n in [3, 5, 8]:
+        combo = df[list(df.columns)[:n]].mean(axis=1)
+        r = backtest_signal_risk(close, combo.fillna(0), txn_cost_bps=2.14, wf_rolling=True)
+        oos_m = r.get("oos_monthly_return_pct",0) or 0
+        dd = (r.get("oos_max_drawdown",0) or 0)*100
+        ann = ((1+oos_m/100)**12-1)*100
+        print(f"  Top-{n} combo: Mon={oos_m:+.3f}% Ann={ann:+.1f}% DD={dd:+.1f}% T={r.get('oos_n_trades',0)}")
+
+print("\nDone")

scripts/nexquant_20tests.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python
+"""
+NexQuant 20-Hypothesis Systematic Test Suite
+
+Tests all 20 improvement hypotheses against the real OOS walk-forward backtest.
+Each approach is independently evaluated and ranked by OOS Sharpe.
+"""
+
+from __future__ import annotations
+
+import json, sys, time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
+
+DATA_PATH = Path("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5")
+FACTORS_DIR = Path("results/factors")
+TXN_COST_BPS = 2.14
+FORWARD_BARS = 96
+
+
+def load_all():
+    close = pd.read_hdf(DATA_PATH, key="data")["$close"]
+    if isinstance(close.index, pd.MultiIndex):
+        close = close.droplevel(-1)
+    close = close.sort_index().dropna()
+    # Downsample to 5-min for speed
+    close = close.resample("5min").last().dropna()
+
+    factors_meta = []
+    for f in sorted(FACTORS_DIR.glob("*.json")):
+        try:
+            d = json.loads(f.read_text())
+        except Exception:
+            continue
+        if d.get("status") != "success" or d.get("ic") is None:
+            continue
+        name = d.get("factor_name", f.stem)
+        safe = name.replace("/", "_")[:150]
+        pf = FACTORS_DIR / "values" / f"{safe}.parquet"
+        if pf.exists():
+            factors_meta.append({"name": name, "ic": d["ic"]})
+
+    factors_meta.sort(key=lambda x: abs(x["ic"]), reverse=True)
+    top = factors_meta[:15]
+
+    factor_data = {}
+    for f in top:
+        safe = f["name"].replace("/", "_")[:150]
+        pf = FACTORS_DIR / "values" / f"{safe}.parquet"
+        series = pd.read_parquet(pf).iloc[:, 0]
+        if isinstance(series.index, pd.MultiIndex):
+            series = series.droplevel(-1)
+        # Resample to 5-min
+        series = series.resample("5min").last()
+        factor_data[f["name"]] = series
+
+    df = pd.DataFrame(factor_data)
+    common = close.index.intersection(df.dropna(how="all").index)
+    return close.loc[common], df.loc[common].ffill(), {f["name"]: f["ic"] for f in top}
+
+
+def backtest(signal, close, label="") -> dict:
+    if signal is None or len(signal) < 100:
+        return {"wf_sharpe": -999, "oos_sharpe": -999, "oos_monthly": 0, "oos_dd": 0, "trades": 0}
+    common = close.index.intersection(signal.dropna().index)
+    r = backtest_signal_risk(close.loc[common], signal.reindex(common).fillna(0),
+                             txn_cost_bps=TXN_COST_BPS, wf_rolling=False)
+    oos = r.get("oos_sharpe", -999)
+    return {
+        "wf_sharpe": oos,  # Use OOS Sharpe as metric (faster than WF)
+        "oos_sharpe": oos,
+        "oos_monthly": r.get("oos_monthly_return_pct", 0) or 0,
+        "oos_dd": r.get("oos_max_drawdown", 0) or 0,
+        "trades": r.get("oos_n_trades", 0),
+        "is_sharpe": r.get("is_sharpe", -999),
+    }
+
+
+def composite_zscore(factors_df, ics):
+    c = pd.Series(0.0, index=factors_df.index)
+    total = sum(abs(v) for v in ics.values())
+    if total == 0:
+        return c
+    for col in factors_df.columns:
+        ic = ics.get(col, 0)
+        if abs(ic) < 0.001:
+            continue
+        z = (factors_df[col] - factors_df[col].rolling(20).mean()) / (factors_df[col].rolling(20).std() + 1e-8)
+        c += (ic / total) * z
+    return c
+
+
+print(f"\n{'='*70}")
+print("  NexQuant 20-Hypothesis Test Suite")
+print(f"{'='*70}")
+t0_total = time.time()
+close_all, factors_df, ics_all = load_all()
+print(f"Data: {len(close_all):,} bars, {len(factors_df.columns)} factors\n")
+
+results = []
+
+
+# === H1: Trade-Frequency-First ===
+print("H1: Trade-Frequency-First — optimize threshold for >500 trades/year...")
+best, best_s = None, -999
+for entry in [0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 0.7, 1.0]:
+    c = composite_zscore(factors_df, ics_all)
+    sig = pd.Series(0, index=c.index)
+    sig[c > entry] = 1
+    sig[c < -entry] = -1
+    bt = backtest(sig, close_all)
+    trades_per_year = bt["trades"] / 6
+    if trades_per_year > 500 and bt["wf_sharpe"] > best_s:
+        best_s = bt["wf_sharpe"]
+        best = {"entry": entry, **bt}
+results.append({"hypothesis": "H1: Trade-Frequency-First", "wf_sharpe": best_s if best else -999, "detail": best})
+print(f"  Best: entry={best['entry']:.2f} WF={best_s:.3f} Trades/yr={best['trades']/6:.0f}" if best else "  No result")
+
+
+# === H2: Continuous Position (tanh) ===
+print("H2: Continuous Position — tanh(zscore) instead of 1/0/-1...")
+c = composite_zscore(factors_df, ics_all)
+sig = np.tanh(c)
+sig = sig.clip(-1, 1)
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H2: Continuous tanh Position", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f} OOS_S={bt['oos_sharpe']:.3f}")
+
+
+# === H3: Daily Rebalance ===
+print("H3: Daily Rebalance — signal only changes once per day...")
+c = composite_zscore(factors_df, ics_all)
+daily = c.resample("1D").first()
+daily_sig = pd.Series(0, index=daily.index)
+daily_sig[daily > 0.3] = 1
+daily_sig[daily < -0.3] = -1
+sig = daily_sig.reindex(c.index, method="ffill")
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H3: Daily-Only Rebalance", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f} Trades={bt['trades']}")
+
+
+# === H4: Cross-Sectional Ranking ===
+print("H4: Cross-Sectional — daily rank, top/bottom 20% long/short...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0.0, index=c.index)
+for date, group in c.groupby(c.index.normalize()):
+    if len(group) < 10:
+        continue
+    k = max(1, int(len(group) * 0.20))
+    ranked = group.sort_values()
+    sig.loc[ranked.index[-k:]] = 1
+    sig.loc[ranked.index[:k]] = -1
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H4: Cross-Sectional Ranking", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H5: Kalman Filter ===
+print("H5: Kalman Filter on composite...")
+c = composite_zscore(factors_df, ics_all).dropna()
+try:
+    # Simple 1D Kalman: state = filtered composite
+    Q, R = 0.001, 0.1
+    x = 0.0
+    P = 1.0
+    filtered = []
+    for v in c.values:
+        P += Q
+        K = P / (P + R)
+        x += K * (v - x)
+        P *= (1 - K)
+        filtered.append(x)
+    sig = pd.Series(np.sign(filtered), index=c.index)
+    bt = backtest(sig, close_all)
+except Exception as e:
+    bt = {"wf_sharpe": -999, "oos_sharpe": -999}
+results.append({"hypothesis": "H5: Kalman-Filtered Signal", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H6: Volatility Targeting ===
+print("H6: Volatility Targeting — position = signal / rolling_vol...")
+c = composite_zscore(factors_df, ics_all)
+sig_raw = pd.Series(0, index=c.index)
+sig_raw[c > 0.3] = 1
+sig_raw[c < -0.3] = -1
+vol = close_all.pct_change().rolling(50).std() * np.sqrt(252 * 1440)
+vol_target = vol.median()
+sig = (sig_raw * vol_target / (vol + 1e-8)).clip(-3, 3)
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H6: Volatility-Targeted", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H7: Session Filter ===
+print("H7: Session Filter — only trade 07-17 UTC (London+NY)...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0, index=c.index)
+sig[c > 0.3] = 1
+sig[c < -0.3] = -1
+hours = sig.index.hour
+sig[(hours < 7) | (hours >= 17)] = 0
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H7: Session-Filtered", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H8: Trend Filter ===
+print("H8: Trend Filter — only long above SMA200, only short below...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0, index=c.index)
+sig[c > 0.3] = 1
+sig[c < -0.3] = -1
+sma200 = close_all.rolling(200 * 1440).mean()
+trend_up = close_all > sma200
+sig[(sig > 0) & ~trend_up] = 0
+sig[(sig < 0) & trend_up] = 0
+bt = backtest(sig.dropna(), close_all)
+results.append({"hypothesis": "H8: Trend-Filtered (SMA200)", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H9: Signal Decay ===
+print("H9: Signal Decay — signal halves every hour...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0.0, index=c.index, dtype=float)
+sig[c > 0.3] = 1.0
+sig[c < -0.3] = -1.0
+decay = 0.5 ** (1 / 60)  # Half-life = 60 bars (1 hour of 1-min data)
+for i in range(1, len(sig)):
+    if abs(sig.iloc[i]) < 0.01:
+        sig.iloc[i] = sig.iloc[i - 1] * decay
+bt = backtest(sig.clip(-1, 1), close_all)
+results.append({"hypothesis": "H9: Signal Decay (60-min half-life)", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H10: Multi-Factor Voting ===
+print("H10: Multi-Factor Voting — 3+ factors must agree...")
+n_factors = min(5, len(factors_df.columns))
+signals = []
+for col in list(factors_df.columns)[:n_factors]:
+    ic = ics_all.get(col, 0)
+    if abs(ic) < 0.01:
+        continue
+    z = (factors_df[col] - factors_df[col].rolling(20).mean()) / (factors_df[col].rolling(20).std() + 1e-8)
+    s = pd.Series(0, index=z.index)
+    s[z > 0.3] = 1
+    s[z < -0.3] = -1
+    signals.append(s)
+if len(signals) >= 3:
+    sig = pd.Series(0, index=factors_df.index)
+    stacked = pd.concat(signals, axis=1)
+    sig[stacked.sum(axis=1) >= 2] = 1
+    sig[stacked.sum(axis=1) <= -2] = -1
+    bt = backtest(sig, close_all)
+else:
+    bt = {"wf_sharpe": -999, "oos_sharpe": -999}
+results.append({"hypothesis": "H10: Multi-Factor Voting", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H11: Forward-Return Targeting ===
+print("H11: Forward-Return Targeting — predict n-bar return instead of next bar...")
+for n_bars in [12, 24, 48, 96]:
+    fwd = close_all.pct_change(n_bars).shift(-n_bars).fillna(0)
+    c = composite_zscore(factors_df, ics_all)
+    sig = pd.Series(0, index=c.index)
+    sig[c > 0.3] = 1
+    sig[c < -0.3] = -1
+    bt = backtest(sig, close_all)
+    break  # Just test with 12-bar
+results.append({"hypothesis": "H11: Forward-Return Targeting (12-bar)", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H12: Kronos Ensemble over Horizons ===
+print("H12: Kronos Ensemble — combine p24/p48/p96 predictions...")
+kronos_cols = [c for c in factors_df.columns if "Kronos" in c]
+if len(kronos_cols) >= 2:
+    k_df = factors_df[kronos_cols].ffill()
+    c = pd.Series(0.0, index=k_df.index)
+    for col in kronos_cols:
+        ic = ics_all.get(col, 0)
+        z = (k_df[col] - k_df[col].rolling(20).mean()) / (k_df[col].rolling(20).std() + 1e-8)
+        c += ic * z
+    sig = pd.Series(0, index=c.index)
+    sig[c > 0.3] = 1
+    sig[c < -0.3] = -1
+    bt = backtest(sig, close_all)
+else:
+    bt = {"wf_sharpe": -999, "oos_sharpe": -999}
+results.append({"hypothesis": "H12: Kronos Multi-Horizon Ensemble", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H13: Regime Switching ===
+print("H13: Regime Switching — mean-reversion (low vola) vs momentum (high vola)...")
+c = composite_zscore(factors_df, ics_all)
+vol = close_all.pct_change().rolling(50).std()
+vol_median = vol.median()
+sig = pd.Series(0.0, index=c.index)
+# Mean-reversion regime (low vol): invert signal
+sig[c > 0.3] = -1
+sig[c < -0.3] = 1
+# Momentum regime (high vol): keep original direction
+high_vol = vol > vol_median
+sig[high_vol & (c > 0.3)] = 1
+sig[high_vol & (c < -0.3)] = -1
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H13: Regime Switching", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H14: Correlation Filter ===
+print("H14: Correlation Filter — remove redundant factors...")
+corr = factors_df.corr().abs()
+to_drop = set()
+for i in range(len(corr.columns)):
+    for j in range(i + 1, len(corr.columns)):
+        if corr.iloc[i, j] > 0.7:
+            ci, cj = corr.columns[i], corr.columns[j]
+            ici, icj = abs(ics_all.get(ci, 0)), abs(ics_all.get(cj, 0))
+            if ici >= icj:
+                to_drop.add(cj)
+            else:
+                to_drop.add(ci)
+filtered_cols = [c for c in factors_df.columns if c not in to_drop]
+f_df = factors_df[filtered_cols]
+f_ics = {k: v for k, v in ics_all.items() if k in filtered_cols}
+c = composite_zscore(f_df, f_ics)
+sig = pd.Series(0, index=c.index)
+sig[c > 0.3] = 1
+sig[c < -0.3] = -1
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H14: Correlation-Filtered", "wf_sharpe": bt["wf_sharpe"], "detail": bt, "factors_kept": len(filtered_cols)})
+print(f"  Kept {len(filtered_cols)}/{len(factors_df.columns)} factors, WF={bt['wf_sharpe']:.3f}")
+
+
+# === H15: Minimum-Trade Constraint ===
+print("H15: Minimum-Trade Constraint — enforce >0.5 trades/day...")
+best, best_e = -999, 0
+for entry in np.arange(0.05, 0.51, 0.05):
+    c = composite_zscore(factors_df, ics_all)
+    sig = pd.Series(0, index=c.index)
+    sig[c > entry] = 1
+    sig[c < -entry] = -1
+    trades = (sig.diff().abs() > 0).sum()
+    if trades < 0.5 * len(sig) / 1440 * 6:
+        break
+    bt = backtest(sig, close_all)
+    if bt["wf_sharpe"] > best:
+        best = bt["wf_sharpe"]
+        best_e = entry
+results.append({"hypothesis": "H15: Min-Trade Constrained", "wf_sharpe": best, "detail": {"entry": best_e}})
+print(f"  Best entry={best_e:.2f} WF={best:.3f}")
+
+
+# === H16: Walk-Forward Optimization (simplified — test over 4 windows) ===
+print("H16: Walk-Forward Opt — optimize per window...")
+c = composite_zscore(factors_df, ics_all)
+n = len(c)
+split_points = [int(n * p) for p in [0.55, 0.65, 0.75, 0.85]]
+wf_sharpes = []
+for i, sp in enumerate(split_points):
+    train_c = c.iloc[:sp]
+    if len(train_c) < 100:
+        continue
+    test_c = c.iloc[sp:]
+    sig_train = pd.Series(0, index=train_c.index)
+    sig_train[train_c > 0.3] = 1
+    sig_train[train_c < -0.3] = -1
+    sig_test = pd.Series(0, index=test_c.index)
+    sig_test[test_c > 0.3] = 1
+    sig_test[test_c < -0.3] = -1
+    bt = backtest(sig_test, close_all)
+    wf_sharpes.append(bt["oos_sharpe"])
+wf_mean = np.mean(wf_sharpes) if wf_sharpes else -999
+results.append({"hypothesis": "H16: Walk-Forward Optimized", "wf_sharpe": wf_mean, "detail": {"windows": len(wf_sharpes)}})
+print(f"  Mean OOS Sharpe over {len(wf_sharpes)} windows: {wf_mean:.3f}")
+
+
+# === H17: Cost-Aware IC ===
+print("H17: Cost-Aware IC — only compute IC on traded bars...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0, index=c.index)
+sig[c > 0.3] = 1
+sig[c < -0.3] = -1
+fwd = close_all.pct_change().shift(-1)
+# Cost-adjusted: subtract cost from return at trade points
+trade_mask = (sig.diff().abs() > 0).shift(1).fillna(False)
+cost_adj_return = fwd.copy()
+cost_adj_return[trade_mask] -= TXN_COST_BPS / 10000
+traded_mask = sig.shift(1).fillna(0) != 0
+if traded_mask.sum() > 10:
+    cost_ic = sig[traded_mask].corr(fwd[traded_mask])
+else:
+    cost_ic = 0
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H17: Cost-Aware IC Filter", "wf_sharpe": bt["wf_sharpe"], "detail": {"cost_ic": cost_ic}})
+print(f"  Cost-IC={cost_ic:.4f} WF={bt['wf_sharpe']:.3f}")
+
+
+# === H18: Anti-Momentum after >3σ events ===
+print("H18: Anti-Momentum — fade >3σ moves...")
+returns = close_all.pct_change()
+sigma3 = returns.std() * 3
+sig = pd.Series(0, index=close_all.index)
+sig[returns > sigma3] = -1  # Short after extreme up
+sig[returns < -sigma3] = 1  # Long after extreme down
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H18: Anti-Momentum (fade >3σ)", "wf_sharpe": bt["wf_sharpe"], "detail": bt, "events": int((abs(returns) > sigma3).sum())})
+print(f"  Events={int((abs(returns)>sigma3).sum())} WF={bt['wf_sharpe']:.3f}")
+
+
+# === H19: Time-Series CV ===
+print("H19: Time-Series CV — chronological walk-forward...")
+c = composite_zscore(factors_df, ics_all)
+sig = pd.Series(0, index=c.index)
+sig[c > 0.3] = 1
+sig[c < -0.3] = -1
+bt = backtest(sig, close_all)
+results.append({"hypothesis": "H19: Time-Series CV (chronological)", "wf_sharpe": bt["wf_sharpe"], "detail": bt})
+print(f"  WF={bt['wf_sharpe']:.3f}")
+
+
+# === H20: Ensemble of Best Approaches ===
+print("H20: Ensemble of Best — combine top-3 approaches by WF Sharpe...")
+sorted_results = sorted([r for r in results if r["wf_sharpe"] is not None and r["wf_sharpe"] > -50],
+                         key=lambda x: x["wf_sharpe"], reverse=True)
+top3_names = [r["hypothesis"] for r in sorted_results[:3]]
+print(f"  Top 3: {top3_names}")
+results.append({"hypothesis": "H20: Ensemble Recommendation", "wf_sharpe": sorted_results[0]["wf_sharpe"] if sorted_results else -999,
+                "detail": {"top3": top3_names}})
+
+
+# === FINAL RANKING ===
+print(f"\n{'='*80}")
+print(f"{'RANK':<5} {'WF Sharpe':>10} {'OOS Sharpe':>10} {'OOS Mon%':>9} {'OOS DD%':>8} {'Trades':>7}  Hypothesis")
+print(f"{'='*80}")
+
+valid = [r for r in results if r.get("wf_sharpe") is not None and r["wf_sharpe"] > -50]
+valid.sort(key=lambda x: x["wf_sharpe"], reverse=True)
+
+for i, r in enumerate(valid, 1):
+    d = r.get("detail", {})
+    wf = r["wf_sharpe"]
+    oos_s = d.get("oos_sharpe", -999)
+    oos_m = d.get("oos_monthly", 0) or 0
+    oos_d = (d.get("oos_dd", 0) or 0) * 100
+    trades = d.get("trades", 0)
+    name = r["hypothesis"]
+    bar = "█" * max(1, min(30, int(max(0, wf + 10) / 10 * 30)))
+    print(f"{i:<5} {wf:>10.3f} {oos_s:>10.3f} {oos_m:>8.2f}% {oos_d:>7.1f}% {trades:>7}  {name}")
+
+print(f"{'='*80}")
+print(f"Total time: {(time.time()-t0_total)/60:.1f} minutes")
+print(f"Best approach: {valid[0]['hypothesis']} (WF Sharpe={valid[0]['wf_sharpe']:.3f})" if valid else "No valid results")

scripts/nexquant_30min_scan.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+"""30min Full Factor Scan — find all profitable signals."""
+import json, numpy as np, pandas as pd
+from pathlib import Path
+from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
+
+c = pd.read_hdf("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5", key="data")["$close"]
+c = c.droplevel(-1).sort_index().dropna().resample("30min").last().dropna()
+is_s = (c.index.hour >= 7) & (c.index.hour < 17)
+F = Path("results/factors"); V = F / "values"
+
+factors = []
+for f in sorted(F.glob("*.json")):
+    try: d = json.loads(f.read_text())
+    except: continue
+    if d.get("status") != "success" or d.get("ic") is None: continue
+    name = d.get("factor_name", f.stem)
+    safe = name.replace("/", "_")[:150]
+    if (V / f"{safe}.parquet").exists():
+        factors.append({"name": name, "ic": d["ic"], "safe": safe})
+factors.sort(key=lambda x: abs(x["ic"]), reverse=True)
+print(f"30min: {len(c):,} bars, {len(factors)} factors")
+print(f"Scanning top-200 factors...")
+
+results = []
+for i, f in enumerate(factors[:200]):
+    try:
+        s = pd.read_parquet(V / f"{f['safe']}.parquet").iloc[:, 0]
+        if isinstance(s.index, pd.MultiIndex): s = s.droplevel(-1)
+        fac = s.resample("30min").last().reindex(c.index).ffill()
+    except: continue
+    for dr in [1, -1]:
+        sig = pd.Series(dr * np.sign(fac).fillna(0), index=c.index)
+        sig[~is_s] = 0
+        if sig.abs().sum() < 20: continue
+        r = backtest_signal_risk(c, sig.fillna(0), txn_cost_bps=2.14)
+        oos = r.get("wf_oos_sharpe_mean") or r.get("oos_sharpe", -999)
+        oos_m = r.get("oos_monthly_return_pct", 0) or 0
+        if oos_m > 0.2:
+            results.append((f"{f['name']}_{dr}", oos, oos_m, r.get("oos_n_trades", 0)))
+    if i % 40 == 0 and results:
+        best = sorted(results, key=lambda x: x[2], reverse=True)[:2]
+        print(f"  {i}/200... best: {best[0][0][:40]} Mon={best[0][2]:+.2f}%")
+
+results.sort(key=lambda x: x[2], reverse=True)
+print(f"\nProfitable (>0.2%/mon): {len(results)}")
+print(f"\nTOP 20:")
+for i, (n, o, m, t) in enumerate(results[:20]):
+    print(f"  {i+1:2d}. {n[:52]:52s} OOS={o:+8.1f} Mon={m:+7.2f}% T={t:5d}")
+
+# Save top signals for combo testing
+if results:
+    top = results[:15]
+    all_sig = {}
+    for name, oos, mon, t in top:
+        fn = name.rsplit("_", 1)[0]
+        dr = -1 if name.endswith("_-1") else 1
+        if dr == -1: dr = -1
+        safe = fn.replace("/", "_")[:150]
+        try:
+            s = pd.read_parquet(V / f"{safe}.parquet").iloc[:, 0]
+            if isinstance(s.index, pd.MultiIndex): s = s.droplevel(-1)
+            fac = s.resample("30min").last().reindex(c.index).ffill()
+            sig = pd.Series(dr * np.sign(fac).fillna(0), index=c.index)
+            sig[~is_s] = 0
+            all_sig[name] = sig
+        except: pass
+    
+    if all_sig:
+        df = pd.DataFrame(all_sig, index=c.index).fillna(0)
+        cols = list(df.columns)
+        print(f"\n=== COMBO TESTS ===")
+        for n in [2, 3, 5, 8, len(cols)]:
+            combo = df[cols[:n]].mean(axis=1)
+            r = backtest_signal_risk(c, combo.fillna(0), txn_cost_bps=2.14, wf_rolling=True)
+            m = r.get("oos_monthly_return_pct", 0) or 0
+            dd = (r.get("oos_max_drawdown", 0) or 0) * 100
+            t = r.get("oos_n_trades", 0)
+            hit = "🎯" if m >= 4 else "✅" if m > 0 else ""
+            print(f"  {n:2d} sig: Mon={m:+.2f}% DD={dd:+.1f}% T={t} {hit}")
+
+print("\nDone!")

scripts/nexquant_add_risk_management.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 """
-Add FTMO-compliant risk management to existing strategies.
+Add RiskMgmt-compliant risk management to existing strategies.
 
 For each accepted strategy, add:
 - Stop Loss: 2%
@@ -10,8 +10,8 @@ For each accepted strategy, add:
 - Generate Live Trading report
 
 Usage:
-    python predix_add_risk_management.py
-    python predix_add_risk_management.py --live  # Mark as live-ready
+    python nexquant_add_risk_management.py
+    python nexquant_add_risk_management.py --live  # Mark as live-ready
 """
 import os, sys, json, time
 from pathlib import Path
@@ -27,11 +27,11 @@ console = Console()
 STRATEGIES_DIR = Path('results/strategies_new')
 OHLCV_PATH = Path('git_ignore_folder/factor_implementation_source_data/intraday_pv.h5')
 
-# FTMO Risk Parameters
+# RiskMgmt Risk Parameters
 STOP_LOSS = 0.02      # 2% hard stop
 TAKE_PROFIT = 0.04    # 4% target (2x SL)
 TRAILING_STOP = 0.015 # 1.5% trail after 2% profit
-MAX_DAILY_LOSS = 0.05 # 5% FTMO daily limit
+MAX_DAILY_LOSS = 0.05 # 5% RiskMgmt daily limit
 
 def load_ohlcv():
     """Load OHLCV close prices."""
@@ -147,11 +147,11 @@ def evaluate_strategy(strategy_returns, signal_aligned):
         'n_bars': int(n_bars),
         'n_months': float(n_months),
         'max_daily_loss': float(max_daily_loss),
-        'ftmo_compliant': max_daily_loss <= MAX_DAILY_LOSS and max_dd > -0.10,
+        'riskmgmt_compliant': max_daily_loss <= MAX_DAILY_LOSS and max_dd > -0.10,
     }
 
 def main():
-    console.print("[bold cyan]🔒 Adding FTMO Risk Management to Existing Strategies[/bold cyan]\n")
+    console.print("[bold cyan]🔒 Adding RiskMgmt Risk Management to Existing Strategies[/bold cyan]\n")
     
     # Load OHLCV
     console.print("📊 Loading OHLCV data...")
@@ -254,7 +254,7 @@ def main():
                 'new_trades': metrics['n_trades'],
                 'new_monthly_ret': metrics['monthly_return_pct'],
                 'max_daily_loss': metrics['max_daily_loss'],
-                'ftmo_compliant': bool(metrics['ftmo_compliant']),
+                'riskmgmt_compliant': bool(metrics['riskmgmt_compliant']),
             }
             results.append(result)
             
@@ -265,7 +265,7 @@ def main():
                 'trailing_stop': TRAILING_STOP,
                 'trailing_trigger': 0.02,
                 'max_daily_loss': MAX_DAILY_LOSS,
-                'ftmo_compliant': bool(metrics['ftmo_compliant']),
+                'riskmgmt_compliant': bool(metrics['riskmgmt_compliant']),
             }
             data['evaluated_with_risk_mgmt'] = metrics
             data['summary'] = {
@@ -275,7 +275,7 @@ def main():
                 'monthly_return_pct': metrics['monthly_return_pct'],
                 'real_ic': metrics['ic'],
                 'real_n_trades': metrics['n_trades'],
-                'ftmo_compliant': bool(metrics['ftmo_compliant']),
+                'riskmgmt_compliant': bool(metrics['riskmgmt_compliant']),
                 'forward_bars': 12,
                 'trading_style': 'daytrading',
             }
@@ -296,7 +296,7 @@ def main():
     # Display results
     console.print("\n[bold green]✓ All strategies processed![/bold green]\n")
     
-    table = Table(title="📊 FTMO Risk Management Results")
+    table = Table(title="📊 RiskMgmt Risk Management Results")
     table.add_column("#", justify="right")
     table.add_column("Strategy", style="cyan")
     table.add_column("IC", justify="right")
@@ -304,11 +304,11 @@ def main():
     table.add_column("Trades", justify="right")
     table.add_column("Monthly %", justify="right")
     table.add_column("Max DD", justify="right")
-    table.add_column("FTMO", justify="center")
+    table.add_column("RiskMgmt", justify="center")
     
     results.sort(key=lambda x: x['new_sharpe'], reverse=True)
     for i, r in enumerate(results, 1):
-        ftmo = "✅" if r['ftmo_compliant'] else "❌"
+        riskmgmt = "✅" if r['riskmgmt_compliant'] else "❌"
         table.add_row(
             str(i), r['name'],
             f"{r['new_ic']:.4f}",
@@ -316,14 +316,14 @@ def main():
             str(r['new_trades']),
             f"{r['new_monthly_ret']:.2f}%",
             f"{r['new_max_dd']:.1%}",
-            ftmo
+            riskmgmt
         )
     
     console.print(table)
     
     # Summary
-    ftmo_count = sum(1 for r in results if r['ftmo_compliant'])
-    console.print(f"\n[bold]FTMO-Compliant:[/bold] {ftmo_count}/{len(results)} strategies")
+    riskmgmt_count = sum(1 for r in results if r['riskmgmt_compliant'])
+    console.print(f"\n[bold]RiskMgmt-Compliant:[/bold] {riskmgmt_count}/{len(results)} strategies")
     
     if results:
         best = results[0]
@@ -331,7 +331,7 @@ def main():
         console.print(f"   Sharpe: {best['new_sharpe']:.2f}")
         console.print(f"   Monthly Return: {best['new_monthly_ret']:.2f}%")
         console.print(f"   Max Drawdown: {best['new_max_dd']:.1%}")
-        console.print(f"   FTMO Compliant: {'✅' if best['ftmo_compliant'] else '❌'}")
+        console.print(f"   RiskMgmt Compliant: {'✅' if best['riskmgmt_compliant'] else '❌'}")
 
 if __name__ == '__main__':
     main()

scripts/nexquant_autopilot.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+"""
+NexQuant Auto-Pilot — vollautomatischer Strategie-Generator.
+
+Läuft unbegrenzt, kein menschlicher Eingriff nötig.
+Jede Runde: Factors laden → LLM Code → Pre-Flight → Backtest → Optuna → Ensemble
+Bei Crash: auto-restart nach 30s.
+
+Usage:
+    python scripts/nexquant_autopilot.py
+"""
+from __future__ import annotations
+
+import json, logging, os, sys, time, traceback
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np, pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+# Load .env before any rdagent imports (required for pydantic-settings)
+try:
+    from dotenv import load_dotenv
+    _env_path = Path(__file__).resolve().parent.parent / ".env"
+    load_dotenv(_env_path)
+except ImportError:
+    pass
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("autopilot")
+
+LOG_FILE = Path(__file__).resolve().parent.parent / "git_ignore_folder" / "logs" / f"autopilot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+fh = logging.FileHandler(str(LOG_FILE))
+fh.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+logger.addHandler(fh)
+
+BATCH_SIZE = 2
+OPTUNA_TRIALS = 10
+COOLDOWN = 30
+MAX_CONSECUTIVE_FAILS = 5
+
+def main_round(style: str, round_num: int) -> int:
+    """Run one round. Returns number of accepted strategies."""
+    from rdagent.scenarios.qlib.local.strategy_orchestrator import StrategyOrchestrator
+
+    accepted_count = 0
+    try:
+        orch = StrategyOrchestrator(
+            top_factors=20, trading_style=style,
+            min_sharpe=0.1, use_optuna=True, optuna_trials=OPTUNA_TRIALS,
+        )
+    except Exception as e:
+        logger.error(f"Orchestrator init failed: {e}")
+        return 0
+
+    try:
+        results = orch.generate_strategies(count=BATCH_SIZE, workers=1)
+    except Exception as e:
+        logger.error(f"generate_strategies failed: {e}")
+        return 0
+
+    for r in results:
+        status = r.get("status", "?")
+        if status == "accepted":
+            accepted_count += 1
+            logger.info(f"  ✓ {r.get('strategy_name','?')[:40]:40s} S={r.get('sharpe_ratio',0):.1f} OOS={r.get('oos_sharpe',0):.1f}")
+        else:
+            reason = r.get("reason", "?")[:80]
+            logger.debug(f"  ✗ {r.get('strategy_name','?')[:40]:40s} {reason}")
+
+    if accepted_count >= 2:
+        try:
+            ensemble = orch.build_ensemble(results)
+            if ensemble and ensemble.get("status") == "success":
+                logger.info(f"  Ensemble: S={ensemble['sharpe_ratio']:.1f} OOS={ensemble['oos_sharpe']:.1f} ({len(ensemble['members'])} members)")
+        except Exception:
+            pass
+
+    return accepted_count
+
+
+def main():
+    print(f"\n{'='*50}")
+    print(f"  NexQuant Auto-Pilot")
+    print(f"  Log: {LOG_FILE}")
+    print(f"  Batch: {BATCH_SIZE} | Optuna: {OPTUNA_TRIALS} trials")
+    print(f"{'='*50}\n")
+
+    round_num = 0
+    total_accepted = 0
+    consecutive_fails = 0
+    start_time = datetime.now()
+    styles = ["swing", "daytrading"]
+
+    while True:
+        round_num += 1
+        style = styles[round_num % 2]
+        print(f"\n[Round {round_num}] {style} | {datetime.now().strftime('%H:%M:%S')}", flush=True)
+
+        try:
+            accepted = main_round(style, round_num)
+            total_accepted += accepted
+
+            if accepted == 0:
+                consecutive_fails += 1
+            else:
+                consecutive_fails = 0
+
+            elapsed = (datetime.now() - start_time).total_seconds()
+            rate = total_accepted / (elapsed / 3600) if elapsed > 0 else 0
+            print(f"  Accepted: {accepted} | Total: {total_accepted} | Rate: {rate:.1f}/h | Fails: {consecutive_fails}", flush=True)
+
+            if consecutive_fails >= MAX_CONSECUTIVE_FAILS:
+                logger.warning(f"{consecutive_fails} consecutive failures — cooling down {COOLDOWN*2}s")
+                time.sleep(COOLDOWN * 2)
+                consecutive_fails = 0
+
+        except KeyboardInterrupt:
+            print(f"\n\nStopped after {round_num} rounds. Total accepted: {total_accepted}")
+            break
+        except Exception as e:
+            logger.error(f"Round {round_num} crashed: {e}\n{traceback.format_exc()[-500:]}")
+            consecutive_fails += 1
+            time.sleep(COOLDOWN)
+
+        time.sleep(COOLDOWN)
+
+
+if __name__ == "__main__":
+    main()

scripts/nexquant_batch_backtest.py

@@ -1,14 +1,14 @@
 """
-Predix Batch Backtest Script - Extract and backtest existing factors.
+NexQuant Batch Backtest Script - Extract and backtest existing factors.
 
 Scans generated factor code from workspaces, runs Qlib backtests directly
 (bypassing CoSTEER), and saves results to JSON + SQLite.
 
 Usage:
-    python predix_batch_backtest.py --factors 100        # Backtest top 100 factors
-    python predix_batch_backtest.py --all                # Backtest all discovered factors
-    python predix_batch_backtest.py --parallel 5         # 5 parallel backtests
-    python predix_batch_backtest.py --scan-only          # Only scan, don't run backtests
+    python nexquant_batch_backtest.py --factors 100        # Backtest top 100 factors
+    python nexquant_batch_backtest.py --all                # Backtest all discovered factors
+    python nexquant_batch_backtest.py --parallel 5         # 5 parallel backtests
+    python nexquant_batch_backtest.py --scan-only          # Only scan, don't run backtests
 """
 
 import json
@@ -660,7 +660,7 @@ def _run_factor_directly(factor_info: FactorInfo) -> Optional[BacktestResult]:
     import tempfile
     import subprocess
 
-    with tempfile.TemporaryDirectory(prefix="predix_factor_") as tmp_dir:
+    with tempfile.TemporaryDirectory(prefix="nexquant_factor_") as tmp_dir:
         ws = Path(tmp_dir)
 
         # Write factor code
@@ -742,7 +742,7 @@ def _run_qlib_single(factor_info: FactorInfo) -> BacktestResult:
     import tempfile
 
     # Create temp workspace
-    with tempfile.TemporaryDirectory(prefix="predix_bt_") as tmp_dir:
+    with tempfile.TemporaryDirectory(prefix="nexquant_bt_") as tmp_dir:
         ws = Path(tmp_dir)
 
         # Write factor code
@@ -1182,7 +1182,7 @@ def main(
         Metric for ranking ('ic' or 'sharpe')
     """
     console.print(Panel(
-        "[bold cyan]Predix Batch Backtest Runner[/bold cyan]\n"
+        "[bold cyan]NexQuant Batch Backtest Runner[/bold cyan]\n"
         f"Scanning workspaces for generated factors...",
         border_style="cyan",
     ))
@@ -1196,7 +1196,7 @@ def main(
     if not all_factors_list:
         console.print("\n[red]No factors found in workspaces![/red]")
         console.print(
-            "[yellow]Ensure factors have been generated via `predix.py quant` first.[/yellow]"
+            "[yellow]Ensure factors have been generated via `nexquant.py quant` first.[/yellow]"
         )
         return
 
@@ -1407,7 +1407,7 @@ if __name__ == "__main__":
     import argparse
 
     parser = argparse.ArgumentParser(
-        description="Predix Batch Backtest - Extract and backtest existing factors"
+        description="NexQuant Batch Backtest - Extract and backtest existing factors"
     )
     parser.add_argument(
         "--factors", "-n",

scripts/nexquant_continuous_strategies.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python
+"""
+Continuous Strategy Generator — runs indefinitely, improving over time.
+
+Features:
+- Infinite loop: generate → optimize → ensemble → repeat
+- Walk-Forward validation required (OOS Sharpe > 0)
+- Multi-Timeframe check (1min, 5min, 15min, 1h)
+- Rolling stability check (12-month Sharpe never negative)
+- ML model training when LLM suggests it's beneficial
+- Auto-ensemble from top strategies
+- Daytrading AND swing style alternating
+
+Usage:
+    python scripts/nexquant_continuous_strategies.py
+    python scripts/nexquant_continuous_strategies.py --style daytrading --rounds 100
+    python scripts/nexquant_continuous_strategies.py --style both --workers 4
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from rdagent.scenarios.qlib.local.strategy_orchestrator import StrategyOrchestrator
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+BATCH_SIZE = 5
+COOLDOWN_SECONDS = 30
+
+
+def build_ml_model(factor_values: pd.DataFrame, close: pd.Series, style: str) -> dict | None:
+    """Train ML model if data is sufficient, return strategy dict or None."""
+    from sklearn.ensemble import GradientBoostingRegressor
+
+    df = factor_values.ffill().dropna()
+    close_aligned = close.reindex(df.index).ffill()
+
+    common = df.index.intersection(close_aligned.index)
+    if len(common) < 5000:
+        logger.info("ML: insufficient data (<5000 rows)")
+        return None
+
+    X = df.loc[common].values
+    y = close_aligned.loc[common].pct_change(96).shift(-96).fillna(0).values  # forward 96-bar return
+
+    split = int(len(X) * 0.7)
+    X_train, X_test = X[:split], X[split:]
+    y_train, y_test = y[:split], y[split:]
+
+    model = GradientBoostingRegressor(n_estimators=100, max_depth=5, random_state=42)
+    model.fit(X_train, y_train)
+
+    # Generate signal on test data
+    preds = model.predict(X_test)
+    signal = pd.Series(np.sign(preds), index=common[split:])
+
+    # Backtest
+    from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
+    bt = backtest_signal_risk(
+        close=close_aligned.loc[common[split:]],
+        signal=signal,
+        txn_cost_bps=2.14,
+        wf_rolling=True,
+    )
+
+    is_oos_sharpe = bt.get("wf_oos_sharpe_mean", 0)
+    if is_oos_sharpe <= 0:
+        logger.info(f"ML model rejected: OOS Sharpe={is_oos_sharpe:.2f}")
+        return None
+
+    logger.info(f"ML model accepted: Sharpe={bt['sharpe']:.2f} OOS={is_oos_sharpe:.2f}")
+    return {
+        "strategy_name": f"ML_GradientBoost_{style}_{int(time.time())}",
+        "status": "accepted",
+        "sharpe_ratio": round(bt["sharpe"], 4),
+        "max_drawdown": round(bt["max_drawdown"], 4),
+        "win_rate": round(bt["win_rate"], 4),
+        "n_trades": bt["n_trades"],
+        "oos_sharpe": round(is_oos_sharpe, 4),
+        "type": "ml_model",
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--style", default="both", choices=["daytrading", "swing", "both"])
+    parser.add_argument("--workers", type=int, default=2)
+    parser.add_argument("--rounds", type=int, default=0, help="Stop after N rounds (0=infinite)")
+    parser.add_argument("--min-sharpe", type=float, default=1.5)
+    parser.add_argument("--batch-size", type=int, default=5)
+    parser.add_argument("--ml-rounds", type=int, default=3, help="Train ML model every N rounds")
+    args = parser.parse_args()
+
+    print(f"\n{'='*60}")
+    print(f"  NexQuant Continuous Strategy Generator")
+    print(f"  Style: {args.style} | Workers: {args.workers}")
+    print(f"  Min Sharpe: {args.min_sharpe} | Batch: {args.batch_size}")
+    print(f"  ML every {args.ml_rounds} rounds")
+    print(f"{'='*60}\n")
+
+    round_num = 0
+    total_accepted = 0
+    total_ml_accepted = 0
+    start_time = datetime.now()
+
+    while True:
+        round_num += 1
+        styles = [args.style] if args.style != "both" else (["swing", "daytrading"] if round_num % 2 == 1 else ["daytrading", "swing"])
+
+        for style in styles:
+            print(f"\n--- Round {round_num} | Style: {style} ---")
+
+            orch = StrategyOrchestrator(
+                top_factors=20, trading_style=style,
+                min_sharpe=args.min_sharpe,
+                use_optuna=True, optuna_trials=30,
+            )
+
+            try:
+                results = orch.generate_strategies(count=BATCH_SIZE, workers=args.workers)
+            except Exception as e:
+                logger.error(f"Round {round_num} {style} failed: {e}")
+                continue
+
+            accepted = [r for r in results if r.get("status") == "accepted"]
+            total_accepted += len(accepted)
+            print(f"  Accepted: {len(accepted)}/{len(results)}  (Total: {total_accepted})")
+
+            for r in accepted[:3]:
+                print(f"    {r.get('strategy_name', '?')[:40]:40s} S={r.get('sharpe_ratio',0):.1f} OOS={r.get('oos_sharpe',0):.1f}")
+
+            # Ensemble after every round
+            ensemble = orch.build_ensemble(results)
+            if ensemble and ensemble.get("status") == "success":
+                print(f"  Ensemble: S={ensemble['sharpe_ratio']:.1f} OOS={ensemble['oos_sharpe']:.1f} ({len(ensemble['members'])} members)")
+
+            # ML model every N rounds
+            if round_num % args.ml_rounds == 0:
+                print(f"\n  [ML] Training model on all factors...")
+                factors = orch.load_top_factors()
+                if factors:
+                    factor_values = {}
+                    for f in factors:
+                        series = orch.load_factor_values(f["factor_name"])
+                        if series is not None:
+                            factor_values[f["factor_name"]] = series
+                    if len(factor_values) >= 3:
+                        df = pd.DataFrame(factor_values)
+                        if isinstance(df.index, pd.MultiIndex):
+                            df = df.droplevel(-1)
+                        ml_result = build_ml_model(df, orch.ohlcv_close, style)
+                        if ml_result:
+                            total_ml_accepted += 1
+                            print(f"  [ML] Accepted! S={ml_result['sharpe_ratio']:.1f} OOS={ml_result['oos_sharpe']:.1f}")
+
+        elapsed = (datetime.now() - start_time).total_seconds()
+        print(f"\n  Elapsed: {elapsed/60:.0f}min | Accepted: {total_accepted} (+{total_ml_accepted} ML) | Rate: {total_accepted/(elapsed/3600):.1f}/h")
+
+        if args.rounds > 0 and round_num >= args.rounds:
+            break
+
+        time.sleep(COOLDOWN_SECONDS)
+
+    print(f"\n{'='*60}")
+    print(f"  DONE: {total_accepted} strategies + {total_ml_accepted} ML models")
+    print(f"  Total time: {(datetime.now()-start_time).total_seconds()/3600:.1f}h")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    main()

scripts/nexquant_daily_strategies.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""Daily Strategy Generator — Kronos factors at daily resolution.
+
+Daily timeframe eliminates 1-min noise and transaction cost overhead.
+Factors with daily IC translate directly to daily trading edge.
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PROJECT = Path(__file__).resolve().parent.parent
+FACTORS_DIR = PROJECT / "results" / "factors"
+VALUES_DIR = FACTORS_DIR / "values"
+RESULTS_DIR = PROJECT / "results" / "strategies_new"
+OHLCV_PATH = Path(os.getenv("PREDIX_OHLCV_PATH",
+    str(PROJECT / "git_ignore_folder" / "intraday_pv_all.h5")))
+
+MIN_MONTHLY = 5.0       # Raw backtest target (conservative for daily)
+MIN_SHARPE  = 1.0
+MAX_DD      = -0.20
+MIN_TRADES  = 30
+
+
+def load_kronos(name: str) -> pd.Series:
+    s = pd.read_parquet(VALUES_DIR / f"{name}.parquet")
+    col = s.columns[0]
+    return s.xs("EURUSD", level="instrument")[col]
+
+
+def load_factor_ic(name: str) -> float:
+    jf = FACTORS_DIR / f"{name}.json"
+    if jf.exists():
+        return float(json.loads(jf.read_text()).get("ic", 0))
+    return 0.0
+
+
+def daily_backtest(close_daily: pd.Series, signal_daily: pd.Series) -> dict:
+    """Simple daily backtest — no intraday noise, no 1-min costs."""
+    common = close_daily.index.intersection(signal_daily.index)
+    c = close_daily.loc[common]
+    s = signal_daily.loc[common].clip(-1, 1)
+
+    rets = c.pct_change().shift(-1)  # Next day's return
+    strat_rets = s.shift(1) * rets  # Today's signal × tomorrow's return
+    strat_rets = strat_rets.dropna()
+
+    if len(strat_rets) < 10:
+        return {"sharpe": 0, "monthly_pct": 0, "max_dd": 0, "n_trades": 0, "win_rate": 0}
+
+    # Trade-level stats
+    trades = []
+    in_trade = False
+    trade_ret = 0.0
+    wins = 0
+    for r, sig in zip(strat_rets, s.loc[strat_rets.index]):
+        if sig != 0:
+            if not in_trade:
+                in_trade = True
+                trade_ret = r
+            else:
+                trade_ret += r
+        elif in_trade:
+            in_trade = False
+            trades.append(trade_ret)
+            if trade_ret > 0:
+                wins += 1
+            trade_ret = 0.0
+    if in_trade:
+        trades.append(trade_ret)
+        if trade_ret > 0:
+            wins += 1
+
+    n_trades = len(trades)
+    if n_trades < 5:
+        return {"sharpe": 0, "monthly_pct": 0, "max_dd": 0, "n_trades": n_trades, "win_rate": 0}
+
+    t_arr = np.array(trades)
+    sharpe = float(t_arr.mean() / t_arr.std() * np.sqrt(n_trades)) if t_arr.std() > 0 else 0.0
+    win_rate = wins / n_trades
+
+    # Equity curve
+    eq = (1 + pd.Series(trades)).cumprod()
+    peak = eq.cummax()
+    dd = float(((eq - peak) / peak).min())
+
+    total_ret = eq.iloc[-1] - 1 if len(eq) > 0 else 0.0
+    n_days = (close_daily.index[-1] - close_daily.index[0]).days
+    n_months = n_days / 30.44
+    monthly = float((1 + total_ret) ** (1 / max(n_months, 1)) - 1)
+
+    return {
+        "sharpe": sharpe, "monthly_pct": monthly * 100,
+        "max_dd": dd, "n_trades": n_trades, "win_rate": win_rate,
+        "total_return": total_ret, "n_months": n_months,
+    }
+
+
+def build_signal(daily_factor: pd.Series, ic: float, threshold_sigma: float,
+                 session: str = "all") -> pd.Series:
+    """Build daily signal from a single factor."""
+    sigma = daily_factor.std()
+    thresh = threshold_sigma * sigma
+
+    # Invert if IC is negative
+    sign = -1 if ic < 0 else 1
+
+    signal = pd.Series(0, index=daily_factor.index, dtype=int)
+    signal[daily_factor > thresh] = sign
+    signal[daily_factor < -thresh] = -sign
+
+    # Smooth: keep signal for min_hold days to avoid whipsaw
+    signal = signal.replace(0, np.nan).ffill(limit=1).fillna(0).astype(int)
+
+    return signal
+
+
+def combine_signals(s1: pd.Series, s2: pd.Series, mode: str = "confirm") -> pd.Series:
+    """Combine two daily signals."""
+    common = s1.index.intersection(s2.index)
+    s1c = s1.loc[common]
+    s2c = s2.loc[common]
+
+    if mode == "confirm":
+        result = pd.Series(0, index=common, dtype=int)
+        result[(s1c == s2c) & (s1c != 0)] = s1c
+        return result
+    elif mode == "any":
+        result = s1c.copy()
+        result[(result == 0) & (s2c != 0)] = s2c
+        return result
+    else:
+        return s1c
+
+
+def main():
+    print("=" * 60)
+    print("  Daily Strategy Generator")
+    print("=" * 60)
+
+    # Load OHLCV → daily
+    print("\nLoading OHLCV...")
+    df = pd.read_hdf(OHLCV_PATH, key="data")
+    close = df.xs("EURUSD", level="instrument")["$close"].sort_index()
+    close_daily = close.resample("D").last().dropna()
+    print(f"  Daily bars: {len(close_daily)} ({close_daily.index[0].date()} → {close_daily.index[-1].date()})")
+
+    # Load Kronos factors → daily
+    print("\nLoading Kronos factors...")
+    kronos = {}
+    for name in ["KronosPredReturn_p96", "KronosPredReturn_p24", "KronosPredReturn_p48"]:
+        series = load_kronos(name)
+        ic = load_factor_ic(name)
+        daily = series.resample("D").last().dropna()
+        # Align to close_daily
+        daily = daily.reindex(close_daily.index)
+        kronos[name] = {"series": daily, "ic": ic, "std": daily.std()}
+        print(f"  {name}: IC={ic:+.4f} daily_rows={daily.dropna().sum()}")
+
+    # Load top daily factors
+    print("\nLoading top daily factors...")
+    daily_factors = {}
+    for f in sorted(FACTORS_DIR.glob("*.json")):
+        d = json.loads(f.read_text())
+        if not isinstance(d, dict):
+            continue
+        ic = float(d.get("ic") or 0)
+        if abs(ic) < 0.06:
+            continue
+        fname = d.get("factor_name") or d.get("name") or f.stem
+        safe = fname.replace("/", "_").replace("\\", "_")[:150]
+        parq = VALUES_DIR / f"{safe}.parquet"
+        if not parq.exists():
+            continue
+        series = pd.read_parquet(str(parq))
+        if isinstance(series.index, pd.MultiIndex):
+            series = series.xs("EURUSD", level="instrument")[series.columns[0]]
+        daily = series.resample("D").last().dropna().reindex(close_daily.index)
+        daily_factors[fname] = {"series": daily, "ic": ic, "std": daily.std()}
+
+    names = list(daily_factors.keys())
+    print(f"  Loaded {len(names)} factors (IC ≥ 0.06)")
+
+    # Grid search
+    thresholds = [1.0, 1.5, 2.0, 2.5, 3.0]
+    results = []
+    t0 = time.time()
+
+    # A) Kronos single-factor
+    print("\n--- Kronos single-factor grid ---")
+    for kname, kdata in kronos.items():
+        ks = kdata["series"]
+        for thresh in thresholds:
+            signal = build_signal(ks, kdata["ic"], thresh)
+            bt = daily_backtest(close_daily, signal)
+            bt["strategy"] = f"{kname} t={thresh}σ"
+            bt["factors"] = [kname]
+            bt["threshold"] = thresh
+            results.append(bt)
+
+    # B) Kronos + daily factor (confirmation)
+    print("--- Kronos + daily factor combinations ---")
+    for kname, kdata in kronos.items():
+        ks = kdata["series"]
+        for fname, fdata in daily_factors.items():
+            for thresh_k in [1.5, 2.0]:
+                for thresh_f in [1.0, 1.5, 2.0]:
+                    s1 = build_signal(ks, kdata["ic"], thresh_k)
+                    s2 = build_signal(fdata["series"], fdata["ic"], thresh_f)
+                    signal = combine_signals(s1, s2, "confirm")
+                    bt = daily_backtest(close_daily, signal)
+                    bt["strategy"] = f"{kname}(t={thresh_k}) + {fname}(t={thresh_f})"
+                    bt["factors"] = [kname, fname]
+                    bt["threshold"] = f"{thresh_k}/{thresh_f}"
+                    results.append(bt)
+
+    # C) Two daily factors (no Kronos)
+    print("--- Daily factor pairs ---")
+    name_list = list(daily_factors.keys())
+    for i in range(min(len(name_list), 10)):
+        for j in range(i + 1, min(len(name_list), 10)):
+            f1, f2 = name_list[i], name_list[j]
+            for t1 in [1.0, 1.5, 2.0]:
+                for t2 in [1.0, 1.5, 2.0]:
+                    s1 = build_signal(daily_factors[f1]["series"], daily_factors[f1]["ic"], t1)
+                    s2 = build_signal(daily_factors[f2]["series"], daily_factors[f2]["ic"], t2)
+                    signal = combine_signals(s1, s2, "confirm")
+                    bt = daily_backtest(close_daily, signal)
+                    bt["strategy"] = f"{f1[:20]}(t={t1}) + {f2[:20]}(t={t2})"
+                    bt["factors"] = [f1, f2]
+                    bt["threshold"] = f"{t1}/{t2}"
+                    results.append(bt)
+
+    # Filter & sort
+    print(f"\n{'=' * 60}")
+    print(f"  Total evaluations: {len(results)}  Time: {time.time()-t0:.0f}s")
+    print(f"{'=' * 60}")
+
+    valid = [r for r in results
+             if r["sharpe"] >= MIN_SHARPE
+             and r["max_dd"] >= MAX_DD
+             and r["n_trades"] >= MIN_TRADES
+             and r["monthly_pct"] >= MIN_MONTHLY]
+
+    valid.sort(key=lambda r: r["monthly_pct"], reverse=True)
+
+    print(f"\n  Meeting: Sharpe≥{MIN_SHARPE} DD≥{MAX_DD} Tr≥{MIN_TRADES} Mon≥{MIN_MONTHLY}%")
+    print(f"  → {len(valid)} strategies\n")
+
+    fmt = "{:3s} {:55s} {:>7s} {:>7s} {:>7s} {:>5s} {:>6s}"
+    print(fmt.format("#", "Strategy", "Sharpe", "Mon%", "MaxDD", "Tr", "WinRt"))
+    print("-" * 90)
+    for i, r in enumerate(valid[:30], 1):
+        print(fmt.format(str(i), r["strategy"][:55],
+              f'{r["sharpe"]:.2f}', f'{r["monthly_pct"]:.1f}%',
+              f'{r["max_dd"]:.3f}', str(r["n_trades"]),
+              f'{r["win_rate"]:.1%}'))
+
+    if not valid:
+        results.sort(key=lambda r: r["monthly_pct"], reverse=True)
+        print("\n  Top 10 by monthly return:")
+        for i, r in enumerate(results[:10], 1):
+            print(f"  {i:2d}. {r['strategy'][:50]} Mon={r['monthly_pct']:.1f}% Sh={r['sharpe']:.2f} Tr={r['n_trades']}")
+
+    # Save
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    out = RESULTS_DIR / f"daily_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    out.write_text(json.dumps(valid[:50] if valid else results[:50], indent=2, default=str))
+    print(f"\n  Saved → {out}")
+
+
+if __name__ == "__main__":
+    main()

scripts/nexquant_fast_rebacktest.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+"""Fast rebacktest: only strategies with factor parquets, skip already-done."""
+import json, sys, pandas as pd, subprocess, tempfile, numpy as np
+from pathlib import Path
+from datetime import datetime
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from rdagent.components.backtesting.vbt_backtest import backtest_signal
+
+OHLCV = Path("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5")
+FACTORS_DIR = Path("results/factors/values")
+STRAT_DIR = Path("results/strategies_new")
+
+# Pre-build factor name → path map
+fmap = {p.stem: str(p) for p in FACTORS_DIR.glob("*.parquet")}
+
+# Load close once
+print("Loading OHLCV...")
+ohlcv = pd.read_hdf(str(OHLCV), key="data")
+close = ohlcv["$close"].dropna()
+if isinstance(close.index, pd.MultiIndex):
+    close = close.droplevel(-1)
+close = close.astype(float).sort_index()
+print(f"{len(close):,} bars")
+
+# Build work list
+work = []
+for f in sorted(STRAT_DIR.glob("*.json")):
+    try:
+        d = json.loads(f.read_text())
+    except Exception:
+        continue
+    if d.get("reevaluation_status") == "verified_v2":
+        continue
+    names = d.get("factor_names", [])
+    code = d.get("code", "")
+    if not names or not code:
+        continue
+    paths = []
+    for n in names:
+        p = fmap.get(n) or fmap.get(n.replace("/", "_")[:150])
+        if p:
+            paths.append((n, p))
+    if len(paths) >= 2:
+        work.append((f, d, paths))
+
+print(f"{len(work)} strategies to process")
+
+if not work:
+    print("All done!")
+    sys.exit(0)
+
+ok = skip = fail = 0
+start = datetime.now()
+
+for i, (f, data, factor_paths) in enumerate(work):
+    name = data.get("strategy_name", f.stem)[:45]
+    code = data.get("code", "")
+
+    # Load factor series
+    series = {}
+    for fn, fp in factor_paths:
+        try:
+            s = pd.read_parquet(fp).iloc[:, 0]
+            series[fn] = s
+        except Exception:
+            pass
+
+    if len(series) < 2:
+        skip += 1
+        continue
+
+    df = pd.DataFrame(series).sort_index()
+    if isinstance(df.index, pd.MultiIndex):
+        df = df.droplevel(-1)
+
+    try:
+        df_1m = df.reindex(close.index).ffill()
+    except Exception:
+        skip += 1
+        continue
+
+    valid = df_1m.notna().any(axis=1)
+    if valid.sum() < 1000:
+        skip += 1
+        continue
+
+    ca = close.loc[valid]
+    fa = df_1m.loc[valid]
+
+    # Execute strategy code
+    try:
+        with tempfile.TemporaryDirectory() as td:
+            tdp = Path(td)
+            fa.to_parquet(str(tdp / "factors.parquet"))
+            ca.to_pickle(str(tdp / "close.pkl"))
+
+            exec_script = (
+                "import pandas as pd, numpy as np\n"
+                "factors = pd.read_parquet('factors.parquet')\n"
+                "close = pd.read_pickle('close.pkl')\n"
+                "df = factors\n"
+                + code +
+                "\nif 'signal' not in dir():\n"
+                "    raise SystemExit(1)\n"
+                "pd.Series(signal).fillna(0).to_pickle('signal.pkl')\n"
+            )
+            (tdp / "run.py").write_text(exec_script)
+            r = subprocess.run(
+                ["python", "run.py"],
+                capture_output=True, text=True, timeout=60, cwd=str(tdp),
+            )
+            if r.returncode != 0:
+                fail += 1
+                continue
+            sig = pd.read_pickle(tdp / "signal.pkl")
+    except Exception:
+        fail += 1
+        continue
+
+    try:
+        sig = sig.reindex(ca.index).ffill().fillna(0)
+        result = backtest_signal(ca, sig, txn_cost_bps=2.14)
+    except Exception:
+        fail += 1
+        continue
+
+    # Write back
+    data["reevaluation_status"] = "verified_v2"
+    data["sharpe_ratio"] = result.get("sharpe")
+    data["max_drawdown"] = result.get("max_drawdown")
+    data["win_rate"] = result.get("win_rate")
+    data["total_return"] = result.get("total_return")
+    data["summary"] = {
+        **data.get("summary", {}),
+        "sharpe": result.get("sharpe"),
+        "max_drawdown": result.get("max_drawdown"),
+        "win_rate": result.get("win_rate"),
+        "monthly_return_pct": result.get("monthly_return_pct"),
+        "real_n_trades": result.get("n_trades"),
+        "total_return": result.get("total_return"),
+        "annualized_return": result.get("annualized_return"),
+        "engine": "verified_v2",
+        "txn_cost_bps": 2.14,
+    }
+    f.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+    ok += 1
+
+    elapsed = (datetime.now() - start).total_seconds()
+    rate = ok / elapsed * 60 if elapsed > 0 else 0
+    print(f"  [{ok:4d}/{len(work)}] {rate:5.0f}/min  {name:45s}  "
+          f"S={result['sharpe']:6.1f} DD={result['max_drawdown']:7.2%} "
+          f"WR={result['win_rate']:5.1%} T={result['n_trades']:4d}")
+
+elapsed = (datetime.now() - start).total_seconds()
+print(f"\nDONE: ok={ok} skip={skip} fail={fail} in {elapsed:.0f}s")

scripts/nexquant_full_eval.py

@@ -1,13 +1,13 @@
 """
-Predix Full Data Factor Evaluator - Evaluate factors with FULL 1min data.
+NexQuant Full Data Factor Evaluator - Evaluate factors with FULL 1min data.
 
 Evaluates factors using the complete intraday_pv.h5 dataset (2022-2026, ~2.26M rows)
 instead of the debug dataset (2024 only, ~371K rows).
 
 Usage:
-    python predix_full_eval.py --top 100    # Evaluate top 100 factors with full data
-    python predix_full_eval.py --all        # Evaluate all factors
-    python predix_full_eval.py --parallel 4 # 4 parallel workers
+    python nexquant_full_eval.py --top 100    # Evaluate top 100 factors with full data
+    python nexquant_full_eval.py --all        # Evaluate all factors
+    python nexquant_full_eval.py --parallel 4 # 4 parallel workers
 """
 
 import json
@@ -271,7 +271,7 @@ def evaluate_factor_full(factor: FactorInfo, full_data: pd.DataFrame,
     import tempfile
     import subprocess
 
-    with tempfile.TemporaryDirectory(prefix="predix_full_") as tmp_dir:
+    with tempfile.TemporaryDirectory(prefix="nexquant_full_") as tmp_dir:
         ws = Path(tmp_dir)
 
         try:
@@ -357,23 +357,29 @@ def evaluate_factor_full(factor: FactorInfo, full_data: pd.DataFrame,
                 ic = factor_val.loc[valid_idx].corr(forward_ret.loc[valid_idx])
                 rank_ic = factor_val.loc[valid_idx].corr(forward_ret.loc[valid_idx], method="spearman")
 
-            # Compute Sharpe
-            factor_mean = factor_val.loc[valid_idx].mean()
-            factor_std = factor_val.loc[valid_idx].std()
-            sharpe = factor_mean / factor_std if factor_std > 0 else 0
+            # Compute strategy returns from factor signal
+            signal = np.where(factor_val.loc[valid_idx] > 0, 1.0, -1.0)
+            strategy_ret = signal * forward_ret.loc[valid_idx]
+
+            bars_per_year = 252 * 1440
+            ann_factor = np.sqrt(bars_per_year / forward_return_bars)
+
+            # Sharpe: annualized mean/vol of strategy returns
+            ret_mean = strategy_ret.mean()
+            ret_std = strategy_ret.std()
+            sharpe = float(ret_mean / ret_std * ann_factor) if ret_std > 0 else 0.0
 
             # Annualized return
-            ann_factor = np.sqrt(252 * 1440 / forward_return_bars)
-            annualized_return = float(factor_mean * ann_factor * 100)
+            annualized_return = float(ret_mean * bars_per_year / forward_return_bars * 100)
 
-            # Max drawdown
-            cum_perf = factor_val.loc[valid_idx].cumsum()
-            running_max = cum_perf.expanding().max()
-            drawdown = (cum_perf - running_max) / running_max.replace(0, np.nan)
-            max_drawdown = float(drawdown.min()) if len(drawdown) > 0 else 0
+            # Max drawdown on equity curve
+            equity = (1.0 + strategy_ret).cumprod()
+            running_max = equity.expanding().max()
+            drawdown = (equity - running_max) / running_max.replace(0, np.nan)
+            max_drawdown = float(drawdown.min()) if len(drawdown) > 0 else 0.0
 
-            # Win rate
-            win_rate = float((factor_val.loc[valid_idx] > 0).sum()) / len(valid_idx)
+            # Win rate: fraction of positive strategy returns
+            win_rate = float((strategy_ret > 0).sum()) / len(strategy_ret) if len(strategy_ret) > 0 else 0.0
 
             return EvalResult(
                 factor_name=factor.factor_name,
@@ -622,7 +628,7 @@ def main(
 ) -> None:
     """Main entry point."""
     console.print(Panel(
-        "[bold cyan]Predix Full Data Factor Evaluator[/bold cyan]\n"
+        "[bold cyan]NexQuant Full Data Factor Evaluator[/bold cyan]\n"
         f"Using FULL 1min data: {FULL_DATA_FILE}",
         border_style="cyan",
     ))
@@ -673,7 +679,7 @@ if __name__ == "__main__":
     import argparse
 
     parser = argparse.ArgumentParser(
-        description="Predix Full Data Factor Evaluator"
+        description="NexQuant Full Data Factor Evaluator"
     )
     parser.add_argument(
         "--top", "-n",

scripts/nexquant_gen_strategies_real_bt.py

@@ -7,28 +7,35 @@ each with real backtesting on OHLCV data.
 
 Usage:
     # Swing trading (96-bar forward returns)
-    python predix_gen_strategies_real_bt.py 10
+    python nexquant_gen_strategies_real_bt.py 10
 
-    # Daytrading with FTMO constraints (12-bar forward returns)
-    TRADING_STYLE=daytrading python predix_gen_strategies_real_bt.py 5
+    # Daytrading with RiskMgmt constraints (12-bar forward returns)
+    TRADING_STYLE=daytrading python nexquant_gen_strategies_real_bt.py 5
 
     # With parallel workers (default: CPU count)
-    TRADING_STYLE=daytrading WORKERS=4 python predix_gen_strategies_real_bt.py 20
+    TRADING_STYLE=daytrading WORKERS=4 python nexquant_gen_strategies_real_bt.py 20
 """
-import os, sys, json, time, math, random, logging, warnings, subprocess
-from pathlib import Path
+import json
+import logging
+import os
+import random
+import subprocess
+import sys
+import time
+import warnings
 from datetime import datetime
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
 from dotenv import load_dotenv
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
 
 # Suppress warnings and noisy loggers that bleed into Rich progress output
-warnings.filterwarnings('ignore')
-for _noisy in ('rdagent', 'litellm', 'LiteLLM', 'litellm.utils',
-               'litellm.main', 'httpx', 'httpcore', 'openai', 'urllib3'):
+warnings.filterwarnings("ignore")
+for _noisy in ("rdagent", "litellm", "LiteLLM", "litellm.utils",
+               "litellm.main", "httpx", "httpcore", "openai", "urllib3"):
     logging.getLogger(_noisy).setLevel(logging.CRITICAL)
 # Suppress litellm verbose flag if already imported
 try:
@@ -42,36 +49,38 @@ except Exception:
 # ============================================================================
 # Configuration
 # ============================================================================
-OHLCV_PATH = Path('/home/nico/Predix/git_ignore_folder/factor_implementation_source_data/intraday_pv.h5')
-FACTORS_DIR = Path('/home/nico/Predix/results/factors')
-STRATEGIES_DIR = Path('/home/nico/Predix/results/strategies_new')
+OHLCV_PATH = Path("/home/nico/NexQuant/git_ignore_folder/factor_implementation_source_data/intraday_pv.h5")
+FACTORS_DIR = Path("/home/nico/NexQuant/results/factors")
+STRATEGIES_DIR = Path("/home/nico/NexQuant/results/strategies_new")
 STRATEGIES_DIR.mkdir(parents=True, exist_ok=True)
 
 # Trading style
-TRADING_STYLE = os.getenv('TRADING_STYLE', 'swing')
-N_WORKERS = int(os.getenv('WORKERS', os.cpu_count() or 4))
+TRADING_STYLE = os.getenv("TRADING_STYLE", "swing")
+N_WORKERS = int(os.getenv("WORKERS", os.cpu_count() or 4))
 
-if TRADING_STYLE == 'daytrading':
-    FORWARD_BARS = int(os.getenv('FORWARD_BARS', '12'))
+if TRADING_STYLE == "daytrading":
+    FORWARD_BARS = int(os.getenv("FORWARD_BARS", "12"))
     MIN_IC = 0.02
     MIN_SHARPE = 0.5
     MIN_TRADES = 300
     MAX_DRAWDOWN = -0.10
-    STYLE_EMOJI = '🎯 Daytrading'
-    STYLE_DESC = 'short-term intraday with FTMO compliance'
+    MIN_MONTHLY_RETURN_PCT = 15.0
+    STYLE_EMOJI = "🎯 Daytrading"
+    STYLE_DESC = "short-term intraday with RiskMgmt compliance"
 else:
-    FORWARD_BARS = int(os.getenv('FORWARD_BARS', '96'))
+    FORWARD_BARS = int(os.getenv("FORWARD_BARS", "96"))
     MIN_IC = 0.02
     MIN_SHARPE = 0.5
     MIN_TRADES = 10
     MAX_DRAWDOWN = -0.30
-    STYLE_EMOJI = '📈 Swing'
-    STYLE_DESC = 'medium-term intraday'
+    MIN_MONTHLY_RETURN_PCT = 15.0
+    STYLE_EMOJI = "📈 Swing"
+    STYLE_DESC = "medium-term intraday"
 
 # Whether to use raw OHLCV-only strategies (no daily factors)
-OHLCV_ONLY = os.getenv('OHLCV_ONLY', '0') == '1'
+OHLCV_ONLY = os.getenv("OHLCV_ONLY", "0") == "1"
 
-TXN_COST_BPS = float(os.getenv('TXN_COST_BPS', '2.14'))  # 2.35 pip realistic EUR/USD costs
+TXN_COST_BPS = float(os.getenv("TXN_COST_BPS", "2.14"))  # 2.35 pip realistic EUR/USD costs
 
 # ── Logging setup: everything printed goes to log file + stdout ───────────────
 _LOG_DIR = Path(__file__).parent.parent / "git_ignore_folder" / "logs"
@@ -108,14 +117,14 @@ console = Console(file=_TeeFile(sys.stdout, _log_file), highlight=False)
 # ============================================================================
 def setup_llm_env():
     """Setup LLM environment variables."""
-    load_dotenv(Path(__file__).parent.parent / '.env')
-    if os.getenv('OPENAI_API_KEY') == 'local' or os.getenv('LLM_BACKEND', '').lower() == 'local':
+    load_dotenv(Path(__file__).parent.parent / ".env")
+    if os.getenv("OPENAI_API_KEY") == "local" or os.getenv("LLM_BACKEND", "").lower() == "local":
         return
-    router_key = os.getenv('OPENROUTER_API_KEY', '')
+    router_key = os.getenv("OPENROUTER_API_KEY", "")
     if router_key:
-        os.environ['OPENAI_API_KEY'] = router_key
-        os.environ['OPENAI_API_BASE'] = 'https://openrouter.ai/api/v1'
-        os.environ['CHAT_MODEL'] = os.getenv('OPENROUTER_MODEL', 'openrouter/google/gemma-4-26b-a4b-it:free')
+        os.environ["OPENAI_API_KEY"] = router_key
+        os.environ["OPENAI_API_BASE"] = "https://openrouter.ai/api/v1"
+        os.environ["CHAT_MODEL"] = os.getenv("OPENROUTER_MODEL", "openrouter/google/gemma-4-26b-a4b-it:free")
 
 # ============================================================================
 # Factor Loading (cached at module level for each process)
@@ -127,20 +136,20 @@ def load_available_factors(top_n=20):
     global _FACTORS_CACHE
     if _FACTORS_CACHE is not None:
         return _FACTORS_CACHE[:top_n]
-    
+
     factors = []
-    for f in FACTORS_DIR.glob('*.json'):
+    for f in FACTORS_DIR.glob("*.json"):
         try:
             data = json.load(open(f))
-            fname = data.get('factor_name', '')
-            ic = data.get('ic') or 0
-            safe = fname.replace('/','_').replace('\\','_')[:150]
-            if (FACTORS_DIR / 'values' / f"{safe}.parquet").exists():
-                factors.append({'name': fname, 'ic': ic})
+            fname = data.get("factor_name", "")
+            ic = data.get("ic") or 0
+            safe = fname.replace("/","_").replace("\\","_")[:150]
+            if (FACTORS_DIR / "values" / f"{safe}.parquet").exists():
+                factors.append({"name": fname, "ic": ic})
         except:
             pass
-    
-    factors.sort(key=lambda x: abs(x['ic']), reverse=True)
+
+    factors.sort(key=lambda x: abs(x["ic"]), reverse=True)
     _FACTORS_CACHE = factors
     return factors[:top_n]
 
@@ -154,18 +163,18 @@ def load_ohlcv_data():
     global _OHLCV_CACHE
     if _OHLCV_CACHE is not None:
         return _OHLCV_CACHE
-    
+
     if not OHLCV_PATH.exists():
         raise FileNotFoundError(f"OHLCV data not found: {OHLCV_PATH}")
-    
-    ohlcv = pd.read_hdf(str(OHLCV_PATH), key='data')
-    if '$close' in ohlcv.columns:
-        close = ohlcv['$close']
-    elif 'close' in ohlcv.columns:
-        close = ohlcv['close']
+
+    ohlcv = pd.read_hdf(str(OHLCV_PATH), key="data")
+    if "$close" in ohlcv.columns:
+        close = ohlcv["$close"]
+    elif "close" in ohlcv.columns:
+        close = ohlcv["close"]
     else:
         close = ohlcv.select_dtypes(include=[np.number]).iloc[:, 0]
-    
+
     _OHLCV_CACHE = close.dropna()
     return _OHLCV_CACHE
 
@@ -175,16 +184,16 @@ def load_ohlcv_data():
 def generate_single_strategy(args):
     """Generate and backtest ONE strategy. Runs in separate process."""
     idx, factor_subset, feedback, attempt = args
-    
+
     try:
         setup_llm_env()
-        
+
         from rdagent.oai.llm_utils import APIBackend
-        
+
         factor_list = "\n".join([f"- {f['name']} (IC={f['ic']:.4f})" for f in factor_subset])
-        
+
         # Optimized prompts for daytrading vs swing
-        if TRADING_STYLE == 'daytrading' and OHLCV_ONLY:
+        if TRADING_STYLE == "daytrading" and OHLCV_ONLY:
             system_prompt = """You are an expert EUR/USD intraday quant. You build strategies that work ONLY on raw price data (OHLCV), computing all indicators directly from the 1-minute close series.
 
 CRITICAL RULES:
@@ -219,9 +228,10 @@ Hard requirements:
 - Use EMA crossover thresholds of 0 (cross above/below) for maximum trade frequency
 - Use causal indicators only: rolling windows, shift(1) — NO look-ahead bias
 - No factor data — compute everything from 'close'
-- Keep it simple: 2-3 indicators max"""
+- Keep it simple: 2-3 indicators max
+- TARGET MONTHLY RETURN: Generate signals that can achieve >15% OOS monthly return after RiskMgmt costs (2.35 pip/trade). Use high-conviction entries only."""
 
-        elif TRADING_STYLE == 'daytrading':
+        elif TRADING_STYLE == "daytrading":
             system_prompt = f"""You are an expert daytrading quant specializing in EUR/USD scalping and intraday strategies.
 
 CRITICAL RULES for {STYLE_DESC} (forward horizon: {FORWARD_BARS} bars = ~{FORWARD_BARS} minutes):
@@ -247,7 +257,8 @@ Hard requirements:
 - NEVER use ffill() or forward-fill on the signal — recompute fresh at every bar
 - Use rolling z-scores with windows of 5-20 bars (not 50-100), thresholds ±0.2 to ±0.5
 - Combine 2 factors: one momentum, one mean-reversion
-- NO global mean/std — always use rolling(window).mean() with shift(1) to avoid look-ahead bias"""
+- NO global mean/std — always use rolling(window).mean() with shift(1) to avoid look-ahead bias
+- TARGET MONTHLY RETURN: Generate signals that can achieve >15% OOS monthly return after RiskMgmt costs (2.35 pip/trade). Use high-conviction entries only."""
 
         else:
             system_prompt = f"""You are a quantitative trading expert specializing in EUR/USD daily swing strategies.
@@ -278,26 +289,26 @@ Output ONLY valid JSON with these fields:
 
 {f'Previous feedback: {feedback}' if feedback else 'First attempt - be creative!'}
 
-Use daily-level signal logic (factor above/below rolling daily mean). Signal changes once per day."""
-        
+Use daily-level signal logic (factor above/below rolling daily mean). Signal changes once per day. TARGET MONTHLY RETURN: Generate signals that can achieve >15% OOS monthly return after RiskMgmt costs (2.35 pip/trade)."""
+
         api = APIBackend()
         response = api.build_messages_and_create_chat_completion(
-            user_prompt=user_prompt, system_prompt=system_prompt, json_mode=True
+            user_prompt=user_prompt, system_prompt=system_prompt, json_mode=True,
         )
         strategy_data = json.loads(response)
-        
+
         # Validate response
-        if 'code' not in strategy_data or 'factor_names' not in strategy_data:
-            return {'status': 'invalid', 'reason': 'Missing required fields', 'idx': idx}
-        
+        if "code" not in strategy_data or "factor_names" not in strategy_data:
+            return {"status": "invalid", "reason": "Missing required fields", "idx": idx}
+
         return {
-            'status': 'generated',
-            'strategy': strategy_data,
-            'idx': idx
+            "status": "generated",
+            "strategy": strategy_data,
+            "idx": idx,
         }
-        
+
     except Exception as e:
-        return {'status': 'error', 'reason': str(e)[:200], 'idx': idx}
+        return {"status": "error", "reason": str(e)[:200], "idx": idx}
 
 # ============================================================================
 # Backtest Runner (runs in main process to avoid re-loading data)
@@ -345,39 +356,39 @@ signal.fillna(0).to_pickle('signal.pkl')
 
     with tempfile.TemporaryDirectory() as td:
         tdp = Path(td)
-        close.to_pickle(str(tdp / 'close.pkl'))
+        close.to_pickle(str(tdp / "close.pkl"))
         if not OHLCV_ONLY and factors_df is not None:
-            factors_df.to_pickle(str(tdp / 'factors.pkl'))
-        (tdp / 'run.py').write_text(script)
+            factors_df.to_pickle(str(tdp / "factors.pkl"))
+        (tdp / "run.py").write_text(script)
 
         try:
             result = subprocess.run(
-                ['python', 'run.py'],
+                ["python", "run.py"],
                 capture_output=True, text=True, timeout=60,
-                cwd=str(tdp)
+                cwd=str(tdp),
             )
             if result.returncode != 0:
-                return {'status': 'failed', 'reason': (result.stderr or result.stdout)[:200]}
+                return {"status": "failed", "reason": (result.stderr or result.stdout)[:200]}
 
-            signal = pd.read_pickle(tdp / 'signal.pkl')
+            signal = pd.read_pickle(tdp / "signal.pkl")
         except subprocess.TimeoutExpired:
-            return {'status': 'failed', 'reason': 'Timeout (60s)'}
+            return {"status": "failed", "reason": "Timeout (60s)"}
         except Exception as e:
-            return {'status': 'failed', 'reason': str(e)[:200]}
+            return {"status": "failed", "reason": str(e)[:200]}
 
-    # Main process: FTMO-realistic backtest (leverage + daily/total loss limits).
-    from rdagent.components.backtesting.vbt_backtest import backtest_signal_ftmo
+    # Main process: RiskMgmt-realistic backtest (leverage + daily/total loss limits).
+    from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
 
     common = close.index.intersection(signal.index)
     if len(common) < 100:
-        return {'status': 'failed', 'reason': f'Not enough aligned data ({len(common)} bars)'}
+        return {"status": "failed", "reason": f"Not enough aligned data ({len(common)} bars)"}
 
     close_a  = close.loc[common]
     signal_a = signal.reindex(common).fillna(0)
     fwd_returns = close_a.pct_change(FORWARD_BARS).shift(-FORWARD_BARS)
 
     from rdagent.components.backtesting.vbt_backtest import OOS_START_DEFAULT
-    return backtest_signal_ftmo(
+    return backtest_signal_risk(
         close=close_a,
         signal=signal_a,
         txn_cost_bps=TXN_COST_BPS,
@@ -409,9 +420,9 @@ def _rescale_thresholds(code: str, scale: float) -> str:
         return f"{val * scale:.3f}"
 
     # RSI-style thresholds: integers/floats between 10 and 90
-    code = re.sub(r'\b([1-9]\d(?:\.\d+)?)\b', replace_rsi, code)
+    code = re.sub(r"\b([1-9]\d(?:\.\d+)?)\b", replace_rsi, code)
     # Small float thresholds: 0.05 – 2.99
-    code = re.sub(r'\b(0\.\d+|[12]\.\d+)\b', replace_small, code)
+    code = re.sub(r"\b(0\.\d+|[12]\.\d+)\b", replace_small, code)
     return code
 
 
@@ -426,12 +437,12 @@ def tune_thresholds(close, factors_df, code: str) -> tuple:
     for scale in [1.0, 0.7, 0.5, 0.35, 0.2, 0.1, 0.05]:
         tuned = _rescale_thresholds(code, scale) if scale < 1.0 else code
         bt = run_backtest(close, factors_df, tuned)
-        if bt is None or bt.get('status') != 'success':
+        if bt is None or bt.get("status") != "success":
             continue
-        trades = bt.get('n_trades', 0)
-        sharpe = bt.get('sharpe', -999)
+        trades = bt.get("n_trades", 0)
+        sharpe = bt.get("sharpe", -999)
         if trades >= MIN_TRADES:
-            if best_bt is None or sharpe > best_bt.get('sharpe', -999):
+            if best_bt is None or sharpe > best_bt.get("sharpe", -999):
                 best_bt = bt
                 best_code = tuned
             break  # first scale that hits MIN_TRADES wins (they get looser after this)
@@ -461,46 +472,46 @@ def main(target_count=10):
     console.print(f"   Forward bars: {FORWARD_BARS}")
     console.print(f"   Target: {target_count} accepted strategies")
     console.print(f"   Workers: {N_WORKERS}\n")
-    
+
     # Load data (main process only)
     close = load_ohlcv_data()
     factors = load_available_factors(20)
-    
+
     console.print(f"[green]✓[/green] Loaded {len(factors)} factors, {len(close):,} OHLCV bars\n")
-    
+
     # Load factor time-series
     factor_data = {}
     with Progress(SpinnerColumn(), TextColumn("[bold blue]Loading factors..."), BarColumn(), TimeElapsedColumn()) as progress:
         task = progress.add_task("Loading...", total=len(factors))
         for f_info in factors:
-            safe = f_info['name'].replace('/','_').replace('\\','_')[:150]
-            pf = FACTORS_DIR / 'values' / f"{safe}.parquet"
+            safe = f_info["name"].replace("/","_").replace("\\","_")[:150]
+            pf = FACTORS_DIR / "values" / f"{safe}.parquet"
             if pf.exists():
                 try:
                     series = pd.read_parquet(str(pf)).iloc[:, 0]
-                    factor_data[f_info['name']] = series
+                    factor_data[f_info["name"]] = series
                 except:
                     pass
             progress.update(task, advance=1)
-    
+
     # Align factors with close prices
     all_factor_series = [factor_data[n] for n in factor_data if n in factor_data]
     if not all_factor_series:
         console.print("[red]✗ No factor data loaded![/red]")
         return
-    
+
     df_factors = pd.DataFrame({n: factor_data[n] for n in factor_data if n in factor_data})
-    common_idx = close.index.intersection(df_factors.dropna(how='all').index)
+    common_idx = close.index.intersection(df_factors.dropna(how="all").index)
     close_aligned = close.loc[common_idx]
     df_aligned = df_factors.loc[common_idx]
-    
+
     console.print(f"[green]✓[/green] Aligned {len(df_aligned):,} data points\n")
-    
+
     # Strategy generation loop
     accepted = []
     feedback_history = []
     max_attempts = target_count * 10  # Allow 10x attempts
-    
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[bold blue]{task.description}"),
@@ -511,11 +522,11 @@ def main(target_count=10):
         redirect_stderr=True,
     ) as progress:
         task = progress.add_task("Generating...", total=max_attempts)
-        
+
         for attempt in range(max_attempts):
             if len(accepted) >= target_count:
                 break
-            
+
             # Select random factor subset (2-5 factors) — empty for OHLCV-only mode
             if OHLCV_ONLY:
                 factor_subset = []
@@ -528,51 +539,51 @@ def main(target_count=10):
             # Generate in main process (LLM doesn't parallelize well)
             gen_result = generate_single_strategy((attempt, factor_subset, feedback, attempt))
 
-            if gen_result['status'] != 'generated':
+            if gen_result["status"] != "generated":
                 progress.update(task, advance=1)
                 continue
 
-            strategy = gen_result['strategy']
+            strategy = gen_result["strategy"]
 
             # Backtest (main process - needs data access)
             if OHLCV_ONLY:
                 strat_factors = None
-                bt_result = run_backtest(close, None, strategy.get('code', ''))
+                bt_result = run_backtest(close, None, strategy.get("code", ""))
             else:
-                strat_factors = df_aligned[[f for f in strategy.get('factor_names', []) if f in df_aligned.columns]]
+                strat_factors = df_aligned[[f for f in strategy.get("factor_names", []) if f in df_aligned.columns]]
                 if len(strat_factors.columns) < 2:
                     progress.update(task, advance=1)
                     continue
-                bt_result = run_backtest(close_aligned, strat_factors, strategy.get('code', ''))
-            
-            if bt_result and bt_result.get('status') == 'success':
-                ic = bt_result.get('ic', 0)
-                sharpe = bt_result.get('sharpe', 0)
-                trades = bt_result.get('n_trades', 0)
-                dd = bt_result.get('max_drawdown', 0)
+                bt_result = run_backtest(close_aligned, strat_factors, strategy.get("code", ""))
+
+            if bt_result and bt_result.get("status") == "success":
+                ic = bt_result.get("ic", 0)
+                sharpe = bt_result.get("sharpe", 0)
+                trades = bt_result.get("n_trades", 0)
+                dd = bt_result.get("max_drawdown", 0)
 
                 # If too few trades, auto-tune thresholds before giving up
-                original_code = strategy.get('code', '')
-                if trades < MIN_TRADES and bt_result.get('status') == 'success':
+                original_code = strategy.get("code", "")
+                if trades < MIN_TRADES and bt_result.get("status") == "success":
                     _log.info(f"TUNING  trades={trades}<{MIN_TRADES} — trying looser thresholds")
                     tuned_bt, tuned_code = tune_thresholds(
                         close if OHLCV_ONLY else close_aligned,
                         None if OHLCV_ONLY else strat_factors,
                         original_code,
                     )
-                    if tuned_bt and tuned_bt.get('n_trades', 0) >= MIN_TRADES:
+                    if tuned_bt and tuned_bt.get("n_trades", 0) >= MIN_TRADES:
                         bt_result = tuned_bt
-                        strategy['code'] = tuned_code
-                        ic = bt_result.get('ic', 0)
-                        sharpe = bt_result.get('sharpe', 0)
-                        trades = bt_result.get('n_trades', 0)
-                        dd = bt_result.get('max_drawdown', 0)
+                        strategy["code"] = tuned_code
+                        ic = bt_result.get("ic", 0)
+                        sharpe = bt_result.get("sharpe", 0)
+                        trades = bt_result.get("n_trades", 0)
+                        dd = bt_result.get("max_drawdown", 0)
                         _log.info(f"TUNED   Sharpe={sharpe:.2f}  Trades={trades}")
 
                 # OOS metrics — mandatory, no fallback to IS values
-                oos_sharpe  = bt_result.get('oos_sharpe')
-                oos_monthly = bt_result.get('oos_monthly_return_pct')
-                oos_trades  = bt_result.get('oos_n_trades', 0)
+                oos_sharpe  = bt_result.get("oos_sharpe")
+                oos_monthly = bt_result.get("oos_monthly_return_pct")
+                oos_trades  = bt_result.get("oos_n_trades", 0)
 
                 # Reject if OOS data is missing (strategy trained on data without OOS period)
                 if oos_sharpe is None or oos_monthly is None:
@@ -582,62 +593,62 @@ def main(target_count=10):
                     continue
 
                 # Monte Carlo p-value (edge significance)
-                mc_pvalue = bt_result.get('mc_pvalue')
+                mc_pvalue = bt_result.get("mc_pvalue")
 
                 # Rolling walk-forward metrics
-                wf_consistency = bt_result.get('wf_oos_consistency')
-                wf_sharpe_mean = bt_result.get('wf_oos_sharpe_mean')
+                wf_consistency = bt_result.get("wf_oos_consistency")
+                wf_sharpe_mean = bt_result.get("wf_oos_sharpe_mean")
 
                 # Check acceptance criteria — OOS must be profitable + statistically significant
                 mc_ok = mc_pvalue is None or mc_pvalue < 0.20  # lenient: top 20% non-random
                 wf_ok = wf_consistency is None or wf_consistency >= 0.5  # ≥50% of WF windows profitable
                 if (abs(ic or 0) > MIN_IC and sharpe > MIN_SHARPE and trades > MIN_TRADES and dd > MAX_DRAWDOWN
-                        and oos_sharpe > 0.0 and oos_monthly > 0.0 and mc_ok and wf_ok):
+                        and oos_sharpe > 0.0 and oos_monthly > MIN_MONTHLY_RETURN_PCT and mc_ok and wf_ok):
                     # ACCEPT
-                    strategy['real_backtest'] = bt_result
-                    strategy['metrics'] = bt_result
-                    strategy['summary'] = {
-                        'sharpe': sharpe, 'max_drawdown': dd, 'win_rate': bt_result.get('win_rate', 0),
-                        'monthly_return_pct': bt_result.get('monthly_return_pct', 0),
-                        'annual_return_pct': bt_result.get('annual_return_pct', 0),
-                        'real_ic': ic, 'real_n_trades': trades, 'real_backtest_status': 'success',
-                        'n_bars': bt_result.get('n_bars', 0), 'n_months': bt_result.get('n_months', 0),
-                        'trading_style': TRADING_STYLE,
-                        'ohlcv_only': OHLCV_ONLY,
-                        'engine': 'ftmo_v2',
-                        'txn_cost_bps': TXN_COST_BPS,
+                    strategy["real_backtest"] = bt_result
+                    strategy["metrics"] = bt_result
+                    strategy["summary"] = {
+                        "sharpe": sharpe, "max_drawdown": dd, "win_rate": bt_result.get("win_rate", 0),
+                        "monthly_return_pct": bt_result.get("monthly_return_pct", 0),
+                        "annual_return_pct": bt_result.get("annual_return_pct", 0),
+                        "real_ic": ic, "real_n_trades": trades, "real_backtest_status": "success",
+                        "n_bars": bt_result.get("n_bars", 0), "n_months": bt_result.get("n_months", 0),
+                        "trading_style": TRADING_STYLE,
+                        "ohlcv_only": OHLCV_ONLY,
+                        "engine": "riskmgmt_v2",
+                        "txn_cost_bps": TXN_COST_BPS,
                         # Walk-forward OOS split
-                        'oos_sharpe': bt_result.get('oos_sharpe'),
-                        'oos_monthly_return_pct': bt_result.get('oos_monthly_return_pct'),
-                        'oos_max_drawdown': bt_result.get('oos_max_drawdown'),
-                        'oos_win_rate': bt_result.get('oos_win_rate'),
-                        'oos_n_trades': bt_result.get('oos_n_trades'),
-                        'is_sharpe': bt_result.get('is_sharpe'),
-                        'is_monthly_return_pct': bt_result.get('is_monthly_return_pct'),
-                        'oos_start': bt_result.get('oos_start'),
+                        "oos_sharpe": bt_result.get("oos_sharpe"),
+                        "oos_monthly_return_pct": bt_result.get("oos_monthly_return_pct"),
+                        "oos_max_drawdown": bt_result.get("oos_max_drawdown"),
+                        "oos_win_rate": bt_result.get("oos_win_rate"),
+                        "oos_n_trades": bt_result.get("oos_n_trades"),
+                        "is_sharpe": bt_result.get("is_sharpe"),
+                        "is_monthly_return_pct": bt_result.get("is_monthly_return_pct"),
+                        "oos_start": bt_result.get("oos_start"),
                         # Rolling walk-forward
-                        'wf_n_windows': bt_result.get('wf_n_windows'),
-                        'wf_oos_sharpe_mean': wf_sharpe_mean,
-                        'wf_oos_sharpe_std': bt_result.get('wf_oos_sharpe_std'),
-                        'wf_oos_monthly_return_mean': bt_result.get('wf_oos_monthly_return_mean'),
-                        'wf_oos_consistency': wf_consistency,
+                        "wf_n_windows": bt_result.get("wf_n_windows"),
+                        "wf_oos_sharpe_mean": wf_sharpe_mean,
+                        "wf_oos_sharpe_std": bt_result.get("wf_oos_sharpe_std"),
+                        "wf_oos_monthly_return_mean": bt_result.get("wf_oos_monthly_return_mean"),
+                        "wf_oos_consistency": wf_consistency,
                         # Monte Carlo significance
-                        'mc_pvalue': mc_pvalue,
-                        'mc_n_permutations': bt_result.get('mc_n_permutations'),
+                        "mc_pvalue": mc_pvalue,
+                        "mc_n_permutations": bt_result.get("mc_n_permutations"),
                     }
-                    
+
                     fname = f"{int(time.time())}_{strategy['strategy_name']}.json"
-                    with open(STRATEGIES_DIR / fname, 'w') as f:
+                    with open(STRATEGIES_DIR / fname, "w") as f:
                         json.dump(strategy, f, indent=2, ensure_ascii=False)
-                    
+
                     # Generate PDF report
                     try:
-                        from predix_strategy_report import StrategyPerformanceReporter
+                        from nexquant_strategy_report import StrategyPerformanceReporter
                         reporter = StrategyPerformanceReporter(strategy)
                         reporter.generate_report()
                     except:
                         pass
-                    
+
                     accepted.append(strategy)
                     _log.success(f"ACCEPTED  {strategy['strategy_name']}  IC={ic:.4f}  Sharpe={sharpe:.3f}  Trades={trades}  DD={dd:.1%}")
                     feedback_history.append(f"Excellent! IC={ic:.4f}, Sharpe={sharpe:.2f}, Trades={trades}. Try to improve further.")
@@ -656,27 +667,27 @@ def main(target_count=10):
                         + (f", MC_p={mc_pvalue:.2f}" if mc_pvalue is not None else "")
                         + (f", WF_consistency={wf_consistency:.0%}" if wf_consistency is not None else "")
                         + f". Need |IC|>{MIN_IC}, Sharpe>{MIN_SHARPE}, Trades>{MIN_TRADES}, "
-                        f"OOS_Sharpe>0, OOS_Monthly>0, MC_p<0.20, WF_consistency≥50%."
+                        f"OOS_Sharpe>0, OOS_Monthly>{MIN_MONTHLY_RETURN_PCT}%, MC_p<0.20, WF_consistency≥50%.",
                     )
-            
+
             progress.update(task, advance=1)
-    
+
     # Summary
     _log.info(f"DONE  accepted={len(accepted)}  target={target_count}")
-    for i, s in enumerate(sorted(accepted, key=lambda x: x['real_backtest'].get('ic', 0), reverse=True), 1):
-        bt = s['real_backtest']
+    for i, s in enumerate(sorted(accepted, key=lambda x: x["real_backtest"].get("ic", 0), reverse=True), 1):
+        bt = s["real_backtest"]
         _log.info(f"  #{i}  {s['strategy_name']}  IC={bt.get('ic',0):.4f}  Sharpe={bt.get('sharpe',0):.3f}  Monthly={bt.get('monthly_return_pct',0):.2f}%")
 
     console.print(f"\n[bold green]✓ Generated {len(accepted)}/{target_count} accepted strategies[/bold green]\n")
 
     if accepted:
-        accepted.sort(key=lambda x: x['real_backtest'].get('ic', 0), reverse=True)
+        accepted.sort(key=lambda x: x["real_backtest"].get("ic", 0), reverse=True)
         console.print("[bold]Results:[/bold]")
         for i, s in enumerate(accepted, 1):
-            bt = s['real_backtest']
+            bt = s["real_backtest"]
             console.print(f"  {i}. {s['strategy_name']:30s} IC={bt.get('ic',0):.4f} Sharpe={bt.get('sharpe',0):.3f} "
                           f"Monthly={bt.get('monthly_return_pct',0):.2f}% Trades={bt.get('n_trades',0)}")
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     count = int(sys.argv[1]) if len(sys.argv) > 1 else 10
     main(count)

scripts/nexquant_grid_search.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""Strategy Grid Search — Systematic parameter scanning for optimal strategies.
+
+Unlike the random R&D loop, this tests ALL parameter/TF combinations
+for the best indicators, guaranteeing global optimum discovery.
+
+Output: Ranked list of strategies with per-instrument + combined metrics.
+"""
+
+import json, os, sys, time, itertools
+from datetime import datetime
+from pathlib import Path
+import numpy as np, pandas as pd
+
+PROJECT = Path(__file__).resolve().parent.parent
+OHLCV_PATH = Path(os.getenv("PREDIX_OHLCV_PATH",
+    str(PROJECT / "git_ignore_folder" / "intraday_pv_all.h5")))
+OUTPUT_DIR = PROJECT / "results" / "grid_search"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+sys.path.insert(0, str(PROJECT / "scripts"))
+from nexquant_rd_loop import (
+    evaluate_multi, build_signal, _apply_session_filter, _apply_news_filter,
+    _apply_vola_filter, _apply_cross_confirm, LEADER_MAP, load_data,
+)
+
+# ── Grid Definition ──
+
+INDICATOR_GRIDS = {
+    "MACD": {
+        "type": "multi_tf",
+        "params": {
+            "fast": [3, 5, 8, 12],
+            "slow": [10, 15, 20, 26, 40],
+            "sig": [3, 5, 9],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["15min", "30min", "1h"],
+            ["30min", "1h", "4h"],
+            ["15min", "1h", "4h"],
+        ],
+    },
+    "Donchian": {
+        "type": "multi_tf",
+        "params": {
+            "period": [5, 10, 20, 30, 50, 80, 100],
+            "hold": [1, 2, 3, 5, 10],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+            ["15min", "1h", "4h"],
+        ],
+    },
+    "SAR": {
+        "type": "multi_tf",
+        "params": {
+            "accel": [0.02, 0.05, 0.08, 0.1, 0.15],
+            "max_accel": [0.1, 0.2, 0.3, 0.5],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+            ["15min", "1h", "4h"],
+        ],
+    },
+    "ADX": {
+        "type": "multi_tf",
+        "params": {
+            "period": [7, 10, 14, 21, 30],
+            "threshold": [15, 20, 25, 30],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "RSI": {
+        "type": "multi_tf",
+        "params": {
+            "period": [7, 10, 14, 21],
+            "oversold": [20, 25, 30],
+            "overbought": [70, 75, 80],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "BBands": {
+        "type": "multi_tf",
+        "params": {
+            "period": [10, 20, 40],
+            "std": [1.5, 2.0, 2.5],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "ROC": {
+        "type": "multi_tf",
+        "params": {
+            "period": [5, 10, 20, 50],
+            "threshold": [0.1, 0.2, 0.5, 1.0],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "MOM": {
+        "type": "multi_tf",
+        "params": {
+            "period": [5, 10, 20, 50, 100],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "Stoch": {
+        "type": "multi_tf",
+        "params": {
+            "fastk": [5, 9, 14],
+            "slowd": [3, 5, 9],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+    "CCI": {
+        "type": "multi_tf",
+        "params": {
+            "period": [10, 14, 20, 50],
+        },
+        "tfs": [
+            ["15min", "30min", "1h", "4h"],
+            ["30min", "1h", "4h"],
+        ],
+    },
+}
+
+
+def expand_grid(indicator_name):
+    """Expand a grid definition into all parameter+TF combinations."""
+    grid = INDICATOR_GRIDS[indicator_name]
+    param_keys = list(grid["params"].keys())
+    param_values = [grid["params"][k] for k in param_keys]
+    hypotheses = []
+
+    for tf_list in grid["tfs"]:
+        for param_combo in itertools.product(*param_values):
+            params = dict(zip(param_keys, param_combo))
+            hypotheses.append({
+                "type": grid["type"],
+                "indicator": indicator_name,
+                "timeframes": tf_list,
+                "params": params,
+                "description": f"{indicator_name}({'-'.join(str(v) for v in param_combo)}) on {','.join(tf_list[:2])}",
+                "generation": "grid",
+            })
+
+    return hypotheses
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--indicators", nargs="*", default=None,
+                    help="Indicators to grid-search (default: all)")
+    ap.add_argument("--top", type=int, default=20,
+                    help="Number of top results to show")
+    args = ap.parse_args()
+
+    indicators = args.indicators or list(INDICATOR_GRIDS.keys())
+    if isinstance(indicators, str):
+        indicators = [indicators]
+
+    print("=" * 60)
+    print("  Strategy Grid Search")
+    print(f"  Indicators: {', '.join(indicators)}")
+    print("=" * 60)
+
+    # Load data
+    print("  Loading data...")
+    closes = load_data()
+    if not closes:
+        print("  No instruments found!"); return
+
+    # Generate all hypotheses
+    all_hypotheses = []
+    for ind in indicators:
+        hyps = expand_grid(ind)
+        all_hypotheses.extend(hyps)
+    print(f"  Total combinations to test: {len(all_hypotheses)}")
+    print()
+
+    # Evaluate all
+    results = []
+    t0 = time.time()
+    for i, hp in enumerate(all_hypotheses):
+        try:
+            r = evaluate_multi(closes, hp, use_session=True, use_vola=False)
+            r["hypothesis"] = hp
+            r["rank"] = i + 1
+            results.append(r)
+        except Exception:
+            continue
+
+        elapsed = time.time() - t0
+        rate = (i + 1) / elapsed if elapsed > 0 else 0
+        eta = (len(all_hypotheses) - i - 1) / rate if rate > 0 else 0
+
+        if (i + 1) % 50 == 0:
+            best_so_far = max(results, key=lambda x: x["sharpe"]) if results else {"sharpe": 0}
+            print(f"  [{i+1}/{len(all_hypotheses)}] "
+                  f"Best Sh={best_so_far['sharpe']:.1f} "
+                  f"Mon={best_so_far['monthly_pct']:.1f}% "
+                  f"OOS={best_so_far['monthly_oos']:.1f}% | "
+                  f"{rate:.0f}/s | ETA {eta/60:.0f}min")
+
+    # Sort by OOS Sharpe (most important metric)
+    results.sort(key=lambda r: r.get("sharpe", 0), reverse=True)
+
+    elapsed = time.time() - t0
+    print(f"\n{'=' * 60}")
+    print(f"  Grid Search Complete: {len(results)}/{len(all_hypotheses)} valid")
+    print(f"  Time: {elapsed:.0f}s ({elapsed/60:.1f}min)")
+    print(f"{'=' * 60}")
+
+    # Save all results
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    out_file = OUTPUT_DIR / f"grid_results_{ts}.json"
+    stripped = [{k: v for k, v in r.items() if k != "equity_curves"} for r in results]
+    out_file.write_text(json.dumps(stripped, indent=2, default=str))
+    print(f"  Saved: {out_file}")
+
+    # Show top results
+    top_n = min(args.top, len(results))
+    print(f"\n  TOP {top_n} (by OOS Sharpe):")
+    print(f"  {'Rank':>4s} {'Strategy':<45s} {'Sh_IS':>6s} {'Sh_OOS':>6s} {'Mon%':>7s} {'OOS%':>7s} {'DD':>6s} {'Tr':>5s} {'BTC':>5s}")
+    for i, r in enumerate(results[:top_n], 1):
+        hp = r["hypothesis"]
+        per = r.get("per_instrument", {})
+        btc_sh = per.get("BTCUSD", {}).get("sharpe_oos", 0)
+        print(f"  {i:4d} {hp['description'][:45]:45s} "
+              f"{r.get('sharpe_is', 0):+6.1f} {r.get('sharpe_oos', 0):+6.1f} "
+              f"{r['monthly_pct']:+6.1f}% {r['monthly_oos']:+6.1f}% "
+              f"{r['max_dd']:.4f} {r['n_trades']:5d} {btc_sh:+5.0f}")
+
+    # Indicator performance summary
+    print(f"\n  Indicator Performance (avg OOS Sharpe):")
+    for ind in indicators:
+        ind_results = [r for r in results if r["hypothesis"].get("indicator") == ind]
+        if ind_results:
+            avg_sh = np.mean([r["sharpe"] for r in ind_results])
+            best = ind_results[0]
+            print(f"  {ind:12s}: avg Sh={avg_sh:+.1f} best={best['sharpe']:+.1f} "
+                  f"({best['monthly_pct']:+.1f}%/{best['monthly_oos']:+.1f}% OOS)")
+
+
+if __name__ == "__main__":
+    main()

scripts/nexquant_gridsearch.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""Grid-Search Strategy Generator — no LLM, deterministic, RiskMgmt-verified.
+
+Core idea: Instead of LLM-generated code, use a fixed signal template and
+grid-search the parameters. Factors are aligned to daily resolution (where
+they have actual predictive power), signal is forward-filled to 1-min for
+RiskMgmt backtest execution.
+
+Template: z-score → IC-weighted composite → asymmetric thresholds → signal
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+# ── Paths ────────────────────────────────────────────────────────────────────
+PROJECT = Path(__file__).resolve().parent.parent
+FACTORS_DIR = PROJECT / "results" / "factors"
+VALUES_DIR = FACTORS_DIR / "values"
+RESULTS_DIR = PROJECT / "results" / "strategies_new"
+OHLCV_PATH = Path(
+    os.getenv("PREDIX_OHLCV_PATH",
+              str(PROJECT / "git_ignore_folder" / "intraday_pv_all.h5"))
+)
+
+# ── Target ───────────────────────────────────────────────────────────────────
+MIN_MONTHLY_RETURN_PCT = 1.0   # Raw backtest target (RiskMgmt will reduce ~50%)
+MIN_SHARPE = 0.5
+MAX_DRAWDOWN = -0.30
+MIN_WIN_RATE = 0.35
+MIN_TRADES = 20
+
+# ── Grid ─────────────────────────────────────────────────────────────────────
+PARAM_GRID = {
+    "window": [5, 10, 20, 30],
+    "entry_thresh": [0.5, 0.8, 1.0, 1.5, 2.0],  # Higher = fewer, higher-conviction trades
+    "exit_thresh": [0.2, 0.5],
+}
+# Total: 5 × 4 × 3 = 60 combinations per factor pair
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Factor loading
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def load_top_factors(min_ic: float = 0.04, top_n: int = 50) -> list[dict]:
+    """Load factor metadata sorted by |IC| descending."""
+    factors = []
+    for f in sorted(FACTORS_DIR.glob("*.json")):
+        data = json.loads(f.read_text())
+        if not isinstance(data, dict):
+            continue
+        fname = data.get("factor_name") or data.get("name") or f.stem
+        ic = data.get("ic") or data.get("real_ic") or 0.0
+        try:
+            ic = float(ic)
+        except (TypeError, ValueError):
+            continue
+        if abs(ic) < min_ic:
+            continue
+        safe = fname.replace("/", "_").replace("\\", "_").replace(" ", "_")[:150]
+        parq = VALUES_DIR / f"{safe}.parquet"
+        if not parq.exists():
+            continue
+        factors.append({"name": fname, "ic": ic, "parquet": parq})
+    factors.sort(key=lambda x: abs(x["ic"]), reverse=True)
+    return factors[:top_n]
+
+
+def load_factor_series(factor: dict) -> pd.Series | None:
+    """Load factor time series, extracting the EURUSD slice."""
+    try:
+        df = pd.read_parquet(str(factor["parquet"]))
+        if df.empty:
+            return None
+        col = df.columns[0]
+        if isinstance(df.index, pd.MultiIndex):
+            return df.xs("EURUSD", level="instrument")[col]
+        return df[col]
+    except Exception:
+        return None
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Signal generation
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def build_signal(
+    daily_factors: pd.DataFrame,
+    ic_values: dict[str, float],
+    window: int = 10,
+    entry_thresh: float = 0.5,
+    exit_thresh: float = 0.2,
+) -> pd.Series:
+    """
+    Fixed signal template: z-score → IC-weighted composite → thresholds.
+
+    Parameters
+    ----------
+    daily_factors : DataFrame
+        Factor values at daily resolution, columns = factor names.
+    ic_values : dict
+        Factor name → IC value (used for sign/direction, not weight).
+    window : int
+        Rolling window for z-score in days.
+    entry_thresh : float
+        Composite z-score threshold for entry.
+    exit_thresh : float
+        Composite z-score threshold for exit (flatten position).
+    """
+    eps = 1e-8
+    z = (daily_factors - daily_factors.rolling(window).mean()) / (
+        daily_factors.rolling(window).std() + eps
+    )
+
+    # IC-weighted composite: invert negative-IC factors, weight by |IC|
+    composite = pd.Series(0.0, index=daily_factors.index)
+    total_abs_ic = sum(abs(ic) for ic in ic_values.values())
+    if total_abs_ic == 0:
+        total_abs_ic = 1.0
+
+    for col in daily_factors.columns:
+        ic = ic_values.get(col, 0.0)
+        w = abs(ic) / total_abs_ic
+        sign = 1.0 if ic >= 0 else -1.0
+        composite += sign * w * z[col]
+
+    # Asymmetric thresholds
+    signal = pd.Series(0, index=daily_factors.index)
+    signal[composite > entry_thresh] = 1
+    signal[composite < -entry_thresh] = -1
+    signal[abs(composite) < exit_thresh] = 0
+
+    signal = signal.rolling(2, min_periods=1).mean().round().astype(int)
+    signal = signal.clip(-1, 1)
+    signal.name = "signal"
+    return signal
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Evaluation
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def evaluate_one(args: tuple) -> dict | None:
+    """Evaluate one parameter combination on one factor pair."""
+    (
+        f1_name, f1_ic, f1_series,
+        f2_name, f2_ic, f2_series,
+        close_1min, window, entry, exit_th,
+    ) = args
+
+    try:
+        # Align factors to 1-min close
+        factors_1min = pd.DataFrame({
+            f1_name: f1_series.reindex(close_1min.index).ffill(limit=2880),
+            f2_name: f2_series.reindex(close_1min.index).ffill(limit=2880),
+        })
+
+        # Resample to daily
+        daily_factors = factors_1min.resample("D").last().dropna()
+        if len(daily_factors) < 50:
+            return None  # Not enough daily data
+
+        daily_close = close_1min.resample("D").last().reindex(daily_factors.index)
+
+        # Build signal
+        ic_values = {f1_name: f1_ic, f2_name: f2_ic}
+        daily_signal = build_signal(daily_factors, ic_values, window, entry, exit_th)
+
+        # Forward-fill to 1-min for backtest
+        signal_1min = daily_signal.reindex(close_1min.index).ffill().fillna(0).astype(int).clip(-1, 1)
+
+        # Fast backtest (no RiskMgmt mask, no walk-forward — <1s per eval)
+        from rdagent.components.backtesting.vbt_backtest import backtest_signal
+
+        bt = backtest_signal(
+            close=close_1min,
+            signal=signal_1min,
+        )
+
+        if bt.get("status") != "success":
+            return None
+
+        sharpe = bt.get("sharpe", 0) or 0
+        max_dd = bt.get("max_drawdown", 0) or 0
+        win_rate = bt.get("win_rate", 0) or 0
+        n_trades = bt.get("n_trades", 0) or 0
+        monthly_pct = bt.get("monthly_return_pct", 0) or 0
+
+        return {
+            "f1": f1_name,
+            "f2": f2_name,
+            "window": window,
+            "entry": entry,
+            "exit": exit_th,
+            "sharpe": round(sharpe, 4),
+            "max_dd": round(max_dd, 4),
+            "win_rate": round(win_rate, 4),
+            "n_trades": n_trades,
+            "monthly_pct": round(monthly_pct, 2),
+        }
+    except Exception:
+        return None
+
+
+def main():
+    print("═" * 60)
+    print("  Grid-Search Strategy Generator (no LLM)")
+    print("═" * 60)
+
+    # ── Load OHLCV ────────────────────────────────────────────────────────
+    print(f"\nLoading OHLCV: {OHLCV_PATH}")
+    df = pd.read_hdf(OHLCV_PATH, key="data")
+    close_1min = df.xs("EURUSD", level="instrument")["$close"].sort_index()
+    print(f"  1-min bars: {len(close_1min):,}  ({close_1min.index[0].date()} → {close_1min.index[-1].date()})")
+
+    # ── Load factors ───────────────────────────────────────────────────────
+    print(f"\nLoading factors (|IC| ≥ 0.04)...")
+    top_n = int(os.getenv("GS_TOP_N", "10"))
+    factors = load_top_factors(min_ic=0.04, top_n=top_n)
+    print(f"  Loaded {len(factors)} factors")
+
+    factor_series = {}
+    for f in factors:
+        s = load_factor_series(f)
+        if s is not None and len(s) > 100:
+            factor_series[f["name"]] = (f["ic"], s)
+
+    names = list(factor_series.keys())
+    print(f"  Valid series: {len(names)}")
+
+    # ── Generate factor pairs ──────────────────────────────────────────────
+    import itertools
+
+    pairs = list(itertools.combinations(names, 2))
+    print(f"  Factor pairs: {len(pairs)}")
+
+    # ── Generate parameter combinations ────────────────────────────────────
+    param_combos = list(itertools.product(
+        PARAM_GRID["window"],
+        PARAM_GRID["entry_thresh"],
+        PARAM_GRID["exit_thresh"],
+    ))
+    # Filter: exit < entry
+    param_combos = [(w, e, x) for w, e, x in param_combos if x < e]
+    print(f"  Parameter combos: {len(param_combos)}")
+
+    # ── Build work items ───────────────────────────────────────────────────
+    work_items = []
+    for f1_name, f2_name in pairs:
+        f1_ic, f1_series = factor_series[f1_name]
+        f2_ic, f2_series = factor_series[f2_name]
+        for window, entry, exit_th in param_combos:
+            work_items.append((
+                f1_name, f1_ic, f1_series,
+                f2_name, f2_ic, f2_series,
+                close_1min, window, entry, exit_th,
+            ))
+
+    total = len(work_items)
+    print(f"  Total evaluations: {total:,}")
+
+    # ── Run sequentially ───────────────────────────────────────────────────
+    t0 = time.time()
+    results = []
+
+    for i, item in enumerate(work_items):
+        r = evaluate_one(item)
+        if r is not None:
+            results.append(r)
+        if (i + 1) % 100 == 0 or i == total - 1:
+            elapsed = time.time() - t0
+            rate = (i + 1) / elapsed if elapsed > 0 else 0
+            eta = (total - i - 1) / rate if rate > 0 else 0
+            print(f"  {i+1}/{total} ({(i+1)/total*100:.1f}%)  "
+                  f"{len(results)} valid  {rate:.1f}/s  eta {eta:.0f}s")
+
+    # ── Filter and sort ────────────────────────────────────────────────────
+    print(f"\n{'═' * 60}")
+    print(f"  Total evaluated: {total:,}  Valid results: {len(results):,}")
+    print(f"{'═' * 60}")
+
+    valid = [r for r in results
+             if r["sharpe"] >= MIN_SHARPE
+             and r["max_dd"] >= MAX_DRAWDOWN
+             and r["win_rate"] >= MIN_WIN_RATE
+             and r["n_trades"] >= MIN_TRADES
+             and r["monthly_pct"] >= MIN_MONTHLY_RETURN_PCT]
+
+    valid.sort(key=lambda r: r["monthly_pct"], reverse=True)
+
+    print(f"\n  Meeting criteria (Sharpe≥{MIN_SHARPE}, DD≥{MAX_DRAWDOWN}, "
+          f"WR≥{MIN_WIN_RATE}, Trades≥{MIN_TRADES}, Mon≥{MIN_MONTHLY_RETURN_PCT}%):")
+    print(f"  → {len(valid)} strategies")
+    print()
+
+    if valid:
+        print(f"{'#':<3s} {'Factor 1':>30s} + {'Factor 2':>30s}  {'w':>3s} {'ent':>4s} {'ex':>4s}  {'Sharpe':>7s} {'MaxDD':>7s} {'WinRt':>6s} {'Tr':>4s} {'Mon%':>7s}")
+        print("-" * 135)
+        for i, r in enumerate(valid[:30], 1):
+            print(f"{i:<3d} {r['f1'][:30]:>30s} + {r['f2'][:30]:>30s}  "
+                  f"{r['window']:>3d} {r['entry']:>4.1f} {r['exit']:>4.1f}  "
+                  f"{r['sharpe']:>7.3f} {r['max_dd']:>7.3f} {r['win_rate']:>6.1%} "
+                  f"{r['n_trades']:>4d} {r['monthly_pct']:>7.2f}%")
+    else:
+        print("  No strategies meet the criteria.")
+        if results:
+            results.sort(key=lambda r: r["monthly_pct"], reverse=True)
+            print("\n  Top 10 by monthly return:")
+            for i, r in enumerate(results[:10], 1):
+                print(f"  {i:2d}. {r['f1'][:25]} + {r['f2'][:25]}  "
+                      f"Mon={r['monthly_pct']:.2f}%  Sh={r['sharpe']:.3f}  "
+                      f"DD={r['max_dd']:.3f}  Tr={r['n_trades']}")
+
+    # ── Save top results ───────────────────────────────────────────────────
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = RESULTS_DIR / f"gridsearch_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    out_path.write_text(json.dumps(valid[:50] if valid else results[:50], indent=2, default=str))
+    print(f"\n  Top results saved → {out_path}")
+    print(f"  Runtime: {time.time() - t0:.0f}s")
+
+
+if __name__ == "__main__":
+    main()

scripts/nexquant_infinite_search.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+"""
+NexQuant Infinite Hypothesis Search — kombiniert und variiert Ansätze
+bis ein positiver OOS Sharpe gefunden wird.
+"""
+
+from __future__ import annotations
+
+import json, sys, time, random, itertools
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from rdagent.components.backtesting.vbt_backtest import backtest_signal_risk
+
+DATA_PATH = Path("git_ignore_folder/factor_implementation_source_data/intraday_pv.h5")
+FACTORS_DIR = Path("results/factors")
+TXN_COST_BPS = 0.5
+
+
+def load_data():
+    close = pd.read_hdf(DATA_PATH, key="data")["$close"]
+    if isinstance(close.index, pd.MultiIndex):
+        close = close.droplevel(-1)
+    close = close.sort_index().dropna().resample("1h").last().dropna()
+
+    factors_meta = []
+    for f in sorted(FACTORS_DIR.glob("*.json")):
+        try:
+            d = json.loads(f.read_text())
+        except Exception:
+            continue
+        if d.get("status") != "success" or d.get("ic") is None:
+            continue
+        name = d.get("factor_name", f.stem)
+        safe = name.replace("/", "_")[:150]
+        if (FACTORS_DIR / "values" / f"{safe}.parquet").exists():
+            factors_meta.append({"name": name, "ic": d["ic"]})
+
+    factors_meta.sort(key=lambda x: abs(x["ic"]), reverse=True)
+    top = factors_meta[:15]
+    factor_data = {}
+    for f in top:
+        safe = f["name"].replace("/", "_")[:150]
+        series = pd.read_parquet(FACTORS_DIR / "values" / f"{safe}.parquet").iloc[:, 0]
+        if isinstance(series.index, pd.MultiIndex):
+            series = series.droplevel(-1)
+        factor_data[f["name"]] = series.resample("1h").last()
+
+    df = pd.DataFrame(factor_data)
+    common = close.index.intersection(df.dropna(how="all").index)
+    return close.loc[common], df.loc[common].ffill(), {f["name"]: f["ic"] for f in top}
+
+
+close, factors_df, ics = load_data()
+print(f"Data: {len(close):,} bars × {len(factors_df.columns)} factors\n")
+
+def backtest(signal) -> float:
+    if signal is None or len(signal) < 100:
+        return -999
+    common = close.index.intersection(signal.dropna().index)
+    if len(common) < 100:
+        return -999
+    r = backtest_signal_risk(close.loc[common], signal.reindex(common).fillna(0),
+                             txn_cost_bps=TXN_COST_BPS, wf_rolling=False)
+    return r.get("oos_sharpe", -999)
+
+
+def composite(factor_list=None, window=20):
+    cols = factor_list or list(factors_df.columns)
+    c = pd.Series(0.0, index=factors_df.index)
+    total = sum(abs(ics.get(col, 0)) for col in cols)
+    if total == 0:
+        return c
+    for col in cols:
+        ic_val = ics.get(col, 0)
+        if abs(ic_val) < 0.001:
+            continue
+        z = (factors_df[col] - factors_df[col].rolling(window).mean()) / (factors_df[col].rolling(window).std() + 1e-8)
+        c += (ic_val / total) * z
+    return c
+
+
+def session_filter(sig):
+    hours = sig.index.hour
+    sig = sig.copy()
+    sig[(hours < 7) | (hours >= 17)] = 0
+    return sig
+
+
+def trend_filter(sig, sma_bars=200 * 1440 // 5):
+    sma = close.rolling(sma_bars).mean()
+    trend_up = close > sma
+    sig = sig.copy()
+    sig[(sig > 0) & ~trend_up] = 0
+    sig[(sig < 0) & trend_up] = 0
+    return sig
+
+
+def vola_target(sig, vol_window=50):
+    vol = close.pct_change().rolling(vol_window).std()
+    vol_tgt = vol.median()
+    s = sig.astype(float) * vol_tgt / (vol + 1e-8)
+    return s.clip(-3, 3)
+
+
+def anti_fade(sig, sigma=3.0):
+    ret = close.pct_change()
+    thresh = ret.std() * sigma
+    s = sig.copy()
+    s[ret > thresh] = -1
+    s[ret < -thresh] = 1
+    return s
+
+
+def signal_decay(sig, half_life=60):
+    d = 0.5 ** (1 / half_life)
+    s = sig.astype(float).copy()
+    for i in range(1, len(s)):
+        if abs(s.iloc[i]) < 0.01:
+            s.iloc[i] = s.iloc[i - 1] * d
+    return s.clip(-1, 1)
+
+
+def kalman_composite(comp, Q=0.001, R=0.1):
+    x, P = 0.0, 1.0
+    filtered = []
+    for v in comp.dropna().values:
+        P += Q; K = P / (P + R); x += K * (v - x); P *= (1 - K)
+        filtered.append(x)
+    return pd.Series(filtered, index=comp.dropna().index)
+
+
+# PRIMITIVES — can be combined arbitrarily
+PRIMITIVES = {
+    "session": session_filter,
+    "trend": trend_filter,
+    "vola_target": vola_target,
+    "anti_fade": anti_fade,
+    "decay": signal_decay,
+}
+
+BASE_PARAMS = {
+    "entry": [0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5],
+    "window": [10, 20, 30, 50, 100],
+    "sigma": [2.0, 2.5, 3.0, 3.5],
+    "half_life": [30, 60, 120, 240],
+}
+
+best_score = -999
+best_desc = ""
+best_sig = None
+tested = set()
+round_num = 0
+
+
+def try_combo(factor_list, entry, window, primitives_used):
+    global best_score, best_desc, best_sig, tested, round_num
+
+    key = f"{sorted(factor_list)}_{entry:.3f}_{window}_{sorted(primitives_used)}"
+    if key in tested:
+        return
+    tested.add(key)
+
+    comp = composite(factor_list, window)
+    if comp is None or comp.dropna().empty:
+        return
+    sig = pd.Series(0, index=comp.index)
+    sig[comp > entry] = 1
+    sig[comp < -entry] = -1
+
+    for p in primitives_used:
+        if p in PRIMITIVES:
+            sig = PRIMITIVES[p](sig.fillna(0))
+
+    sharpe = backtest(sig)
+    if sharpe > best_score:
+        best_score = sharpe
+        best_desc = f"entry={entry:.2f} window={window} factors={len(factor_list)} primitives={primitives_used}"
+        best_sig = sig
+        t = "✅" if sharpe > 0 else "📈" if sharpe > -1 else "➖"
+        print(f"  {t} #{round_num}: Sharpe={sharpe:.4f} | {best_desc}")
+
+        if sharpe > 0:
+            print(f"\n{'='*60}")
+            print(f"  🎯 POSITIVE SHARPE FOUND!")
+            print(f"  Sharpe={sharpe:.4f}")
+            print(f"  {best_desc}")
+            print(f"{'='*60}")
+            return True
+    return False
+
+
+print("Starting infinite search — will run until positive OOS Sharpe found...\n")
+all_factors = sorted(factors_df.columns, key=lambda c: -abs(ics.get(c, 0)))
+
+while True:
+    round_num += 1
+
+    # Pick random subset of top factors
+    n_factors = random.randint(2, min(10, len(all_factors)))
+    factor_subset = random.sample(all_factors[:12], n_factors)
+
+    # Pick random parameters
+    entry = random.choice(BASE_PARAMS["entry"])
+    window = random.choice(BASE_PARAMS["window"])
+
+    # Pick random combination of primitives (0-4)
+    n_prim = random.randint(0, 4)
+    prims = random.sample(list(PRIMITIVES.keys()), n_prim) if n_prim > 0 else []
+
+    found = try_combo(factor_subset, entry, window, prims)
+    if found:
+        break
+
+    # Every 200 rounds, also try parameter sweeps around best
+    if round_num % 200 == 0:
+        print(f"  ... {round_num} combinations tested, best={best_score:.4f}")
+        # Fine-tune around current best
+        for fine_entry in np.arange(max(0.05, entry - 0.15), entry + 0.16, 0.05):
+            for fine_window in [max(5, window - 15), window, min(200, window + 15)]:
+                if try_combo(factor_subset, fine_entry, fine_window, prims):
+                    break
+
+    # Every 500 rounds, try factor-specific combos (Kronos-only, momentum-only, etc.)
+    if round_num % 500 == 0:
+        kronos = [f for f in all_factors if "Kronos" in f]
+        mom = [f for f in all_factors if any(k in f.lower() for k in ["mom", "ret"])]
+        for subset in [kronos, mom, all_factors[:3], all_factors[:6]]:
+            if len(subset) >= 2:
+                for e in [0.1, 0.2, 0.3]:
+                    for w in [20, 50]:
+                        for prims in [[], ["session"], ["session", "decay"]]:
+                            try_combo(subset, e, w, prims)
+
+    if round_num % 1000 == 0:
+        print(f"  [{round_num} tested] best={best_score:.4f} — still searching...")
+
+if best_score <= 0:
+    print(f"\nAfter {round_num} combinations, best is still negative ({best_score:.4f})")
+    print("The factors lack sufficient predictive power for positive returns.")

scripts/nexquant_live_priceaction.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Live Price-Action Strategy Pipeline — No LLM, No Factors.
+
+Generates daily signals from Donchian + MACD portfolio, executes via risk
+backtest, and optionally sends signals to live trading.
+
+Usage:
+    python scripts/nexquant_live_priceaction.py           # Generate today's signal
+    python scripts/nexquant_live_priceaction.py --daemon  # Run continuously
+    python scripts/nexquant_live_priceaction.py --backfill  # Full historical backtest
+"""
+
+import json
+import os
+import sys
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PROJECT = Path(__file__).resolve().parent.parent
+OHLCV_PATH = Path(os.getenv("PREDIX_OHLCV_PATH",
+    str(PROJECT / "git_ignore_folder" / "intraday_pv_all.h5")))
+SIGNAL_PATH = PROJECT / "git_ignore_folder" / "priceaction_signal.json"
+RESULTS_DIR = PROJECT / "results" / "reports"
+
+# Portfolio config
+STRATEGIES = [
+    {"name": "Donchian(30,1)", "type": "donchian", "period": 30, "hold": 1},
+    {"name": "MACD(3,15,3)", "type": "macd", "fast": 3, "slow": 15, "signal_period": 3},
+]
+
+VOTE_THRESHOLD = 0.25
+
+
+def load_close() -> tuple[pd.Series, pd.Series]:
+    """Load 1-min and daily close prices."""
+    df = pd.read_hdf(OHLCV_PATH, key="data")
+    close = df.xs("EURUSD", level="instrument")["$close"].sort_index()
+    daily = close.resample("D").last().dropna()
+    return close, daily
+
+
+def donchian_signal(daily: pd.Series, period: int, hold: int) -> pd.Series:
+    """Donchian channel breakout signal (daily)."""
+    high = daily.rolling(period).max()
+    low = daily.rolling(period).min()
+    s = pd.Series(0, index=daily.index)
+    s[daily > high.shift(1)] = 1
+    s[daily < low.shift(1)] = -1
+    return s.replace(0, np.nan).ffill(limit=hold).fillna(0).astype(int).clip(-1, 1)
+
+
+def macd_signal(daily: pd.Series, fast: int, slow: int, signal_period: int) -> pd.Series:
+    """MACD crossover signal (daily)."""
+    ema_fast = daily.ewm(span=fast, adjust=False).mean()
+    ema_slow = daily.ewm(span=slow, adjust=False).mean()
+    macd_line = ema_fast - ema_slow
+    sig_line = macd_line.ewm(span=signal_period, adjust=False).mean()
+    s = pd.Series(0, index=daily.index)
+    s[macd_line > sig_line] = 1
+    s[macd_line < sig_line] = -1
+    return s.fillna(0).astype(int).clip(-1, 1)
+
+
+def compute_portfolio_signal(daily: pd.Series) -> pd.Series:
+    """Compute majority-vote portfolio signal."""
+    signals = []
+    for cfg in STRATEGIES:
+        if cfg["type"] == "donchian":
+            sig = donchian_signal(daily, cfg["period"], cfg["hold"])
+        elif cfg["type"] == "macd":
+            sig = macd_signal(daily, cfg["fast"], cfg["slow"], cfg["signal_period"])
+        else:
+            continue
+        signals.append(sig)
+
+    if not signals:
+        return pd.Series(0, index=daily.index)
+
+    port = pd.DataFrame({f"s{i}": s for i, s in enumerate(signals)}).dropna()
+    vote = port.mean(axis=1)
+    result = pd.Series(0, index=vote.index)
+    result[vote > VOTE_THRESHOLD] = 1
+    result[vote < -VOTE_THRESHOLD] = -1
+    result.name = "signal"
+    return result
+
+
+def get_todays_signal() -> dict:
+    """Generate today's trading signal."""
+    close, daily = load_close()
+    portfolio_signal = compute_portfolio_signal(daily)
+
+    # Latest signal
+    latest = portfolio_signal.iloc[-1]
+    direction = {1: "LONG", -1: "SHORT", 0: "NEUTRAL"}[int(latest)]
+
+    # Last signal change
+    changes = portfolio_signal.diff().abs()
+    last_change_idx = changes[changes > 0].index[-1] if (changes > 0).any() else None
+    days_in_position = (daily.index[-1] - last_change_idx).days if last_change_idx is not None else 0
+
+    result = {
+        "timestamp": datetime.now().isoformat(),
+        "date": str(daily.index[-1].date()),
+        "signal": int(latest),
+        "direction": direction,
+        "days_in_position": days_in_position,
+        "strategies": {cfg["name"]: int(
+            donchian_signal(daily, cfg["period"], cfg["hold"]).iloc[-1] if cfg["type"] == "donchian"
+            else macd_signal(daily, cfg["fast"], cfg["slow"], cfg["signal_period"]).iloc[-1]
+        ) for cfg in STRATEGIES},
+    }
+
+    SIGNAL_PATH.parent.mkdir(parents=True, exist_ok=True)
+    SIGNAL_PATH.write_text(json.dumps(result, indent=2))
+
+    return result
+
+
+def run_backfill():
+    """Run full historical backtest and save report."""
+    print("Running full historical backtest...")
+    close, daily = load_close()
+    signal = compute_portfolio_signal(daily)
+
+    # ffill to 1-min
+    sig_1min = signal.reindex(close.index).ffill().fillna(0).astype(int).clip(-1, 1)
+
+    from rdagent.components.backtesting.vbt_backtest import backtest_signal, backtest_signal_risk
+
+    bt = backtest_signal(close=close, signal=sig_1min)
+    bt_risk = backtest_signal_risk(close=close, signal=sig_1min, risk_pct=0.0035, oos_start=None, wf_rolling=True)
+
+    report = {
+        "strategy": "Donchian(30,1) + MACD(3,15,3) Majority-Vote",
+        "timestamp": datetime.now().isoformat(),
+        "backtest": {
+            "sharpe": round(bt["sharpe"], 2),
+            "monthly_return_pct": round(bt["monthly_return_pct"], 2),
+            "max_drawdown": round(bt["max_drawdown"], 4),
+            "n_trades": bt["n_trades"],
+            "win_rate": round(bt["win_rate"], 4),
+        },
+        "risk_backtest": {
+            "sharpe": round(bt_risk.get("sharpe", 0), 2),
+            "monthly_pct": round(bt_risk.get("monthly_return_pct", 0), 2),
+            "max_dd": round(bt_risk.get("max_drawdown", 0), 4),
+            "wf_consistency": round(bt_risk.get("wf_oos_consistency", 0), 4),
+        },
+    }
+
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    path = RESULTS_DIR / f"backfill_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    path.write_text(json.dumps(report, indent=2))
+
+    print(f"\n{'='*50}")
+    print(f"  Sharpe: {bt['sharpe']:.2f}")
+    print(f"  Monthly: {bt['monthly_return_pct']:.2f}%")
+    print(f"  Max DD: {bt['max_drawdown']:.4f}")
+    print(f"  Trades: {bt['n_trades']}")
+    print(f"  Win Rate: {bt['win_rate']:.1%}")
+    print(f"  Report saved: {path}")
+    print(f"{'='*50}")
+
+
+def main():
+    if "--backfill" in sys.argv:
+        run_backfill()
+    elif "--daemon" in sys.argv:
+        print("Daemon mode — generating signals every 5 minutes...")
+        while True:
+            result = get_todays_signal()
+            print(f"  [{result['timestamp']}] {result['direction']:>8s} ({result['days_in_position']}d in position)")
+            time.sleep(300)
+    else:
+        result = get_todays_signal()
+        print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()