diff --git a/config/initial_config.json b/config/initial_config.json
index ca3b3c4..a6c8f19 100644
--- a/config/initial_config.json
+++ b/config/initial_config.json
@@ -1,62 +1,53 @@
 {
   "model_type": "hybrid",
   "features": {
-    "technical_indicators": ["RSI_14", "RSI_7", "MACD_line", "MACD_signal", "MACD_hist", "BB_upper", "BB_lower", "BB_width", "ATR_14", "SMA_20", "SMA_50", "EMA_10", "EMA_20", "OBV", "stoch_k", "stoch_d", "williams_r", "CCI_20", "ROC_10"],
-    "lookback_periods": [3, 5, 10, 20],
-    "use_volume_features": true,
-    "use_volatility_features": true,
-    "use_candle_patterns": false,
-    "use_lag_features": true,
-    "lag_periods": [1, 2, 3, 5],
+    "use_price_position": true,
+    "use_momentum": true,
+    "use_volatility": true,
+    "use_volume": true,
+    "use_cycle": true,
     "use_pca": true,
     "pca_variance": 0.95,
     "use_scaler": true
   },
   "target": {
-    "type": "classification",
-    "direction": "both",
-    "horizon_candles": 8,
-    "threshold_pct": 1.5
+    "type": "regression",
+    "forward_periods_1h": [168, 720, 2160],
+    "forward_periods_4h": [42, 180, 540],
+    "weights": [0.2, 0.3, 0.5],
+    "score_range": [0, 100]
   },
   "hyperparameters": {
-    "learning_rate": 0.001,
+    "learning_rate": 0.01,
     "max_depth": 5,
-    "n_estimators": 300,
+    "n_estimators": 500,
     "subsample": 0.8,
     "colsample_bytree": 0.8,
-    "min_child_weight": 5,
+    "min_child_weight": 10,
     "gamma": 0.3,
-    "reg_alpha": 0.1,
-    "reg_lambda": 2.0,
+    "reg_alpha": 0.5,
+    "reg_lambda": 3.0,
     "lstm_hidden_size": 128,
     "lstm_num_layers": 2,
     "lstm_dropout": 0.3,
     "lstm_epochs": 100,
     "lstm_batch_size": 64,
-    "lstm_sequence_length": 20,
+    "lstm_sequence_length": 30,
     "lstm_patience": 10
   },
   "strategy": {
-    "entry_threshold": 0.60,
-    "exit_type": "trailing_stop",
-    "stop_loss_pct": 2.0,
-    "take_profit_pct": 4.0,
-    "trailing_stop_pct": 1.5,
-    "position_sizing": "confidence_scaled",
-    "max_position_pct": 100,
-    "min_confidence_to_trade": 0.55,
-    "dynamic_sl_tp": true,
-    "atr_sl_multiplier": 1.5,
-    "atr_tp_multiplier": 3.0
+    "strong_buy_threshold": 80,
+    "good_buy_threshold": 70,
+    "poor_threshold": 30
   },
   "training": {
+    "rolling_window": true,
+    "rolling_train_size": 2500,
+    "rolling_test_size": 300,
     "walk_forward_windows": 5,
     "train_pct": 0.7,
     "validation_pct": 0.15,
-    "test_pct": 0.15,
-    "rolling_window": true,
-    "rolling_train_size": 2000,
-    "rolling_test_size": 200
+    "test_pct": 0.15
   },
   "timeframe": "4h"
-}
+}
\ No newline at end of file
diff --git a/dashboard/server.py b/dashboard/server.py
index 8b77f87..72aa0e8 100644
--- a/dashboard/server.py
+++ b/dashboard/server.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-BTC ML Trading Strategy Optimizer — Web Dashboard
+BTC Accumulation Signal Optimizer -- Web Dashboard
 FastAPI server with inline HTML/CSS/JS dashboard.
 """
 
@@ -13,42 +13,35 @@ from fastapi import FastAPI
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from pydantic import BaseModel
 
-# Add project root to path
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, BASE_DIR)
 
 import orchestrator
 
-app = FastAPI(title="BTC ML Optimizer Dashboard")
+app = FastAPI(title="BTC Accumulation Signal Optimizer")
 
 CONFIG_DIR = os.path.join(BASE_DIR, "config")
 RESULTS_DIR = os.path.join(BASE_DIR, "results")
 ITERATIONS_LOG = os.path.join(RESULTS_DIR, "iterations.jsonl")
 
-# Background thread reference
-_opt_thread: threading.Thread | None = None
+_opt_thread = None
 
 
 class ConfigUpdate(BaseModel):
     config: dict
 
 
-# ── API Endpoints ──────────────────────────────────────────────
-
-
 @app.get("/api/status")
 def api_status():
-    status = orchestrator.get_status()
-    return status
+    return orchestrator.get_status()
 
 
 @app.get("/api/iterations")
 def api_iterations():
     iterations = orchestrator.load_iteration_history()
-    # Strip heavy config from list view
     slim = []
     for it in iterations:
-        entry = {k: v for k, v in it.items() if k != "config"}
+        entry = {k: v for k, v in it.items() if k not in ("config", "results")}
         slim.append(entry)
     return slim
 
@@ -94,11 +87,11 @@ def api_stop():
 def api_best():
     best_path = os.path.join(CONFIG_DIR, "best_config.json")
     if not os.path.exists(best_path):
-        return {"config": None, "sharpe": 0}
+        return {"config": None, "best_score": 0}
     with open(best_path) as f:
         config = json.load(f)
     iterations = orchestrator.load_iteration_history()
-    best_iter = max(iterations, key=lambda x: x.get("sharpe", 0)) if iterations else {}
+    best_iter = max(iterations, key=lambda x: x.get("cost_improvement", 0)) if iterations else {}
     return {"config": config, "best_iteration": best_iter}
 
 
@@ -117,15 +110,12 @@ def api_download_best_config():
     return JSONResponse({"error": "No best config yet"}, status_code=404)
 
 
-# ── Dashboard HTML ─────────────────────────────────────────────
-
-
 DASHBOARD_HTML = """<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>BTC ML Optimizer</title>
+<title>BTC Accumulation Signal Optimizer</title>
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
 <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.4/dist/chart.umd.min.js"></script>
@@ -138,7 +128,6 @@ h1{font-size:1.5rem;font-weight:700;display:flex;align-items:center;gap:10px}
 h1 .btc{color:var(--accent);font-size:1.8rem}
 h2{font-size:1rem;font-weight:600;color:var(--text-dim);margin-bottom:12px;text-transform:uppercase;letter-spacing:.05em;font-size:.8rem}
 
-/* Header */
 .header{display:flex;justify-content:space-between;align-items:center;padding:16px 0;border-bottom:1px solid var(--border);margin-bottom:16px;flex-wrap:wrap;gap:12px}
 .controls{display:flex;gap:8px;align-items:center}
 .btn{padding:8px 18px;border:none;border-radius:6px;font-family:inherit;font-weight:600;font-size:.85rem;cursor:pointer;transition:all .15s}
@@ -147,7 +136,6 @@ h2{font-size:1rem;font-weight:600;color:var(--text-dim);margin-bottom:12px;text-
 .btn-secondary{background:var(--border);color:var(--text)}.btn-secondary:hover{background:var(--card-hover)}
 .btn:disabled{opacity:.4;cursor:not-allowed}
 
-/* Status badge */
 .status-badge{display:inline-flex;align-items:center;gap:6px;padding:4px 12px;border-radius:20px;font-size:.8rem;font-weight:600}
 .status-idle{background:#1e3a5f;color:#60a5fa}
 .status-running{background:#1a3a2a;color:var(--green)}
@@ -156,19 +144,16 @@ h2{font-size:1rem;font-weight:600;color:var(--text-dim);margin-bottom:12px;text-
 .pulse{width:8px;height:8px;border-radius:50%;background:currentColor;animation:pulse 1.5s infinite}
 @keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
 
-/* Best Sharpe display */
-.best-sharpe{text-align:right}
-.best-sharpe .label{font-size:.7rem;text-transform:uppercase;letter-spacing:.1em;color:var(--text-dim)}
-.best-sharpe .value{font-size:2.2rem;font-weight:700;color:var(--accent);font-family:var(--mono)}
+.best-score{text-align:right}
+.best-score .label{font-size:.7rem;text-transform:uppercase;letter-spacing:.1em;color:var(--text-dim)}
+.best-score .value{font-size:2.2rem;font-weight:700;color:var(--accent);font-family:var(--mono)}
+.best-score .unit{font-size:1rem;color:var(--text-dim)}
 
-/* Grid layout */
 .grid{display:grid;grid-template-columns:1fr 360px;gap:16px}
 @media(max-width:900px){.grid{grid-template-columns:1fr}}
 
-/* Cards */
 .card{background:var(--card);border-radius:10px;padding:16px;border:1px solid var(--border)}
 
-/* Iteration table */
 .table-wrap{overflow-x:auto;max-height:400px;overflow-y:auto}
 table{width:100%;border-collapse:collapse;font-size:.82rem}
 th{position:sticky;top:0;background:var(--card);text-align:left;padding:8px 10px;color:var(--text-dim);font-weight:600;border-bottom:2px solid var(--border);font-size:.75rem;text-transform:uppercase;letter-spacing:.04em}
@@ -177,15 +162,12 @@ tr.best-row{background:rgba(34,197,94,.1)}
 tr.best-row td:first-child{border-left:3px solid var(--green)}
 tr:hover{background:var(--card-hover)}
 
-/* Chart */
 .chart-container{position:relative;height:260px}
 
-/* LLM panel */
 .llm-panel{max-height:500px;overflow-y:auto}
 .llm-entry{padding:10px;border-bottom:1px solid var(--border);font-size:.82rem;line-height:1.5}
 .llm-entry .iter-label{font-weight:600;color:var(--accent);font-size:.75rem;margin-bottom:4px}
 
-/* Config editor */
 .config-section{margin-top:16px}
 .config-toggle{cursor:pointer;user-select:none;display:flex;align-items:center;gap:6px}
 .config-toggle .arrow{transition:transform .2s;font-size:.7rem}
@@ -195,22 +177,19 @@ tr:hover{background:var(--card-hover)}
 textarea.config-editor{width:100%;height:300px;background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:6px;padding:12px;font-family:var(--mono);font-size:.8rem;resize:vertical}
 .config-actions{display:flex;gap:8px;margin-top:8px}
 
-/* Downloads */
 .downloads{display:flex;gap:8px;margin-top:16px;flex-wrap:wrap}
 .downloads a{color:var(--accent);text-decoration:none;font-size:.82rem;padding:6px 12px;border:1px solid var(--accent);border-radius:6px;transition:all .15s}
 .downloads a:hover{background:var(--accent);color:#000}
 
-/* Footer */
 .footer{text-align:center;color:var(--text-dim);font-size:.75rem;padding:20px 0;margin-top:16px;border-top:1px solid var(--border)}
 </style>
 </head>
 <body>
 <div class="container">
 
-<!-- Header -->
 <div class="header">
   <div>
-    <h1><span class="btc">&#x20BF;</span> ML Strategy Optimizer</h1>
+    <h1><span class="btc">&#x20BF;</span> Accumulation Signal Optimizer</h1>
     <div style="margin-top:8px">
       <span id="statusBadge" class="status-badge status-idle"><span class="pulse"></span> Idle</span>
     </div>
@@ -220,47 +199,41 @@ textarea.config-editor{width:100%;height:300px;background:var(--bg);color:var(--
       <button id="btnStart" class="btn btn-start" onclick="startOpt()">Start Optimization</button>
       <button id="btnStop" class="btn btn-stop" onclick="stopOpt()" disabled>Stop</button>
     </div>
-    <div class="best-sharpe">
-      <div class="label">Best Sharpe Ratio</div>
-      <div class="value" id="bestSharpe">0.000</div>
+    <div class="best-score">
+      <div class="label">Best Cost Improvement</div>
+      <div class="value" id="bestScore">0.0<span class="unit">%</span></div>
     </div>
   </div>
 </div>
 
-<!-- Main grid -->
 <div class="grid">
   <div class="left">
-    <!-- Iteration Table -->
     <div class="card" style="margin-bottom:16px">
       <h2>Iterations</h2>
       <div class="table-wrap">
         <table>
           <thead>
-            <tr><th>#</th><th>Sharpe</th><th>Return%</th><th>MaxDD%</th><th>WinRate</th><th>Trades</th><th>PF</th><th>Model</th></tr>
+            <tr><th>#</th><th>Cost Imp%</th><th>Signals</th><th>Frequency</th><th>R2</th><th>Bottoms</th><th>Tops</th><th>Model</th></tr>
           </thead>
           <tbody id="iterBody"></tbody>
         </table>
       </div>
     </div>
-    <!-- Equity Curve Chart -->
     <div class="card">
-      <h2>Performance Over Iterations</h2>
+      <h2>Cost Improvement Over Iterations</h2>
       <div class="chart-container">
-        <canvas id="sharpeChart"></canvas>
+        <canvas id="mainChart"></canvas>
       </div>
     </div>
   </div>
 
   <div class="right">
-    <!-- LLM Analysis -->
     <div class="card" style="margin-bottom:16px">
       <h2>LLM Analysis</h2>
       <div class="llm-panel" id="llmPanel">
         <div style="color:var(--text-dim);font-size:.82rem;padding:10px">No suggestions yet.</div>
       </div>
     </div>
-
-    <!-- Downloads -->
     <div class="card">
       <h2>Downloads</h2>
       <div class="downloads">
@@ -271,7 +244,6 @@ textarea.config-editor{width:100%;height:300px;background:var(--bg);color:var(--
   </div>
 </div>
 
-<!-- Config Editor (collapsible) -->
 <div class="card config-section">
   <div class="config-toggle" id="configToggle" onclick="toggleConfig()">
     <span class="arrow">&#9654;</span>
@@ -286,22 +258,21 @@ textarea.config-editor{width:100%;height:300px;background:var(--bg);color:var(--
   </div>
 </div>
 
-<div class="footer">BTC ML Trading Strategy Optimizer &mdash; VPS &rarr; Windows GPU &rarr; Mac Mini LLM</div>
+<div class="footer">BTC Accumulation Signal Optimizer &mdash; VPS &rarr; Windows GPU &rarr; Mac Mini LLM</div>
 </div>
 
 <script>
 let chart = null;
 let pollInterval = null;
 
-// Init chart
 function initChart() {
-  const ctx = document.getElementById('sharpeChart').getContext('2d');
+  const ctx = document.getElementById('mainChart').getContext('2d');
   chart = new Chart(ctx, {
     type: 'line',
     data: {
       labels: [],
       datasets: [{
-        label: 'Sharpe Ratio',
+        label: 'Cost Improvement %',
         data: [],
         borderColor: '#f7931a',
         backgroundColor: 'rgba(247,147,26,0.1)',
@@ -311,7 +282,7 @@ function initChart() {
         pointRadius: 4,
         pointBackgroundColor: '#f7931a'
       }, {
-        label: 'Return %',
+        label: 'Signal Count',
         data: [],
         borderColor: '#22c55e',
         borderWidth: 1.5,
@@ -331,8 +302,8 @@ function initChart() {
       },
       scales: {
         x: { ticks: { color: '#94a3b8' }, grid: { color: '#1e293b' } },
-        y: { position: 'left', ticks: { color: '#f7931a' }, grid: { color: '#1e293b' }, title: { display: true, text: 'Sharpe', color: '#f7931a' } },
-        y1: { position: 'right', ticks: { color: '#22c55e' }, grid: { drawOnChartArea: false }, title: { display: true, text: 'Return %', color: '#22c55e' } }
+        y: { position: 'left', ticks: { color: '#f7931a' }, grid: { color: '#1e293b' }, title: { display: true, text: 'Cost Improvement %', color: '#f7931a' } },
+        y1: { position: 'right', ticks: { color: '#22c55e' }, grid: { drawOnChartArea: false }, title: { display: true, text: 'Signal Count', color: '#22c55e' } }
       }
     }
   });
@@ -353,7 +324,7 @@ function updateStatusBadge(status) {
 
   document.getElementById('btnStart').disabled = (state === 'running');
   document.getElementById('btnStop').disabled = (state !== 'running');
-  document.getElementById('bestSharpe').textContent = (status.best_sharpe || 0).toFixed(3);
+  document.getElementById('bestScore').innerHTML = (status.best_score || 0).toFixed(1) + '<span class="unit">%</span>';
 }
 
 function updateIterations(iterations) {
@@ -362,24 +333,23 @@ function updateIterations(iterations) {
     tbody.innerHTML = '<tr><td colspan="8" style="color:var(--text-dim);text-align:center">No iterations yet</td></tr>';
     return;
   }
-  const bestSharpe = Math.max(...iterations.map(i => i.sharpe || 0));
+  const bestCI = Math.max(...iterations.map(i => i.cost_improvement || 0));
   let html = '';
   for (const it of iterations) {
-    const isBest = it.sharpe === bestSharpe && bestSharpe > 0;
-    const sc = it.sharpe > 1.5 ? 'var(--green)' : it.sharpe > 1.0 ? 'var(--yellow)' : 'var(--red)';
+    const isBest = it.cost_improvement === bestCI && bestCI > 0;
+    const sc = it.cost_improvement > 15 ? 'var(--green)' : it.cost_improvement > 10 ? 'var(--yellow)' : 'var(--red)';
     html += '<tr class="' + (isBest ? 'best-row' : '') + '">';
     html += '<td>' + it.iteration + '</td>';
-    html += '<td style="color:' + sc + ';font-weight:600">' + (it.sharpe||0).toFixed(3) + '</td>';
-    html += '<td>' + (it["return"]||0).toFixed(1) + '</td>';
-    html += '<td>' + (it.max_drawdown||0).toFixed(1) + '</td>';
-    html += '<td>' + ((it.win_rate||0)*100).toFixed(1) + '%</td>';
-    html += '<td>' + (it.trades||0) + '</td>';
-    html += '<td>' + (it.profit_factor||0).toFixed(2) + '</td>';
-    html += '<td>' + (it.model_type||'—') + '</td>';
+    html += '<td style="color:' + sc + ';font-weight:600">' + (it.cost_improvement||0).toFixed(1) + '</td>';
+    html += '<td>' + (it.signal_count||0) + '</td>';
+    html += '<td>' + (it.signal_frequency||0).toFixed(1) + '%</td>';
+    html += '<td>' + (it.r2_score||0).toFixed(4) + '</td>';
+    html += '<td>' + (it.score_at_bottoms||0).toFixed(1) + '</td>';
+    html += '<td>' + (it.score_at_tops||0).toFixed(1) + '</td>';
+    html += '<td>' + (it.model_type||'-') + '</td>';
     html += '</tr>';
   }
   tbody.innerHTML = html;
-  // auto-scroll to bottom
   const wrap = tbody.closest('.table-wrap');
   wrap.scrollTop = wrap.scrollHeight;
 }
@@ -387,8 +357,8 @@ function updateIterations(iterations) {
 function updateChart(iterations) {
   if (!chart || !iterations.length) return;
   chart.data.labels = iterations.map(i => '#' + i.iteration);
-  chart.data.datasets[0].data = iterations.map(i => i.sharpe || 0);
-  chart.data.datasets[1].data = iterations.map(i => i["return"] || 0);
+  chart.data.datasets[0].data = iterations.map(i => i.cost_improvement || 0);
+  chart.data.datasets[1].data = iterations.map(i => i.signal_count || 0);
   chart.update('none');
 }
 
@@ -468,14 +438,9 @@ async function updateConfig() {
 
 async function resetConfig() {
   if (!confirm('Reset to initial config?')) return;
-  try {
-    const r = await fetch('/api/config');
-    // Fetch the initial config by reading it — for now just reload
-    location.reload();
-  } catch(e) { alert(e); }
+  try { location.reload(); } catch(e) { alert(e); }
 }
 
-// Init
 initChart();
 poll();
 pollInterval = setInterval(poll, 10000);
diff --git a/llm_client/analyzer.py b/llm_client/analyzer.py
index 4c9a45b..6d0c985 100755
--- a/llm_client/analyzer.py
+++ b/llm_client/analyzer.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-LLM Strategy Analyzer -- Calls Ollama on Mac Mini to analyze results
+LLM Accumulation Signal Analyzer -- Calls Ollama on Mac Mini to analyze results
 and suggest config modifications for the next iteration.
 """
 
@@ -11,121 +11,130 @@ import requests
 OLLAMA_URL = "http://100.100.242.21:11434"
 MODEL = "qwen3.5:27b"
 
-SYSTEM_PROMPT = """You are a quantitative trading strategy optimizer. You analyze ML model backtesting results for a BTC/USDT trading strategy and suggest precise modifications to improve performance.
+SYSTEM_PROMPT = """You are a quantitative analyst optimizing a BTC ACCUMULATION SIGNAL model. The goal is NOT day-trading -- it is finding statistically optimal times to BUY BTC for long-term holding.
 
-## Your Task
-Given the current configuration and results, suggest 1-3 specific, justified changes to the configuration for the next iteration. Be methodical and scientific -- change one thing at a time when possible.
+## Core Question
+"Given current market conditions, is NOW a good time to BUY BTC for long-term holding?"
+
+## What the Model Does
+For each candle, the model predicts an Accumulation Score (0-100):
+- 90-100: STRONG BUY -- historically rare, excellent entry point
+- 70-89: GOOD BUY -- better than average entry
+- 50-69: NEUTRAL -- average time to buy
+- 30-49: WAIT -- price likely to come down
+- 0-29: POOR -- historically bad time to buy (near local tops)
+
+The model is trained on ACTUAL forward returns at 7d, 30d, and 90d horizons, weighted 20/30/50. Times when buying led to the best long-term returns get the highest scores.
+
+## Primary Metric: cost_basis_improvement_pct
+This measures how much better the model's average buy price is vs uniform DCA.
+- 10%+ = good
+- 15%+ = excellent
+- 20%+ = exceptional
+Also require strong_buy_signal_count >= 30 for statistical validity.
 
 ## Config Parameters You Can Modify
 
-**model_type**: "xgboost", "lightgbm", "catboost", "ensemble", "lstm", or "hybrid"
-  - xgboost: Generally best for structured data, fast GPU training
-  - lightgbm: Faster training, good with large feature sets
-  - catboost: Handles feature interactions well, less tuning needed
-  - ensemble: Combines xgboost+lightgbm+catboost, reduces variance but slower
-  - lstm: PyTorch LSTM neural network, captures temporal/sequential patterns in price data
-  - hybrid: Combines LSTM (60% weight) + XGBoost (40% weight). Only enters trades when BOTH models agree on direction. The hybrid model typically outperforms single models -- LSTM captures temporal patterns while XGBoost handles feature interactions. Recommended as default.
+**model_type**: "xgboost", "lightgbm", "catboost", "lstm", or "hybrid"
+  - hybrid: Average of LSTM + XGBoost regression predictions. Recommended default.
+  - xgboost: Fast GPU training, good for structured features.
+  - lstm: Captures temporal patterns in price sequences.
 
 **hyperparameters** (gradient boosting):
-  - learning_rate (0.001-0.3): Lower = more robust but slower. If overfitting, decrease.
-  - max_depth (3-10): Controls model complexity. Deeper = more overfitting risk.
-  - n_estimators (100-2000): More trees = better fit but diminishing returns.
-  - subsample (0.5-1.0): Row sampling. Lower = more regularization.
-  - colsample_bytree (0.5-1.0): Feature sampling per tree. Lower = more diversity.
-  - min_child_weight (1-20): Higher = more conservative splits.
-  - gamma (0-5): Minimum loss reduction for split. Higher = more pruning.
-  - reg_alpha (0-10): L1 regularization. Encourages sparsity.
-  - reg_lambda (0-10): L2 regularization. Prevents large weights.
+  - learning_rate (0.001-0.1): Lower = more robust. Start conservative.
+  - max_depth (3-8): Controls complexity. Deeper risks overfitting.
+  - n_estimators (200-1500): More trees = better fit but diminishing returns.
+  - subsample (0.5-1.0): Row sampling for regularization.
+  - colsample_bytree (0.5-1.0): Feature sampling per tree.
+  - min_child_weight (5-30): Higher = more conservative (important for noisy targets).
+  - gamma (0-5): Minimum loss reduction for split.
+  - reg_alpha (0-10): L1 regularization.
+  - reg_lambda (1-10): L2 regularization. Higher values prevent overfitting.
 
-**hyperparameters** (LSTM-specific, used by lstm and hybrid model_types):
-  - lstm_hidden_size (32-256): LSTM hidden units. Larger = more capacity but overfitting risk. Default 128.
-  - lstm_num_layers (1-4): Stacked LSTM layers. 2 is usually optimal. More layers need more data.
-  - lstm_dropout (0.1-0.5): Dropout between LSTM layers and before output. Higher = more regularization.
-  - lstm_epochs (50-200): Max training epochs. Early stopping usually triggers before this.
-  - lstm_batch_size (32-128): Training batch size. Smaller = noisier gradients but better generalization.
-  - lstm_sequence_length (10-50): How many past candles the LSTM sees per prediction. Longer = more context but more memory. Default 20.
-  - lstm_patience (5-20): Early stopping patience on validation loss. Lower = stop sooner.
+**hyperparameters** (LSTM):
+  - lstm_hidden_size (32-256): Hidden units.
+  - lstm_num_layers (1-4): Stacked layers. 2 is usually optimal.
+  - lstm_dropout (0.1-0.5): Regularization.
+  - lstm_epochs (50-200): Max training epochs (early stopping usually triggers).
+  - lstm_batch_size (32-128): Smaller = noisier but better generalization.
+  - lstm_sequence_length (15-60): Past candles the LSTM sees. Longer = more context.
+  - lstm_patience (5-20): Early stopping patience.
 
 **target**:
-  - direction: "long", "short", or "both"
-  - horizon_candles (1-20): How far ahead to predict. Longer = smoother but lagging.
-  - threshold_pct (0.3-3.0): Minimum move % to label as positive. Higher = fewer but clearer signals.
+  - forward_periods_4h: List of 3 forward periods in 4h candles [short, medium, long].
+    Defaults: [42, 180, 540] = roughly [7d, 30d, 90d]
+  - weights: Weights for each period. Default [0.2, 0.3, 0.5] (emphasize long-term).
+  - score_range: [0, 100] -- do not change.
 
 **strategy**:
-  - entry_threshold (0.5-0.8): Min prediction probability to enter trade. Higher = fewer trades, higher quality.
-  - stop_loss_pct (0.5-5.0): Max loss before exit (used when dynamic_sl_tp is false).
-  - take_profit_pct (1.0-10.0): Target profit (used when dynamic_sl_tp is false). Should be > stop_loss for positive expectancy.
-  - trailing_stop_pct (0.5-3.0): Trailing stop distance. Tighter = locks profit faster but exits early.
-  - min_confidence_to_trade (0.5-0.9): Absolute minimum confidence to consider.
-  - exit_type: "trailing_stop" or "fixed" (just SL/TP)
-  - dynamic_sl_tp (true/false): Use ATR-based dynamic stop-loss and take-profit instead of fixed percentages. Adapts to current volatility. Recommended: true.
-  - atr_sl_multiplier (1.0-3.0): ATR multiplier for stop-loss. E.g., 1.5 means SL = 1.5 * ATR(14). Lower = tighter stops.
-  - atr_tp_multiplier (2.0-5.0): ATR multiplier for take-profit. E.g., 3.0 means TP = 3.0 * ATR(14). Should be > atr_sl_multiplier.
+  - strong_buy_threshold (70-95): Score above which = STRONG BUY signal. Higher = fewer but better signals.
+  - good_buy_threshold (50-80): Score above which = GOOD BUY. Used for cost basis comparison.
+  - poor_threshold (10-40): Score below which = POOR time to buy.
 
 **features**:
-  - use_volume_features (true/false): Volume features can be noisy in crypto.
-  - use_candle_patterns (true/false): Candle patterns may or may not help.
-  - use_lag_features (true/false): Lagged features capture momentum.
-  - lag_periods: List of lag periods [1,2,3,5,10]
-  - lookback_periods: List of lookback windows [3,5,10,20]
-  - use_scaler (true/false): Apply StandardScaler normalization to all features. Critical for LSTM, also helps gradient boosting. Recommended: true.
-  - use_pca (true/false): Apply PCA dimensionality reduction after scaling. Reduces noise and multicollinearity. Recommended with many features.
-  - pca_variance (0.80-0.99): Fraction of variance to retain with PCA. 0.95 keeps 95% of information. Lower = fewer dimensions, more noise removed.
+  - use_price_position (true/false): Distance from ATH, 52w high/low, percentile.
+  - use_momentum (true/false): RSI, MACD, Stochastic, Williams %R, ROC.
+  - use_volatility (true/false): Bollinger Bands, ATR, consecutive red candles, drawdown.
+  - use_volume (true/false): Volume ratio, OBV, red/green volume ratio.
+  - use_cycle (true/false): MA cross regime, candles since major drawdown.
+  - use_pca (true/false): PCA dimensionality reduction.
+  - pca_variance (0.80-0.99): Variance to retain.
+  - use_scaler (true/false): StandardScaler. Critical for LSTM.
 
 **training**:
-  - walk_forward_windows (3-10): More windows = more robust but less data per window. Used when rolling_window is false.
-  - rolling_window (true/false): Use rolling window instead of static walk-forward splits. Trains on last N candles, tests on next M, slides forward. More realistic for time series. Recommended: true.
-  - rolling_train_size (1000-5000): Number of candles in the rolling training window. Larger = more data but older patterns.
-  - rolling_test_size (100-500): Number of candles in the rolling test window. Smaller = more retraining, better adaptation.
+  - rolling_window (true/false): Rolling vs static walk-forward.
+  - rolling_train_size (1500-5000): Training window candles.
+  - rolling_test_size (100-500): Test window candles.
 
-## Key Metrics to Optimize (in priority order)
-1. **Sharpe Ratio** (target: > 2.0): Risk-adjusted return. Most important metric.
-2. **Profit Factor** (target: > 1.5): Gross profit / gross loss.
-3. **Max Drawdown** (target: > -15%): Worst peak-to-trough decline.
-4. **Win Rate** (target: > 55%): Percentage of winning trades.
-5. **Trade Count**: Need enough trades for statistical significance (>50).
+## Key Metrics to Analyze
+1. **cost_basis_improvement_pct**: PRIMARY metric. How much better is model buy price vs DCA.
+2. **strong_buy_signal_count**: Must be >= 30 for validity. Too few = raise threshold. Too many = lower it.
+3. **signal_frequency_pct**: Should be 5-15%. If outside, adjust thresholds.
+4. **avg_score_at_actual_bottoms**: Should be high (>70). Model should recognize bottoms.
+5. **avg_score_at_actual_tops**: Should be low (<30). Model should avoid tops.
+6. **model_r2_score**: Regression fit quality. > 0.2 is decent for financial data.
+7. **per_window_cost_improvement**: Consistency across windows. Low variance = robust.
 
 ## Decision Guidelines
-- If Sharpe < 1.0: The strategy is not working well. Consider larger changes (switch to hybrid, enable PCA/scaler, adjust target).
-- If Sharpe 1.0-1.5: Decent. Fine-tune hyperparameters and thresholds.
-- If Sharpe 1.5-2.0: Good. Make small, targeted improvements.
-- If Sharpe > 2.0: Very good. Be careful not to overfit.
-- If win_rate < 0.50 but profit_factor > 1.5: Strategy relies on big wins -- ok, tighten SL.
-- If win_rate > 0.60 but profit_factor < 1.2: Many small wins but losses are too big -- widen TP or tighten SL.
-- If trade_count < 30: Not enough trades. Lower entry_threshold or min_confidence.
-- If max_drawdown < -20%: Too risky. Increase regularization, tighten stop loss, enable dynamic_sl_tp.
-- If per_window_sharpe has high variance: Model is not stable. More regularization, enable PCA, or try hybrid.
-- Check feature_importances: If top features make financial sense, good. If random features dominate, possible overfitting -- enable PCA or reduce features.
-- For LSTM/hybrid: if underfitting, increase lstm_hidden_size or lstm_num_layers. If overfitting, increase lstm_dropout or decrease lstm_sequence_length.
-- The hybrid model combining LSTM + XGBoost typically outperforms single models. LSTM captures temporal patterns while XGBoost handles feature interactions. Use hybrid as the default unless you have a specific reason not to.
+- If cost_improvement < 5%: Strategy is barely working. Try: switch model type, enable all features, increase training window, lower good_buy_threshold.
+- If cost_improvement 5-10%: Decent. Fine-tune thresholds and hyperparameters.
+- If cost_improvement 10-15%: Good. Make targeted improvements -- focus on signal consistency.
+- If cost_improvement > 15%: Very good. Be careful not to overfit. Check per_window variance.
+- If signal_count < 30: Not statistically valid. Lower strong_buy_threshold, increase training data.
+- If signal_frequency > 20%: Too many signals = not selective enough. Raise threshold.
+- If signal_frequency < 3%: Too few signals. Lower threshold.
+- If score_at_bottoms < 60: Model is missing bottoms. More features, different model type.
+- If score_at_tops > 40: Model is not avoiding tops. More regularization.
+- If per_window has high variance: Model is unstable. Increase regularization, try hybrid.
+- Check feature_importances: price position features should dominate (distance from ATH, percentile).
 
 ## Response Format
 You MUST respond with ONLY a JSON object (no markdown, no explanation outside the JSON):
 ```
 {
-  "reasoning": "Explanation of what you observed and why you're making these changes",
+  "reasoning": "Explanation of observations and why you are making these changes",
   "changes": ["Change 1 description", "Change 2 description"],
   "config": { <complete modified config JSON> }
 }
 ```
-The "config" field must contain the COMPLETE config (not just changes) so it can be used directly."""
+The "config" field must contain the COMPLETE config so it can be used directly."""
 
 
-def analyze_and_suggest(current_config: dict, results: dict,
-                        iteration_history: list = None) -> tuple[dict, str]:
+def analyze_and_suggest(current_config, results, iteration_history=None):
     """
     Send current results to LLM and get suggested config modifications.
     Returns (new_config, reasoning).
     """
-    # Build the user prompt with context
     history_text = ""
     if iteration_history:
         history_text = "\n## Previous Iterations (most recent last)\n"
         for h in iteration_history[-5:]:
             history_text += (
-                f"- Iteration {h['iteration']}: Sharpe={h['sharpe']}, "
-                f"Return={h['return']}%, WinRate={h['win_rate']}, "
-                f"Trades={h['trades']}, Model={h['model_type']}\n"
+                f"- Iteration {h.get('iteration', '?')}: "
+                f"CostImprovement={h.get('cost_improvement', 0):.1f}%, "
+                f"Signals={h.get('signal_count', 0)}, "
+                f"R2={h.get('r2_score', 0):.4f}, "
+                f"Model={h.get('model_type', '?')}\n"
             )
 
     user_prompt = f"""## Current Configuration
@@ -134,21 +143,24 @@ def analyze_and_suggest(current_config: dict, results: dict,
 ```
 
 ## Current Results
-- Sharpe Ratio: {results.get('sharpe_ratio', 0)}
-- Total Return: {results.get('total_return_pct', 0)}%
-- Max Drawdown: {results.get('max_drawdown_pct', 0)}%
-- Win Rate: {results.get('win_rate', 0)}
-- Trade Count: {results.get('trade_count', 0)}
-- Profit Factor: {results.get('profit_factor', 0)}
-- Avg Trade Duration: {results.get('avg_trade_duration_candles', 0)} candles
-- Per-Window Sharpe: {results.get('per_window_sharpe', [])}
+- Cost Basis Improvement: {results.get('cost_basis_improvement_pct', 0):.1f}%
+- Avg Cost (Model): ${results.get('avg_cost_basis_model', 0):,.2f}
+- Avg Cost (DCA): ${results.get('avg_cost_basis_dca', 0):,.2f}
+- Strong Buy Signals: {results.get('strong_buy_signal_count', 0)}
+- Good Buy Signals: {results.get('good_buy_signal_count', 0)}
+- Signal Frequency: {results.get('signal_frequency_pct', 0):.1f}%
+- Quality of Strong Buys: {results.get('pct_quality_strong_buy', 0):.1%}
+- Model R2: {results.get('model_r2_score', 0):.4f}
+- Score at Actual Bottoms: {results.get('avg_score_at_actual_bottoms', 0):.1f}
+- Score at Actual Tops: {results.get('avg_score_at_actual_tops', 0):.1f}
+- Per-Window Improvement: {results.get('per_window_cost_improvement', [])}
+- Score Distribution: {results.get('score_distribution', {})}
 
 ## Top Feature Importances
 {json.dumps(dict(list(results.get('feature_importances', {}).items())[:15]), indent=2)}
 {history_text}
 Analyze these results and suggest 1-3 specific modifications to the config. Return ONLY valid JSON."""
 
-    # Call Ollama
     payload = {
         "model": MODEL,
         "messages": [
@@ -168,7 +180,6 @@ Analyze these results and suggest 1-3 specific modifications to the config. Retu
     resp.raise_for_status()
     content = resp.json()["message"]["content"]
 
-    # Parse JSON from response (handle markdown code blocks)
     # Strip thinking tags if present
     content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
 
@@ -176,8 +187,6 @@ Analyze these results and suggest 1-3 specific modifications to the config. Retu
     if json_match:
         parsed = json.loads(json_match.group(1))
     else:
-        # Try parsing the whole response as JSON
-        # Find the outermost JSON object
         brace_start = content.find("{")
         if brace_start >= 0:
             depth = 0
@@ -198,7 +207,6 @@ Analyze these results and suggest 1-3 specific modifications to the config. Retu
     changes = parsed.get("changes", [])
     new_config = parsed.get("config", current_config)
 
-    # Validate that config has required fields
     required_keys = ["model_type", "features", "target", "hyperparameters", "strategy", "training"]
     for key in required_keys:
         if key not in new_config:
@@ -209,22 +217,25 @@ Analyze these results and suggest 1-3 specific modifications to the config. Retu
 
 
 if __name__ == "__main__":
-    # Test with dummy data
     import sys
     config_path = sys.argv[1] if len(sys.argv) > 1 else "config/initial_config.json"
     with open(config_path) as f:
         config = json.load(f)
 
     dummy_results = {
-        "sharpe_ratio": 1.2,
-        "total_return_pct": 15.3,
-        "max_drawdown_pct": -12.5,
-        "win_rate": 0.55,
-        "trade_count": 120,
-        "profit_factor": 1.4,
-        "avg_trade_duration_candles": 7.2,
-        "feature_importances": {"RSI_14": 0.15, "MACD_hist": 0.12, "BB_width": 0.10},
-        "per_window_sharpe": [1.0, 1.3, 1.5, 0.9, 1.1],
+        "cost_basis_improvement_pct": 8.5,
+        "avg_cost_basis_model": 65000,
+        "avg_cost_basis_dca": 71000,
+        "strong_buy_signal_count": 45,
+        "good_buy_signal_count": 120,
+        "signal_frequency_pct": 7.2,
+        "pct_quality_strong_buy": 0.72,
+        "model_r2_score": 0.22,
+        "avg_score_at_actual_bottoms": 68.5,
+        "avg_score_at_actual_tops": 35.2,
+        "per_window_cost_improvement": [7.1, 9.3, 8.8, 10.2, 7.0],
+        "score_distribution": {"0-20": 80, "20-40": 150, "40-60": 200, "60-80": 130, "80-100": 40},
+        "feature_importances": {"dist_from_ath_pct": 0.18, "RSI_14": 0.12, "price_percentile_365": 0.10},
     }
 
     new_config, reasoning = analyze_and_suggest(config, dummy_results)
diff --git a/ml_engine/train_and_backtest.py b/ml_engine/train_and_backtest.py
index cc77d41..a991d68 100755
--- a/ml_engine/train_and_backtest.py
+++ b/ml_engine/train_and_backtest.py
@@ -1,8 +1,11 @@
 #!/usr/bin/env python3
 """
-BTC ML Trading Strategy -- Train & Backtest Engine
+BTC Accumulation Signal Optimizer -- Train & Backtest Engine
 Self-contained script that runs on the Windows PC with GPU.
 
+Predicts the best times to BUY BTC for long-term holding by scoring
+each candle with an Accumulation Score (0-100).
+
 Usage:
     python train_and_backtest.py --config config.json --data btc_4h.csv --output results.json
 """
@@ -18,7 +21,7 @@ from datetime import datetime
 import ta
 from ta.momentum import RSIIndicator, StochasticOscillator, WilliamsRIndicator, ROCIndicator
 from ta.trend import MACD, CCIIndicator, SMAIndicator, EMAIndicator
-from ta.volatility import BollingerBands, AverageTrueRange, KeltnerChannel
+from ta.volatility import BollingerBands, AverageTrueRange
 from ta.volume import OnBalanceVolumeIndicator
 
 from sklearn.preprocessing import StandardScaler
@@ -30,121 +33,194 @@ warnings.filterwarnings("ignore")
 # Feature Engineering
 # ---------------------------------------------------------------------------
 
-def compute_features(df: pd.DataFrame, config: dict) -> pd.DataFrame:
-    """Compute 60+ technical features from OHLCV data."""
+def compute_features(df, config):
+    """Compute accumulation-focused features from OHLCV data."""
     feat = config.get("features", {})
     c, h, l, o, v = df["close"], df["high"], df["low"], df["open"], df["volume"]
 
-    # --- Price SMAs & EMAs ---
-    for p in [5, 10, 20, 50, 200]:
-        df[f"SMA_{p}"] = SMAIndicator(c, window=p).sma_indicator()
-        df[f"price_vs_SMA_{p}"] = c / df[f"SMA_{p}"] - 1
-    for p in [5, 10, 20, 50]:
-        df[f"EMA_{p}"] = EMAIndicator(c, window=p).ema_indicator()
+    # --- Price Position ---
+    if feat.get("use_price_position", True):
+        # Distance from ATH (all-time high in dataset) as %
+        rolling_ath = c.expanding().max()
+        df["dist_from_ath_pct"] = (c - rolling_ath) / rolling_ath * 100
 
-    # --- Momentum ---
-    for p in [7, 14, 21]:
-        df[f"RSI_{p}"] = RSIIndicator(c, window=p).rsi()
+        # Distance from 52-week high/low (using ~2190 4h candles = 365 days)
+        period_52w = min(2190, len(df) - 1)
+        if period_52w > 50:
+            rolling_52w_high = h.rolling(period_52w, min_periods=50).max()
+            rolling_52w_low = l.rolling(period_52w, min_periods=50).min()
+            df["dist_from_52w_high_pct"] = (c - rolling_52w_high) / rolling_52w_high * 100
+            df["dist_from_52w_low_pct"] = (c - rolling_52w_low) / rolling_52w_low * 100
 
-    macd = MACD(c, window_slow=26, window_fast=12, window_sign=9)
-    df["MACD_line"] = macd.macd()
-    df["MACD_signal"] = macd.macd_signal()
-    df["MACD_hist"] = macd.macd_diff()
+        # Price vs SMA(50) and SMA(200)
+        sma50 = SMAIndicator(c, window=50).sma_indicator()
+        sma200 = SMAIndicator(c, window=200).sma_indicator()
+        df["SMA_50"] = sma50
+        df["SMA_200"] = sma200
+        df["price_vs_sma50_pct"] = (c - sma50) / sma50 * 100
+        df["price_vs_sma200_pct"] = (c - sma200) / sma200 * 100
+        df["sma50_vs_sma200"] = (sma50 - sma200) / sma200 * 100  # golden/death cross
 
-    stoch = StochasticOscillator(h, l, c, window=14, smooth_window=3)
-    df["stoch_k"] = stoch.stoch()
-    df["stoch_d"] = stoch.stoch_signal()
+        # Price percentile over last 365 candles (~2190 for 4h, ~8760 for 1h)
+        period_365 = min(2190, len(df) - 1)
+        if period_365 > 50:
+            df["price_percentile_365"] = c.rolling(period_365, min_periods=50).apply(
+                lambda x: pd.Series(x).rank(pct=True).iloc[-1], raw=False
+            )
 
-    df["williams_r"] = WilliamsRIndicator(h, l, c, lbp=14).williams_r()
-    df["ROC_10"] = ROCIndicator(c, window=10).roc()
-    df["CCI_20"] = CCIIndicator(h, l, c, window=20).cci()
+        # Additional SMAs
+        for p in [10, 20]:
+            sma = SMAIndicator(c, window=p).sma_indicator()
+            df[f"price_vs_sma{p}_pct"] = (c - sma) / sma * 100
 
-    # --- Volatility ---
-    bb = BollingerBands(c, window=20, window_dev=2)
-    df["BB_upper"] = bb.bollinger_hband()
-    df["BB_lower"] = bb.bollinger_lband()
-    df["BB_width"] = (df["BB_upper"] - df["BB_lower"]) / c
-    df["BB_pctb"] = bb.bollinger_pband()
+    # --- Momentum / Oversold ---
+    if feat.get("use_momentum", True):
+        df["RSI_14"] = RSIIndicator(c, window=14).rsi()
+        df["RSI_7"] = RSIIndicator(c, window=7).rsi()
 
-    df["ATR_14"] = AverageTrueRange(h, l, c, window=14).average_true_range()
-    df["ATR_pct"] = df["ATR_14"] / c
+        macd = MACD(c, window_slow=26, window_fast=12, window_sign=9)
+        df["MACD_line"] = macd.macd()
+        df["MACD_signal"] = macd.macd_signal()
+        df["MACD_hist"] = macd.macd_diff()
 
-    kc = KeltnerChannel(h, l, c, window=20)
-    df["keltner_upper"] = kc.keltner_channel_hband()
-    df["keltner_lower"] = kc.keltner_channel_lband()
+        stoch = StochasticOscillator(h, l, c, window=14, smooth_window=3)
+        df["stoch_k"] = stoch.stoch()
+        df["stoch_d"] = stoch.stoch_signal()
 
-    df["hist_volatility"] = c.pct_change().rolling(20).std() * np.sqrt(252)
+        df["williams_r"] = WilliamsRIndicator(h, l, c, lbp=14).williams_r()
+
+        df["ROC_30"] = ROCIndicator(c, window=30).roc()
+        df["ROC_90"] = ROCIndicator(c, window=90).roc()
+
+    # --- Volatility / Fear ---
+    if feat.get("use_volatility", True):
+        bb = BollingerBands(c, window=20, window_dev=2)
+        df["BB_width"] = (bb.bollinger_hband() - bb.bollinger_lband()) / c
+        df["BB_pctb"] = bb.bollinger_pband()
+        df["price_vs_lower_bb"] = (c - bb.bollinger_lband()) / c
+
+        atr = AverageTrueRange(h, l, c, window=14)
+        df["ATR_14"] = atr.average_true_range()
+        df["ATR_pct"] = df["ATR_14"] / c * 100
+
+        # Consecutive red candles
+        is_red = (c < o).astype(int)
+        df["consecutive_red"] = is_red.groupby(
+            (is_red != is_red.shift()).cumsum()
+        ).cumsum() * is_red
+
+        # Max drawdown over last 30 candles
+        if len(df) > 30:
+            rolling_max_30 = c.rolling(30, min_periods=1).max()
+            df["drawdown_30"] = (c - rolling_max_30) / rolling_max_30 * 100
+
+        # Historical volatility
+        df["hist_volatility_20"] = c.pct_change().rolling(20).std() * np.sqrt(252)
 
     # --- Volume ---
-    if feat.get("use_volume_features", True):
+    if feat.get("use_volume", True):
         df["OBV"] = OnBalanceVolumeIndicator(c, v).on_balance_volume()
-        df["volume_sma_20"] = v.rolling(20).mean()
-        df["volume_ratio"] = v / df["volume_sma_20"]
-        df["volume_momentum"] = v.pct_change(5)
-        # VWAP approximation (rolling)
-        tp = (h + l + c) / 3
-        df["vwap_approx"] = (tp * v).rolling(20).sum() / v.rolling(20).sum()
-        df["price_vs_vwap"] = c / df["vwap_approx"] - 1
+        vol_sma20 = v.rolling(20).mean()
+        df["volume_ratio"] = v / vol_sma20
 
-    # --- Candle Patterns ---
-    if feat.get("use_candle_patterns", True):
-        body = (c - o).abs()
-        full_range = h - l
-        df["candle_body_ratio"] = body / full_range.replace(0, np.nan)
-        df["upper_wick_ratio"] = (h - pd.concat([c, o], axis=1).max(axis=1)) / full_range.replace(0, np.nan)
-        df["lower_wick_ratio"] = (pd.concat([c, o], axis=1).min(axis=1) - l) / full_range.replace(0, np.nan)
-        df["is_bullish"] = (c > o).astype(int)
-        # Consecutive up/down
-        df["consecutive_up"] = df["is_bullish"].groupby((df["is_bullish"] != df["is_bullish"].shift()).cumsum()).cumsum()
-        df["consecutive_down"] = (1 - df["is_bullish"]).groupby(((1 - df["is_bullish"]) != (1 - df["is_bullish"]).shift()).cumsum()).cumsum()
+        # Volume on red vs green candles ratio (rolling 20)
+        is_green = (c >= o).astype(float)
+        is_red_f = (c < o).astype(float)
+        green_vol = (v * is_green).rolling(20).sum()
+        red_vol = (v * is_red_f).rolling(20).sum()
+        df["red_green_vol_ratio"] = red_vol / (green_vol + 1e-10)
 
-    # --- Lag Features ---
-    if feat.get("use_lag_features", True):
-        lag_periods = feat.get("lag_periods", [1, 2, 3, 5])
-        for lag in lag_periods:
-            df[f"return_lag_{lag}"] = c.pct_change(lag)
-            df[f"volume_lag_{lag}"] = v.pct_change(lag)
-            if f"RSI_14" in df.columns:
-                df[f"RSI_14_lag_{lag}"] = df["RSI_14"].shift(lag)
+        # OBV trend (slope over 20 candles)
+        df["OBV_slope"] = df["OBV"].diff(20) / (df["OBV"].rolling(20).mean().abs() + 1e-10)
 
-    # --- Lookback period features ---
-    for p in feat.get("lookback_periods", [3, 5, 10, 20]):
-        df[f"return_{p}"] = c.pct_change(p)
-        df[f"volatility_{p}"] = c.pct_change().rolling(p).std()
-        df[f"high_low_range_{p}"] = (h.rolling(p).max() - l.rolling(p).min()) / c
+    # --- Cycle ---
+    if feat.get("use_cycle", True):
+        # MA(50) vs MA(200) position (bull/bear regime) -- already computed if price_position
+        if "sma50_vs_sma200" not in df.columns:
+            sma50 = SMAIndicator(c, window=50).sma_indicator()
+            sma200 = SMAIndicator(c, window=200).sma_indicator()
+            df["sma50_vs_sma200"] = (sma50 - sma200) / sma200 * 100
+
+        # Days since last major drawdown (>20% from peak)
+        rolling_peak = c.expanding().max()
+        drawdown_from_peak = (c - rolling_peak) / rolling_peak
+        major_dd = (drawdown_from_peak < -0.20).astype(int)
+        # Count candles since last major drawdown
+        dd_groups = major_dd.groupby((major_dd != major_dd.shift()).cumsum())
+        df["candles_since_major_dd"] = dd_groups.cumcount()
+        # Reset to 0 at drawdown points, count up otherwise
+        df.loc[major_dd == 1, "candles_since_major_dd"] = 0
 
     return df
 
 
 # ---------------------------------------------------------------------------
-# Target Labeling
+# Target: Accumulation Score
 # ---------------------------------------------------------------------------
 
-def create_target(df: pd.DataFrame, config: dict) -> pd.Series:
-    """Create binary target: will price move >= threshold% within horizon?"""
+def create_accumulation_target(df, config):
+    """Create accumulation score target based on forward returns.
+
+    For each candle, compute actual forward returns at multiple horizons,
+    rank them, and create a weighted accumulation score (0-100).
+    Times when buying led to the best long-term returns get highest scores.
+    """
     tgt = config.get("target", {})
-    horizon = tgt.get("horizon_candles", 6)
-    threshold = tgt.get("threshold_pct", 1.0) / 100.0
-    direction = tgt.get("direction", "long")
+    timeframe = config.get("timeframe", "4h")
 
-    future_max = df["close"].shift(-1).rolling(horizon).max().shift(-horizon + 1)
-    future_min = df["close"].shift(-1).rolling(horizon).min().shift(-horizon + 1)
+    if timeframe == "1h":
+        forward_periods = tgt.get("forward_periods_1h", [168, 720, 2160])
+    else:
+        forward_periods = tgt.get("forward_periods_4h", [42, 180, 540])
 
-    if direction == "long":
-        target = ((future_max / df["close"]) - 1 >= threshold).astype(int)
-    elif direction == "short":
-        target = ((df["close"] / future_min) - 1 >= threshold).astype(int)
-    else:  # both
-        long_signal = ((future_max / df["close"]) - 1 >= threshold).astype(int)
-        short_signal = ((df["close"] / future_min) - 1 >= threshold).astype(int)
-        target = long_signal  # Simplify: use long for now
-        target[short_signal == 1] = 1
+    weights = tgt.get("weights", [0.2, 0.3, 0.5])
 
-    return target
+    # Ensure weights sum to 1
+    w_sum = sum(weights)
+    weights = [w / w_sum for w in weights]
+
+    close = df["close"].values
+    n = len(close)
+
+    # Compute forward returns for each horizon
+    forward_returns = []
+    for period in forward_periods:
+        fwd = np.full(n, np.nan)
+        for i in range(n - period):
+            fwd[i] = (close[i + period] - close[i]) / close[i] * 100
+        forward_returns.append(fwd)
+
+    # Rank each forward return (percentile rank, 0-1)
+    # Higher rank = better buy point (higher future return)
+    ranked = []
+    for fwd in forward_returns:
+        valid_mask = ~np.isnan(fwd)
+        ranks = np.full(n, np.nan)
+        valid_vals = fwd[valid_mask]
+        if len(valid_vals) > 0:
+            from scipy.stats import rankdata
+            r = rankdata(valid_vals, method="average") / len(valid_vals)
+            ranks[valid_mask] = r
+        ranked.append(ranks)
+
+    # Weighted combination of ranks -> accumulation score (0-100)
+    score = np.zeros(n)
+    valid = np.ones(n, dtype=bool)
+    for r, w in zip(ranked, weights):
+        nan_mask = np.isnan(r)
+        valid &= ~nan_mask
+        r_filled = np.where(nan_mask, 0, r)
+        score += w * r_filled
+
+    # Scale to 0-100
+    score = score * 100
+    score[~valid] = np.nan
+
+    return pd.Series(score, index=df.index, name="target")
 
 
 # ---------------------------------------------------------------------------
-# LSTM Model (PyTorch)
+# LSTM Regressor (PyTorch)
 # ---------------------------------------------------------------------------
 
 def get_device():
@@ -155,8 +231,8 @@ def get_device():
     return torch.device("cpu")
 
 
-class LSTMClassifier:
-    """PyTorch LSTM for binary classification of trading signals."""
+class LSTMRegressor:
+    """PyTorch LSTM for regression of accumulation scores."""
 
     def __init__(self, input_size, hp):
         import torch
@@ -164,7 +240,7 @@ class LSTMClassifier:
 
         self.hp = hp
         self.device = get_device()
-        self.sequence_length = hp.get("lstm_sequence_length", 20)
+        self.sequence_length = hp.get("lstm_sequence_length", 30)
 
         hidden_size = hp.get("lstm_hidden_size", 128)
         num_layers = hp.get("lstm_num_layers", 2)
@@ -182,16 +258,12 @@ class LSTMClassifier:
                 )
                 self_net.dropout = nn.Dropout(dropout)
                 self_net.fc = nn.Linear(hidden_size, 1)
-                self_net.sigmoid = nn.Sigmoid()
 
             def forward(self_net, x):
-                # x: (batch, seq_len, features)
                 lstm_out, _ = self_net.lstm(x)
-                # Take last time step
                 last_hidden = lstm_out[:, -1, :]
                 out = self_net.dropout(last_hidden)
                 out = self_net.fc(out)
-                out = self_net.sigmoid(out)
                 return out.squeeze(-1)
 
         self.model = _LSTMNet().to(self.device)
@@ -223,7 +295,7 @@ class LSTMClassifier:
         patience = self.hp.get("lstm_patience", 10)
 
         optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
-        criterion = nn.BCELoss()
+        criterion = nn.MSELoss()
 
         X_seq, y_seq = self._make_sequences(X_train, y_train)
         if X_val is not None and y_val is not None:
@@ -240,17 +312,16 @@ class LSTMClassifier:
         n_samples = len(X_seq)
 
         for epoch in range(epochs):
-            # Shuffle
             perm = torch.randperm(n_samples)
-            X_seq = X_seq[perm]
-            y_seq = y_seq[perm]
+            X_seq_shuffled = X_seq[perm]
+            y_seq_shuffled = y_seq[perm]
 
             epoch_loss = 0.0
             n_batches = 0
             for start in range(0, n_samples, batch_size):
                 end = min(start + batch_size, n_samples)
-                X_batch = X_seq[start:end]
-                y_batch = y_seq[start:end]
+                X_batch = X_seq_shuffled[start:end]
+                y_batch = y_seq_shuffled[start:end]
 
                 optimizer.zero_grad()
                 preds = self.model(X_batch)
@@ -263,7 +334,6 @@ class LSTMClassifier:
 
             avg_loss = epoch_loss / max(n_batches, 1)
 
-            # Validation
             if has_val:
                 self.model.eval()
                 with torch.no_grad():
@@ -290,35 +360,30 @@ class LSTMClassifier:
         if best_state is not None:
             self.model.load_state_dict(best_state)
 
-    def predict_proba(self, X):
+    def predict(self, X):
         import torch
         self.model.eval()
         X_seq = self._make_sequences(X)
         with torch.no_grad():
-            proba_pos = self.model(X_seq).cpu().numpy()
-        proba_neg = 1.0 - proba_pos
-        return np.column_stack([proba_neg, proba_pos])
-
-    def predict(self, X):
-        proba = self.predict_proba(X)
-        return (proba[:, 1] >= 0.5).astype(int)
+            preds = self.model(X_seq).cpu().numpy()
+        # Clamp to 0-100
+        return np.clip(preds, 0, 100)
 
 
 # ---------------------------------------------------------------------------
 # Model Building
 # ---------------------------------------------------------------------------
 
-def build_model(config: dict, input_size: int = 0):
-    """Build the ML model based on config."""
+def build_model(config, input_size=0):
+    """Build regression model based on config."""
     model_type = config.get("model_type", "xgboost")
     hp = config.get("hyperparameters", {})
 
     if model_type == "lstm":
-        return LSTMClassifier(input_size, hp)
+        return LSTMRegressor(input_size, hp)
 
     if model_type == "xgboost":
         import xgboost as xgb
-        # Detect GPU
         try:
             import torch
             gpu_available = torch.cuda.is_available()
@@ -326,46 +391,48 @@ def build_model(config: dict, input_size: int = 0):
             gpu_available = False
 
         params = {
-            "learning_rate": hp.get("learning_rate", 0.05),
-            "max_depth": hp.get("max_depth", 6),
+            "learning_rate": hp.get("learning_rate", 0.01),
+            "max_depth": hp.get("max_depth", 5),
             "n_estimators": hp.get("n_estimators", 500),
             "subsample": hp.get("subsample", 0.8),
             "colsample_bytree": hp.get("colsample_bytree", 0.8),
-            "min_child_weight": hp.get("min_child_weight", 5),
-            "gamma": hp.get("gamma", 0.1),
-            "reg_alpha": hp.get("reg_alpha", 0.1),
-            "reg_lambda": hp.get("reg_lambda", 1.0),
-            "eval_metric": "logloss",
+            "min_child_weight": hp.get("min_child_weight", 10),
+            "gamma": hp.get("gamma", 0.3),
+            "reg_alpha": hp.get("reg_alpha", 0.5),
+            "reg_lambda": hp.get("reg_lambda", 3.0),
+            "objective": "reg:squarederror",
+            "eval_metric": "rmse",
             "random_state": 42,
             "device": "cuda" if gpu_available else "cpu",
             "verbosity": 0,
         }
-        return xgb.XGBClassifier(**params)
+        return xgb.XGBRegressor(**params)
 
     elif model_type == "lightgbm":
         import lightgbm as lgb
         params = {
-            "learning_rate": hp.get("learning_rate", 0.05),
-            "max_depth": hp.get("max_depth", 6),
+            "learning_rate": hp.get("learning_rate", 0.01),
+            "max_depth": hp.get("max_depth", 5),
             "n_estimators": hp.get("n_estimators", 500),
             "subsample": hp.get("subsample", 0.8),
             "colsample_bytree": hp.get("colsample_bytree", 0.8),
-            "min_child_samples": hp.get("min_child_weight", 5),
-            "reg_alpha": hp.get("reg_alpha", 0.1),
-            "reg_lambda": hp.get("reg_lambda", 1.0),
+            "min_child_samples": hp.get("min_child_weight", 10),
+            "reg_alpha": hp.get("reg_alpha", 0.5),
+            "reg_lambda": hp.get("reg_lambda", 3.0),
+            "objective": "regression",
+            "metric": "rmse",
             "random_state": 42,
             "verbose": -1,
         }
         try:
             params["device"] = "gpu"
-            model = lgb.LGBMClassifier(**params)
-            return model
+            return lgb.LGBMRegressor(**params)
         except Exception:
             params["device"] = "cpu"
-            return lgb.LGBMClassifier(**params)
+            return lgb.LGBMRegressor(**params)
 
     elif model_type == "catboost":
-        from catboost import CatBoostClassifier
+        from catboost import CatBoostRegressor
         try:
             import torch
             gpu_available = torch.cuda.is_available()
@@ -373,25 +440,20 @@ def build_model(config: dict, input_size: int = 0):
             gpu_available = False
 
         params = {
-            "learning_rate": hp.get("learning_rate", 0.05),
-            "depth": hp.get("max_depth", 6),
+            "learning_rate": hp.get("learning_rate", 0.01),
+            "depth": hp.get("max_depth", 5),
             "iterations": hp.get("n_estimators", 500),
             "subsample": hp.get("subsample", 0.8),
-            "l2_leaf_reg": hp.get("reg_lambda", 1.0),
+            "l2_leaf_reg": hp.get("reg_lambda", 3.0),
+            "loss_function": "RMSE",
             "random_seed": 42,
             "verbose": 0,
             "task_type": "GPU" if gpu_available else "CPU",
         }
-        return CatBoostClassifier(**params)
+        return CatBoostRegressor(**params)
 
     elif model_type == "ensemble":
-        from sklearn.ensemble import VotingClassifier
-        models = []
-        for sub_type in ["xgboost", "lightgbm", "catboost"]:
-            sub_config = {**config, "model_type": sub_type}
-            m = build_model(sub_config)
-            models.append((sub_type, m))
-        return VotingClassifier(estimators=models, voting="soft")
+        raise ValueError("Use 'hybrid' instead of 'ensemble' for accumulation mode")
 
     else:
         raise ValueError(f"Unknown model_type: {model_type}")
@@ -402,12 +464,12 @@ def build_model(config: dict, input_size: int = 0):
 # ---------------------------------------------------------------------------
 
 def apply_scaling_pca(X_train, X_val, X_test, config):
-    """Apply StandardScaler and optional PCA. Returns transformed arrays and fitted objects."""
+    """Apply StandardScaler and optional PCA."""
     feat_cfg = config.get("features", {})
     scaler = None
     pca = None
 
-    if feat_cfg.get("use_scaler", False):
+    if feat_cfg.get("use_scaler", True):
         scaler = StandardScaler()
         X_train = scaler.fit_transform(X_train)
         if X_val is not None:
@@ -427,116 +489,25 @@ def apply_scaling_pca(X_train, X_val, X_test, config):
 
 
 # ---------------------------------------------------------------------------
-# Walk-Forward / Rolling Window Validation + Backtesting
+# Rolling Window Validation
 # ---------------------------------------------------------------------------
 
-def walk_forward_train_test(df: pd.DataFrame, feature_cols: list, config: dict) -> dict:
-    """Walk-forward or rolling window validation with backtesting."""
+def rolling_window_train_test(df, feature_cols, config):
+    """Rolling window train/test for accumulation score prediction."""
     training_cfg = config.get("training", {})
-    strategy = config.get("strategy", {})
+    train_size = training_cfg.get("rolling_train_size", 2500)
+    test_size = training_cfg.get("rolling_test_size", 300)
+    val_pct = training_cfg.get("validation_pct", 0.15)
     model_type = config.get("model_type", "xgboost")
-    use_rolling = training_cfg.get("rolling_window", False)
-
-    if use_rolling:
-        return rolling_window_train_test(df, feature_cols, config)
-
-    # Standard walk-forward
-    n_windows = training_cfg.get("walk_forward_windows", 5)
-    train_pct = training_cfg.get("train_pct", 0.7)
-    val_pct = training_cfg.get("validation_pct", 0.15)
 
     n = len(df)
-    window_size = n // n_windows
-
-    all_trades = []
-    per_window_sharpe = []
-    feature_importances_sum = None
-    fi_count = 0
-    effective_n_features = len(feature_cols)
-
-    for w in range(n_windows):
-        start = w * window_size
-        end = min((w + 1) * window_size + int(window_size * 0.3), n)  # overlap for test
-        if end > n:
-            end = n
-
-        window_data = df.iloc[start:end].copy()
-        wn = len(window_data)
-
-        train_end = int(wn * train_pct)
-        val_end = int(wn * (train_pct + val_pct))
-
-        train_df = window_data.iloc[:train_end]
-        val_df = window_data.iloc[train_end:val_end]
-        test_df = window_data.iloc[val_end:]
-
-        if len(test_df) < 10 or train_df["target"].nunique() < 2:
-            continue
-
-        X_train = train_df[feature_cols].values
-        y_train = train_df["target"].values
-        X_val = val_df[feature_cols].values
-        y_val = val_df["target"].values
-        X_test = test_df[feature_cols].values
-
-        # Scale and PCA
-        X_train, X_val, X_test, scaler, pca = apply_scaling_pca(X_train, X_val, X_test, config)
-        current_n_features = X_train.shape[1]
-        if feature_importances_sum is None:
-            effective_n_features = current_n_features
-            feature_importances_sum = np.zeros(effective_n_features)
-
-        # Build and train
-        trades, fi = _train_and_backtest_window(
-            X_train, y_train, X_val, y_val, X_test, test_df,
-            config, strategy, current_n_features, w, n_windows
-        )
-
-        if fi is not None and len(fi) == effective_n_features:
-            feature_importances_sum += fi
-            fi_count += 1
-
-        all_trades.extend(trades)
-
-        # Window sharpe
-        if trades:
-            returns = [t["return_pct"] for t in trades]
-            mean_r = np.mean(returns)
-            std_r = np.std(returns) if len(returns) > 1 else 1.0
-            sharpe = (mean_r / std_r) * np.sqrt(252 / max(1, len(trades))) if std_r > 0 else 0
-            per_window_sharpe.append(round(sharpe, 3))
-        else:
-            per_window_sharpe.append(0.0)
-
-        print(f"  Window {w+1}/{n_windows}: {len(trades)} trades, sharpe={per_window_sharpe[-1]}")
-
-    # Build feature names for output
-    if pca is not None and config.get("features", {}).get("use_pca", False):
-        effective_feature_names = [f"PC_{i+1}" for i in range(effective_n_features)]
-    else:
-        effective_feature_names = feature_cols
-
-    if feature_importances_sum is None:
-        feature_importances_sum = np.zeros(len(effective_feature_names))
-
-    return compile_results(all_trades, per_window_sharpe, feature_importances_sum, fi_count, effective_feature_names, df)
-
-
-def rolling_window_train_test(df: pd.DataFrame, feature_cols: list, config: dict) -> dict:
-    """Rolling window train/test with sliding forward."""
-    training_cfg = config.get("training", {})
-    strategy = config.get("strategy", {})
-    train_size = training_cfg.get("rolling_train_size", 2000)
-    test_size = training_cfg.get("rolling_test_size", 200)
-    val_pct = training_cfg.get("validation_pct", 0.15)
-
-    n = len(df)
-    all_trades = []
-    per_window_sharpe = []
+    all_predictions = []  # list of (predicted_score, actual_score, close_price)
+    per_window_results = []
     feature_importances_sum = None
     fi_count = 0
     effective_n_features = len(feature_cols)
     window_count = 0
+    last_pca = None
 
     start = 0
     while start + train_size + test_size <= n:
@@ -546,7 +517,13 @@ def rolling_window_train_test(df: pd.DataFrame, feature_cols: list, config: dict
         train_full = df.iloc[start:train_end]
         test_df = df.iloc[train_end:test_end]
 
-        if len(test_df) < 10 or train_full["target"].nunique() < 2:
+        if len(test_df) < 10:
+            start += test_size
+            continue
+
+        # Check target has variance
+        train_target = train_full["target"].dropna()
+        if len(train_target) < 100 or train_target.std() < 1.0:
             start += test_size
             continue
 
@@ -560,9 +537,11 @@ def rolling_window_train_test(df: pd.DataFrame, feature_cols: list, config: dict
         X_val = val_df[feature_cols].values
         y_val = val_df["target"].values
         X_test = test_df[feature_cols].values
+        y_test = test_df["target"].values
 
         # Scale and PCA
         X_train, X_val, X_test, scaler, pca = apply_scaling_pca(X_train, X_val, X_test, config)
+        last_pca = pca
         current_n_features = X_train.shape[1]
         if feature_importances_sum is None:
             effective_n_features = current_n_features
@@ -571,31 +550,66 @@ def rolling_window_train_test(df: pd.DataFrame, feature_cols: list, config: dict
         window_count += 1
         total_possible = (n - train_size) // test_size
 
-        trades, fi = _train_and_backtest_window(
-            X_train, y_train, X_val, y_val, X_test, test_df,
-            config, strategy, current_n_features, window_count - 1, total_possible
+        # Train and predict
+        preds, fi = _train_and_predict_window(
+            X_train, y_train, X_val, y_val, X_test,
+            config, current_n_features, window_count - 1, total_possible
         )
 
         if fi is not None and len(fi) == effective_n_features:
             feature_importances_sum += fi
             fi_count += 1
 
-        all_trades.extend(trades)
-
-        if trades:
-            returns = [t["return_pct"] for t in trades]
-            mean_r = np.mean(returns)
-            std_r = np.std(returns) if len(returns) > 1 else 1.0
-            sharpe = (mean_r / std_r) * np.sqrt(252 / max(1, len(trades))) if std_r > 0 else 0
-            per_window_sharpe.append(round(sharpe, 3))
+        # Align predictions with test data
+        if model_type in ("lstm", "hybrid"):
+            seq_len = config.get("hyperparameters", {}).get("lstm_sequence_length", 30)
+            offset = seq_len if model_type == "lstm" else seq_len
+            if len(preds) < len(test_df):
+                test_aligned = test_df.iloc[offset:offset + len(preds)]
+            else:
+                test_aligned = test_df.iloc[:len(preds)]
         else:
-            per_window_sharpe.append(0.0)
+            test_aligned = test_df.iloc[:len(preds)]
 
-        print(f"  Rolling window {window_count}: {len(trades)} trades, sharpe={per_window_sharpe[-1]}")
+        min_len = min(len(preds), len(test_aligned))
+        preds = preds[:min_len]
+        test_aligned = test_aligned.iloc[:min_len]
+
+        for pred_score, actual_score, close_price in zip(
+            preds, test_aligned["target"].values, test_aligned["close"].values
+        ):
+            if not np.isnan(actual_score):
+                all_predictions.append({
+                    "predicted": float(pred_score),
+                    "actual": float(actual_score),
+                    "close": float(close_price),
+                })
+
+        # Per-window cost improvement
+        window_preds = [p for p in zip(preds, test_aligned["target"].values, test_aligned["close"].values)
+                        if not np.isnan(p[1])]
+        if window_preds:
+            wp_pred = [p[0] for p in window_preds]
+            wp_close = [p[2] for p in window_preds]
+            dca_avg = np.mean(wp_close)
+            # Model buys: only when predicted score > strong_buy_threshold
+            threshold = config.get("strategy", {}).get("strong_buy_threshold", 80)
+            buy_prices = [close for pred, _, close in window_preds if pred >= threshold]
+            if len(buy_prices) >= 3:
+                model_avg = np.mean(buy_prices)
+                improvement = (dca_avg - model_avg) / dca_avg * 100
+            else:
+                improvement = 0.0
+            per_window_results.append(round(improvement, 1))
+            print(f"  Window {window_count}: {len(buy_prices)} signals, cost improvement={improvement:.1f}%")
+        else:
+            per_window_results.append(0.0)
+            print(f"  Window {window_count}: no valid predictions")
 
         start += test_size
 
-    if pca is not None and config.get("features", {}).get("use_pca", False):
+    # Build feature names
+    if last_pca is not None and config.get("features", {}).get("use_pca", False):
         effective_feature_names = [f"PC_{i+1}" for i in range(effective_n_features)]
     else:
         effective_feature_names = feature_cols
@@ -603,21 +617,143 @@ def rolling_window_train_test(df: pd.DataFrame, feature_cols: list, config: dict
     if feature_importances_sum is None:
         feature_importances_sum = np.zeros(len(effective_feature_names))
 
-    return compile_results(all_trades, per_window_sharpe, feature_importances_sum, fi_count, effective_feature_names, df)
+    return compile_results(all_predictions, per_window_results,
+                           feature_importances_sum, fi_count,
+                           effective_feature_names, config)
 
 
-def _train_and_backtest_window(X_train, y_train, X_val, y_val, X_test, test_df,
-                                config, strategy, n_features, w_idx, n_windows):
-    """Train model on one window and backtest. Returns (trades, feature_importances)."""
+def walk_forward_train_test(df, feature_cols, config):
+    """Walk-forward or rolling window validation."""
+    training_cfg = config.get("training", {})
+    if training_cfg.get("rolling_window", True):
+        return rolling_window_train_test(df, feature_cols, config)
+
+    # Static walk-forward: split into N windows
+    n_windows = training_cfg.get("walk_forward_windows", 5)
+    train_pct = training_cfg.get("train_pct", 0.7)
+    val_pct = training_cfg.get("validation_pct", 0.15)
+
+    n = len(df)
+    window_size = n // n_windows
+
+    all_predictions = []
+    per_window_results = []
+    feature_importances_sum = None
+    fi_count = 0
+    effective_n_features = len(feature_cols)
+    last_pca = None
+
+    for w in range(n_windows):
+        w_start = w * window_size
+        w_end = min((w + 1) * window_size + int(window_size * 0.3), n)
+        if w_end > n:
+            w_end = n
+
+        window_data = df.iloc[w_start:w_end].copy()
+        wn = len(window_data)
+
+        train_end = int(wn * train_pct)
+        val_end = int(wn * (train_pct + val_pct))
+
+        train_df = window_data.iloc[:train_end]
+        val_df = window_data.iloc[train_end:val_end]
+        test_df = window_data.iloc[val_end:]
+
+        if len(test_df) < 10:
+            continue
+
+        train_target = train_df["target"].dropna()
+        if len(train_target) < 100 or train_target.std() < 1.0:
+            continue
+
+        X_train = train_df[feature_cols].values
+        y_train = train_df["target"].values
+        X_val = val_df[feature_cols].values
+        y_val = val_df["target"].values
+        X_test = test_df[feature_cols].values
+
+        X_train, X_val, X_test, scaler, pca = apply_scaling_pca(X_train, X_val, X_test, config)
+        last_pca = pca
+        current_n_features = X_train.shape[1]
+        if feature_importances_sum is None:
+            effective_n_features = current_n_features
+            feature_importances_sum = np.zeros(effective_n_features)
+
+        preds, fi = _train_and_predict_window(
+            X_train, y_train, X_val, y_val, X_test,
+            config, current_n_features, w, n_windows
+        )
+
+        if fi is not None and len(fi) == effective_n_features:
+            feature_importances_sum += fi
+            fi_count += 1
+
+        model_type = config.get("model_type", "xgboost")
+        if model_type in ("lstm", "hybrid"):
+            seq_len = config.get("hyperparameters", {}).get("lstm_sequence_length", 30)
+            test_aligned = test_df.iloc[seq_len:seq_len + len(preds)]
+        else:
+            test_aligned = test_df.iloc[:len(preds)]
+
+        min_len = min(len(preds), len(test_aligned))
+        preds = preds[:min_len]
+        test_aligned = test_aligned.iloc[:min_len]
+
+        for pred_score, actual_score, close_price in zip(
+            preds, test_aligned["target"].values, test_aligned["close"].values
+        ):
+            if not np.isnan(actual_score):
+                all_predictions.append({
+                    "predicted": float(pred_score),
+                    "actual": float(actual_score),
+                    "close": float(close_price),
+                })
+
+        # Per-window metrics
+        window_preds = [p for p in zip(preds, test_aligned["target"].values, test_aligned["close"].values)
+                        if not np.isnan(p[1])]
+        if window_preds:
+            threshold = config.get("strategy", {}).get("strong_buy_threshold", 80)
+            wp_close = [p[2] for p in window_preds]
+            buy_prices = [close for pred, _, close in window_preds if pred >= threshold]
+            dca_avg = np.mean(wp_close)
+            if len(buy_prices) >= 3:
+                improvement = (dca_avg - np.mean(buy_prices)) / dca_avg * 100
+            else:
+                improvement = 0.0
+            per_window_results.append(round(improvement, 1))
+            print(f"  Window {w+1}/{n_windows}: {len(buy_prices)} signals, improvement={improvement:.1f}%")
+        else:
+            per_window_results.append(0.0)
+
+    if last_pca is not None and config.get("features", {}).get("use_pca", False):
+        effective_feature_names = [f"PC_{i+1}" for i in range(effective_n_features)]
+    else:
+        effective_feature_names = feature_cols
+
+    if feature_importances_sum is None:
+        feature_importances_sum = np.zeros(len(effective_feature_names))
+
+    return compile_results(all_predictions, per_window_results,
+                           feature_importances_sum, fi_count,
+                           effective_feature_names, config)
+
+
+# ---------------------------------------------------------------------------
+# Train & Predict Helpers
+# ---------------------------------------------------------------------------
+
+def _train_and_predict_window(X_train, y_train, X_val, y_val, X_test,
+                               config, n_features, w_idx, n_windows):
+    """Train model and return predictions + feature importances."""
     model_type = config.get("model_type", "xgboost")
 
     if model_type == "hybrid":
-        return _hybrid_train_and_backtest(
-            X_train, y_train, X_val, y_val, X_test, test_df,
-            config, strategy, n_features
+        return _hybrid_train_and_predict(
+            X_train, y_train, X_val, y_val, X_test,
+            config, n_features
         )
 
-    # Single model path
     if model_type == "lstm":
         model = build_model(config, input_size=n_features)
     else:
@@ -630,83 +766,61 @@ def _train_and_backtest_window(X_train, y_train, X_val, y_val, X_test, test_df,
             model.fit(X_train, y_train)
     except Exception as e:
         print(f"  Window {w_idx+1}: training failed -- {e}", file=sys.stderr)
-        return [], None
+        return np.array([]), None
 
-    # Get predictions
     try:
         if model_type == "lstm":
-            seq_len = config.get("hyperparameters", {}).get("lstm_sequence_length", 20)
-            proba = model.predict_proba(X_test)[:, 1]
-            # Align test_df to account for sequence trimming
-            test_df_aligned = test_df.iloc[seq_len:]
+            preds = model.predict(X_test)
         else:
-            proba = model.predict_proba(X_test)[:, 1]
-            test_df_aligned = test_df
-    except Exception:
-        preds = model.predict(X_test)
-        proba = preds.astype(float)
-        test_df_aligned = test_df
+            preds = model.predict(X_test)
+            preds = np.clip(preds, 0, 100)
+    except Exception as e:
+        print(f"  Window {w_idx+1}: prediction failed -- {e}", file=sys.stderr)
+        return np.array([]), None
 
-    # Feature importances
     fi = _extract_feature_importances(model, n_features)
-
-    # Backtest
-    trades = backtest(test_df_aligned, proba, strategy)
-    return trades, fi
+    return preds, fi
 
 
-def _hybrid_train_and_backtest(X_train, y_train, X_val, y_val, X_test, test_df,
-                                config, strategy, n_features):
-    """Hybrid: LSTM (60%) + XGBoost (40%), only enter when both agree."""
+def _hybrid_train_and_predict(X_train, y_train, X_val, y_val, X_test,
+                               config, n_features):
+    """Hybrid: average of LSTM + XGBoost regression predictions."""
     hp = config.get("hyperparameters", {})
-    seq_len = hp.get("lstm_sequence_length", 20)
+    seq_len = hp.get("lstm_sequence_length", 30)
 
     # Train LSTM
     lstm_config = {**config, "model_type": "lstm"}
     lstm_model = build_model(lstm_config, input_size=n_features)
     try:
         lstm_model.fit(X_train, y_train, X_val, y_val)
-        lstm_proba_full = lstm_model.predict_proba(X_test)[:, 1]
+        lstm_preds = lstm_model.predict(X_test)
     except Exception as e:
         print(f"    Hybrid LSTM failed: {e}", file=sys.stderr)
-        lstm_proba_full = np.full(max(0, len(X_test) - seq_len), 0.5)
+        lstm_preds = np.full(max(0, len(X_test) - seq_len), 50.0)
 
     # Train XGBoost
     xgb_config = {**config, "model_type": "xgboost"}
     xgb_model = build_model(xgb_config)
     try:
         xgb_model.fit(X_train, y_train)
-        xgb_proba_full = xgb_model.predict_proba(X_test)[:, 1]
+        xgb_preds_full = xgb_model.predict(X_test)
+        xgb_preds_full = np.clip(xgb_preds_full, 0, 100)
     except Exception as e:
         print(f"    Hybrid XGBoost failed: {e}", file=sys.stderr)
-        xgb_proba_full = np.full(len(X_test), 0.5)
+        xgb_preds_full = np.full(len(X_test), 50.0)
 
     # Align: LSTM output is shorter by seq_len
-    xgb_proba = xgb_proba_full[seq_len:]
-    lstm_proba = lstm_proba_full
-    min_len = min(len(lstm_proba), len(xgb_proba))
-    lstm_proba = lstm_proba[:min_len]
-    xgb_proba = xgb_proba[:min_len]
-    test_df_aligned = test_df.iloc[seq_len:seq_len + min_len]
+    xgb_preds = xgb_preds_full[seq_len:]
+    min_len = min(len(lstm_preds), len(xgb_preds))
+    lstm_preds = lstm_preds[:min_len]
+    xgb_preds = xgb_preds[:min_len]
 
-    # Combine: 60% LSTM + 40% XGBoost, only when both agree
-    lstm_weight = 0.6
-    xgb_weight = 0.4
-    combined_proba = lstm_weight * lstm_proba + xgb_weight * xgb_proba
+    # Average (equal weight)
+    combined = 0.5 * lstm_preds + 0.5 * xgb_preds
+    combined = np.clip(combined, 0, 100)
 
-    # Both must agree on direction (both > 0.5 or both < 0.5)
-    lstm_bullish = lstm_proba > 0.5
-    xgb_bullish = xgb_proba > 0.5
-    agreement = lstm_bullish == xgb_bullish
-
-    # Zero out signals where models disagree
-    combined_proba[~agreement] = 0.5
-
-    # Feature importances from XGBoost
     fi = _extract_feature_importances(xgb_model, n_features)
-
-    trades = backtest(test_df_aligned, combined_proba, strategy)
-    return trades, fi
+    return combined, fi
 
 
 def _extract_feature_importances(model, n_features):
@@ -725,192 +839,150 @@ def _extract_feature_importances(model, n_features):
 
 
 # ---------------------------------------------------------------------------
-# Backtesting
+# Results Compilation
 # ---------------------------------------------------------------------------
 
-def backtest(test_df: pd.DataFrame, proba: np.ndarray, strategy: dict) -> list:
-    """Simulate trades using model predictions. Supports ATR-based dynamic SL/TP."""
-    entry_threshold = strategy.get("entry_threshold", 0.6)
-    stop_loss_fixed = strategy.get("stop_loss_pct", 2.0) / 100
-    take_profit_fixed = strategy.get("take_profit_pct", 4.0) / 100
-    trailing_stop = strategy.get("trailing_stop_pct", 1.5) / 100
-    exit_type = strategy.get("exit_type", "trailing_stop")
-    min_confidence = strategy.get("min_confidence_to_trade", 0.55)
-    use_dynamic = strategy.get("dynamic_sl_tp", False)
-    atr_sl_mult = strategy.get("atr_sl_multiplier", 1.5)
-    atr_tp_mult = strategy.get("atr_tp_multiplier", 3.0)
-    fee = 0.001  # 0.1% per trade
+def compile_results(predictions, per_window_cost_improvement,
+                    fi_sum, fi_count, feature_cols, config):
+    """Compile accumulation signal results into output JSON."""
+    strategy = config.get("strategy", {})
+    strong_threshold = strategy.get("strong_buy_threshold", 80)
+    good_threshold = strategy.get("good_buy_threshold", 70)
+    poor_threshold = strategy.get("poor_threshold", 30)
 
-    closes = test_df["close"].values
-    highs = test_df["high"].values
-    lows = test_df["low"].values
+    if not predictions:
+        return _empty_results(per_window_cost_improvement)
 
-    # ATR for dynamic SL/TP
-    if use_dynamic and "ATR_14" in test_df.columns:
-        atr_values = test_df["ATR_14"].values
+    pred_scores = np.array([p["predicted"] for p in predictions])
+    actual_scores = np.array([p["actual"] for p in predictions])
+    close_prices = np.array([p["close"] for p in predictions])
+
+    total_candles = len(predictions)
+
+    # --- Signal Quality: STRONG BUY (score > strong_threshold) ---
+    strong_buy_mask = pred_scores >= strong_threshold
+    strong_buy_count = int(np.sum(strong_buy_mask))
+
+    if strong_buy_count > 0:
+        strong_buy_actual = actual_scores[strong_buy_mask]
+        # Actual scores correspond to forward return quality
+        avg_actual_strong = float(np.mean(strong_buy_actual))
     else:
-        atr_values = None
+        avg_actual_strong = 0.0
 
-    trades = []
-    i = 0
+    # We need forward return info. Since actual_score is a rank-based measure (0-100),
+    # and we want to report real forward returns, we approximate:
+    # actual_score > 80 means the buy was in the top 20% of quality.
+    # For actual forward return stats, we use actual score as a proxy.
 
-    while i < len(closes) - 1:
-        if i >= len(proba):
-            break
-        if proba[i] < min_confidence or proba[i] < entry_threshold:
-            i += 1
-            continue
+    # Profitable signals: those where actual score is also above median (50)
+    if strong_buy_count > 0:
+        pct_profitable_strong = float(np.mean(actual_scores[strong_buy_mask] > 50))
+    else:
+        pct_profitable_strong = 0.0
 
-        # Enter trade
-        entry_price = closes[i]
-        confidence = proba[i]
+    # --- Cost Basis Comparison vs DCA ---
+    dca_avg = float(np.mean(close_prices))
 
-        # Compute dynamic SL/TP if enabled
-        if use_dynamic and atr_values is not None and not np.isnan(atr_values[i]):
-            atr = atr_values[i]
-            stop_loss = (atr * atr_sl_mult) / entry_price
-            take_profit = (atr * atr_tp_mult) / entry_price
-        else:
-            stop_loss = stop_loss_fixed
-            take_profit = take_profit_fixed
+    # Model strategy: buy when predicted score >= good_threshold
+    good_buy_mask = pred_scores >= good_threshold
+    good_buy_prices = close_prices[good_buy_mask]
+    good_buy_count = len(good_buy_prices)
 
-        # Position sizing based on confidence
-        if strategy.get("position_sizing") == "confidence_scaled":
-            if confidence > 0.8:
-                size_mult = 1.0
-            elif confidence > 0.65:
-                size_mult = 0.75
-            else:
-                size_mult = 0.5
-        else:
-            size_mult = 1.0
+    if good_buy_count >= 3:
+        model_avg = float(np.mean(good_buy_prices))
+        cost_basis_improvement = (dca_avg - model_avg) / dca_avg * 100
+    else:
+        model_avg = dca_avg
+        cost_basis_improvement = 0.0
 
-        peak = entry_price
-        j = i + 1
+    # --- Signal Frequency ---
+    signal_frequency = strong_buy_count / total_candles * 100 if total_candles > 0 else 0
 
-        while j < len(closes):
-            current_high = highs[j]
-            current_low = lows[j]
-            current_close = closes[j]
-            peak = max(peak, current_high)
+    # --- Score at actual extremes ---
+    # "Actual bottoms" = candles with actual score > 85 (top 15% buy opportunities)
+    actual_bottom_mask = actual_scores > 85
+    if np.any(actual_bottom_mask):
+        avg_score_at_bottoms = float(np.mean(pred_scores[actual_bottom_mask]))
+    else:
+        avg_score_at_bottoms = 0.0
 
-            # Check stop loss
-            if (entry_price - current_low) / entry_price >= stop_loss:
-                exit_price = entry_price * (1 - stop_loss)
-                break
-            # Check take profit
-            if (current_high - entry_price) / entry_price >= take_profit:
-                exit_price = entry_price * (1 + take_profit)
-                break
-            # Check trailing stop
-            if exit_type == "trailing_stop" and (peak - current_low) / peak >= trailing_stop:
-                exit_price = peak * (1 - trailing_stop)
-                break
+    # "Actual tops" = candles with actual score < 15 (worst 15% buy times)
+    actual_top_mask = actual_scores < 15
+    if np.any(actual_top_mask):
+        avg_score_at_tops = float(np.mean(pred_scores[actual_top_mask]))
+    else:
+        avg_score_at_tops = 50.0
 
-            j += 1
-        else:
-            # Exit at end of test period
-            exit_price = closes[-1]
+    # --- Model R2 Score ---
+    ss_res = np.sum((actual_scores - pred_scores) ** 2)
+    ss_tot = np.sum((actual_scores - np.mean(actual_scores)) ** 2)
+    r2 = 1 - ss_res / (ss_tot + 1e-10)
 
-        raw_return = (exit_price - entry_price) / entry_price
-        net_return = raw_return - 2 * fee  # entry + exit fees
-        net_return *= size_mult
-
-        trades.append({
-            "entry_idx": i,
-            "exit_idx": j if j < len(closes) else len(closes) - 1,
-            "entry_price": float(entry_price),
-            "exit_price": float(exit_price),
-            "return_pct": float(net_return * 100),
-            "confidence": float(confidence),
-            "size_mult": float(size_mult),
-            "duration": j - i,
-        })
-
-        i = j + 1  # Skip to after exit
-
-    return trades
-
-
-def compile_results(trades: list, per_window_sharpe: list,
-                    fi_sum: np.ndarray, fi_count: int,
-                    feature_cols: list, df: pd.DataFrame) -> dict:
-    """Compile all results into output JSON."""
-    if not trades:
-        return {
-            "sharpe_ratio": 0.0,
-            "total_return_pct": 0.0,
-            "max_drawdown_pct": 0.0,
-            "win_rate": 0.0,
-            "trade_count": 0,
-            "profit_factor": 0.0,
-            "avg_trade_duration_candles": 0.0,
-            "feature_importances": {},
-            "monthly_returns": [],
-            "equity_curve": [],
-            "per_window_sharpe": per_window_sharpe,
-        }
-
-    returns = [t["return_pct"] for t in trades]
-    wins = [r for r in returns if r > 0]
-    losses = [r for r in returns if r <= 0]
-
-    total_return = 1.0
-    equity = [1.0]
-    for r in returns:
-        total_return *= (1 + r / 100)
-        equity.append(total_return)
-
-    # Max drawdown
-    peak_eq = equity[0]
-    max_dd = 0
-    for eq in equity:
-        peak_eq = max(peak_eq, eq)
-        dd = (eq - peak_eq) / peak_eq
-        max_dd = min(max_dd, dd)
-
-    # Sharpe (annualized approximation)
-    mean_r = np.mean(returns)
-    std_r = np.std(returns) if len(returns) > 1 else 1.0
-    trades_per_year = 252  # approximate
-    sharpe = (mean_r / std_r) * np.sqrt(trades_per_year / max(1, len(returns))) if std_r > 0 else 0
-
-    # Profit factor
-    gross_profit = sum(wins) if wins else 0
-    gross_loss = abs(sum(losses)) if losses else 1
-    profit_factor = gross_profit / gross_loss if gross_loss > 0 else gross_profit
-
-    # Feature importances
+    # --- Feature Importances ---
     fi_avg = fi_sum / max(fi_count, 1)
     fi_sorted = sorted(zip(feature_cols, fi_avg), key=lambda x: -x[1])
     feature_importances = {name: round(float(val), 4) for name, val in fi_sorted[:30]}
 
-    # Monthly returns (approximate by grouping trades)
-    monthly_returns = []
-    trades_per_month = max(1, len(trades) // 12)
-    for i in range(0, len(returns), trades_per_month):
-        chunk = returns[i:i + trades_per_month]
-        monthly_returns.append(round(sum(chunk), 2))
+    # --- Score Distribution ---
+    bins = [(0, 20), (20, 40), (40, 60), (60, 80), (80, 100)]
+    score_distribution = {}
+    for lo, hi in bins:
+        key = f"{lo}-{hi}"
+        count = int(np.sum((pred_scores >= lo) & (pred_scores < (hi if hi < 100 else 101))))
+        score_distribution[key] = count
 
-    # Sample equity curve to ~100 points
-    if len(equity) > 100:
-        step = len(equity) // 100
-        equity_sampled = [round(equity[i], 4) for i in range(0, len(equity), step)]
+    # --- Forward return approximation from actual scores ---
+    # Map actual score to approximate return quality
+    # Score 90+ = historically best 10% buys, score 10- = worst 10%
+    # Use actual score as proxy for "quality rank"
+    if strong_buy_count > 0:
+        # Average actual quality score for strong buy signals
+        avg_quality_strong = float(np.mean(actual_scores[strong_buy_mask]))
+        # Estimate: top quality signals should be 70+
+        quality_good = avg_quality_strong > 60
     else:
-        equity_sampled = [round(e, 4) for e in equity]
+        avg_quality_strong = 0.0
+        quality_good = False
 
     return {
-        "sharpe_ratio": round(sharpe, 3),
-        "total_return_pct": round((total_return - 1) * 100, 2),
-        "max_drawdown_pct": round(max_dd * 100, 2),
-        "win_rate": round(len(wins) / len(returns), 3) if returns else 0,
-        "trade_count": len(trades),
-        "profit_factor": round(profit_factor, 3),
-        "avg_trade_duration_candles": round(np.mean([t["duration"] for t in trades]), 1),
+        "cost_basis_improvement_pct": round(cost_basis_improvement, 2),
+        "avg_cost_basis_model": round(model_avg, 2),
+        "avg_cost_basis_dca": round(dca_avg, 2),
+        "strong_buy_signal_count": strong_buy_count,
+        "good_buy_signal_count": good_buy_count,
+        "total_candles_tested": total_candles,
+        "signal_frequency_pct": round(signal_frequency, 2),
+        "pct_quality_strong_buy": round(pct_profitable_strong, 3),
+        "avg_score_at_actual_bottoms": round(avg_score_at_bottoms, 1),
+        "avg_score_at_actual_tops": round(avg_score_at_tops, 1),
+        "model_r2_score": round(float(r2), 4),
+        "avg_quality_score_strong_buy": round(avg_quality_strong, 1),
         "feature_importances": feature_importances,
-        "monthly_returns": monthly_returns,
-        "equity_curve": equity_sampled,
-        "per_window_sharpe": per_window_sharpe,
+        "per_window_cost_improvement": per_window_cost_improvement,
+        "score_distribution": score_distribution,
+        "model_type": config.get("model_type", "unknown"),
+    }
+
+
+def _empty_results(per_window):
+    return {
+        "cost_basis_improvement_pct": 0.0,
+        "avg_cost_basis_model": 0.0,
+        "avg_cost_basis_dca": 0.0,
+        "strong_buy_signal_count": 0,
+        "good_buy_signal_count": 0,
+        "total_candles_tested": 0,
+        "signal_frequency_pct": 0.0,
+        "pct_quality_strong_buy": 0.0,
+        "avg_score_at_actual_bottoms": 0.0,
+        "avg_score_at_actual_tops": 0.0,
+        "model_r2_score": 0.0,
+        "avg_quality_score_strong_buy": 0.0,
+        "feature_importances": {},
+        "per_window_cost_improvement": per_window,
+        "score_distribution": {},
+        "model_type": "unknown",
     }
 
 
@@ -919,48 +991,51 @@ def compile_results(trades: list, per_window_sharpe: list,
 # ---------------------------------------------------------------------------
 
 def main():
-    parser = argparse.ArgumentParser(description="BTC ML Trading -- Train & Backtest")
+    parser = argparse.ArgumentParser(description="BTC Accumulation Signal Optimizer")
     parser.add_argument("--config", required=True, help="Path to config JSON")
     parser.add_argument("--data", required=True, help="Path to OHLCV CSV")
     parser.add_argument("--output", required=True, help="Path to output results JSON")
     args = parser.parse_args()
 
-    # Load config
     with open(args.config) as f:
         config = json.load(f)
 
-    # Load data
     print(f"Loading data from {args.data}...")
     df = pd.read_csv(args.data, parse_dates=["timestamp"])
     print(f"  {len(df)} rows, {df['timestamp'].iloc[0]} -> {df['timestamp'].iloc[-1]}")
 
-    # Compute features
-    print("Computing features...")
+    print("Computing accumulation features...")
     df = compute_features(df, config)
 
-    # Create target
-    print("Creating target labels...")
-    df["target"] = create_target(df, config)
+    print("Creating accumulation score targets...")
+    df["target"] = create_accumulation_target(df, config)
 
     # Drop NaN rows
-    feature_cols = [c for c in df.columns if c not in ["timestamp", "open", "high", "low", "close", "volume", "target"]]
+    feature_cols = [c for c in df.columns
+                    if c not in ["timestamp", "open", "high", "low", "close", "volume", "target"]]
     df = df.dropna(subset=feature_cols + ["target"]).reset_index(drop=True)
-    print(f"  {len(df)} rows after dropping NaN, {len(feature_cols)} features")
-    print(f"  Target distribution: {df['target'].value_counts().to_dict()}")
+    print(f"  {len(df)} rows after cleanup, {len(feature_cols)} features")
+
+    target_stats = df["target"].describe()
+    print(f"  Target stats: mean={target_stats['mean']:.1f}, std={target_stats['std']:.1f}, "
+          f"min={target_stats['min']:.1f}, max={target_stats['max']:.1f}")
 
-    # Run walk-forward training + backtesting
     model_type = config.get("model_type", "xgboost")
-    rolling = config.get("training", {}).get("rolling_window", False)
+    rolling = config.get("training", {}).get("rolling_window", True)
     print(f"\nModel: {model_type}, Rolling: {rolling}")
-    print("Running validation...")
+    print("Running accumulation signal optimization...")
     results = walk_forward_train_test(df, feature_cols, config)
 
-    # Save results
     with open(args.output, "w") as f:
         json.dump(results, f, indent=2)
+
     print(f"\nResults saved to {args.output}")
-    print(f"  Sharpe: {results['sharpe_ratio']}, Return: {results['total_return_pct']}%, "
-          f"Win Rate: {results['win_rate']}, Trades: {results['trade_count']}")
+    print(f"  Cost Basis Improvement: {results['cost_basis_improvement_pct']:.1f}%")
+    print(f"  Strong Buy Signals: {results['strong_buy_signal_count']}")
+    print(f"  Signal Frequency: {results['signal_frequency_pct']:.1f}%")
+    print(f"  Model R2: {results['model_r2_score']:.4f}")
+    print(f"  Score at Bottoms: {results['avg_score_at_actual_bottoms']:.1f}")
+    print(f"  Score at Tops: {results['avg_score_at_actual_tops']:.1f}")
 
 
 if __name__ == "__main__":
diff --git a/orchestrator.py b/orchestrator.py
index 6ca033c..daec0f2 100755
--- a/orchestrator.py
+++ b/orchestrator.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-BTC ML Trading Strategy Optimizer — Orchestrator
+BTC Accumulation Signal Optimizer -- Orchestrator
 Coordinates the optimization loop across VPS, Windows PC (GPU), and Mac Mini (LLM).
 """
 
@@ -28,7 +28,8 @@ MAC_MINI_HOST = "bizzle@bizzles-mac-mini-1"
 MAX_ITERATIONS = 50
 CONVERGENCE_WINDOW = 5
 CONVERGENCE_THRESHOLD = 0.01  # 1% improvement
-TARGET_SHARPE = 3.0
+TARGET_COST_IMPROVEMENT = 20.0  # 20% cost basis improvement = exceptional
+MIN_SIGNAL_COUNT = 30  # Minimum strong buy signals for valid results
 ML_TIMEOUT = 600  # 10 minutes
 
 # Colors
@@ -98,7 +99,6 @@ def run_ml_training():
     )
     if result.returncode != 0:
         raise RuntimeError(f"ML training failed:\n{result.stderr}\n{result.stdout}")
-    # Print training output
     for line in result.stdout.strip().split("\n"):
         log(f"  {C.DIM}{line}", C.DIM)
     return True
@@ -127,45 +127,53 @@ def check_convergence(history):
     if len(history) < CONVERGENCE_WINDOW + 1:
         return False, "Not enough iterations"
 
-    recent = history[-CONVERGENCE_WINDOW:]
-    sharpes = [h["sharpe"] for h in recent]
+    # Only consider valid results (enough signals)
+    valid = [h for h in history if h.get("signal_count", 0) >= MIN_SIGNAL_COUNT]
 
-    # Check if best sharpe exceeds target
-    best_sharpe = max(h["sharpe"] for h in history)
-    if best_sharpe >= TARGET_SHARPE:
-        return True, f"Target Sharpe reached: {best_sharpe:.3f}"
+    if not valid:
+        return False, "No valid results yet"
+
+    recent = history[-CONVERGENCE_WINDOW:]
+    scores = [h.get("cost_improvement", 0) for h in recent]
+
+    # Check if best score exceeds target
+    best_score = max(h.get("cost_improvement", 0) for h in valid)
+    if best_score >= TARGET_COST_IMPROVEMENT:
+        return True, f"Target cost improvement reached: {best_score:.1f}%"
 
     # Check if improvement has stalled
-    best_recent = max(sharpes)
-    worst_recent = min(sharpes)
+    best_recent = max(scores)
+    worst_recent = min(scores)
     if best_recent > 0 and (best_recent - worst_recent) / best_recent < CONVERGENCE_THRESHOLD:
-        return True, f"Converged: Sharpe variance < {CONVERGENCE_THRESHOLD*100}% over {CONVERGENCE_WINDOW} iterations"
+        return True, f"Converged: variance < {CONVERGENCE_THRESHOLD*100}% over {CONVERGENCE_WINDOW} iterations"
 
     return False, ""
 
 
 def print_header():
     print(f"""
-{C.BOLD}{C.CYAN}╔══════════════════════════════════════════════════╗
-║       BTC ML Trading Strategy Optimizer          ║
-║     VPS → Windows GPU → Mac Mini LLM → Loop      ║
-╚══════════════════════════════════════════════════╝{C.RESET}
+{C.BOLD}{C.CYAN}========================================================
+       BTC Accumulation Signal Optimizer
+     VPS -> Windows GPU -> Mac Mini LLM -> Loop
+========================================================{C.RESET}
 """)
 
 
 def print_results(results, iteration):
-    sharpe = results.get("sharpe_ratio", 0)
-    sharpe_color = C.GREEN if sharpe > 1.5 else C.YELLOW if sharpe > 1.0 else C.RED
+    cost_imp = results.get("cost_basis_improvement_pct", 0)
+    color = C.GREEN if cost_imp > 15 else C.YELLOW if cost_imp > 10 else C.RED
     print(f"""
-{C.BOLD}━━━ Iteration {iteration} Results ━━━{C.RESET}
-  Sharpe Ratio:    {sharpe_color}{C.BOLD}{sharpe:.3f}{C.RESET}
-  Total Return:    {results.get('total_return_pct', 0):.1f}%
-  Max Drawdown:    {results.get('max_drawdown_pct', 0):.1f}%
-  Win Rate:        {results.get('win_rate', 0):.1%}
-  Trade Count:     {results.get('trade_count', 0)}
-  Profit Factor:   {results.get('profit_factor', 0):.3f}
-  Avg Duration:    {results.get('avg_trade_duration_candles', 0):.1f} candles
-  Window Sharpes:  {results.get('per_window_sharpe', [])}
+{C.BOLD}--- Iteration {iteration} Results ---{C.RESET}
+  Cost Improvement: {color}{C.BOLD}{cost_imp:.1f}%{C.RESET}
+  Avg Cost (Model): ${results.get('avg_cost_basis_model', 0):,.2f}
+  Avg Cost (DCA):   ${results.get('avg_cost_basis_dca', 0):,.2f}
+  Strong Signals:   {results.get('strong_buy_signal_count', 0)}
+  Signal Frequency: {results.get('signal_frequency_pct', 0):.1f}%
+  Quality Score:    {results.get('pct_quality_strong_buy', 0):.1%}
+  Model R2:         {results.get('model_r2_score', 0):.4f}
+  Score@Bottoms:    {results.get('avg_score_at_actual_bottoms', 0):.1f}
+  Score@Tops:       {results.get('avg_score_at_actual_tops', 0):.1f}
+  Window Improvements: {results.get('per_window_cost_improvement', [])}
 """)
 
 
@@ -173,14 +181,11 @@ def main():
     print_header()
     os.makedirs(RESULTS_DIR, exist_ok=True)
 
-    # Step 1: Ensure data
     ensure_data()
 
-    # Step 2: Load or create initial config
     config_path = os.path.join(CONFIG_DIR, "initial_config.json")
     best_config_path = os.path.join(CONFIG_DIR, "best_config.json")
 
-    # Resume from best config if it exists
     if os.path.exists(best_config_path):
         log("Resuming from best_config.json", C.GREEN)
         with open(best_config_path) as f:
@@ -191,29 +196,24 @@ def main():
 
     history = load_iteration_history()
     start_iter = len(history) + 1
-    best_sharpe = max((h["sharpe"] for h in history), default=0)
+    best_score = max((h.get("cost_improvement", 0) for h in history), default=0)
 
-    log(f"Starting at iteration {start_iter}, best Sharpe so far: {best_sharpe:.3f}", C.BOLD)
+    log(f"Starting at iteration {start_iter}, best cost improvement so far: {best_score:.1f}%", C.BOLD)
 
-    # Step 3: Setup Windows remote
     setup_windows_remote()
 
-    # SCP the ML engine script (once)
     log("Uploading ML engine to Windows...", C.CYAN)
     scp_to_windows(os.path.join(BASE_DIR, "ml_engine", "train_and_backtest.py"), "train_and_backtest.py")
 
-    # SCP data files (once)
     for tf in ["1h", "4h"]:
         data_file = os.path.join(DATA_DIR, f"btc_{tf}.csv")
         if os.path.exists(data_file):
             log(f"Uploading btc_{tf}.csv to Windows...", C.CYAN)
             scp_to_windows(data_file, f"btc_{tf}.csv")
 
-    # Import LLM analyzer
     sys.path.insert(0, os.path.join(BASE_DIR, "llm_client"))
     from analyzer import analyze_and_suggest
 
-    # Main optimization loop
     for iteration in range(start_iter, MAX_ITERATIONS + 1):
         log(f"\n{'='*50}", C.BOLD)
         log(f"ITERATION {iteration}/{MAX_ITERATIONS}", f"{C.BOLD}{C.CYAN}")
@@ -222,13 +222,11 @@ def main():
             f"Depth: {config.get('hyperparameters', {}).get('max_depth', '?')}", C.DIM)
         log(f"{'='*50}", C.BOLD)
 
-        # Write current config to temp file and SCP
         tmp_config = os.path.join(BASE_DIR, "config", "current_config.json")
         with open(tmp_config, "w") as f:
             json.dump(config, f, indent=2)
         scp_to_windows(tmp_config, "config.json")
 
-        # Run ML training on Windows
         try:
             run_ml_training()
         except (RuntimeError, subprocess.TimeoutExpired) as e:
@@ -238,7 +236,6 @@ def main():
                 config = history[-1].get("config", config)
             continue
 
-        # Fetch results from Windows
         results_local = os.path.join(RESULTS_DIR, f"results_iter_{iteration}.json")
         scp_from_windows("results.json", results_local)
 
@@ -247,34 +244,35 @@ def main():
 
         print_results(results, iteration)
 
-        # Track best
-        current_sharpe = results.get("sharpe_ratio", 0)
-        is_best = current_sharpe > best_sharpe
+        current_score = results.get("cost_basis_improvement_pct", 0)
+        signal_count = results.get("strong_buy_signal_count", 0)
+        is_best = current_score > best_score and signal_count >= MIN_SIGNAL_COUNT
 
         if is_best:
-            best_sharpe = current_sharpe
+            best_score = current_score
             with open(best_config_path, "w") as f:
                 json.dump(config, f, indent=2)
-            log(f"NEW BEST! Sharpe: {best_sharpe:.3f}", f"{C.BOLD}{C.GREEN}")
+            log(f"NEW BEST! Cost Improvement: {best_score:.1f}%", f"{C.BOLD}{C.GREEN}")
 
-        # Log iteration
         iter_data = {
             "iteration": iteration,
             "timestamp": datetime.now(timezone.utc).isoformat(),
-            "sharpe": current_sharpe,
-            "return": results.get("total_return_pct", 0),
-            "max_drawdown": results.get("max_drawdown_pct", 0),
-            "win_rate": results.get("win_rate", 0),
-            "trades": results.get("trade_count", 0),
-            "profit_factor": results.get("profit_factor", 0),
+            "cost_improvement": current_score,
+            "avg_30d_return": results.get("avg_quality_score_strong_buy", 0),
+            "avg_90d_return": results.get("pct_quality_strong_buy", 0),
+            "signal_count": signal_count,
+            "signal_frequency": results.get("signal_frequency_pct", 0),
+            "r2_score": results.get("model_r2_score", 0),
+            "score_at_bottoms": results.get("avg_score_at_actual_bottoms", 0),
+            "score_at_tops": results.get("avg_score_at_actual_tops", 0),
             "model_type": config.get("model_type", "unknown"),
             "is_best": is_best,
             "config": config,
+            "results": results,
         }
         save_iteration(iter_data)
         history.append(iter_data)
 
-        # Check convergence
         converged, reason = check_convergence(history)
         if converged:
             log(f"\nOptimization converged: {reason}", f"{C.BOLD}{C.GREEN}")
@@ -284,17 +282,15 @@ def main():
             log(f"\nMax iterations ({MAX_ITERATIONS}) reached.", C.YELLOW)
             break
 
-        # Ask LLM for next config
         log("\nConsulting LLM for strategy modifications...", C.MAGENTA)
         try:
             summary_history = [
                 {
                     "iteration": h["iteration"],
-                    "sharpe": h["sharpe"],
-                    "return": h["return"],
-                    "win_rate": h["win_rate"],
-                    "trades": h["trades"],
-                    "model_type": h["model_type"],
+                    "cost_improvement": h.get("cost_improvement", 0),
+                    "signal_count": h.get("signal_count", 0),
+                    "r2_score": h.get("r2_score", 0),
+                    "model_type": h.get("model_type", "unknown"),
                 }
                 for h in history
             ]
@@ -304,37 +300,34 @@ def main():
         except Exception as e:
             log(f"LLM call failed: {e}", C.RED)
             log("Continuing with current config + random perturbation...", C.YELLOW)
-            # Small random perturbation as fallback
             import random
             hp = config.get("hyperparameters", {})
-            hp["learning_rate"] = hp.get("learning_rate", 0.05) * random.uniform(0.8, 1.2)
-            hp["max_depth"] = max(3, min(10, hp.get("max_depth", 6) + random.choice([-1, 0, 1])))
+            hp["learning_rate"] = hp.get("learning_rate", 0.01) * random.uniform(0.8, 1.2)
+            hp["max_depth"] = max(3, min(10, hp.get("max_depth", 5) + random.choice([-1, 0, 1])))
             config["hyperparameters"] = hp
 
-    # Final summary
     print(f"""
-{C.BOLD}{C.GREEN}╔══════════════════════════════════════════════════╗
-║              Optimization Complete!               ║
-╚══════════════════════════════════════════════════╝{C.RESET}
+{C.BOLD}{C.GREEN}========================================================
+              Optimization Complete!
+========================================================{C.RESET}
 
-  Total Iterations: {len(history)}
-  Best Sharpe:      {C.BOLD}{best_sharpe:.3f}{C.RESET}
-  Best Config:      {best_config_path}
-  Iteration Log:    {ITERATIONS_LOG}
+  Total Iterations:     {len(history)}
+  Best Cost Improvement: {C.BOLD}{best_score:.1f}%{C.RESET}
+  Best Config:          {best_config_path}
+  Iteration Log:        {ITERATIONS_LOG}
 """)
 
 
 # --- Library API for dashboard integration ---
 
-# Shared state for dashboard
 _stop_event = threading.Event()
 _status = {
-    "state": "idle",  # idle, running, completed, error
+    "state": "idle",
     "iteration": 0,
     "max_iterations": MAX_ITERATIONS,
-    "best_sharpe": 0.0,
+    "best_score": 0.0,
     "error": None,
-    "llm_suggestions": [],  # list of {iteration, reasoning, changes}
+    "llm_suggestions": [],
 }
 _status_lock = threading.Lock()
 
@@ -352,15 +345,9 @@ def update_status(**kwargs):
 
 
 def run_optimization_loop(callback=None, config_override=None):
-    """
-    Run the optimization loop. Designed to be called from a background thread.
-
-    Args:
-        callback: Called after each iteration with (iteration_number, iter_data_dict).
-        config_override: Optional dict to use instead of loading from disk.
-    """
+    """Run the optimization loop from a background thread."""
     _stop_event.clear()
-    update_status(state="running", iteration=0, error=None, best_sharpe=0.0)
+    update_status(state="running", iteration=0, error=None, best_score=0.0)
 
     try:
         os.makedirs(RESULTS_DIR, exist_ok=True)
@@ -380,8 +367,8 @@ def run_optimization_loop(callback=None, config_override=None):
 
         history = load_iteration_history()
         start_iter = len(history) + 1
-        best_sharpe = max((h["sharpe"] for h in history), default=0)
-        update_status(best_sharpe=best_sharpe)
+        best_score = max((h.get("cost_improvement", 0) for h in history), default=0)
+        update_status(best_score=best_score)
 
         setup_windows_remote()
         scp_to_windows(os.path.join(BASE_DIR, "ml_engine", "train_and_backtest.py"), "train_and_backtest.py")
@@ -418,23 +405,26 @@ def run_optimization_loop(callback=None, config_override=None):
             with open(results_local) as f:
                 results = json.load(f)
 
-            current_sharpe = results.get("sharpe_ratio", 0)
-            is_best = current_sharpe > best_sharpe
+            current_score = results.get("cost_basis_improvement_pct", 0)
+            signal_count = results.get("strong_buy_signal_count", 0)
+            is_best = current_score > best_score and signal_count >= MIN_SIGNAL_COUNT
+
             if is_best:
-                best_sharpe = current_sharpe
+                best_score = current_score
                 with open(best_config_path, "w") as f:
                     json.dump(config, f, indent=2)
-                update_status(best_sharpe=best_sharpe)
+                update_status(best_score=best_score)
 
             iter_data = {
                 "iteration": iteration,
                 "timestamp": datetime.now(timezone.utc).isoformat(),
-                "sharpe": current_sharpe,
-                "return": results.get("total_return_pct", 0),
-                "max_drawdown": results.get("max_drawdown_pct", 0),
-                "win_rate": results.get("win_rate", 0),
-                "trades": results.get("trade_count", 0),
-                "profit_factor": results.get("profit_factor", 0),
+                "cost_improvement": current_score,
+                "signal_count": signal_count,
+                "signal_frequency": results.get("signal_frequency_pct", 0),
+                "r2_score": results.get("model_r2_score", 0),
+                "score_at_bottoms": results.get("avg_score_at_actual_bottoms", 0),
+                "score_at_tops": results.get("avg_score_at_actual_tops", 0),
+                "quality": results.get("pct_quality_strong_buy", 0),
                 "model_type": config.get("model_type", "unknown"),
                 "is_best": is_best,
                 "config": config,
@@ -459,10 +449,10 @@ def run_optimization_loop(callback=None, config_override=None):
                 update_status(state="completed")
                 return
 
-            # LLM suggestion
             try:
                 summary_history = [
-                    {k: h[k] for k in ("iteration", "sharpe", "return", "win_rate", "trades", "model_type")}
+                    {k: h[k] for k in ("iteration", "cost_improvement", "signal_count", "r2_score", "model_type")
+                     if k in h}
                     for h in history
                 ]
                 new_config, reasoning = analyze_and_suggest(config, results, summary_history)
@@ -475,8 +465,8 @@ def run_optimization_loop(callback=None, config_override=None):
             except Exception:
                 import random
                 hp = config.get("hyperparameters", {})
-                hp["learning_rate"] = hp.get("learning_rate", 0.05) * random.uniform(0.8, 1.2)
-                hp["max_depth"] = max(3, min(10, hp.get("max_depth", 6) + random.choice([-1, 0, 1])))
+                hp["learning_rate"] = hp.get("learning_rate", 0.01) * random.uniform(0.8, 1.2)
+                hp["max_depth"] = max(3, min(10, hp.get("max_depth", 5) + random.choice([-1, 0, 1])))
                 config["hyperparameters"] = hp
 
         update_status(state="completed")