fix: make sync endpoint market-aware — prevent US scan results from overwriting BIST file

Root cause: /api/trading/sync always wrote scan_results to
paper_trading/bist100_scan_results.json regardless of market_id.
When the US worker synced its data, it overwrote the BIST scan file,
causing both BIST and US eligible pages to show US stocks.

Changes:
- Add market_id field to TradingSyncPayload
- Use get_scan_results_path(market_id) for correct file paths
- Store per-market scan_results in _remote_cache (scan_results:bist, scan_results:us)
- Update _get_trading_status() to read from scan_results:bist cache key

_archive_scripts/_backfill_runlog.py

@@ -0,0 +1,61 @@
+"""One-time backfill of daily_run_log from daemon stderr log history."""
+import re
+import sqlite3
+from collections import defaultdict
+
+LOG_FILE = "/Users/onerozbey/Library/Logs/borsa-trading-worker/worker_stderr.log"
+DB_PATH = "/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space/paper_trading/trading.db"
+
+# Parse "Cycle: OK", "Cycle: SKIPPED", etc. from log lines
+pattern = re.compile(r"^(\d{4}-\d{2}-\d{2}) [\d:,]+ .* Cycle: (\w+)")
+
+day_status = {}  # date -> best status
+with open(LOG_FILE) as f:
+    for line in f:
+        m = pattern.match(line)
+        if m:
+            date, status = m.group(1), m.group(2)
+            # Priority: OK > SKIPPED > NO_ELIGIBLE_STOCKS
+            if status == "OK" or date not in day_status:
+                day_status[date] = status
+
+print(f"Found {len(day_status)} unique dates with cycles")
+
+conn = sqlite3.connect(DB_PATH)
+cur = conn.cursor()
+
+# Ensure table exists
+cur.execute("""
+    CREATE TABLE IF NOT EXISTS daily_run_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        date TEXT NOT NULL,
+        market_id TEXT NOT NULL DEFAULT 'bist',
+        status TEXT NOT NULL,
+        trades_executed INTEGER DEFAULT 0,
+        elapsed_sec REAL DEFAULT 0,
+        equity REAL,
+        cash REAL,
+        model_safe INTEGER,
+        cycle_detail TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+    )
+""")
+
+# Check existing entries
+existing = set(r[0] for r in cur.execute("SELECT DISTINCT date FROM daily_run_log").fetchall())
+print(f"Already have {len(existing)} dates in run_log")
+
+inserted = 0
+for date in sorted(day_status):
+    if date not in existing:
+        status = day_status[date]
+        cur.execute(
+            "INSERT INTO daily_run_log (date, market_id, status) VALUES (?, 'bist', ?)",
+            (date, status)
+        )
+        inserted += 1
+
+conn.commit()
+conn.close()
+print(f"Backfilled {inserted} run log entries")
+print(f"Total run dates: {len(day_status)}")

_archive_scripts/_backfill_trades.py

@@ -0,0 +1,147 @@
+"""One-time: recover 12 closed trades from daemon logs into runtime DB."""
+import sqlite3, pathlib, datetime as _dt
+
+RUNTIME_DB = pathlib.Path.home() / "borsa_uygulamasi_runtime/huggingface-space/paper_trading/trading.db"
+
+# Raw fills parsed from daemon stderr log (all 29 entries, in chronological order)
+FILLS = [
+    # (date, action, qty, symbol, price, commission)
+    ("2026-02-25", "BUY",   99, "RALYH",  150.7753, 15.67),
+    ("2026-02-26", "BUY",   49, "THYAO",  306.4031, 15.76),
+    ("2026-02-27", "BUY", 1597, "IZENR",    9.4347, 15.82),
+    ("2026-03-02", "SELL",  99, "RALYH",  147.4263, 15.32),
+    ("2026-03-02", "SELL",  49, "THYAO",  287.6061, 14.80),
+    ("2026-03-02", "SELL",1597, "IZENR",    8.9055, 14.93),
+    ("2026-03-02", "BUY", 1484, "AKSA",     9.8749, 15.39),
+    ("2026-03-02", "BUY", 1648, "IZENR",    8.9145, 15.43),
+    ("2026-03-02", "BUY",   79, "ASTOR",  183.3917, 15.21),
+    ("2026-03-02", "BUY",   50, "THYAO",  287.8939, 15.11),
+    ("2026-03-03", "SELL",1648, "IZENR",    8.9455, 15.48),
+    ("2026-03-04", "SELL",  50, "THYAO",  283.8580, 14.90),
+    ("2026-03-04", "BUY",  185, "AKBNK",   78.5392, 15.26),
+    ("2026-03-05", "SELL",  79, "ASTOR",  172.2139, 14.29),
+    ("2026-03-05", "SELL", 185, "AKBNK",   80.9595, 15.73),
+    ("2026-03-05", "BUY",   84, "ASTOR",  172.3862, 15.20),
+    ("2026-03-05", "BUY",   98, "RALYH",  147.2736, 15.15),
+    ("2026-03-05", "BUY", 2702, "BTCIM",    5.4027, 15.33),
+    ("2026-03-06", "SELL",1484, "AKSA",    10.0150, 15.61),
+    ("2026-03-06", "SELL",  98, "RALYH",  143.7281, 14.79),
+    ("2026-03-06", "BUY",   51, "THYAO",  284.1420, 15.22),
+    ("2026-03-09", "SELL",  51, "THYAO",  267.1164, 14.30),
+    ("2026-03-11", "SELL",  84, "ASTOR",  193.7031, 17.08),
+    ("2026-03-12", "SELL",2702, "BTCIM",    6.1269, 17.38),
+    # Mar 30 BUYs already in DB as open trades — skip
+]
+
+def match_trades(fills):
+    """FIFO matching: pair BUY fills with subsequent SELL fills by (symbol, qty)."""
+    open_positions = []  # list of BUY fills waiting for a match
+    closed = []
+    
+    for f in fills:
+        date, action, qty, sym, price, comm = f
+        if action == "BUY":
+            open_positions.append(f)
+        else:  # SELL
+            # find matching BUY with same symbol and qty
+            for i, op in enumerate(open_positions):
+                if op[3] == sym and op[2] == qty:
+                    entry = op
+                    exit_ = f
+                    closed.append((entry, exit_))
+                    open_positions.pop(i)
+                    break
+    return closed
+
+def build_trade_record(entry, exit_):
+    e_date, _, qty, sym, e_price, e_comm = entry
+    x_date, _, _, _, x_price, x_comm = exit_
+    
+    gross_pnl = round((x_price - e_price) * qty, 4)
+    net_pnl = round(gross_pnl - e_comm - x_comm, 4)
+    return_pct = round((x_price - e_price) / e_price * 100, 4)
+    
+    d1 = _dt.date.fromisoformat(e_date)
+    d2 = _dt.date.fromisoformat(x_date)
+    holding_days = (d2 - d1).days
+    
+    return {
+        "symbol": sym,
+        "side": "BUY",
+        "entry_price": e_price,
+        "exit_price": x_price,
+        "quantity": qty,
+        "entry_date": e_date,
+        "exit_date": x_date,
+        "entry_commission": e_comm,
+        "exit_commission": x_comm,
+        "gross_pnl": gross_pnl,
+        "net_pnl": net_pnl,
+        "return_pct": return_pct,
+        "holding_days": holding_days,
+        "signal_confidence": 0.0,
+        "predicted_return": 0.0,
+        "entry_reason": "ML_BUY_SIGNAL",
+        "exit_reason": "SIGNAL_SELL",
+        "is_closed": 1,
+        "created_at": f"{e_date} 10:30:00",
+        "updated_at": f"{x_date} 10:30:00",
+    }
+
+def main():
+    pairs = match_trades(FILLS)
+    print(f"Matched {len(pairs)} closed trades from daemon logs\n")
+    
+    records = []
+    total_net = 0.0
+    winners = 0
+    for entry, exit_ in pairs:
+        r = build_trade_record(entry, exit_)
+        records.append(r)
+        total_net += r["net_pnl"]
+        if r["net_pnl"] > 0:
+            winners += 1
+        print(f"  {r['symbol']:6s} {r['entry_date']}→{r['exit_date']}  "
+              f"net={r['net_pnl']:+.2f}  ret={r['return_pct']:+.2f}%  "
+              f"hold={r['holding_days']}d")
+    
+    losers = len(records) - winners
+    win_pnl = sum(r["net_pnl"] for r in records if r["net_pnl"] > 0)
+    loss_pnl = abs(sum(r["net_pnl"] for r in records if r["net_pnl"] <= 0))
+    pf = win_pnl / loss_pnl if loss_pnl > 0 else 0
+    
+    print(f"\nSummary: {len(records)} trades, {winners}W/{losers}L")
+    print(f"  WR={winners/len(records)*100:.1f}%  PF={pf:.2f}  Net={total_net:+.2f}")
+    
+    # Insert into runtime DB
+    db = sqlite3.connect(str(RUNTIME_DB))
+    cur = db.cursor()
+    
+    # Check for existing closed trades to avoid duplicates
+    cur.execute("SELECT COUNT(*) FROM trades WHERE is_closed=1")
+    existing = cur.fetchone()[0]
+    if existing > 0:
+        print(f"\n⚠ Already {existing} closed trades in DB. Skipping insert.")
+        db.close()
+        return
+    
+    cols = list(records[0].keys())
+    placeholders = ",".join(["?"] * len(cols))
+    col_names = ",".join(cols)
+    
+    for r in records:
+        vals = [r[c] for c in cols]
+        cur.execute(f"INSERT INTO trades ({col_names}) VALUES ({placeholders})", vals)
+    
+    db.commit()
+    print(f"\n✅ Inserted {len(records)} closed trades into {RUNTIME_DB}")
+    
+    # Verify
+    cur.execute("SELECT COUNT(*) FROM trades WHERE is_closed=1")
+    print(f"   Closed trades in DB: {cur.fetchone()[0]}")
+    cur.execute("SELECT COUNT(*) FROM trades WHERE is_closed=0")
+    print(f"   Open trades in DB: {cur.fetchone()[0]}")
+    db.close()
+
+if __name__ == "__main__":
+    main()

_archive_scripts/_diag.py

@@ -0,0 +1,30 @@
+import sqlite3
+conn = sqlite3.connect('paper_trading/trading.db')
+cur = conn.cursor()
+
+cur.execute('SELECT * FROM daily_run_log ORDER BY date DESC LIMIT 10')
+runs = cur.fetchall()
+print('=== DAILY RUN LOG ===')
+for r in runs: print(r)
+
+cur.execute('SELECT date, equity, cash, positions_count FROM daily_snapshots ORDER BY date DESC LIMIT 10')
+snaps = cur.fetchall()
+print('\n=== DAILY SNAPSHOTS ===')
+for s in snaps: print(s)
+
+cur.execute("SELECT key, value FROM state WHERE key LIKE '%predict%' OR key LIKE '%model%' OR key LIKE '%bootstrap%'")
+preds = cur.fetchall()
+print('\n=== PREDICTION STATE ===')
+for p in preds: print(p)
+
+cur.execute('SELECT id, symbol, side, entry_date, exit_date, is_closed, exit_reason, gross_pnl FROM trades ORDER BY id')
+trades = cur.fetchall()
+print('\n=== ALL TRADES ===')
+for t in trades: print(t)
+
+cur.execute('SELECT COUNT(*) FROM signals_log')
+print('\n=== SIGNALS LOG COUNT:', cur.fetchone()[0], '===')
+cur.execute('SELECT date, symbol, action, score FROM signals_log ORDER BY date DESC LIMIT 5')
+for s in cur.fetchall(): print(s)
+
+conn.close()

ai/predictions_api.py

@@ -79,35 +79,31 @@ def _compute_confidence(r2: float, direction_correct: float) -> float:
         r2_c = float(r2) if np.isfinite(r2) else 0.0
         dir_c = float(direction_correct) if np.isfinite(direction_correct) else 0.5
 
-        # ── R² component (30% weight) ──
-        # Financial R²: 0.0→0.25, 0.05→0.50, 0.15→0.85, 0.25→1.0
-        if r2_c >= 0:
+        # Hard floor: if model is no better than random, confidence = 0
+        if r2_c <= 0 and dir_c <= 0.52:
+            return 0.0
+
+        # ── R² component (40% weight) ──
+        # Financial R²: 0.0→0, 0.05→0.40, 0.15→0.80, 0.25→1.0
+        if r2_c > 0:
             r2_norm = min(1.0, r2_c / 0.25)
         else:
-            # Negative R²: model worse than mean – still give partial credit
-            # R²=-0.5→0.10, R²=-2.0→0.0
-            r2_norm = max(0.0, 0.20 + r2_c * 0.10)
+            r2_norm = 0.0
 
-        # ── Direction component (40% weight) ──
-        # 50%→0.20, 52%→0.35, 55%→0.55, 60%→0.80, 65%→1.0
-        if dir_c >= 0.65:
+        # ── Direction component (60% weight) ──
+        # ≤52%→0, 55%→0.30, 60%→0.67, 65%→1.0
+        if dir_c <= 0.52:
+            dir_norm = 0.0
+        elif dir_c >= 0.65:
             dir_norm = 1.0
-        elif dir_c >= 0.50:
-            dir_norm = 0.2 + (dir_c - 0.50) / 0.15 * 0.8
         else:
-            # Below coin-flip → small credit for having a model at all
-            dir_norm = max(0.0, dir_c / 0.50 * 0.2)
-
-        # ── Base component (30% weight) ──
-        # Having a trained multi-model ensemble is itself valuable.
-        # This ensures minimum ~25-30 confidence for any working model.
-        base = 0.85
+            dir_norm = (dir_c - 0.52) / (0.65 - 0.52)
 
-        raw = r2_norm * 0.25 + dir_norm * 0.40 + base * 0.35
+        raw = r2_norm * 0.40 + dir_norm * 0.60
 
-        return max(10.0, min(95.0, raw * 100.0))
+        return max(0.0, min(95.0, raw * 100.0))
     except Exception:
-        return 15.0
+        return 0.0
 
 
 def _apply_shrinkage(predicted_change_pct: float, confidence_pct: float, days_ahead: int) -> float:
@@ -330,6 +326,10 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
         # Current price is the most recent close; prediction is for +days_ahead
         current_price = float(df['Close'].iloc[-1])
 
+        # ── Target clipping: cap extreme returns to prevent outlier-driven training ──
+        _clip_limit = 3.5 * float(np.sqrt(max(1, days_ahead)))  # ~9% for 7 days
+        y = np.clip(y, -_clip_limit, _clip_limit)
+
         # Final safety: ensure finite values for sklearn
         X = np.nan_to_num(X, nan=0.0, posinf=0.0, neginf=0.0)
         y = np.nan_to_num(y, nan=0.0, posinf=0.0, neginf=0.0)
@@ -345,66 +345,108 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
             val_start = split_idx  # fallback if not enough data for purge
         X_train, X_test = X_scaled[:split_idx], X_scaled[val_start:]
         y_train, y_test = y[:split_idx], y[val_start:]
-        
+
+        # ── Sample weighting: exponential recency (recent data 3x more important) ──
+        _n_train = len(X_train)
+        _sample_weights = np.exp(np.linspace(-1.0, 0.0, _n_train))
+
+        # ── Feature importance selection: reduce overfitting from high dimensionality ──
+        _n_keep = min(10, X_train.shape[1])
+        _selector_rf = RandomForestRegressor(
+            n_estimators=50, max_depth=4, min_samples_leaf=5,
+            max_features='sqrt', random_state=42, n_jobs=-1,
+        )
+        _selector_rf.fit(X_train, y_train, sample_weight=_sample_weights)
+        _importances = _selector_rf.feature_importances_
+        _top_feat_idx = np.argsort(_importances)[-_n_keep:]
+        X_train = X_train[:, _top_feat_idx]
+        X_test = X_test[:, _top_feat_idx]
+
         # Model seç ve eğit
         if model_type == 'xgboost' and XGBOOST_AVAILABLE:
             model = xgb.XGBRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                colsample_bytree=0.7,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                min_child_weight=5,
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
         elif model_type == 'lightgbm' and LIGHTGBM_AVAILABLE:
             model = lgb.LGBMRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                colsample_bytree=0.7,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                min_child_samples=10,
                 random_state=42,
                 n_jobs=-1,
-                verbose=-1
+                verbose=-1,
             )
         elif model_type == 'rf':
             model = RandomForestRegressor(
-                n_estimators=100,
-                max_depth=10,
+                n_estimators=200,
+                max_depth=3,
+                min_samples_split=10,
+                min_samples_leaf=5,
+                max_features='sqrt',
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
         elif model_type == 'ensemble':
-            # Ensemble: XGBoost + LightGBM + RandomForest
+            # Ensemble: XGBoost + LightGBM + RandomForest (regularized)
             models = []
             
             if XGBOOST_AVAILABLE:
                 xgb_model = xgb.XGBRegressor(
-                    n_estimators=80,
-                    max_depth=5,
-                    learning_rate=0.1,
+                    n_estimators=200,
+                    max_depth=3,
+                    learning_rate=0.03,
+                    subsample=0.8,
+                    colsample_bytree=0.7,
+                    reg_alpha=0.1,
+                    reg_lambda=1.0,
+                    min_child_weight=5,
                     random_state=42,
-                    n_jobs=-1
+                    n_jobs=-1,
                 )
-                xgb_model.fit(X_train, y_train)
+                xgb_model.fit(X_train, y_train, sample_weight=_sample_weights)
                 models.append(xgb_model)
             
             if LIGHTGBM_AVAILABLE:
                 lgb_model = lgb.LGBMRegressor(
-                    n_estimators=80,
-                    max_depth=5,
-                    learning_rate=0.1,
+                    n_estimators=200,
+                    max_depth=3,
+                    learning_rate=0.03,
+                    subsample=0.8,
+                    colsample_bytree=0.7,
+                    reg_alpha=0.1,
+                    reg_lambda=1.0,
+                    min_child_samples=10,
                     random_state=42,
                     n_jobs=-1,
-                    verbose=-1
+                    verbose=-1,
                 )
-                lgb_model.fit(X_train, y_train)
+                lgb_model.fit(X_train, y_train, sample_weight=_sample_weights)
                 models.append(lgb_model)
             
             rf_model = RandomForestRegressor(
-                n_estimators=80,
-                max_depth=10,
+                n_estimators=200,
+                max_depth=3,
+                min_samples_split=10,
+                min_samples_leaf=5,
+                max_features='sqrt',
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
-            rf_model.fit(X_train, y_train)
+            rf_model.fit(X_train, y_train, sample_weight=_sample_weights)
             models.append(rf_model)
             
             # Ensemble tahmin: ortalama
@@ -433,15 +475,18 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
                 
                 confidence_pct = _compute_confidence(r2, direction_correct)
                 
-                # Son tahmin (latest bar)
+                # Son tahmin (latest bar — apply same feature selection)
                 last_features_raw = np.nan_to_num(X_all[-1].reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0)
-                last_features = scaler_X.transform(last_features_raw)
+                last_features = scaler_X.transform(last_features_raw)[:, _top_feat_idx]
                 predictions_final = np.array([
                     float(np.asarray(m.predict(last_features), dtype=float).ravel()[0])
                     for m in models
                 ], dtype=float)
                 predicted_change = float(predictions_final.mean())  # already % return
 
+                # Base shrinkage: models overfit, shrink 70% toward zero
+                predicted_change *= 0.30
+
                 # Bayesian shrinkage: dampen extreme predictions when confidence is low
                 predicted_change = _apply_shrinkage(predicted_change, confidence_pct, days_ahead)
                 predicted_price = current_price * (1 + predicted_change / 100)
@@ -469,18 +514,23 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
                 return res
             else:
                 # Fallback to GradientBoosting if no advanced models
-                model = GradientBoostingRegressor(n_estimators=100, random_state=42)
+                model = GradientBoostingRegressor(
+                    n_estimators=200, max_depth=3, learning_rate=0.03,
+                    subsample=0.8, min_samples_split=10, random_state=42,
+                )
         else:
             # Default: GradientBoosting
             model = GradientBoostingRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
-                random_state=42
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                min_samples_split=10,
+                random_state=42,
             )
         
         # Tek model durumunda eğitim
-        model.fit(X_train, y_train)
+        model.fit(X_train, y_train, sample_weight=_sample_weights)
         
         # Test seti üzerinde performans (target is % return, no inverse transform)
         y_pred_test = np.asarray(model.predict(X_test), dtype=float)
@@ -505,11 +555,14 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
         # Convert to a UI-friendly 0-100 confidence score
         confidence_pct = _compute_confidence(r2, direction_correct)
         
-        # Tahmin yap (latest bar)
+        # Tahmin yap (latest bar — apply same feature selection)
         last_features_raw = np.nan_to_num(X_all[-1].reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0)
-        last_features = scaler_X.transform(last_features_raw)
+        last_features = scaler_X.transform(last_features_raw)[:, _top_feat_idx]
         predicted_change = float(np.asarray(model.predict(last_features), dtype=float).ravel()[0])  # already % return
 
+        # Base shrinkage: models overfit, shrink 70% toward zero
+        predicted_change *= 0.30
+
         # Bayesian shrinkage: dampen extreme predictions when confidence is low
         predicted_change = _apply_shrinkage(predicted_change, confidence_pct, days_ahead)
         predicted_price = current_price * (1 + predicted_change / 100)

analysis/walk_forward_backtest.py

@@ -297,6 +297,13 @@ def walk_forward_backtest(
     df_feat = add_macro_features(df_feat)
     df_feat["target_return"] = (df_feat["Close"].shift(-days_ahead) / df_feat["Close"] - 1) * 100.0
 
+    # Target clipping: cap extreme returns to prevent outlier-driven training
+    _target_clip = 3.5 * float(np.sqrt(max(1, days_ahead)))  # ~9% for 7 days
+    _extreme_mask = df_feat["target_return"].abs() > _target_clip
+    df_feat.loc[_extreme_mask, "target_return"] = np.clip(
+        df_feat.loc[_extreme_mask, "target_return"], -_target_clip, _target_clip,
+    )
+
     # Corporate action filter: poison target_return around suspected artifact days
     # so the model never trains on contaminated bedelsiz/bedelli/temettu data.
     _ca_suspect = flag_corp_action_days(df)
@@ -395,10 +402,13 @@ def walk_forward_backtest(
         X_test_s = scaler.transform(np.nan_to_num(X_test, nan=0.0, posinf=0.0, neginf=0.0))
 
         # --- Feature importance selection: train quick RF, keep top features ---
-        _sel_rf = RandomForestRegressor(n_estimators=80, max_depth=8, random_state=42, n_jobs=-1)
+        _sel_rf = RandomForestRegressor(
+            n_estimators=50, max_depth=4, min_samples_leaf=5,
+            max_features='sqrt', random_state=42, n_jobs=-1,
+        )
         _sel_rf.fit(X_train_s, y_train)
         importances = _sel_rf.feature_importances_
-        n_keep = min(25, len(FEATURES))
+        n_keep = min(10, len(FEATURES))
         top_idx = np.argsort(importances)[-n_keep:]
         X_train_s = X_train_s[:, top_idx]
         X_test_s = X_test_s[:, top_idx]
@@ -413,10 +423,14 @@ def walk_forward_backtest(
 
         # --- Ensemble of classifiers ---
         clf_rf = RandomForestClassifier(
-            n_estimators=200, max_depth=10, random_state=42, n_jobs=-1, class_weight="balanced"
+            n_estimators=200, max_depth=3, min_samples_split=10,
+            min_samples_leaf=5, max_features='sqrt',
+            random_state=42, n_jobs=-1, class_weight="balanced",
         )
         clf_gb = GradientBoostingClassifier(
-            n_estimators=150, max_depth=5, learning_rate=0.05, random_state=42
+            n_estimators=200, max_depth=3, learning_rate=0.03,
+            subsample=0.8, min_samples_split=10,
+            random_state=42,
         )
         clf_rf.fit(X_train_s, y_train_cls, sample_weight=sample_weights)
         clf_gb.fit(X_train_s, y_train_cls, sample_weight=sample_weights)
@@ -435,9 +449,17 @@ def walk_forward_backtest(
         # Also train regression model for magnitude estimate
         reg_model: Any
         if str(model_type).lower() == "rf":
-            reg_model = RandomForestRegressor(n_estimators=150, max_depth=10, random_state=42, n_jobs=-1)
+            reg_model = RandomForestRegressor(
+                n_estimators=200, max_depth=3, min_samples_split=10,
+                min_samples_leaf=5, max_features='sqrt',
+                random_state=42, n_jobs=-1,
+            )
         else:
-            reg_model = GradientBoostingRegressor(n_estimators=150, learning_rate=0.05, random_state=42)
+            reg_model = GradientBoostingRegressor(
+                n_estimators=200, max_depth=3, learning_rate=0.03,
+                subsample=0.8, min_samples_split=10,
+                random_state=42,
+            )
         reg_model.fit(X_train_s, y_train, sample_weight=sample_weights)
         y_pred_reg = np.asarray(reg_model.predict(X_test_s), dtype=float)
         r2 = float(r2_score(y_test, y_pred_reg))
@@ -457,6 +479,7 @@ def walk_forward_backtest(
             X_pred_row = scaler.transform(np.nan_to_num(row_t[FEATURES].to_numpy(dtype=float).reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0))
             X_pred_sel = X_pred_row[:, top_idx]
             reg_pred = float(np.asarray(reg_model.predict(X_pred_sel), dtype=float).ravel()[0])
+            reg_pred *= 0.30  # Base shrinkage: 70% toward zero
             predicted_change = float(_apply_shrinkage(reg_pred, confidence_pct, days_ahead))
             ml_signal = "HOLD"  # Model not confident enough
             _current_prob_up = 0.5
@@ -472,6 +495,7 @@ def walk_forward_backtest(
 
             # Regression for magnitude
             reg_pred = float(np.asarray(reg_model.predict(X_pred_sel), dtype=float).ravel()[0])
+            reg_pred *= 0.30  # Base shrinkage: 70% toward zero
             predicted_change = float(_apply_shrinkage(reg_pred, confidence_pct, days_ahead))
 
             # Signal from classification probability — RAISED thresholds for higher conviction

com.borsa.scan-bist.plist

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.borsa.scan-bist</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space/.venv/bin/python</string>
+    <string>run_bist100_scan.py</string>
+    <string>--force</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PYTHONPATH</key>
+    <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space</string>
+    <key>PYTHONUNBUFFERED</key>
+    <string>1</string>
+  </dict>
+
+  <!-- Run every Sunday at 18:00 local time -->
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Weekday</key>
+    <integer>0</integer>
+    <key>Hour</key>
+    <integer>18</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>/Users/onerozbey/Library/Logs/borsa-trading-worker/scan_bist_stdout.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>/Users/onerozbey/Library/Logs/borsa-trading-worker/scan_bist_stderr.log</string>
+
+  <key>Nice</key>
+  <integer>10</integer>
+</dict>
+</plist>

com.borsa.scan-us.plist

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.borsa.scan-us</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space/.venv/bin/python</string>
+    <string>run_us_scan.py</string>
+    <string>--force</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PYTHONPATH</key>
+    <string>/Users/onerozbey/borsa_uygulamasi_runtime/huggingface-space</string>
+    <key>PYTHONUNBUFFERED</key>
+    <string>1</string>
+  </dict>
+
+  <!-- Run every Sunday at 23:00 local time (after BIST scan finishes) -->
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Weekday</key>
+    <integer>0</integer>
+    <key>Hour</key>
+    <integer>23</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>/Users/onerozbey/Library/Logs/borsa-trading-worker/scan_us_stdout.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>/Users/onerozbey/Library/Logs/borsa-trading-worker/scan_us_stderr.log</string>
+
+  <key>Nice</key>
+  <integer>10</integer>
+</dict>
+</plist>

com.borsa.trading-worker-us.plist

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.borsa.trading-worker-us</string>
+
+        <!--
+            US market worker LaunchAgent.
+            Runs the worker daemon with --market us for NYSE/NASDAQ/SP100.
+            The worker enforces US market hours (16:30 TR / 13:30 UTC open).
+
+            Use install_launchagent.sh (or the install steps below) to load:
+              cp com.borsa.trading-worker-us.plist ~/Library/LaunchAgents/
+              launchctl load ~/Library/LaunchAgents/com.borsa.trading-worker-us.plist
+        -->
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/bin/env</string>
+        <string>python3</string>
+        <string>-m</string>
+        <string>trading.worker</string>
+        <string>--daemon</string>
+        <string>--mode</string>
+        <string>paper</string>
+        <string>--interval</string>
+        <string>60</string>
+        <string>--market</string>
+        <string>us</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>/PATH/TO/borsa_uygulamasi</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>/PATH/TO/borsa_uygulamasi/paper_trading/markets/us/worker_stdout.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/PATH/TO/borsa_uygulamasi/paper_trading/markets/us/worker_stderr.log</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PYTHONPATH</key>
+        <string>/PATH/TO/borsa_uygulamasi</string>
+        <key>PYTHONUNBUFFERED</key>
+        <string>1</string>
+    </dict>
+
+    <key>KeepAlive</key>
+    <true/>
+</dict>
+</plist>

huggingface-space/_test_us_audit.py

@@ -0,0 +1,595 @@
+#!/usr/bin/env python3
+"""Ruthless US market audit script."""
+import sys, json, os, sqlite3, traceback
+from pathlib import Path
+from datetime import datetime, timezone
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+PASS = "✅ PASS"
+FAIL = "❌ FAIL"
+WARN = "⚠️  WARN"
+results = []
+
+def check(name, expr_fn):
+    try:
+        msg = expr_fn()
+        if msg is None:
+            results.append((PASS, name, "OK"))
+            return True
+        elif isinstance(msg, str) and msg.startswith("WARN:"):
+            results.append((WARN, name, msg[5:].strip()))
+            return True
+        else:
+            results.append((PASS, name, str(msg)))
+            return True
+    except AssertionError as e:
+        results.append((FAIL, name, str(e)))
+        return False
+    except Exception as e:
+        results.append((FAIL, name, f"{type(e).__name__}: {e}"))
+        return False
+
+# ─────────────────────────────────────────────
+# SECTION 1: MarketConfig
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 1: MarketConfig")
+print("="*60)
+
+def test_market_config():
+    from trading.market_registry import get_market_config
+    cfg = get_market_config("us")
+    assert cfg.market_id == "us", f"market_id={cfg.market_id}"
+    assert cfg.currency == "USD", f"currency={cfg.currency}"
+    assert cfg.timezone == "America/New_York", f"tz={cfg.timezone}"
+    assert cfg.run_start_hour == 9, f"run_start_hour={cfg.run_start_hour}"
+    assert cfg.run_end_hour == 16, f"run_end_hour={cfg.run_end_hour}"
+    assert cfg.scan_start_hour == 17, f"scan_start_hour={cfg.scan_start_hour}"
+    assert cfg.scan_start_minute == 0
+    return f"USD, 09:30-16:00 ET, scan@17:00"
+
+check("1.1 MarketConfig basic fields", test_market_config)
+
+def test_scan_path():
+    from trading.market_registry import get_scan_results_path
+    p = get_scan_results_path("us", completed=True)
+    assert "markets/us" in str(p), f"wrong path: {p}"
+    assert p.name == "scan_results.json", f"wrong filename: {p.name}"
+    return f"path={p}, exists={p.exists()}"
+
+check("1.2 get_scan_results_path for US", test_scan_path)
+
+def test_db_path():
+    from trading.market_registry import get_trading_db_path
+    p = get_trading_db_path("us")
+    assert "markets/us" in str(p), f"wrong path: {p}"
+    assert p.name == "trading.db"
+    return f"path={p}, exists={p.exists()}"
+
+check("1.3 get_trading_db_path for US", test_db_path)
+
+def test_market_open():
+    from trading.market_registry import is_market_open_window
+    from datetime import timezone
+    now = datetime.now(timezone.utc)
+    result = is_market_open_window("us", now_utc=now)
+    # Just verify it returns bool without crashing
+    assert isinstance(result, bool)
+    return f"is_open={result} (UTC {now.strftime('%H:%M')})"
+
+check("1.4 is_market_open_window US", test_market_open)
+
+# ─────────────────────────────────────────────
+# SECTION 2: Universe Fetcher
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 2: US Universe Fetcher")
+print("="*60)
+
+def test_universe_fallback():
+    # run_us_scan.py is right here
+    from run_us_scan import _SP100_FALLBACK, get_universe
+    assert len(_SP100_FALLBACK) == 100, f"SP100 fallback has {len(_SP100_FALLBACK)} symbols (expected 100)"
+    # Check no duplicates
+    assert len(set(_SP100_FALLBACK)) == len(_SP100_FALLBACK), "Duplicates in fallback list"
+    return f"fallback has {len(_SP100_FALLBACK)} unique symbols"
+
+check("2.1 SP100 fallback list has 100 unique symbols", test_universe_fallback)
+
+def test_get_universe_returns_symbols():
+    from run_us_scan import get_universe
+    # Use fallback path (will try Wikipedia first but fallback if needed)
+    import run_us_scan as m
+    orig = m._fetch_universe_from_wikipedia
+    m._fetch_universe_from_wikipedia = lambda name: []  # force fallback
+    try:
+        syms = get_universe("sp100")
+        assert len(syms) >= 90, f"Too few symbols: {len(syms)}"
+        assert all(isinstance(s, str) and len(s) <= 5 for s in syms), "Bad symbol format"
+    finally:
+        m._fetch_universe_from_wikipedia = orig
+    return f"fallback returns {len(syms)} symbols"
+
+check("2.2 get_universe fallback path works", test_get_universe_returns_symbols)
+
+def test_result_persistence():
+    from run_us_scan import FINAL_RESULTS_FILE, _load_results
+    data = _load_results()
+    assert isinstance(data, dict)
+    assert "stage1" in data
+    assert "stage2" in data
+    return f"file={'exists' if FINAL_RESULTS_FILE.exists() else 'missing'}, stage1={len(data['stage1'])}, stage2={len(data['stage2'])}"
+
+check("2.3 _load_results works", test_result_persistence)
+
+# ─────────────────────────────────────────────
+# SECTION 3: Scan Results Quality
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 3: Scan Results Quality")
+print("="*60)
+
+def test_scan_results_format():
+    scan_file = Path("paper_trading/markets/us/scan_results.json")
+    if not scan_file.exists():
+        raise AssertionError("scan_results.json does not exist")
+    data = json.loads(scan_file.read_text())
+    assert data.get("market_id") == "us", f"market_id={data.get('market_id')}"
+    assert data.get("completed") is True, "scan not completed"
+    s1 = data.get("stage1", {})
+    s2 = data.get("stage2", {})
+    return f"stage1={len(s1)}, stage2={len(s2)}, universe={data.get('universe')}"
+
+check("3.1 scan_results.json exists and is completed", test_scan_results_format)
+
+def test_scan_has_enough_symbols():
+    scan_file = Path("paper_trading/markets/us/scan_results.json")
+    if not scan_file.exists():
+        raise AssertionError("scan_results.json missing")
+    data = json.loads(scan_file.read_text())
+    s1 = data.get("stage1", {})
+    total = len(s1)
+    # A real sp100 scan should have at least 50 symbols
+    if total < 10:
+        raise AssertionError(f"Only {total} symbols in stage1 — scan was a test run, NOT a full SP100 scan! universekey={data.get('universe_key')}")
+    if total < 80:
+        return f"WARN: only {total} stage1 symbols — partial scan?"
+    return f"{total} stage1 symbols scanned"
+
+check("3.2 Scan covers enough SP100 symbols", test_scan_has_enough_symbols)
+
+def test_scan_eligible_symbols_field():
+    scan_file = Path("paper_trading/markets/us/scan_results.json")
+    if not scan_file.exists():
+        raise AssertionError("scan_results.json missing")
+    data = json.loads(scan_file.read_text())
+    # New run_us_scan.py sets eligible_symbols
+    el = data.get("eligible_symbols")
+    ec = data.get("eligible_count")
+    # compute from stage2 as fallback
+    stage2 = data.get("stage2", {})
+    computed_eligible = [s for s, v in stage2.items() if v.get("eligible")]
+    if el is None:
+        return f"WARN: eligible_symbols field missing — old scan format (from scanner_engine.py); computed from stage2: {len(computed_eligible)}"
+    assert isinstance(el, list), f"eligible_symbols not a list: {type(el)}"
+    assert ec == len(el), f"eligible_count={ec} != len(eligible_symbols)={len(el)}"
+    return f"{len(el)} eligible symbols"
+
+check("3.3 eligible_symbols field present and correct", test_scan_eligible_symbols_field)
+
+def test_scan_eligible_via_app_logic():
+    """Simulate how app.py get_eligible_stocks reads the file."""
+    scan_file = Path("paper_trading/markets/us/scan_results.json")
+    if not scan_file.exists():
+        raise AssertionError("scan_results.json missing")
+    data = json.loads(scan_file.read_text())
+    stage2 = data.get("stage2") or {}
+    eligible = [s for s, v in stage2.items() if v.get("eligible")]
+    excluded = [s for s, v in stage2.items() if not v.get("eligible")]
+    stage1 = data.get("stage1") or {}
+    s1_pass = [s for s, v in stage1.items() if v.get("passed")]
+    s1_fail = [s for s, v in stage1.items() if not v.get("passed")]
+    if len(eligible) == 0 and len(stage2) > 0:
+        raise AssertionError(f"0 eligible stocks from {len(stage2)} stage2 — suspicious!")
+    return f"stage1: {len(s1_pass)} pass / {len(s1_fail)} fail | stage2: {len(eligible)} eligible / {len(excluded)} excluded | eligible: {eligible[:5]}"
+
+check("3.4 Eligible stocks readable via app logic", test_scan_eligible_via_app_logic)
+
+# ─────────────────────────────────────────────
+# SECTION 4: Auto-Trader State
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 4: Auto-Trader State")
+print("="*60)
+
+def test_state_file():
+    state_file = Path("paper_trading/markets/us/auto_trader/state.json")
+    if not state_file.exists():
+        raise AssertionError("state.json missing")
+    state = json.loads(state_file.read_text())
+    assert state.get("market_id") == "us", f"market_id={state.get('market_id')}"
+    cash = float(state.get("broker_cash", 0))
+    assert cash > 0, f"cash={cash} (zero?)"
+    return f"cash=${cash:,.2f}, total_trades={state.get('total_trades')}, days_run={state.get('total_days_run')}"
+
+check("4.1 state.json exists with correct market_id", test_state_file)
+
+def test_status_file():
+    status_file = Path("paper_trading/markets/us/auto_trader/status.json")
+    if not status_file.exists():
+        raise AssertionError("status.json missing")
+    s = json.loads(status_file.read_text())
+    mkt = s.get("market_id")
+    if mkt and mkt != "us":
+        raise AssertionError(f"status.json market_id={mkt} (should be 'us')")
+    return f"status={s.get('status')}, is_running={s.get('is_running')}"
+
+check("4.2 status.json exists", test_status_file)
+
+def test_no_bist_state_confusion():
+    """State should not have BIST-specific fields crossed in."""
+    state_file = Path("paper_trading/markets/us/auto_trader/state.json")
+    if not state_file.exists():
+        return "WARN: state.json missing — skip"
+    state = json.loads(state_file.read_text())
+    # positions should not contain .IS symbol suffixes
+    positions = state.get("broker_positions", {})
+    bist_positions = [s for s in positions if s.endswith(".IS")]
+    if bist_positions:
+        raise AssertionError(f"US portfolio has BIST symbols: {bist_positions}")
+    return f"{len(positions)} open positions, no BIST contamination"
+
+check("4.3 No BIST symbols in US portfolio", test_no_bist_state_confusion)
+
+def test_initial_cash():
+    """initial_cash should be set (needed for pnlPct calc)."""
+    state_file = Path("paper_trading/markets/us/auto_trader/state.json")
+    if not state_file.exists():
+        raise AssertionError("state.json missing")
+    state = json.loads(state_file.read_text())
+    ic = state.get("initial_cash")
+    if ic is None:
+        return "WARN: initial_cash not in state.json — pnlPct will use hardcoded fallback 100000"
+    assert float(ic) > 0
+    return f"initial_cash=${float(ic):,.0f}"
+
+check("4.4 initial_cash field in state.json", test_initial_cash)
+
+# ─────────────────────────────────────────────
+# SECTION 5: Trading DB
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 5: US Trading Database")
+print("="*60)
+
+def test_db_exists():
+    db = Path("paper_trading/markets/us/trading.db")
+    if not db.exists():
+        raise AssertionError("trading.db missing")
+    con = sqlite3.connect(db)
+    tables = {t[0] for t in con.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
+    required = {"trades", "daily_snapshots", "signals_log"}
+    missing = required - tables
+    if missing:
+        raise AssertionError(f"Missing tables: {missing}")
+    con.close()
+    return f"tables: {sorted(tables)}"
+
+check("5.1 trading.db exists with required tables", test_db_exists)
+
+def test_db_trades():
+    db = Path("paper_trading/markets/us/trading.db")
+    if not db.exists():
+        raise AssertionError("trading.db missing")
+    con = sqlite3.connect(db)
+    trades = con.execute("SELECT * FROM trades LIMIT 20").fetchall()
+    cols = [d[0] for d in con.execute("PRAGMA table_info(trades)").fetchall()]
+    con.close()
+    if len(trades) == 0:
+        return "WARN: 0 trades in DB (no trades yet)"
+    # Check the trades don't have BIST symbols
+    if "symbol" in cols:
+        si = cols.index("symbol")
+    else:
+        si = 1  # fallback
+    symbols = [t[si] for t in trades]
+    bist_trades = [s for s in symbols if str(s).endswith(".IS")]
+    if bist_trades:
+        raise AssertionError(f"US DB has BIST symbol trades: {bist_trades}")
+    return f"{len(trades)} trades: {list(set(symbols))}"
+
+check("5.2 No BIST symbols in US trades", test_db_trades)
+
+def test_db_snapshots():
+    db = Path("paper_trading/markets/us/trading.db")
+    if not db.exists():
+        raise AssertionError("trading.db missing")
+    con = sqlite3.connect(db)
+    snaps = con.execute("SELECT * FROM daily_snapshots ORDER BY id DESC LIMIT 5").fetchall()
+    cols = [d[0] for d in con.execute("PRAGMA table_info(daily_snapshots)").fetchall()]
+    con.close()
+    if len(snaps) == 0:
+        return "WARN: 0 snapshots in DB"
+    latest = dict(zip(cols, snaps[0]))
+    eq = latest.get("equity", latest.get("total_equity", 0))
+    return f"{len(snaps)} snapshots, latest equity=${float(eq or 0):,.2f}"
+
+check("5.3 Daily snapshots in US DB", test_db_snapshots)
+
+# ─────────────────────────────────────────────
+# SECTION 6: Kill Switch
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 6: Kill Switch Logic")
+print("="*60)
+
+def test_kill_switch_path():
+    # Path from app.py: market_dir / ".kill_switch"
+    kill_path = Path("paper_trading/markets/us/.kill_switch")
+    # It should NOT exist (kill switch inactive)
+    if kill_path.exists():
+        content = json.loads(kill_path.read_text())
+        if content.get("active"):
+            raise AssertionError(f"US kill switch is ACTIVE: {content}")
+        return f"WARN: kill switch file exists but active=False: {content}"
+    return "kill switch not active (file absent) — OK"
+
+check("6.1 US kill switch inactive", test_kill_switch_path)
+
+def test_kill_switch_read():
+    """Simulate build_market_snapshot reading kill switch for US."""
+    kill_path = Path("paper_trading/markets/us/.kill_switch")
+    kill_switch = None
+    if kill_path.exists():
+        try:
+            kill_switch = json.loads(kill_path.read_text())
+        except Exception:
+            pass
+    active = (kill_switch or {}).get("active", False)
+    reason = (kill_switch or {}).get("reason")
+    assert isinstance(active, bool)
+    return f"killSwitchActive={active}, reason={reason}"
+
+check("6.2 Kill switch read logic works", test_kill_switch_read)
+
+# ─────────────────────────────────────────────
+# SECTION 7: app.py build_market_snapshot for US
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 7: app.py build_market_snapshot for US")
+print("="*60)
+
+def test_snapshot_import():
+    # Check the app.py can be imported (FastAPI won't start, just test imports)
+    # We'll test the utility functions only
+    from trading.market_registry import get_market_config, get_scan_results_path
+    from trading.db_store import TradingStore
+    cfg = get_market_config("us")
+    assert cfg.currency == "USD"
+    return "market_registry and TradingStore importable"
+
+check("7.1 Core modules importable", test_snapshot_import)
+
+def test_snapshot_pnl_calc():
+    """Test the pnlPct formula with initial_cash from state."""
+    state_file = Path("paper_trading/markets/us/auto_trader/state.json")
+    if not state_file.exists():
+        raise AssertionError("state.json missing")
+    state = json.loads(state_file.read_text())
+    # Simulate what app.py now does
+    equity_value = float(state.get("broker_cash", 100000))
+    initial_cash_base = float((state or {}).get("initial_cash", 100000) or 100000)
+    pnl_pct = round(((equity_value / initial_cash_base - 1) * 100), 2) if equity_value and initial_cash_base > 0 else 0
+    return f"equity=${equity_value:,.2f}, initial_cash=${initial_cash_base:,.0f}, pnlPct={pnl_pct}%"
+
+check("7.2 pnlPct calc uses initial_cash correctly", test_snapshot_pnl_calc)
+
+def test_currency_label():
+    """Simulate currency and label selection."""
+    from trading.market_registry import DEFAULT_MARKET_ID
+    market_id = "us"
+    currency = "USD" if market_id != DEFAULT_MARKET_ID else "TRY"
+    label = "US Equities" if market_id != DEFAULT_MARKET_ID else "Borsa Istanbul"
+    assert currency == "USD"
+    assert label == "US Equities"
+    return f"currency={currency}, label={label}"
+
+check("7.3 Currency and label for US", test_currency_label)
+
+def test_db_store_reads():
+    """Test TradingStore reads for US DB."""
+    from trading.db_store import TradingStore
+    db = Path("paper_trading/markets/us/trading.db")
+    if not db.exists():
+        raise AssertionError("trading.db missing")
+    store = TradingStore(db_path=str(db))
+    trades = store.get_all_trades()
+    equity = store.get_equity_curve()
+    signals = store.get_signals(limit=100)
+    return f"trades={len(trades)}, equity_points={len(equity)}, signals={len(signals)}"
+
+check("7.4 TradingStore reads from US DB", test_db_store_reads)
+
+# ─────────────────────────────────────────────
+# SECTION 8: Scheduler Wiring
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 8: Scheduler Wiring Check")
+print("="*60)
+
+def test_scheduler_function_exists():
+    """Verify _daily_us_scan_scheduler exists in app module without starting it."""
+    import ast
+    app_src = Path("app.py").read_text()
+    tree = ast.parse(app_src)
+    fns = [n.name for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]
+    assert "_daily_us_scan_scheduler" in fns, f"not found; available: {[f for f in fns if 'sched' in f.lower() or 'us' in f.lower()]}"
+    assert "_daily_scan_scheduler" in fns, "BIST scheduler missing"
+    assert "_ensure_background_services_started" in fns
+    return f"schedulers: {[f for f in fns if 'sched' in f.lower()]}"
+
+check("8.1 _daily_us_scan_scheduler defined in app.py", test_scheduler_function_exists)
+
+def test_us_scheduler_thread_global():
+    """Verify _us_scheduler_thread global exists in app.py."""
+    app_src = Path("app.py").read_text()
+    assert "_us_scheduler_thread" in app_src, "_us_scheduler_thread not found in app.py"
+    assert "_us_scheduler_thread = None" in app_src, "thread not initialized to None"
+    return "global defined and initialized"
+
+check("8.2 _us_scheduler_thread global in app.py", test_us_scheduler_thread_global)
+
+def test_ensure_starts_us_scheduler():
+    """Verify _ensure_background_services_started starts US thread."""
+    app_src = Path("app.py").read_text()
+    assert "target=_daily_us_scan_scheduler" in app_src, "US scheduler not started in _ensure"
+    # Check it also checks .is_alive()
+    assert "_us_scheduler_thread.is_alive()" in app_src
+    return "US scheduler started in _ensure_background_services_started"
+
+check("8.3 _ensure_background_services_started starts US scheduler", test_ensure_starts_us_scheduler)
+
+def test_us_scan_hour():
+    """Verify US scan hour is 17:00 ET."""
+    app_src = Path("app.py").read_text()
+    assert "US_SCAN_HOUR_ET = 17" in app_src, "US_SCAN_HOUR_ET not 17"
+    assert "America/New_York" in app_src
+    return "US_SCAN_HOUR_ET=17, America/New_York timezone"
+
+check("8.4 US scan scheduled at 17:00 ET", test_us_scan_hour)
+
+# ─────────────────────────────────────────────
+# SECTION 9: run_us_scan module
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 9: run_us_scan.py module integrity")
+print("="*60)
+
+def test_run_us_scan_importable():
+    import run_us_scan
+    assert hasattr(run_us_scan, "run_scan")
+    assert hasattr(run_us_scan, "get_universe")
+    assert hasattr(run_us_scan, "stage1_prefilter")
+    assert hasattr(run_us_scan, "stage2_backtest")
+    assert hasattr(run_us_scan, "FINAL_RESULTS_FILE")
+    assert "markets/us/scan_results.json" in str(run_us_scan.FINAL_RESULTS_FILE)
+    return "all required functions present"
+
+check("9.1 run_us_scan.py importable with correct API", test_run_us_scan_importable)
+
+def test_run_us_scan_stage1_single():
+    """Run stage1_prefilter on AAPL (fast, just yfinance download)."""
+    from run_us_scan import stage1_prefilter
+    result = stage1_prefilter("AAPL")
+    assert "passed" in result
+    assert "avg_volume" in result
+    assert "last_price" in result
+    assert result.get("symbol") == "AAPL"
+    passed = result.get("passed")
+    price = result.get("last_price", 0)
+    vol = result.get("avg_volume", 0)
+    if not passed:
+        raise AssertionError(f"AAPL failed stage1: {result.get('reason')} (price={price}, vol={vol})")
+    return f"AAPL passed: price=${price:.0f}, avg_vol={vol:,.0f}"
+
+check("9.2 stage1_prefilter(AAPL) passes", test_run_us_scan_stage1_single)
+
+def test_run_us_scan_run_fn_signature():
+    """run_scan signature must match what app.py calls."""
+    import inspect, run_us_scan
+    sig = inspect.signature(run_us_scan.run_scan)
+    params = list(sig.parameters.keys())
+    assert "universe" in params, f"missing 'universe' param: {params}"
+    assert "force" in params, f"missing 'force' param: {params}"
+    assert "stage1_only" in params, f"missing 'stage1_only' param: {params}"
+    defaults = {k: v.default for k, v in sig.parameters.items() if v.default is not inspect.Parameter.empty}
+    assert defaults.get("universe") == "sp100", f"default universe={defaults.get('universe')}"
+    return f"signature OK: {params}"
+
+check("9.3 run_scan signature matches app.py call", test_run_us_scan_stage1_single_sig := test_run_us_scan_run_fn_signature)
+
+# ─────────────────────────────────────────────
+# SECTION 10: Portfolio Isolation
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("SECTION 10: BIST vs US Portfolio Isolation")
+print("="*60)
+
+def test_separate_db_files():
+    bist_db = Path("paper_trading/trading.db")
+    us_db = Path("paper_trading/markets/us/trading.db")
+    assert bist_db.exists(), "BIST trading.db missing"
+    assert us_db.exists(), "US trading.db missing"
+    assert bist_db != us_db, "Same DB file for both markets!"
+    return f"BIST: {bist_db}, US: {us_db}"
+
+check("10.1 Separate trading.db files for each market", test_separate_db_files)
+
+def test_separate_state_files():
+    bist_state = Path("paper_trading/auto_trader/state.json")
+    us_state = Path("paper_trading/markets/us/auto_trader/state.json")
+    if not bist_state.exists():
+        return "WARN: BIST state.json missing"
+    if not us_state.exists():
+        raise AssertionError("US state.json missing")
+    bist_data = json.loads(bist_state.read_text())
+    us_data = json.loads(us_state.read_text())
+    b_cash = bist_data.get("broker_cash", 0)
+    u_cash = us_data.get("broker_cash", 0)
+    # Verify market_id tags
+    b_mkt = bist_data.get("market_id", "bist")
+    u_mkt = us_data.get("market_id", "?")
+    assert u_mkt == "us", f"US state market_id={u_mkt}"
+    return f"BIST cash=₺{b_cash:,.0f} ({b_mkt}), US cash=${u_cash:,.0f} ({u_mkt})"
+
+check("10.2 Separate state.json files with correct market_id", test_separate_state_files)
+
+def test_no_state_leakage():
+    """BIST state should not exist inside US directory and vice versa."""
+    us_dir = Path("paper_trading/markets/us")
+    # Should not have bist100_scan_results.json inside US dir
+    wrong_files = ["bist100_scan_results.json", "bist100_scan_results_work.json"]
+    found = [f for f in wrong_files if (us_dir / f).exists()]
+    if found:
+        raise AssertionError(f"BIST scan files in US dir: {found}")
+    # US scan file should not be in BIST root
+    bist_root = Path("paper_trading")
+    us_scan_in_root = (bist_root / "scan_results.json").exists()
+    if us_scan_in_root:
+        return "WARN: scan_results.json exists in BIST root (could be US file leakage)"
+    return "No cross-market file leakage"
+
+check("10.3 No cross-market file contamination", test_no_state_leakage)
+
+# ─────────────────────────────────────────────
+# SUMMARY
+# ─────────────────────────────────────────────
+print("\n" + "="*60)
+print("AUDIT SUMMARY")
+print("="*60)
+
+passed = [r for r in results if r[0] == PASS]
+warned = [r for r in results if r[0] == WARN]
+failed = [r for r in results if r[0] == FAIL]
+
+print(f"\n{PASS} {len(passed)} passed")
+print(f"{WARN} {len(warned)} warnings")
+print(f"{FAIL} {len(failed)} failed")
+print()
+
+if warned:
+    print("WARNINGS:")
+    for _, name, msg in warned:
+        print(f"  {WARN} {name}: {msg}")
+    print()
+
+if failed:
+    print("FAILURES:")
+    for _, name, msg in failed:
+        print(f"  {FAIL} {name}: {msg}")
+    print()
+
+all_r = [(s, n, m) for s, n, m in results]
+for s, n, m in all_r:
+    print(f"  {s} {n}: {m}")

huggingface-space/ai/predictions_api.py

@@ -79,35 +79,31 @@ def _compute_confidence(r2: float, direction_correct: float) -> float:
         r2_c = float(r2) if np.isfinite(r2) else 0.0
         dir_c = float(direction_correct) if np.isfinite(direction_correct) else 0.5
 
-        # ── R² component (30% weight) ──
-        # Financial R²: 0.0→0.25, 0.05→0.50, 0.15→0.85, 0.25→1.0
-        if r2_c >= 0:
+        # Hard floor: if model is no better than random, confidence = 0
+        if r2_c <= 0 and dir_c <= 0.52:
+            return 0.0
+
+        # ── R² component (40% weight) ──
+        # Financial R²: 0.0→0, 0.05→0.40, 0.15→0.80, 0.25→1.0
+        if r2_c > 0:
             r2_norm = min(1.0, r2_c / 0.25)
         else:
-            # Negative R²: model worse than mean – still give partial credit
-            # R²=-0.5→0.10, R²=-2.0→0.0
-            r2_norm = max(0.0, 0.20 + r2_c * 0.10)
+            r2_norm = 0.0
 
-        # ── Direction component (40% weight) ──
-        # 50%→0.20, 52%→0.35, 55%→0.55, 60%→0.80, 65%→1.0
-        if dir_c >= 0.65:
+        # ── Direction component (60% weight) ──
+        # ≤52%→0, 55%→0.30, 60%→0.67, 65%→1.0
+        if dir_c <= 0.52:
+            dir_norm = 0.0
+        elif dir_c >= 0.65:
             dir_norm = 1.0
-        elif dir_c >= 0.50:
-            dir_norm = 0.2 + (dir_c - 0.50) / 0.15 * 0.8
         else:
-            # Below coin-flip → small credit for having a model at all
-            dir_norm = max(0.0, dir_c / 0.50 * 0.2)
-
-        # ── Base component (30% weight) ──
-        # Having a trained multi-model ensemble is itself valuable.
-        # This ensures minimum ~25-30 confidence for any working model.
-        base = 0.85
+            dir_norm = (dir_c - 0.52) / (0.65 - 0.52)
 
-        raw = r2_norm * 0.25 + dir_norm * 0.40 + base * 0.35
+        raw = r2_norm * 0.40 + dir_norm * 0.60
 
-        return max(10.0, min(95.0, raw * 100.0))
+        return max(0.0, min(95.0, raw * 100.0))
     except Exception:
-        return 15.0
+        return 0.0
 
 
 def _apply_shrinkage(predicted_change_pct: float, confidence_pct: float, days_ahead: int) -> float:
@@ -330,6 +326,10 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
         # Current price is the most recent close; prediction is for +days_ahead
         current_price = float(df['Close'].iloc[-1])
 
+        # ── Target clipping: cap extreme returns to prevent outlier-driven training ──
+        _clip_limit = 3.5 * float(np.sqrt(max(1, days_ahead)))  # ~9% for 7 days
+        y = np.clip(y, -_clip_limit, _clip_limit)
+
         # Final safety: ensure finite values for sklearn
         X = np.nan_to_num(X, nan=0.0, posinf=0.0, neginf=0.0)
         y = np.nan_to_num(y, nan=0.0, posinf=0.0, neginf=0.0)
@@ -345,66 +345,108 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
             val_start = split_idx  # fallback if not enough data for purge
         X_train, X_test = X_scaled[:split_idx], X_scaled[val_start:]
         y_train, y_test = y[:split_idx], y[val_start:]
-        
+
+        # ── Sample weighting: exponential recency (recent data 3x more important) ──
+        _n_train = len(X_train)
+        _sample_weights = np.exp(np.linspace(-1.0, 0.0, _n_train))
+
+        # ── Feature importance selection: reduce overfitting from high dimensionality ──
+        _n_keep = min(10, X_train.shape[1])
+        _selector_rf = RandomForestRegressor(
+            n_estimators=50, max_depth=4, min_samples_leaf=5,
+            max_features='sqrt', random_state=42, n_jobs=-1,
+        )
+        _selector_rf.fit(X_train, y_train, sample_weight=_sample_weights)
+        _importances = _selector_rf.feature_importances_
+        _top_feat_idx = np.argsort(_importances)[-_n_keep:]
+        X_train = X_train[:, _top_feat_idx]
+        X_test = X_test[:, _top_feat_idx]
+
         # Model seç ve eğit
         if model_type == 'xgboost' and XGBOOST_AVAILABLE:
             model = xgb.XGBRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                colsample_bytree=0.7,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                min_child_weight=5,
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
         elif model_type == 'lightgbm' and LIGHTGBM_AVAILABLE:
             model = lgb.LGBMRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                colsample_bytree=0.7,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                min_child_samples=10,
                 random_state=42,
                 n_jobs=-1,
-                verbose=-1
+                verbose=-1,
             )
         elif model_type == 'rf':
             model = RandomForestRegressor(
-                n_estimators=100,
-                max_depth=10,
+                n_estimators=200,
+                max_depth=3,
+                min_samples_split=10,
+                min_samples_leaf=5,
+                max_features='sqrt',
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
         elif model_type == 'ensemble':
-            # Ensemble: XGBoost + LightGBM + RandomForest
+            # Ensemble: XGBoost + LightGBM + RandomForest (regularized)
             models = []
             
             if XGBOOST_AVAILABLE:
                 xgb_model = xgb.XGBRegressor(
-                    n_estimators=80,
-                    max_depth=5,
-                    learning_rate=0.1,
+                    n_estimators=200,
+                    max_depth=3,
+                    learning_rate=0.03,
+                    subsample=0.8,
+                    colsample_bytree=0.7,
+                    reg_alpha=0.1,
+                    reg_lambda=1.0,
+                    min_child_weight=5,
                     random_state=42,
-                    n_jobs=-1
+                    n_jobs=-1,
                 )
-                xgb_model.fit(X_train, y_train)
+                xgb_model.fit(X_train, y_train, sample_weight=_sample_weights)
                 models.append(xgb_model)
             
             if LIGHTGBM_AVAILABLE:
                 lgb_model = lgb.LGBMRegressor(
-                    n_estimators=80,
-                    max_depth=5,
-                    learning_rate=0.1,
+                    n_estimators=200,
+                    max_depth=3,
+                    learning_rate=0.03,
+                    subsample=0.8,
+                    colsample_bytree=0.7,
+                    reg_alpha=0.1,
+                    reg_lambda=1.0,
+                    min_child_samples=10,
                     random_state=42,
                     n_jobs=-1,
-                    verbose=-1
+                    verbose=-1,
                 )
-                lgb_model.fit(X_train, y_train)
+                lgb_model.fit(X_train, y_train, sample_weight=_sample_weights)
                 models.append(lgb_model)
             
             rf_model = RandomForestRegressor(
-                n_estimators=80,
-                max_depth=10,
+                n_estimators=200,
+                max_depth=3,
+                min_samples_split=10,
+                min_samples_leaf=5,
+                max_features='sqrt',
                 random_state=42,
-                n_jobs=-1
+                n_jobs=-1,
             )
-            rf_model.fit(X_train, y_train)
+            rf_model.fit(X_train, y_train, sample_weight=_sample_weights)
             models.append(rf_model)
             
             # Ensemble tahmin: ortalama
@@ -433,15 +475,18 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
                 
                 confidence_pct = _compute_confidence(r2, direction_correct)
                 
-                # Son tahmin (latest bar)
+                # Son tahmin (latest bar — apply same feature selection)
                 last_features_raw = np.nan_to_num(X_all[-1].reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0)
-                last_features = scaler_X.transform(last_features_raw)
+                last_features = scaler_X.transform(last_features_raw)[:, _top_feat_idx]
                 predictions_final = np.array([
                     float(np.asarray(m.predict(last_features), dtype=float).ravel()[0])
                     for m in models
                 ], dtype=float)
                 predicted_change = float(predictions_final.mean())  # already % return
 
+                # Base shrinkage: models overfit, shrink 70% toward zero
+                predicted_change *= 0.30
+
                 # Bayesian shrinkage: dampen extreme predictions when confidence is low
                 predicted_change = _apply_shrinkage(predicted_change, confidence_pct, days_ahead)
                 predicted_price = current_price * (1 + predicted_change / 100)
@@ -469,18 +514,23 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
                 return res
             else:
                 # Fallback to GradientBoosting if no advanced models
-                model = GradientBoostingRegressor(n_estimators=100, random_state=42)
+                model = GradientBoostingRegressor(
+                    n_estimators=200, max_depth=3, learning_rate=0.03,
+                    subsample=0.8, min_samples_split=10, random_state=42,
+                )
         else:
             # Default: GradientBoosting
             model = GradientBoostingRegressor(
-                n_estimators=100,
-                max_depth=5,
-                learning_rate=0.1,
-                random_state=42
+                n_estimators=200,
+                max_depth=3,
+                learning_rate=0.03,
+                subsample=0.8,
+                min_samples_split=10,
+                random_state=42,
             )
         
         # Tek model durumunda eğitim
-        model.fit(X_train, y_train)
+        model.fit(X_train, y_train, sample_weight=_sample_weights)
         
         # Test seti üzerinde performans (target is % return, no inverse transform)
         y_pred_test = np.asarray(model.predict(X_test), dtype=float)
@@ -505,11 +555,14 @@ def predict_stock_for_api(symbol, days_ahead=5, model_type='ensemble', market_id
         # Convert to a UI-friendly 0-100 confidence score
         confidence_pct = _compute_confidence(r2, direction_correct)
         
-        # Tahmin yap (latest bar)
+        # Tahmin yap (latest bar — apply same feature selection)
         last_features_raw = np.nan_to_num(X_all[-1].reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0)
-        last_features = scaler_X.transform(last_features_raw)
+        last_features = scaler_X.transform(last_features_raw)[:, _top_feat_idx]
         predicted_change = float(np.asarray(model.predict(last_features), dtype=float).ravel()[0])  # already % return
 
+        # Base shrinkage: models overfit, shrink 70% toward zero
+        predicted_change *= 0.30
+
         # Bayesian shrinkage: dampen extreme predictions when confidence is low
         predicted_change = _apply_shrinkage(predicted_change, confidence_pct, days_ahead)
         predicted_price = current_price * (1 + predicted_change / 100)

huggingface-space/analysis/walk_forward_backtest.py

@@ -297,6 +297,13 @@ def walk_forward_backtest(
     df_feat = add_macro_features(df_feat)
     df_feat["target_return"] = (df_feat["Close"].shift(-days_ahead) / df_feat["Close"] - 1) * 100.0
 
+    # Target clipping: cap extreme returns to prevent outlier-driven training
+    _target_clip = 3.5 * float(np.sqrt(max(1, days_ahead)))  # ~9% for 7 days
+    _extreme_mask = df_feat["target_return"].abs() > _target_clip
+    df_feat.loc[_extreme_mask, "target_return"] = np.clip(
+        df_feat.loc[_extreme_mask, "target_return"], -_target_clip, _target_clip,
+    )
+
     # Corporate action filter: poison target_return around suspected artifact days
     # so the model never trains on contaminated bedelsiz/bedelli/temettu data.
     _ca_suspect = flag_corp_action_days(df)
@@ -395,10 +402,13 @@ def walk_forward_backtest(
         X_test_s = scaler.transform(np.nan_to_num(X_test, nan=0.0, posinf=0.0, neginf=0.0))
 
         # --- Feature importance selection: train quick RF, keep top features ---
-        _sel_rf = RandomForestRegressor(n_estimators=80, max_depth=8, random_state=42, n_jobs=-1)
+        _sel_rf = RandomForestRegressor(
+            n_estimators=50, max_depth=4, min_samples_leaf=5,
+            max_features='sqrt', random_state=42, n_jobs=-1,
+        )
         _sel_rf.fit(X_train_s, y_train)
         importances = _sel_rf.feature_importances_
-        n_keep = min(25, len(FEATURES))
+        n_keep = min(10, len(FEATURES))
         top_idx = np.argsort(importances)[-n_keep:]
         X_train_s = X_train_s[:, top_idx]
         X_test_s = X_test_s[:, top_idx]
@@ -413,10 +423,14 @@ def walk_forward_backtest(
 
         # --- Ensemble of classifiers ---
         clf_rf = RandomForestClassifier(
-            n_estimators=200, max_depth=10, random_state=42, n_jobs=-1, class_weight="balanced"
+            n_estimators=200, max_depth=3, min_samples_split=10,
+            min_samples_leaf=5, max_features='sqrt',
+            random_state=42, n_jobs=-1, class_weight="balanced",
         )
         clf_gb = GradientBoostingClassifier(
-            n_estimators=150, max_depth=5, learning_rate=0.05, random_state=42
+            n_estimators=200, max_depth=3, learning_rate=0.03,
+            subsample=0.8, min_samples_split=10,
+            random_state=42,
         )
         clf_rf.fit(X_train_s, y_train_cls, sample_weight=sample_weights)
         clf_gb.fit(X_train_s, y_train_cls, sample_weight=sample_weights)
@@ -435,9 +449,17 @@ def walk_forward_backtest(
         # Also train regression model for magnitude estimate
         reg_model: Any
         if str(model_type).lower() == "rf":
-            reg_model = RandomForestRegressor(n_estimators=150, max_depth=10, random_state=42, n_jobs=-1)
+            reg_model = RandomForestRegressor(
+                n_estimators=200, max_depth=3, min_samples_split=10,
+                min_samples_leaf=5, max_features='sqrt',
+                random_state=42, n_jobs=-1,
+            )
         else:
-            reg_model = GradientBoostingRegressor(n_estimators=150, learning_rate=0.05, random_state=42)
+            reg_model = GradientBoostingRegressor(
+                n_estimators=200, max_depth=3, learning_rate=0.03,
+                subsample=0.8, min_samples_split=10,
+                random_state=42,
+            )
         reg_model.fit(X_train_s, y_train, sample_weight=sample_weights)
         y_pred_reg = np.asarray(reg_model.predict(X_test_s), dtype=float)
         r2 = float(r2_score(y_test, y_pred_reg))
@@ -457,6 +479,7 @@ def walk_forward_backtest(
             X_pred_row = scaler.transform(np.nan_to_num(row_t[FEATURES].to_numpy(dtype=float).reshape(1, -1), nan=0.0, posinf=0.0, neginf=0.0))
             X_pred_sel = X_pred_row[:, top_idx]
             reg_pred = float(np.asarray(reg_model.predict(X_pred_sel), dtype=float).ravel()[0])
+            reg_pred *= 0.30  # Base shrinkage: 70% toward zero
             predicted_change = float(_apply_shrinkage(reg_pred, confidence_pct, days_ahead))
             ml_signal = "HOLD"  # Model not confident enough
             _current_prob_up = 0.5
@@ -472,6 +495,7 @@ def walk_forward_backtest(
 
             # Regression for magnitude
             reg_pred = float(np.asarray(reg_model.predict(X_pred_sel), dtype=float).ravel()[0])
+            reg_pred *= 0.30  # Base shrinkage: 70% toward zero
             predicted_change = float(_apply_shrinkage(reg_pred, confidence_pct, days_ahead))
 
             # Signal from classification probability — RAISED thresholds for higher conviction

huggingface-space/app.py

@@ -2,29 +2,18 @@
 Hugging Face Space: Borsa ML API
 FastAPI backend for stock analysis and ML predictions
 """
-# --- HF Space DNS fix: api.telegram.org DNS çözümü engellenmiş ---
-import socket as _socket
-_orig_getaddrinfo = _socket.getaddrinfo
-def _tg_dns_fix(host, port, family=0, type=0, proto=0, flags=0):
-    if host == "api.telegram.org":
-        return _orig_getaddrinfo("149.154.167.220", port, family, type, proto, flags)
-    return _orig_getaddrinfo(host, port, family, type, proto, flags)
-_socket.getaddrinfo = _tg_dns_fix
-
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 import sys
 import os
 import json
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 
 import math
 
-from trading.market_registry import DEFAULT_MARKET_ID, get_scan_results_path, get_trading_db_path
-
 # Add parent directory to path for imports
 sys.path.insert(0, os.path.dirname(__file__))
 
@@ -65,7 +54,6 @@ _scan_status = {"running": False, "progress": "", "started_at": None}
 
 # ─── Remote sync cache (survives ephemeral filesystem resets) ─────────
 _remote_cache: dict = {}
-_SUPPORTED_MARKETS = ("bist", "us")
 
 # ─── Daily Auto-Scan Scheduler ────────────────────────
 # Runs a full-market scan every day at 19:00 Turkey time (16:00 UTC)
@@ -74,387 +62,211 @@ _SUPPORTED_MARKETS = ("bist", "us")
 import threading
 import time as _time
 
-_scheduler_thread = None
-_us_scheduler_thread = None
-_watchdog_thread = None
-_background_services_started = False
-_background_services_lock = threading.Lock()
+def _make_scan_progress_cb(label: str):
+    """Return a progress callback that updates the global _scan_status."""
+    def _cb(stage: str, info: dict) -> None:
+        global _scan_status
+        idx = info.get("index", "")
+        total = info.get("total", "")
+        sym = info.get("symbol", "")
+        s1p = info.get("stage1_passed", 0)
+        s1f = info.get("stage1_failed", 0)
+        elig = info.get("eligible_count", 0)
+        excl = info.get("excluded_count", 0)
+        if stage in ("stage1_start", "stage1"):
+            _scan_status["progress"] = (
+                f"[{label}] Stage 1: {idx}/{total} ({sym}). "
+                f"Geçti: {s1p}, Elendi: {s1f}"
+            )
+        elif stage in ("stage2_start", "stage2"):
+            _scan_status["progress"] = (
+                f"[{label}] Stage 2: {idx}/{total} ({sym}). "
+                f"Eligible: {elig}, Elenen: {excl}"
+            )
+    return _cb
 
-def _daily_scan_scheduler():
-    """Background thread: triggers a full BIST100 scan daily at 19:00 TR.
-    
-    Timing rationale:
-      - BIST market closes at 18:00 TR
-      - Scan starts at 19:00 TR (after market close)
-      - BIST100 takes ~5-6 hours → finishes by ~01:00 TR
-      - Market opens at 10:00 TR → 9 hours margin
-    
-    On first boot (no scan results), runs an immediate BIST30 scan so the
-    trading worker has data within minutes instead of waiting until evening.
-    """
+
+def _run_scan_in_thread(universe: str, label: str, stage1_only: bool = False, market_id: str = "bist"):
+    """Run a scan in a background thread. Non-blocking."""
     global _scan_thread, _scan_status
-    from datetime import timezone, timedelta
-    from pathlib import Path
 
-    TR_TZ = timezone(timedelta(hours=3))
-    _SCAN_FILE = Path("paper_trading/bist100_scan_results.json")
-    SCAN_HOUR_TR = 19  # 19:00 Turkey time = 16:00 UTC
+    if _scan_status.get("running"):
+        print(f"[scheduler] Scan already running, skipping {label}")
+        return
+
+    title = "BIST" if market_id == "bist" else market_id.upper()
+    _scan_status = {
+        "running": True,
+        "progress": f"{label} taraması başlatılıyor ({universe}, {title})...",
+        "started_at": datetime.now().isoformat(),
+        "universe": universe,
+        "market_id": market_id,
+        "scheduled": True,
+    }
 
-    # ── Initial boot scan ──────────────────────────────────────────────
-    scan_stale = False
-    if _SCAN_FILE.exists():
-        # Check if scan results are too old (> 3 days → stale, needs rescan)
-        try:
-            scan_data = json.loads(_SCAN_FILE.read_text())
-            finished = scan_data.get("scan_finished") or scan_data.get("updated_at")
-            if finished:
-                scan_dt = datetime.fromisoformat(str(finished).replace("Z", "+00:00"))
-                age_hours = (datetime.now(timezone(timedelta(hours=0))) - scan_dt).total_seconds() / 3600
-                if age_hours > 72:  # 3 days
-                    scan_stale = True
-                    print(f"[scheduler] Scan results stale ({age_hours:.0f}h old) — forcing rescan")
-                else:
-                    print(f"[scheduler] Scan results fresh ({age_hours:.0f}h old)")
-            else:
-                scan_stale = True
-                print("[scheduler] Scan results have no timestamp — forcing rescan")
-        except Exception as e:
-            scan_stale = True
-            print(f"[scheduler] Error reading scan file: {e} — forcing rescan")
-
-    if not _SCAN_FILE.exists() or scan_stale:
-        reason = "stale" if scan_stale else "missing"
-        # Boot scan: BIST30 kullan (hızlı ~5dk). Gece taraması BIST100 yapar.
-        boot_universe = "bist30"
-        print(f"[scheduler] Scan results {reason} — running immediate {boot_universe} boot scan...")
-        _scan_status = {
-            "running": True,
-            "progress": f"Boot taraması başlatılıyor ({boot_universe}, {reason})...",
-            "started_at": datetime.now().isoformat(),
-            "universe": boot_universe,
-            "market": "bist",
-            "scheduled": True,
-        }
+    def _do_scan():
+        global _scan_status
         try:
-            # Telegram: tarama başladı bildirimi
-            try:
-                import telegram_bot as _tg_bot
-                _tg_bot.notify_scan_started()
-            except Exception:
-                pass
-
-            from run_bist100_scan import run_scan
-            _scan_status["progress"] = f"Stage 1: Likidite filtresi ({boot_universe})..."
-            run_scan(universe=boot_universe, force=False, stage1_only=False)
+            from trading.scanner_engine import ScanConfig, run_scan as _engine_scan
+            import logging as _logging
+            _scan_logger = _logging.getLogger(f"scan-{label.lower()}-{market_id}")
+            config = ScanConfig(market_id=market_id, universe_name=universe, title=title)
+            _engine_scan(config, _scan_logger, force=False, stage1_only=stage1_only)
             _scan_status = {
                 "running": False,
-                "progress": f"Boot taraması tamamlandı ({boot_universe})!",
+                "progress": f"{label} taraması tamamlandı ({universe}, {title})!",
                 "finished_at": datetime.now().isoformat(),
-                "universe": boot_universe,
-                "market": "bist",
+                "universe": universe,
+                "market_id": market_id,
                 "scheduled": True,
             }
-            print(f"[scheduler] Boot scan ({boot_universe}) completed at {datetime.now().isoformat()}")
-
-            # Telegram: tarama bitti bildirimi
-            try:
-                import telegram_bot as _tg_bot
-                if _SCAN_FILE.exists():
-                    _tg_bot.notify_scan_complete(json.loads(_SCAN_FILE.read_text()))
-            except Exception:
-                pass
-
+            print(f"[scheduler] {label} scan ({market_id}/{universe}) completed at {datetime.now().isoformat()}")
         except Exception as e:
             _scan_status = {
                 "running": False,
-                "progress": f"Boot taraması hatası: {e}",
+                "progress": f"{label} tarama hatası ({title}): {e}",
                 "error": str(e),
-                "market": "bist",
-            }
-            print(f"[scheduler] Boot scan error: {e}")
-            # Telegram: hata bildirimi
-            try:
-                import telegram_bot as _tg_bot
-                _tg_bot.notify_error("Boot Tarama Hatası", str(e))
-            except Exception:
-                pass
-
-    # ── Nightly recurring scan loop (19:00 TR) ────────────────────────
-    while True:
-        try:
-            now_tr = datetime.now(TR_TZ)
-            
-            # Calculate next 19:00 TR
-            target = now_tr.replace(hour=SCAN_HOUR_TR, minute=0, second=0, microsecond=0)
-            if now_tr >= target:
-                # Already past 19:00 today → schedule for tomorrow 19:00
-                target = target + timedelta(days=1)
-            
-            wait_seconds = (target - now_tr).total_seconds()
-            print(f"[scheduler] Next auto-scan at {target.isoformat()} (in {wait_seconds/3600:.1f}h)")
-            _time.sleep(wait_seconds)
-
-            # Check if scan already running
-            if _scan_status.get("running"):
-                print("[scheduler] Scan already running, skipping scheduled scan")
-                continue
-
-            print("[scheduler] Starting daily ALL auto-scan...")
-            _scan_status = {
-                "running": True,
-                "progress": "Günlük otomatik tarama başlatılıyor (ALL)...",
-                "started_at": datetime.now().isoformat(),
-                "universe": "all",
-                "market": "bist",
+                "universe": universe,
+                "market_id": market_id,
                 "scheduled": True,
             }
+            print(f"[scheduler] {label} scan error ({market_id}): {e}")
 
-            def _auto_scan():
-                global _scan_status
-                try:
-                    # Telegram: tarama başladı
-                    try:
-                        import telegram_bot as _tg_bot
-                        _tg_bot.notify_scan_started()
-                    except Exception:
-                        pass
-
-                    from run_bist100_scan import run_scan
-                    _scan_status["progress"] = "Stage 1: Likidite filtresi..."
-                    run_scan(universe="all", force=False, stage1_only=False)
-                    _scan_status = {
-                        "running": False,
-                        "progress": "Günlük tarama tamamlandı!",
-                        "finished_at": datetime.now().isoformat(),
-                        "universe": "all",
-                        "market": "bist",
-                        "scheduled": True,
-                    }
-                    print(f"[scheduler] Daily scan completed at {datetime.now().isoformat()}")
-
-                    # Telegram: tarama bitti
-                    try:
-                        import telegram_bot as _tg_bot
-                        if _SCAN_FILE.exists():
-                            _tg_bot.notify_scan_complete(json.loads(_SCAN_FILE.read_text()))
-                    except Exception:
-                        pass
+    _scan_thread = threading.Thread(target=_do_scan, daemon=True, name=f"scan-{label.lower()}-{market_id}")
+    _scan_thread.start()
+    print(f"[scheduler] {label} scan thread started ({market_id}/{universe}, stage1_only={stage1_only})")
 
-                except Exception as e:
-                    _scan_status = {
-                        "running": False,
-                        "progress": f"Günlük tarama hatası: {e}",
-                        "error": str(e),
-                        "universe": "all",
-                        "market": "bist",
-                        "scheduled": True,
-                    }
-                    print(f"[scheduler] Daily scan error: {e}")
-                    # Telegram: hata
-                    try:
-                        import telegram_bot as _tg_bot
-                        _tg_bot.notify_error("Günlük Tarama Hatası", str(e))
-                    except Exception:
-                        pass
 
-            _scan_thread = threading.Thread(target=_auto_scan, daemon=True, name="daily-bist-scan")
-            _scan_thread.start()
+def _daily_scan_scheduler():
+    """Background thread: triggers scans for BIST and US markets.
 
-        except Exception as e:
-            print(f"[scheduler] Scheduler error: {e}")
-            _time.sleep(3600)  # wait an hour on error and retry
+    Boot behaviour (non-blocking):
+      - If scan results missing/stale → start a stage1-only boot scan in a thread.
+        Stage1 takes ~5 min (vs hours for full scan) and gives the worker
+        enough data to trade while keeping memory low on HF free tier.
+    
+    Nightly scans:
+      - BIST: 19:00 TR  (1hr after BIST close)
+      - US:   00:30 TR  (≈17:30 ET, 1.5hr after NYSE close)
+    """
+    from datetime import timezone, timedelta
+    from trading.market_registry import get_scan_results_path
 
+    TR_TZ = timezone(timedelta(hours=3))
+    BIST_SCAN_HOUR_TR = 19
+    US_SCAN_HOUR_TR = 0    # midnight TR ≈ 17:00 ET (after NYSE 16:00 close)
+    US_SCAN_MIN_TR = 30
+
+    # ── 10s grace for uvicorn to bind port first ──────────────────────
+    _time.sleep(10)
+
+    # ── Helper: check if a market needs boot scan ─────────────────────
+    def _needs_boot_scan(market_id: str) -> bool:
+        scan_file = get_scan_results_path(market_id, completed=True)
+        work_file = get_scan_results_path(market_id, completed=False)
+        if not scan_file.exists() and not work_file.exists():
+            print(f"[scheduler] No {market_id} scan results — will run boot scan")
+            return True
+        if scan_file.exists():
+            try:
+                scan_data = json.loads(scan_file.read_text())
+                finished = scan_data.get("scan_finished") or scan_data.get("updated_at")
+                if finished:
+                    scan_dt = datetime.fromisoformat(str(finished).replace("Z", "+00:00"))
+                    age_hours = (datetime.now(timezone(timedelta(hours=0))) - scan_dt).total_seconds() / 3600
+                    if age_hours > 72:
+                        print(f"[scheduler] {market_id} scan results stale ({age_hours:.0f}h old)")
+                        return True
+                    else:
+                        print(f"[scheduler] {market_id} scan results fresh ({age_hours:.0f}h old)")
+                        return False
+                else:
+                    return True
+            except Exception as e:
+                print(f"[scheduler] Error reading {market_id} scan file: {e}")
+                return True
+        return False
 
-def _daily_us_scan_scheduler():
-    """Background thread: triggers a US (SP100) scan daily at 17:00 ET.
+    # ── Boot scans (non-blocking, stage1 only) ────────────────��───────
+    if _needs_boot_scan("bist"):
+        _run_scan_in_thread("bist100", "Boot-BIST", stage1_only=True, market_id="bist")
 
-    Timing rationale:
-      - US market closes at 16:00 ET
-      - Scan starts at 17:00 ET (1 hour after close)
-      - SP100 scan takes ~2-3 hours on HF free tier
-      - Results ready well before next 09:30 ET market open
+    # Wait for BIST boot scan to finish before starting US (memory-safe)
+    _time.sleep(30)
+    while _scan_status.get("running"):
+        _time.sleep(15)
 
-    On first boot (no scan results), runs an immediate SP100 scan so the
-    trading worker has data within minutes instead of waiting until evening.
-    """
-    global _scan_thread, _scan_status
-    from datetime import timedelta
-    from pathlib import Path
-    from zoneinfo import ZoneInfo
-
-    ET_TZ = ZoneInfo("America/New_York")
-    _US_SCAN_FILE = Path("paper_trading/markets/us/scan_results.json")
-    US_SCAN_HOUR_ET = 17
-    BOOT_UNIVERSE = "sp100"
-
-    # ── Initial boot scan ──────────────────────────────────────────────
-    scan_stale = False
-    if _US_SCAN_FILE.exists():
-        try:
-            scan_data = json.loads(_US_SCAN_FILE.read_text())
-            finished = scan_data.get("scan_finished") or scan_data.get("updated_at")
-            if finished:
-                scan_dt = datetime.fromisoformat(str(finished).replace("Z", "+00:00"))
-                age_hours = (datetime.now(timezone.utc) - scan_dt).total_seconds() / 3600
-                if age_hours > 72:
-                    scan_stale = True
-                    print(f"[us-scheduler] US scan results stale ({age_hours:.0f}h old) — forcing rescan")
-                else:
-                    print(f"[us-scheduler] US scan results fresh ({age_hours:.0f}h old)")
-            else:
-                scan_stale = True
-                print("[us-scheduler] US scan results have no timestamp — forcing rescan")
-        except Exception as e:
-            scan_stale = True
-            print(f"[us-scheduler] Error reading US scan file: {e} — forcing rescan")
-
-    if not _US_SCAN_FILE.exists() or scan_stale:
-        reason = "stale" if scan_stale else "missing"
-        print(f"[us-scheduler] US scan results {reason} — running immediate {BOOT_UNIVERSE} boot scan...")
-        _scan_status = {
-            "running": True,
-            "progress": f"US boot taraması başlatılıyor ({BOOT_UNIVERSE}, {reason})...",
-            "started_at": datetime.now().isoformat(),
-            "universe": BOOT_UNIVERSE,
-            "market": "us",
-            "scheduled": True,
-        }
-        try:
-            from run_us_scan import run_scan as _us_run_scan
-            _scan_status["progress"] = f"US Stage 1: Liquidity filter ({BOOT_UNIVERSE})..."
-            _us_run_scan(universe=BOOT_UNIVERSE, force=False, stage1_only=False)
-            _scan_status = {
-                "running": False,
-                "progress": f"US boot taraması tamamlandı ({BOOT_UNIVERSE})!",
-                "finished_at": datetime.now().isoformat(),
-                "universe": BOOT_UNIVERSE,
-                "market": "us",
-                "scheduled": True,
-            }
-            print(f"[us-scheduler] US boot scan ({BOOT_UNIVERSE}) completed at {datetime.now().isoformat()}")
-        except Exception as e:
-            _scan_status = {
-                "running": False,
-                "progress": f"US boot taraması hatası: {e}",
-                "error": str(e),
-                "market": "us",
-            }
-            print(f"[us-scheduler] US boot scan error: {e}")
+    if _needs_boot_scan("us"):
+        _run_scan_in_thread("sp100", "Boot-US", stage1_only=True, market_id="us")
 
-    # ── Nightly recurring scan loop (17:00 ET) ────────────────────────
+    # ── Nightly recurring scan loop ───────────────────────────────────
     while True:
         try:
-            now_et = datetime.now(ET_TZ)
-            target = now_et.replace(hour=US_SCAN_HOUR_ET, minute=0, second=0, microsecond=0)
-            if now_et >= target:
-                target = target + timedelta(days=1)
-
-            wait_seconds = (target - now_et).total_seconds()
-            print(f"[us-scheduler] Next US auto-scan at {target.isoformat()} (in {wait_seconds/3600:.1f}h)")
-            _time.sleep(wait_seconds)
-
-            if _scan_status.get("running"):
-                print("[us-scheduler] Scan already running, skipping scheduled US scan")
-                continue
-
-            print("[us-scheduler] Starting daily US SP100 auto-scan...")
-            _scan_status = {
-                "running": True,
-                "progress": "US günlük otomatik tarama başlatılıyor (SP100)...",
-                "started_at": datetime.now().isoformat(),
-                "universe": "sp100",
-                "market": "us",
-                "scheduled": True,
-            }
+            now_tr = datetime.now(TR_TZ)
 
-            def _auto_us_scan():
-                global _scan_status
-                try:
-                    from run_us_scan import run_scan as _us_run_scan
-                    _scan_status["progress"] = "US Stage 1: Liquidity filter..."
-                    _us_run_scan(universe="sp100", force=False, stage1_only=False)
-                    _scan_status = {
-                        "running": False,
-                        "progress": "US günlük tarama tamamlandı!",
-                        "finished_at": datetime.now().isoformat(),
-                        "universe": "sp100",
-                        "market": "us",
-                        "scheduled": True,
-                    }
-                    print(f"[us-scheduler] Daily US scan completed at {datetime.now().isoformat()}")
-                except Exception as e:
-                    _scan_status = {
-                        "running": False,
-                        "progress": f"US günlük tarama hatası: {e}",
-                        "error": str(e),
-                        "universe": "sp100",
-                        "market": "us",
-                        "scheduled": True,
-                    }
-                    print(f"[us-scheduler] Daily US scan error: {e}")
+            # Next BIST scan: 19:00 TR
+            bist_target = now_tr.replace(hour=BIST_SCAN_HOUR_TR, minute=0, second=0, microsecond=0)
+            if now_tr >= bist_target:
+                bist_target = bist_target + timedelta(days=1)
+
+            # Next US scan: 00:30 TR
+            us_target = now_tr.replace(hour=US_SCAN_HOUR_TR, minute=US_SCAN_MIN_TR, second=0, microsecond=0)
+            if now_tr >= us_target:
+                us_target = us_target + timedelta(days=1)
+
+            # Pick whichever is sooner
+            if bist_target <= us_target:
+                next_target = bist_target
+                next_market = "bist"
+                next_universe = "bist100"
+            else:
+                next_target = us_target
+                next_market = "us"
+                next_universe = "sp100"
 
-            _scan_thread = threading.Thread(target=_auto_us_scan, daemon=True, name="daily-us-scan")
-            _scan_thread.start()
+            wait_seconds = (next_target - now_tr).total_seconds()
+            print(f"[scheduler] Next auto-scan: {next_market}/{next_universe} at {next_target.isoformat()} (in {wait_seconds/3600:.1f}h)")
+            _time.sleep(wait_seconds)
 
+            _run_scan_in_thread(next_universe, f"Nightly-{next_market.upper()}", stage1_only=False, market_id=next_market)
         except Exception as e:
-            print(f"[us-scheduler] Scheduler error: {e}")
+            print(f"[scheduler] Scheduler error: {e}")
             _time.sleep(3600)
 
-
-def _ensure_background_services_started() -> None:
-    """Start long-running background services only once.
-
-    Importing this module should stay side-effect free so smoke tests and helper
-    invocations do not unexpectedly launch scans or watchdog processes.
-    """
-    global _scheduler_thread, _us_scheduler_thread, _watchdog_thread, _background_services_started
-
-    with _background_services_lock:
-        if _background_services_started:
-            return
-
-        if _scheduler_thread is None or not _scheduler_thread.is_alive():
-            _scheduler_thread = threading.Thread(target=_daily_scan_scheduler, daemon=True, name="scan-scheduler")
-            _scheduler_thread.start()
-            print("[scheduler] Daily auto-scan scheduler started (19:00 TR / 16:00 UTC — ALL)")
-
-        if _us_scheduler_thread is None or not _us_scheduler_thread.is_alive():
-            _us_scheduler_thread = threading.Thread(target=_daily_us_scan_scheduler, daemon=True, name="us-scan-scheduler")
-            _us_scheduler_thread.start()
-            print("[scheduler] US daily scan scheduler started (17:00 ET — SP100)")
-
-        if _watchdog_thread is None or not _watchdog_thread.is_alive():
-            _watchdog_thread = threading.Thread(target=_worker_watchdog, daemon=True, name="worker-watchdog")
-            _watchdog_thread.start()
-            print("[watchdog] Worker health watchdog started (checks every 5 min)")
-
-        _background_services_started = True
-
-
-@app.on_event("startup")
-def _startup_background_services() -> None:
-    _ensure_background_services_started()
+# Start scheduler on import
+_scheduler_thread = threading.Thread(target=_daily_scan_scheduler, daemon=True, name="scan-scheduler")
+_scheduler_thread.start()
+print("[scheduler] Daily auto-scan scheduler started (19:00 TR / 16:00 UTC — BIST100)")
 
 
 def _get_trading_status():
     """Read trading status from file-based state."""
     paper_dir = Path("paper_trading")
-
-    def read_json(path: Path) -> Optional[Dict[str, Any]]:
+    state_file = paper_dir / "auto_trader" / "state.json"
+    status_file = paper_dir / "auto_trader" / "status.json"
+    trades_file = paper_dir / "journal" / "trades.jsonl"
+    equity_file = paper_dir / "journal" / "daily_pnl.jsonl"
+    signals_file = paper_dir / "journal" / "signals_log.jsonl"
+    kill_file = paper_dir / "kill_switch.json"
+    scan_file = paper_dir / "bist100_scan_results.json"
+    pid_file = paper_dir / "auto_trader" / "worker.pid"
+    db_file = paper_dir / "trading.db"
+
+    def read_json(p):
         try:
-            return json.loads(path.read_text()) if path.exists() else None
+            return json.loads(p.read_text()) if p.exists() else None
         except Exception:
             return None
 
-    def read_jsonl(path: Path) -> List[Dict[str, Any]]:
+    def read_jsonl(p):
         try:
-            if not path.exists():
+            if not p.exists():
                 return []
-            return [json.loads(line) for line in path.read_text().strip().split("\n") if line.strip()]
+            return [json.loads(line) for line in p.read_text().strip().split("\n") if line.strip()]
         except Exception:
             return []
 
-    def check_pid(pid_file: Path) -> tuple[bool, Optional[int]]:
+    def check_pid():
         try:
             if not pid_file.exists():
                 return False, None
@@ -464,233 +276,188 @@ def _get_trading_status():
         except Exception:
             return False, None
 
-    def market_paths(market_id: str) -> Dict[str, Path]:
-        market_key = market_id if market_id in _SUPPORTED_MARKETS else DEFAULT_MARKET_ID
-        market_dir = paper_dir if market_key == DEFAULT_MARKET_ID else paper_dir / "markets" / market_key
-        auto_dir = market_dir / "auto_trader"
-        journal_dir = paper_dir / "journal" if market_key == DEFAULT_MARKET_ID else market_dir / "journal"
-        return {
-            "market_dir": market_dir,
-            "auto_dir": auto_dir,
-            "journal_dir": journal_dir,
-            "state": auto_dir / "state.json",
-            "status": auto_dir / "status.json",
-            "trades": journal_dir / "trades.jsonl",
-            "equity": journal_dir / "daily_pnl.jsonl",
-            "signals": journal_dir / "signals_log.jsonl",
-            "kill": paper_dir / "kill_switch.json" if market_key == DEFAULT_MARKET_ID else market_dir / ".kill_switch",
-            "scan": get_scan_results_path(market_key, completed=True),
-            "pid": auto_dir / "worker.pid",
-            "db": get_trading_db_path(market_key),
-        }
-
-    def market_cache(market_id: str) -> Dict[str, Any]:
-        markets = _remote_cache.get("markets") or {}
-        cached = markets.get(market_id)
-        return cached if isinstance(cached, dict) else {}
-
-    def build_market_snapshot(market_id: str) -> Dict[str, Any]:
-        paths = market_paths(market_id)
-        cache = market_cache(market_id)
-
-        state = cache.get("state") or read_json(paths["state"])
-        status = cache.get("status") or read_json(paths["status"])
-        trades = cache.get("trades") or read_jsonl(paths["trades"])
-        equity = cache.get("equity_curve") or read_jsonl(paths["equity"])
-        signals = cache.get("signals") or read_jsonl(paths["signals"])
-        scan_data = cache.get("scan_results") or read_json(paths["scan"])
-        kill_switch = read_json(paths["kill"])
-        worker_running, worker_pid = check_pid(paths["pid"])
-
-        if paths["db"].exists() and ((not trades) or (not equity) or (not signals)):
-            try:
-                from trading.db_store import TradingStore
-
-                store = TradingStore(db_path=str(paths["db"]))
-                if not trades:
-                    trades = store.get_all_trades()
-                if not equity:
-                    equity = store.get_equity_curve()
-                if not signals:
-                    signals = store.get_signals(limit=500)
-            except Exception as exc:
-                status = status or {}
-                status["db_fallback_error"] = str(exc)
-
-        eligible = []
+    # Remote cache takes priority (survives ephemeral FS resets).
+    # Files are only used as fallback when cache is empty (fresh boot before first sync).
+    state = _remote_cache.get("state") or read_json(state_file)
+    status = _remote_cache.get("status") or read_json(status_file)
+    trades = _remote_cache.get("trades", []) or read_jsonl(trades_file)
+    equity = _remote_cache.get("equity_curve", []) or read_jsonl(equity_file)
+    signals = _remote_cache.get("signals", []) or read_jsonl(signals_file)
+    kill_switch = read_json(kill_file)
+    scan_data = _remote_cache.get("scan_results:bist") or read_json(scan_file)
+    worker_running, worker_pid = check_pid()
+
+    # SQLite fallback: worker now persists journal to DB, JSONL may be empty.
+    if db_file.exists() and (
+        (not trades) or (not equity) or (not signals)
+    ):
         try:
-            stage2 = (scan_data or {}).get("stage2", {})
-            eligible = sorted([sym for sym, value in stage2.items() if value.get("eligible")])
-        except Exception:
-            pass
+            from trading.db_store import TradingStore
+
+            store = TradingStore(db_path=str(db_file))
+            if not trades:
+                trades = store.get_all_trades()
+            if not equity:
+                equity = store.get_equity_curve()
+            if not signals:
+                signals = store.get_signals(limit=500)
+        except Exception as e:
+            # Keep file-based fallback; surface the error for diagnostics.
+            status = status or {}
+            status["db_fallback_error"] = str(e)
 
-        open_trades = [trade for trade in trades if not trade.get("is_closed")]
-        closed_trades = [trade for trade in trades if trade.get("is_closed")]
-
-        total_pnl = sum(trade.get("net_pnl", 0) for trade in closed_trades)
-        winners = [trade for trade in closed_trades if (trade.get("net_pnl", 0)) > 0]
-        losers = [trade for trade in closed_trades if (trade.get("net_pnl", 0)) < 0]
-        win_rate = (len(winners) / len(closed_trades) * 100) if closed_trades else 0
-        avg_win = (sum(trade.get("net_pnl", 0) for trade in winners) / len(winners)) if winners else 0
-        avg_loss = (abs(sum(trade.get("net_pnl", 0) for trade in losers)) / len(losers)) if losers else 0
-        profit_factor = (avg_win / avg_loss) if avg_loss > 0 else (float("inf") if avg_win > 0 else 0)
-        best_trade = max((trade.get("return_pct", 0) for trade in closed_trades), default=0)
-        worst_trade = min((trade.get("return_pct", 0) for trade in closed_trades), default=0)
-
-        symbol_stats: Dict[str, Dict[str, float]] = {}
-        for trade in closed_trades:
-            symbol = trade.get("symbol", "?")
-            if symbol not in symbol_stats:
-                symbol_stats[symbol] = {"trades": 0, "pnl": 0, "wins": 0}
-            symbol_stats[symbol]["trades"] += 1
-            symbol_stats[symbol]["pnl"] += trade.get("net_pnl", 0)
-            if trade.get("net_pnl", 0) > 0:
-                symbol_stats[symbol]["wins"] += 1
-
-        cash = float((state or {}).get("broker_cash", 100000))
-        positions = (state or {}).get("broker_positions", {})
-        latest_eq = equity[-1] if equity else None
-        last_result = (status or {}).get("last_result") if isinstance(status, dict) else None
-        last_worker_status = (status or {}).get("status") if isinstance(status, dict) else None
-        last_worker_reason = (status or {}).get("reason") if isinstance(status, dict) else None
+    # Eligible stocks
+    eligible = []
+    try:
+        s2 = (scan_data or {}).get("stage2", {})
+        eligible = sorted([sym for sym, v in s2.items() if v.get("eligible")])
+    except Exception:
+        pass
+
+    open_trades = [t for t in trades if not t.get("is_closed")]
+    closed_trades = [t for t in trades if t.get("is_closed")]
+
+    total_pnl = sum(t.get("net_pnl", 0) for t in closed_trades)
+    winners = [t for t in closed_trades if (t.get("net_pnl", 0)) > 0]
+    losers = [t for t in closed_trades if (t.get("net_pnl", 0)) < 0]
+    win_rate = (len(winners) / len(closed_trades) * 100) if closed_trades else 0
+    avg_win = (sum(t.get("net_pnl", 0) for t in winners) / len(winners)) if winners else 0
+    avg_loss = (abs(sum(t.get("net_pnl", 0) for t in losers)) / len(losers)) if losers else 0
+    profit_factor = (avg_win / avg_loss) if avg_loss > 0 else (float("inf") if avg_win > 0 else 0)
+    best_trade = max((t.get("return_pct", 0) for t in closed_trades), default=0)
+    worst_trade = min((t.get("return_pct", 0) for t in closed_trades), default=0)
+
+    # Per-symbol breakdown
+    symbol_stats = {}
+    for t in closed_trades:
+        sym = t.get("symbol", "?")
+        if sym not in symbol_stats:
+            symbol_stats[sym] = {"trades": 0, "pnl": 0, "wins": 0}
+        symbol_stats[sym]["trades"] += 1
+        symbol_stats[sym]["pnl"] += t.get("net_pnl", 0)
+        if t.get("net_pnl", 0) > 0:
+            symbol_stats[sym]["wins"] += 1
+
+    cash = float((state or {}).get("broker_cash", 100000))
+    positions = (state or {}).get("broker_positions", {})
+    latest_eq = equity[-1] if equity else None
+
+    last_worker_status = None
+    last_worker_reason = None
+    last_result = None
+    if isinstance(status, dict):
+        last_worker_status = status.get("status")
+        last_worker_reason = status.get("reason")
+        last_result = status.get("last_result")
+        # Back-compat: sometimes only last_result exists
         if not last_worker_status and isinstance(last_result, dict):
             last_worker_status = last_result.get("status")
         if not last_worker_reason and isinstance(last_result, dict):
             last_worker_reason = last_result.get("reason")
 
-        currency = "TRY" if market_id == DEFAULT_MARKET_ID else "USD"
-        display_name = "Borsa Istanbul" if market_id == DEFAULT_MARKET_ID else "US Equities"
-        equity_value = latest_eq.get("equity", cash) if latest_eq else cash
-
-        return {
-            "marketId": market_id,
-            "displayName": display_name,
-            "currency": currency,
-            "status": {
-                "isRunning": (status or {}).get("is_running", False),
-                "lastRunDate": (state or {}).get("last_run_date"),
-                "totalDaysRun": (state or {}).get("total_days_run", 0),
-                "totalTrades": (state or {}).get("total_trades", 0),
-                "currentPhase": (status or {}).get("current_phase"),
-                "killSwitchActive": (kill_switch or {}).get("active", False),
-                "killSwitchReason": (kill_switch or {}).get("reason"),
-                "workerRunning": worker_running,
-                "workerPid": worker_pid,
-                "lastWorkerStatus": last_worker_status,
-                "lastWorkerReason": last_worker_reason,
-                "lastResult": last_result,
-            },
-            "portfolio": {
-                "cash": round(cash, 2),
-                "equity": equity_value,
-                "positionCount": len(positions),
-                "positions": [
-                    {
-                        "symbol": sym,
-                        "quantity": pos.get("qty"),
-                        "avgCost": pos.get("avg_cost"),
-                        "entryDate": pos.get("entry_date"),
-                        "notional": (pos.get("qty", 0)) * (pos.get("avg_cost", 0)),
-                    }
-                    for sym, pos in positions.items()
-                ],
-                "pnlPct": round(((equity_value / float((state or {}).get("initial_cash", 100000) or 100000) - 1) * 100), 2) if equity_value else 0,
-                "unrealizedPnl": latest_eq.get("unrealized_pnl", 0) if latest_eq else 0,
-            },
-            "equityCurve": [
-                {
-                    "date": item.get("date"),
-                    "equity": item.get("equity"),
-                    "cash": item.get("cash"),
-                    "positions": item.get("positions_count"),
-                    "realizedPnl": item.get("realized_pnl_today", 0),
-                }
-                for item in equity
-            ],
-            "openTrades": [
+    return {
+        "status": {
+            "isRunning": (status or {}).get("is_running", False),
+            "lastRunDate": (state or {}).get("last_run_date"),
+            "totalDaysRun": (state or {}).get("total_days_run", 0),
+            "totalTrades": (state or {}).get("total_trades", 0),
+            "currentPhase": (status or {}).get("current_phase"),
+            "killSwitchActive": (kill_switch or {}).get("active", False),
+            "killSwitchReason": (kill_switch or {}).get("reason"),
+            "workerRunning": worker_running,
+            "workerPid": worker_pid,
+            "lastWorkerStatus": last_worker_status,
+            "lastWorkerReason": last_worker_reason,
+            "lastResult": last_result,
+        },
+        "portfolio": {
+            "cash": round(cash, 2),
+            "equity": latest_eq.get("equity", cash) if latest_eq else cash,
+            "positionCount": len(positions),
+            "positions": [
                 {
-                    "symbol": trade["symbol"],
-                    "quantity": trade.get("quantity"),
-                    "entryPrice": trade.get("entry_price"),
-                    "entryDate": trade.get("entry_date"),
-                    "confidence": trade.get("signal_confidence"),
-                    "predictedReturn": trade.get("predicted_return"),
-                    "commission": trade.get("entry_commission"),
+                    "symbol": sym,
+                    "quantity": pos.get("qty"),
+                    "avgCost": pos.get("avg_cost"),
+                    "entryDate": pos.get("entry_date"),
+                    "notional": (pos.get("qty", 0)) * (pos.get("avg_cost", 0)),
                 }
-                for trade in open_trades
+                for sym, pos in positions.items()
             ],
-            "closedTrades": [
+            "pnlPct": round(((latest_eq.get("equity", cash) / 100000 - 1) * 100), 2) if latest_eq else 0,
+            "unrealizedPnl": latest_eq.get("unrealized_pnl", 0) if latest_eq else 0,
+        },
+        "equityCurve": [
+            {
+                "date": e.get("date"),
+                "equity": e.get("equity"),
+                "cash": e.get("cash"),
+                "positions": e.get("positions_count"),
+                "realizedPnl": e.get("realized_pnl_today", 0),
+            }
+            for e in equity
+        ],
+        "openTrades": [
+            {
+                "symbol": t["symbol"],
+                "quantity": t.get("quantity"),
+                "entryPrice": t.get("entry_price"),
+                "entryDate": t.get("entry_date"),
+                "confidence": t.get("signal_confidence"),
+                "predictedReturn": t.get("predicted_return"),
+                "commission": t.get("entry_commission"),
+            }
+            for t in open_trades
+        ],
+        "closedTrades": [
+            {
+                "symbol": t["symbol"],
+                "quantity": t.get("quantity"),
+                "entryPrice": t.get("entry_price"),
+                "exitPrice": t.get("exit_price"),
+                "entryDate": t.get("entry_date"),
+                "exitDate": t.get("exit_date"),
+                "netPnl": t.get("net_pnl"),
+                "returnPct": t.get("return_pct"),
+                "holdingDays": t.get("holding_days"),
+                "exitReason": t.get("exit_reason"),
+            }
+            for t in closed_trades
+        ],
+        "performance": {
+            "totalPnl": round(total_pnl, 2),
+            "closedTradesCount": len(closed_trades),
+            "openTradesCount": len(open_trades),
+            "winRate": round(win_rate, 1),
+            "profitFactor": "Inf" if profit_factor == float("inf") else round(profit_factor, 2),
+            "avgWin": round(avg_win, 2),
+            "avgLoss": round(avg_loss, 2),
+            "bestTrade": round(best_trade, 2),
+            "worstTrade": round(worst_trade, 2),
+            "symbolBreakdown": [
                 {
-                    "symbol": trade["symbol"],
-                    "quantity": trade.get("quantity"),
-                    "entryPrice": trade.get("entry_price"),
-                    "exitPrice": trade.get("exit_price"),
-                    "entryDate": trade.get("entry_date"),
-                    "exitDate": trade.get("exit_date"),
-                    "netPnl": trade.get("net_pnl"),
-                    "returnPct": trade.get("return_pct"),
-                    "holdingDays": trade.get("holding_days"),
-                    "exitReason": trade.get("exit_reason"),
+                    "symbol": sym,
+                    "trades": s["trades"],
+                    "pnl": round(s["pnl"], 2),
+                    "winRate": round((s["wins"] / s["trades"]) * 100) if s["trades"] > 0 else 0,
                 }
-                for trade in closed_trades
+                for sym, s in symbol_stats.items()
             ],
-            "performance": {
-                "totalPnl": round(total_pnl, 2),
-                "closedTradesCount": len(closed_trades),
-                "openTradesCount": len(open_trades),
-                "winRate": round(win_rate, 1),
-                "profitFactor": "Inf" if profit_factor == float("inf") else round(profit_factor, 2),
-                "avgWin": round(avg_win, 2),
-                "avgLoss": round(avg_loss, 2),
-                "bestTrade": round(best_trade, 2),
-                "worstTrade": round(worst_trade, 2),
-                "symbolBreakdown": [
-                    {
-                        "symbol": sym,
-                        "trades": stats["trades"],
-                        "pnl": round(stats["pnl"], 2),
-                        "winRate": round((stats["wins"] / stats["trades"]) * 100) if stats["trades"] > 0 else 0,
-                    }
-                    for sym, stats in symbol_stats.items()
-                ],
-            },
-            "signals": [
-                {
-                    "date": signal.get("date"),
-                    "symbol": signal.get("symbol"),
-                    "signal": signal.get("signal"),
-                    "mlSignal": signal.get("ml_signal"),
-                    "techSignal": signal.get("tech_signal"),
-                    "confidence": signal.get("confidence"),
-                    "predictedReturn": signal.get("predicted_return"),
-                    "actionTaken": signal.get("action_taken"),
-                }
-                for signal in signals[-50:]
-            ][::-1],
-            "eligibleStocks": eligible,
-            "scan": {
-                "universe": (scan_data or {}).get("universe"),
-                "completed": bool((scan_data or {}).get("completed", False)),
-                "stage1Count": len((scan_data or {}).get("stage1", {})),
-                "stage2Count": len((scan_data or {}).get("stage2", {})),
-                "updatedAt": (scan_data or {}).get("updated_at"),
-            },
-        }
-
-    markets = {market_id: build_market_snapshot(market_id) for market_id in _SUPPORTED_MARKETS}
-    default_market = markets[DEFAULT_MARKET_ID]
-
-    return {
-        "status": default_market["status"],
-        "portfolio": default_market["portfolio"],
-        "equityCurve": default_market["equityCurve"],
-        "openTrades": default_market["openTrades"],
-        "closedTrades": default_market["closedTrades"],
-        "performance": default_market["performance"],
-        "signals": default_market["signals"],
-        "eligibleStocks": default_market["eligibleStocks"],
-        "markets": markets,
-        "activeMarketId": DEFAULT_MARKET_ID,
+        },
+        "signals": [
+            {
+                "date": s.get("date"),
+                "symbol": s.get("symbol"),
+                "signal": s.get("signal"),
+                "mlSignal": s.get("ml_signal"),
+                "techSignal": s.get("tech_signal"),
+                "confidence": s.get("confidence"),
+                "predictedReturn": s.get("predicted_return"),
+                "actionTaken": s.get("action_taken"),
+            }
+            for s in signals[-50:]
+        ][::-1],
+        "eligibleStocks": eligible,
         "timestamp": datetime.now().isoformat(),
     }
 
@@ -712,7 +479,6 @@ class MLPredictionRequest(BaseModel):
     symbols: List[str]
     days_ahead: int = 7
     model: str = "ensemble"  # ensemble, xgboost, lightgbm, rf
-    market: str = DEFAULT_MARKET_ID
 
 
 @app.get("/")
@@ -803,7 +569,6 @@ def get_ml_predictions(request: MLPredictionRequest):
             symbols=request.symbols,
             days_ahead=request.days_ahead,
             model_type=request.model,
-            market_id=request.market,
         )
 
         # If data providers rate-limit / return empty, avoid 500 and let UI degrade gracefully.
@@ -818,7 +583,6 @@ def get_ml_predictions(request: MLPredictionRequest):
         return {
             "model": request.model,
             "days_ahead": request.days_ahead,
-            "market": request.market,
             "predictions": results
         }
     except HTTPException:
@@ -1409,12 +1173,9 @@ def get_news(
 # If dead, restart it automatically. This survives HF Space container recycles.
 
 def _worker_watchdog():
-    """Background thread: checks market worker PIDs every 5 minutes, restarts if dead."""
+    """Background thread: checks worker PID every 5 minutes, restarts if dead."""
     import subprocess
-    market_pid_files = {
-        "bist": Path("paper_trading/auto_trader/worker.pid"),
-        "us": Path("paper_trading/markets/us/auto_trader/worker.pid"),
-    }
+    pid_file = Path("paper_trading/auto_trader/worker.pid")
     CHECK_INTERVAL = 300  # 5 minutes
 
     # Give the worker (started by start.sh) time to boot
@@ -1422,40 +1183,45 @@ def _worker_watchdog():
 
     while True:
         try:
-            cwd = str(Path(__file__).parent)
-            for market, pid_file in market_pid_files.items():
-                worker_alive = False
-                if pid_file.exists():
+            worker_alive = False
+            if pid_file.exists():
+                try:
+                    pid = int(pid_file.read_text().strip())
+                    os.kill(pid, 0)  # signal 0 = check if alive
+                    worker_alive = True
+                except (ProcessLookupError, ValueError, OSError):
+                    # PID stale — clean up
                     try:
-                        pid = int(pid_file.read_text().strip())
-                        os.kill(pid, 0)  # signal 0 = check if alive
-                        worker_alive = True
-                    except (ProcessLookupError, ValueError, OSError):
-                        try:
-                            pid_file.unlink(missing_ok=True)
-                        except Exception:
-                            pass
-
-                if not worker_alive:
-                    print(f"[watchdog] {market} worker not running — restarting...")
-                    subprocess.Popen(
-                        [sys.executable, "-m", "trading.worker", "--daemon", "--mode", "paper", "--market", market, "--interval", "3600"],
-                        cwd=cwd,
-                        stdout=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                        start_new_session=True,
-                    )
-                    _time.sleep(5)  # give it time to start
-                    if pid_file.exists():
-                        print(f"[watchdog] {market} worker restarted (PID={pid_file.read_text().strip()})")
-                    else:
-                        print(f"[watchdog] {market} worker restart attempted but no PID file yet")
+                        pid_file.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+
+            if not worker_alive:
+                print("[watchdog] Worker not running — restarting...")
+                cwd = str(Path(__file__).parent)
+                subprocess.Popen(
+                    [sys.executable, "-m", "trading.worker", "--daemon", "--mode", "paper", "--interval", "3600"],
+                    cwd=cwd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+                _time.sleep(5)  # give it time to start
+                if pid_file.exists():
+                    print(f"[watchdog] Worker restarted (PID={pid_file.read_text().strip()})")
+                else:
+                    print("[watchdog] Worker restart attempted but no PID file yet")
         except Exception as e:
             print(f"[watchdog] Error: {e}")
 
         _time.sleep(CHECK_INTERVAL)
 
 
+_watchdog_thread = threading.Thread(target=_worker_watchdog, daemon=True, name="worker-watchdog")
+_watchdog_thread.start()
+print("[watchdog] Worker health watchdog started (checks every 5 min)")
+
+
 # ─── Trading API Endpoints ──────────────────────────────────────────────────
 
 
@@ -1479,17 +1245,14 @@ def get_trading_data():
 @app.post("/api/trading")
 def trading_action(req: TradingActionRequest):
     """Execute trading actions: run, start_worker, stop_worker, kill, unkill."""
-    market_id = (req.market or "bist").strip().lower()
     paper_dir = Path("paper_trading")
-    market_dir = paper_dir if market_id == "bist" else paper_dir / "markets" / market_id
-    auto_trader_dir = market_dir / "auto_trader"
-    kill_file = paper_dir / "kill_switch.json" if market_id == "bist" else market_dir / ".kill_switch"
-    pid_file = auto_trader_dir / "worker.pid"
+    kill_file = paper_dir / "kill_switch.json"
+    pid_file = paper_dir / "auto_trader" / "worker.pid"
 
     if req.action == "run":
         try:
             from trading.worker import TradingWorker
-            worker = TradingWorker(mode="paper", market_id=market_id)
+            worker = TradingWorker(mode="paper")
             result = worker.run_cycle(force=False)
             return {"success": True, "output": str(result), "result": result}
         except Exception as e:
@@ -1498,7 +1261,7 @@ def trading_action(req: TradingActionRequest):
     if req.action == "run_force":
         try:
             from trading.worker import TradingWorker
-            worker = TradingWorker(mode="paper", market_id=market_id)
+            worker = TradingWorker(mode="paper")
             result = worker.run_cycle(force=True)
             return {"success": True, "output": str(result), "result": result}
         except Exception as e:
@@ -1524,7 +1287,7 @@ def trading_action(req: TradingActionRequest):
 
         cwd = str(Path(__file__).parent)
         proc = subprocess.Popen(
-            [sys.executable, "-m", "trading.worker", "--daemon", "--mode", "paper", "--market", market_id, "--interval", "3600"],
+            [sys.executable, "-m", "trading.worker", "--daemon", "--mode", "paper", "--interval", "3600"],
             cwd=cwd,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
@@ -1566,94 +1329,76 @@ def trading_action(req: TradingActionRequest):
             return {"error": f"Worker durdurma hatası: {str(e)}"}
 
     elif req.action == "kill":
-        market_dir.mkdir(parents=True, exist_ok=True)
-        auto_trader_dir.mkdir(parents=True, exist_ok=True)
+        paper_dir.mkdir(parents=True, exist_ok=True)
+        (paper_dir / "auto_trader").mkdir(parents=True, exist_ok=True)
         kill_file.write_text(json.dumps({
             "active": True,
             "reason": req.reason or "Manual kill switch from UI",
             "activated_at": datetime.now().isoformat(),
-            "market_id": market_id,
         }))
-        return {"success": True, "action": "kill", "market": market_id, "timestamp": datetime.now().isoformat()}
+        return {"success": True, "action": "kill", "timestamp": datetime.now().isoformat()}
 
     elif req.action == "unkill":
         try:
             kill_file.unlink(missing_ok=True)
         except Exception:
             pass
-        return {"success": True, "action": "unkill", "market": market_id, "timestamp": datetime.now().isoformat()}
+        return {"success": True, "action": "unkill", "timestamp": datetime.now().isoformat()}
 
     elif req.action == "scan":
-        # Trigger market-specific scan in background
+        # Trigger scan in background (supports both BIST and US)
         global _scan_thread, _scan_status
         import threading
 
         if _scan_status.get("running"):
             return {"success": False, "error": "Tarama zaten çalışıyor", "scanStatus": _scan_status}
 
-        # Backward-compat: older UI used `reason` to pass the universe.
-        universe = (req.universe or req.reason or "bist30").strip().lower()
+        # Determine market and universe
+        market_id = (req.market or "bist").strip().lower()
+        if market_id == "us":
+            universe = (req.universe or req.reason or "sp100").strip().lower()
+        else:
+            universe = (req.universe or req.reason or "bist30").strip().lower()
         force = bool(req.force) if req.force is not None else False
+        title = "BIST" if market_id == "bist" else market_id.upper()
 
         def _run_scan():
             global _scan_status
             try:
-                scan_label = universe.upper()
                 _scan_status = {
                     "running": True,
-                    "progress": f"{market_id.upper()} {scan_label} taraması başlatılıyor...",
+                    "progress": f"{universe.upper()} ({title}) taraması başlatılıyor...",
                     "started_at": datetime.now().isoformat(),
                     "universe": universe,
-                    "market": market_id,
+                    "market_id": market_id,
                 }
-                # Telegram: tarama başladı
-                try:
-                    import telegram_bot as _tg_bot
-                    _tg_bot.notify_scan_started()
-                except Exception:
-                    pass
-
-                if market_id == "us":
-                    from run_us_scan import run_scan
-                else:
-                    from run_bist100_scan import run_scan
-                _scan_status["progress"] = "Stage 1: Likidite filtresi..."
-                run_scan(universe=universe, force=force, stage1_only=False)
+                from trading.scanner_engine import ScanConfig, run_scan as _engine_scan
+                import logging as _logging
+                _scan_logger = _logging.getLogger(f"manual-scan-{market_id}")
+                config = ScanConfig(market_id=market_id, universe_name=universe, title=title)
+                _scan_status["progress"] = f"Stage 1: Likidite filtresi ({title})..."
+                _engine_scan(config, _scan_logger, force=force, stage1_only=False)
                 _scan_status = {
                     "running": False,
-                    "progress": "Tarama tamamlandı!",
+                    "progress": f"Tarama tamamlandı ({title})!",
                     "finished_at": datetime.now().isoformat(),
                     "universe": universe,
-                    "market": market_id,
+                    "market_id": market_id,
                 }
-                # Telegram: tarama bitti
-                try:
-                    import telegram_bot as _tg_bot
-                    scan_file = get_scan_results_path(market_id, completed=True)
-                    if scan_file.exists():
-                        _tg_bot.notify_scan_complete(json.loads(scan_file.read_text()))
-                except Exception:
-                    pass
-
             except Exception as e:
                 _scan_status = {
                     "running": False,
-                    "progress": f"Tarama hatası: {e}",
+                    "progress": f"Tarama hatası ({title}): {e}",
                     "error": str(e),
                     "universe": universe,
-                    "market": market_id,
+                    "market_id": market_id,
                 }
-                try:
-                    import telegram_bot as _tg_bot
-                    _tg_bot.notify_error("Tarama Hatası", str(e))
-                except Exception:
-                    pass
 
-        _scan_thread = threading.Thread(target=_run_scan, daemon=True, name="bist-scan")
+        _scan_thread = threading.Thread(target=_run_scan, daemon=True, name=f"{market_id}-scan")
         _scan_thread.start()
         return {
             "success": True,
-            "message": f"{market_id.upper()} {universe.upper()} taraması arka planda başlatıldı",
+            "message": f"{universe.upper()} ({title}) taraması arka planda başlatıldı",
             "scanStatus": _scan_status,
         }
 
@@ -1666,13 +1411,13 @@ def trading_action(req: TradingActionRequest):
 
 class TradingSyncPayload(BaseModel):
     sync_key: str
-    market_id: Optional[str] = None
     state: Optional[dict] = None
     status: Optional[dict] = None
     trades: Optional[list] = None
     equity_curve: Optional[list] = None
     signals: Optional[list] = None
     scan_results: Optional[dict] = None
+    market_id: Optional[str] = None
 
 
 @app.post("/api/trading/sync")
@@ -1683,14 +1428,9 @@ def trading_sync(payload: TradingSyncPayload):
         raise HTTPException(status_code=403, detail="Invalid sync key")
 
     paper_dir = Path("paper_trading")
-    market_id = (payload.market_id or DEFAULT_MARKET_ID).strip().lower()
-    market_dir = paper_dir if market_id == DEFAULT_MARKET_ID else paper_dir / "markets" / market_id
-    auto_dir = market_dir / "auto_trader"
-    journal_dir = paper_dir / "journal" if market_id == DEFAULT_MARKET_ID else market_dir / "journal"
-    scan_file = get_scan_results_path(market_id, completed=True)
-
+    auto_dir = paper_dir / "auto_trader"
+    journal_dir = paper_dir / "journal"
     paper_dir.mkdir(parents=True, exist_ok=True)
-    market_dir.mkdir(parents=True, exist_ok=True)
     auto_dir.mkdir(parents=True, exist_ok=True)
     journal_dir.mkdir(parents=True, exist_ok=True)
 
@@ -1724,29 +1464,29 @@ def trading_sync(payload: TradingSyncPayload):
         _atomic_write(journal_dir / "signals_log.jsonl", "\n".join(lines) + "\n" if lines else "")
         synced.append(f"signals({len(payload.signals)})")
 
-    # 6. scan_results
+    # 6. scan_results — write to the correct market-specific path
+    sync_market = (payload.market_id or "bist").strip().lower()
     if payload.scan_results is not None:
-        _atomic_write(scan_file, json.dumps(payload.scan_results, indent=2, default=str))
-        synced.append("scan_results")
+        from trading.market_registry import get_scan_results_path
+        scan_path = get_scan_results_path(sync_market, completed=True)
+        scan_path.parent.mkdir(parents=True, exist_ok=True)
+        _atomic_write(scan_path, json.dumps(payload.scan_results, indent=2, default=str))
+        synced.append(f"scan_results({sync_market})")
 
     # 7. Update in-memory cache (survives ephemeral filesystem resets)
     global _remote_cache
-    market_cache = dict((_remote_cache.get("markets") or {}).get(market_id) or {})
-    market_cache.update({
-        "state": payload.state or market_cache.get("state"),
-        "status": payload.status or market_cache.get("status"),
-        "trades": payload.trades if payload.trades is not None else market_cache.get("trades", []),
-        "equity_curve": payload.equity_curve if payload.equity_curve is not None else market_cache.get("equity_curve", []),
-        "signals": payload.signals if payload.signals is not None else market_cache.get("signals", []),
-        "scan_results": payload.scan_results or market_cache.get("scan_results"),
-        "updated_at": datetime.now().isoformat(),
-    })
-    markets_cache = dict(_remote_cache.get("markets") or {})
-    markets_cache[market_id] = market_cache
-    _remote_cache = {
-        "markets": markets_cache,
-        "updated_at": datetime.now().isoformat(),
-    }
+    scan_cache_key = f"scan_results:{sync_market}"
+    _remote_cache["state"] = payload.state or _remote_cache.get("state")
+    _remote_cache["status"] = payload.status or _remote_cache.get("status")
+    if payload.trades is not None:
+        _remote_cache["trades"] = payload.trades
+    if payload.equity_curve is not None:
+        _remote_cache["equity_curve"] = payload.equity_curve
+    if payload.signals is not None:
+        _remote_cache["signals"] = payload.signals
+    if payload.scan_results:
+        _remote_cache[scan_cache_key] = payload.scan_results
+    _remote_cache["updated_at"] = datetime.now().isoformat()
 
     return {
         "success": True,
@@ -1763,30 +1503,31 @@ def _atomic_write(path: Path, content: str) -> None:
 
 
 @app.get("/api/eligible")
-def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist or us")):
+def get_eligible_stocks(market: str = Query("bist")):
     """
-    GET /api/eligible
-    Returns list of eligible stocks from BIST100 scan results
+    GET /api/eligible?market=bist|us
+    Returns list of eligible stocks from scan results
     """
-    market_id = market.strip().lower() if market else DEFAULT_MARKET_ID
-    if market_id not in _SUPPORTED_MARKETS:
-        market_id = DEFAULT_MARKET_ID
+    from trading.market_registry import get_scan_results_path
 
-    scan_file = get_scan_results_path(market_id, completed=True)
+    market_id = market.strip().lower() if market else "bist"
+    final_scan_file = get_scan_results_path(market_id, completed=True)
+    work_scan_file = get_scan_results_path(market_id, completed=False)
 
-    # Filter _scan_status to only use status that belongs to the requested market.
-    # Prevents BIST nightly scan status from leaking into US eligible responses.
-    _mss = _scan_status if _scan_status.get("market", "bist") == market_id else {}
+    def _timestamp_of(value):
+        try:
+            return datetime.fromisoformat(str(value).replace("Z", "+00:00")).timestamp()
+        except Exception:
+            return 0.0
 
-    if not scan_file.exists():
+    if not final_scan_file.exists() and not work_scan_file.exists():
         return {
             "ok": False,
-            "error": f"Scan results not found. Run {market_id.upper()} scan first.",
-            "scanRunning": _mss.get("running", False),
-            "scanProgress": _mss.get("progress", ""),
+            "error": f"Scan results not found for {market_id}. Run scan first.",
+            "scanRunning": _scan_status.get("running", False),
+            "scanProgress": _scan_status.get("progress", ""),
             "scanCompleted": False,
-            "universe": _mss.get("universe"),
-            "market": market_id,
+            "universe": _scan_status.get("universe"),
             "totalStocks": None,
             "stage1Done": None,
             "stage2Done": None,
@@ -1806,8 +1547,36 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
         }
     
     try:
-        with open(scan_file, "r", encoding="utf-8") as f:
-            data = json.load(f)
+        final_data = None
+        work_data = None
+
+        if final_scan_file.exists():
+            with open(final_scan_file, "r", encoding="utf-8") as f:
+                final_data = json.load(f)
+
+        if work_scan_file.exists():
+            with open(work_scan_file, "r", encoding="utf-8") as f:
+                work_data = json.load(f)
+
+        final_ts = max(
+            _timestamp_of((final_data or {}).get("updated_at")),
+            _timestamp_of((final_data or {}).get("scan_finished")),
+            _timestamp_of((final_data or {}).get("scan_started")),
+        )
+        work_ts = max(
+            _timestamp_of((work_data or {}).get("updated_at")),
+            _timestamp_of((work_data or {}).get("scan_finished")),
+            _timestamp_of((work_data or {}).get("scan_started")),
+        )
+
+        using_work_file = bool(work_data) and (
+            not final_data
+            or not work_data.get("completed", False)
+            or work_ts >= final_ts
+        )
+        data = work_data if using_work_file else final_data
+        if data is None:
+            raise RuntimeError("Scan payload is empty")
 
         completed = bool(data.get("completed", False))
         universe = data.get("universe")
@@ -1852,12 +1621,23 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
                     stage1_total = 0
 
             # Be explicit: stage2 empty = scan running, or stage1 filtered everything.
-            base_error = f"Scan results not ready yet. Start/finish the {market_id.upper()} scan first."
-            if not _mss.get("running", False) and stage1_passed_count == 0 and (stage1_failures or stage1):
-                base_error = "Stage 2 empty: Stage 1 filtered all stocks (no symbols passed)."
-
-            scan_running = bool(_mss.get("running", False) or (not completed and stage1_total > 0))
-            scan_progress = _mss.get("progress", "") or f"Stage 1: {stage1_passed_count}/{stage1_total or total_stocks or '?'} ge\u00e7ti"
+            base_error = f"Scan results not ready yet for {market_id}. Run scan first."
+            if not _scan_status.get("running", False) and stage1_passed_count == 0 and (stage1_failures or stage1):
+                base_error = f"Stage 2 empty ({market_id}): Stage 1 filtered all stocks (no symbols passed)."
+
+            scan_running = bool(_scan_status.get("running", False) or using_work_file or (not completed and stage1_total > 0))
+            live_progress = str(_scan_status.get("progress", "") or "")
+            if scan_running and live_progress.startswith("Stage 2:"):
+                scan_progress = live_progress
+            elif scan_running and stage1_total > 0:
+                failed_count = len(stage1_failures)
+                total_for_msg = stage1_total or total_stocks or "?"
+                scan_progress = (
+                    f"Stage 1 tamamlandı: {stage1_passed_count}/{total_for_msg} ge\u00e7ti, "
+                    f"{failed_count} elendi. Stage 2 ba\u015flamak \u00fczere."
+                )
+            else:
+                scan_progress = live_progress or f"Stage 1: {stage1_passed_count}/{stage1_total or total_stocks or '?'} ge\u00e7ti"
 
             return {
                 "ok": False,
@@ -1883,7 +1663,6 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
                     "avgHitRate": 0,
                 },
                 "timestamp": data.get("scan_finished") or data.get("updated_at") or data.get("scan_started"),
-                "market": market_id,
             }
 
         eligible = []
@@ -1962,11 +1741,17 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
         avg_hit_rate = sum(e.get("hit_rate", 0) for e in eligible) / len(eligible) if eligible else 0
 
         # Resolve scan progress for ok:true (stage2 has data)
-        scan_running_flag = bool(_mss.get("running", False) or (not completed and stage2_done > 0))
+        scan_running_flag = bool(_scan_status.get("running", False) or using_work_file or (not completed and stage2_done > 0))
         if not completed:
-            scan_progress_str = _mss.get("progress", "") or f"Stage 2 (ML backtest): {stage2_done}/{stage1_passed_count or '?'} tamamlandı"
+            excluded_count = len(excluded)
+            eligible_count = len(eligible)
+            total_stage2 = stage1_passed_count or '?'
+            scan_progress_str = (
+                f"Stage 2 devam ediyor: {stage2_done}/{total_stage2} tamamlandı. "
+                f"Eligible: {eligible_count}, Elenen: {excluded_count}."
+            )
         else:
-            scan_progress_str = _mss.get("progress", "")
+            scan_progress_str = _scan_status.get("progress", "") or "Tarama tamamlandı"
 
         return {
             "ok": True,
@@ -1974,7 +1759,6 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
             "scanProgress": scan_progress_str,
             "scanCompleted": completed,
             "universe": universe,
-            "market": market_id,
             "totalStocks": total_stocks,
             "stage1Done": stage1_passed_count + len(stage1_failures),
             "stage2Done": stage2_done,
@@ -1998,130 +1782,11 @@ def get_eligible_stocks(market: str = Query(DEFAULT_MARKET_ID, description="bist
         return {
             "ok": False,
             "error": str(e),
-            "scanRunning": _mss.get("running", False),
-            "scanProgress": _mss.get("progress", ""),
-            "market": market_id,
+            "scanRunning": _scan_status.get("running", False),
+            "scanProgress": _scan_status.get("progress", ""),
         }
 
 
-@app.get("/api/diagnose")
-def diagnose(market: str = Query("all", description="bist, us, or all")):
-    """Internal diagnostics — process list, telegram proxy, scan age, worker health."""
-    import subprocess, sys
-    from datetime import timedelta
-
-    selected = [market] if market in _SUPPORTED_MARKETS else list(_SUPPORTED_MARKETS)
-    diag: Dict[str, Any] = {"markets": {}}
-
-    def market_paths(market_id: str) -> Dict[str, Path]:
-        paper_dir = Path("paper_trading")
-        market_dir = paper_dir if market_id == DEFAULT_MARKET_ID else paper_dir / "markets" / market_id
-        auto_dir = market_dir / "auto_trader"
-        return {
-            "scan": get_scan_results_path(market_id, completed=True),
-            "pid": auto_dir / "worker.pid",
-            "state": auto_dir / "state.json",
-            "db": get_trading_db_path(market_id),
-        }
-
-    for market_id in selected:
-        market_diag: Dict[str, Any] = {}
-        paths = market_paths(market_id)
-
-        if paths["scan"].exists():
-            try:
-                sdata = json.loads(paths["scan"].read_text())
-                finished = sdata.get("scan_finished") or sdata.get("updated_at")
-                if finished:
-                    scan_dt = datetime.fromisoformat(str(finished).replace("Z", "+00:00"))
-                    age_h = (datetime.now(timezone.utc) - scan_dt).total_seconds() / 3600
-                    market_diag["scan_age_hours"] = round(age_h, 1)
-                    market_diag["scan_stale"] = age_h > 72
-                market_diag["scan_completed"] = sdata.get("completed", False)
-                market_diag["scan_date"] = sdata.get("scan_date", "?")[:10]
-                stage2 = sdata.get("stage2", {})
-                market_diag["eligible_count"] = sum(1 for value in stage2.values() if value.get("eligible"))
-            except Exception as exc:
-                market_diag["scan_error"] = str(exc)
-        else:
-            market_diag["scan_file"] = "missing"
-
-        if paths["pid"].exists():
-            try:
-                pid = int(paths["pid"].read_text().strip())
-                os.kill(pid, 0)
-                market_diag["worker_pid"] = pid
-                market_diag["worker_alive"] = True
-            except Exception:
-                market_diag["worker_alive"] = False
-                market_diag["worker_pid"] = None
-        else:
-            market_diag["worker_alive"] = False
-            market_diag["worker_pid"] = None
-
-        market_diag["files"] = {
-            "worker_pid": paths["pid"].exists(),
-            "scan_results": paths["scan"].exists(),
-            "state_json": paths["state"].exists(),
-            "trading_db": paths["db"].exists(),
-        }
-        diag["markets"][market_id] = market_diag
-
-    if market in _SUPPORTED_MARKETS:
-        diag.update(diag["markets"][market])
-        diag["market"] = market
-
-    # 3. Scan scheduler thread
-    diag["scheduler_running"] = _scheduler_thread.is_alive() if _scheduler_thread else False
-    diag["watchdog_running"] = _watchdog_thread.is_alive() if _watchdog_thread else False
-    diag["scan_status"] = _scan_status
-
-    # 4. Telegram proxy test
-    proxy_url = os.environ.get("TELEGRAM_PROXY_URL", "https://telegram-proxy-vercel-neon.vercel.app/tgproxy")
-    try:
-        import urllib.request as _ureq
-        _ureq.urlopen(proxy_url, timeout=5)
-        diag["telegram_proxy"] = "ok"
-    except Exception as e:
-        diag["telegram_proxy"] = f"error: {e}"
-
-    # 5. Direct Telegram API reachability (actual bot API call)
-    try:
-        import http.client as _hc2, ssl as _ssl2
-        _ctx = _ssl2.create_default_context()
-        _conn = _hc2.HTTPSConnection("api.telegram.org", context=_ctx, timeout=5)
-        _bot_token = os.environ.get("TELEGRAM_BOT_TOKEN", "")
-        _conn.request("GET", f"/bot{_bot_token}/getMe")
-        _resp = _conn.getresponse()
-        _body = json.loads(_resp.read().decode())
-        diag["telegram_direct"] = f"ok (getMe: {_body.get('ok')})"
-        _conn.close()
-    except Exception as e:
-        diag["telegram_direct"] = f"error: {e}"
-
-    # 5b. DNS debug — essential checks only
-    dns_debug = {}
-    import socket as _s
-    dns_debug["getaddrinfo_patched"] = getattr(_s.getaddrinfo, "__name__", "?") == "_tg_dns_fix"
-    try:
-        sock = _s.create_connection(("api.telegram.org", 443), timeout=5)
-        sock.close()
-        dns_debug["tcp_telegram"] = "ok"
-    except Exception as e:
-        dns_debug["tcp_telegram"] = f"error: {e}"
-    diag["dns_debug"] = dns_debug
-
-    # 6. Env vars check (non-secret)
-    diag["env"] = {
-        "TELEGRAM_BOT_TOKEN": "set" if os.environ.get("TELEGRAM_BOT_TOKEN") else "MISSING",
-        "TELEGRAM_CHAT_ID": "set" if os.environ.get("TELEGRAM_CHAT_ID") else "MISSING",
-        "TELEGRAM_PROXY_URL": os.environ.get("TELEGRAM_PROXY_URL", "(default)"),
-    }
-
-    diag["timestamp"] = datetime.now(timezone.utc).isoformat()
-    return diag
-
-
 # For Hugging Face Spaces
 if __name__ == "__main__":
     import uvicorn

huggingface-space/data/index_constituents.py

@@ -57,7 +57,7 @@ def _normalize_universe_name(name: str) -> str:
         return "bist50"
     if key in ("bist 30", "bist30", "xu030", "xu30", "xu 30", "xu-30"):
         return "bist30"
-    if key in ("all", "tum", "tüm", "tum bist", "tüm bist", "hepsi"):
+    if key in ("all", "bist_all", "bistall", "tum", "tüm", "tum bist", "tüm bist", "hepsi"):
         return "all"
     return key
 

huggingface-space/nextjs-app/package.json

@@ -6,8 +6,7 @@
     "dev": "next dev -p 3001",
     "build": "next build",
     "start": "next start",
-    "lint": "next lint",
-    "smoke:trading-auth": "node ./scripts/trading-auth-smoke.mjs"
+    "lint": "next lint"
   },
   "dependencies": {
     "@supabase/ssr": "^0.8.0",

huggingface-space/nextjs-app/scripts/trading-auth-smoke.mjs

@@ -1,250 +0,0 @@
-import { createBrowserClient } from '@supabase/ssr'
-import crypto from 'node:crypto'
-import fs from 'node:fs'
-import path from 'node:path'
-
-function loadEnvFile(filePath) {
-  if (!fs.existsSync(filePath)) return
-  const content = fs.readFileSync(filePath, 'utf8')
-  for (const rawLine of content.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || line.startsWith('#')) continue
-    const separatorIndex = line.indexOf('=')
-    if (separatorIndex === -1) continue
-    const key = line.slice(0, separatorIndex).trim()
-    const value = line.slice(separatorIndex + 1).trim()
-    if (!(key in process.env)) {
-      process.env[key] = value
-    }
-  }
-}
-
-function getEnv(name) {
-  const value = process.env[name]
-  if (!value) {
-    throw new Error(`Missing required environment variable: ${name}`)
-  }
-  return value
-}
-
-function parseArgs(argv) {
-  const options = {
-    baseUrl: process.env.SMOKE_BASE_URL || 'http://127.0.0.1:3012',
-    market: process.env.SMOKE_MARKET || 'us',
-    reason: 'trading-auth-smoke',
-  }
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]
-    if (arg === '--base-url') options.baseUrl = argv[index + 1]
-    if (arg === '--market') options.market = argv[index + 1]
-  }
-
-  return options
-}
-
-function summarizeTradingPayload(payload, status) {
-  return {
-    status,
-    hasStatus: Object.prototype.hasOwnProperty.call(payload, 'status'),
-    hasPortfolio: Object.prototype.hasOwnProperty.call(payload, 'portfolio'),
-    hasMarkets: Boolean(payload?.markets && typeof payload.markets === 'object' && !Array.isArray(payload.markets)),
-    marketKeys: payload?.markets ? Object.keys(payload.markets).sort() : [],
-    activeMarketId: payload?.activeMarketId ?? null,
-    bistHasStatus: Boolean(payload?.markets?.bist?.status),
-    usHasStatus: Boolean(payload?.markets?.us?.status),
-  }
-}
-
-async function requestJson(url, options = {}) {
-  const response = await fetch(url, options)
-  const text = await response.text()
-  let payload
-  try {
-    payload = JSON.parse(text)
-  } catch {
-    payload = { raw: text }
-  }
-  return { response, payload }
-}
-
-async function assertOkResponse(name, result, expectedStatus = 200) {
-  if (result.response.status !== expectedStatus) {
-    throw new Error(`${name} failed with ${result.response.status}: ${JSON.stringify(result.payload)}`)
-  }
-}
-
-async function main() {
-  const appDir = process.cwd()
-  loadEnvFile(path.join(appDir, '.env.local'))
-
-  const { baseUrl, market, reason } = parseArgs(process.argv.slice(2))
-  const supabaseUrl = getEnv('NEXT_PUBLIC_SUPABASE_URL')
-  const supabaseAnonKey = getEnv('NEXT_PUBLIC_SUPABASE_ANON_KEY')
-  const serviceRoleKey = getEnv('SUPABASE_SERVICE_ROLE_KEY')
-
-  const cookieJar = new Map()
-  const email = `copilot-smoke-${crypto.randomBytes(6).toString('hex')}@example.com`
-  const password = `Tmp-${crypto.randomBytes(12).toString('base64url')}A1!`
-  let createdUserId = null
-  let accessToken = null
-  let cookieHeader = ''
-
-  const getCookieHeader = () => [...cookieJar.entries()].map(([name, value]) => `${name}=${value}`).join('; ')
-
-  try {
-    const createUser = await requestJson(`${supabaseUrl}/auth/v1/admin/users`, {
-      method: 'POST',
-      headers: {
-        apikey: serviceRoleKey,
-        Authorization: `Bearer ${serviceRoleKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ email, password, email_confirm: true }),
-    })
-    await assertOkResponse('createUser', createUser)
-    createdUserId = createUser.payload.id
-
-    const client = createBrowserClient(supabaseUrl, supabaseAnonKey, {
-      cookies: {
-        getAll() {
-          return [...cookieJar.entries()].map(([name, value]) => ({ name, value }))
-        },
-        setAll(cookiesToSet) {
-          for (const cookie of cookiesToSet) {
-            if (cookie.value) cookieJar.set(cookie.name, cookie.value)
-            else cookieJar.delete(cookie.name)
-          }
-        },
-      },
-    })
-
-    const signIn = await client.auth.signInWithPassword({ email, password })
-    if (signIn.error || !signIn.data.session) {
-      throw new Error(`signInWithPassword failed: ${signIn.error?.message || 'No session returned'}`)
-    }
-
-    accessToken = signIn.data.session.access_token
-    cookieHeader = getCookieHeader()
-
-    const getCookie = await requestJson(`${baseUrl}/api/trading`, {
-      headers: { Cookie: cookieHeader },
-    })
-    await assertOkResponse('getCookie', getCookie)
-
-    const getBearer = await requestJson(`${baseUrl}/api/trading`, {
-      headers: { Authorization: `Bearer ${accessToken}` },
-    })
-    await assertOkResponse('getBearer', getBearer)
-
-    const postBody = JSON.stringify({ action: 'kill', market, reason })
-    const postCookie = await requestJson(`${baseUrl}/api/trading`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Cookie: cookieHeader,
-      },
-      body: postBody,
-    })
-    await assertOkResponse('postCookieKill', postCookie)
-
-    const postBearer = await requestJson(`${baseUrl}/api/trading`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${accessToken}`,
-      },
-      body: postBody,
-    })
-    await assertOkResponse('postBearerKill', postBearer)
-
-    const cleanupBody = JSON.stringify({ action: 'unkill', market })
-    const cleanupCookie = await requestJson(`${baseUrl}/api/trading`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Cookie: cookieHeader,
-      },
-      body: cleanupBody,
-    })
-    await assertOkResponse('postCookieUnkill', cleanupCookie)
-
-    const cleanupBearer = await requestJson(`${baseUrl}/api/trading`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${accessToken}`,
-      },
-      body: cleanupBody,
-    })
-    await assertOkResponse('postBearerUnkill', cleanupBearer)
-
-    accessToken = null
-    cookieHeader = ''
-
-    console.log(JSON.stringify({
-      baseUrl,
-      market,
-      cookieNames: [...cookieJar.keys()].sort(),
-      getCookie: summarizeTradingPayload(getCookie.payload, getCookie.response.status),
-      getBearer: summarizeTradingPayload(getBearer.payload, getBearer.response.status),
-      postCookie: {
-        status: postCookie.response.status,
-        success: postCookie.payload?.success ?? false,
-        action: postCookie.payload?.action ?? null,
-      },
-      postBearer: {
-        status: postBearer.response.status,
-        success: postBearer.payload?.success ?? false,
-        action: postBearer.payload?.action ?? null,
-      },
-      cleanupCookie: {
-        status: cleanupCookie.response.status,
-        success: cleanupCookie.payload?.success ?? false,
-        action: cleanupCookie.payload?.action ?? null,
-      },
-      cleanupBearer: {
-        status: cleanupBearer.response.status,
-        success: cleanupBearer.payload?.success ?? false,
-        action: cleanupBearer.payload?.action ?? null,
-      },
-    }))
-  } finally {
-    if (cookieHeader) {
-      await requestJson(`${baseUrl}/api/trading`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Cookie: cookieHeader,
-        },
-        body: JSON.stringify({ action: 'unkill', market }),
-      }).catch(() => undefined)
-    }
-
-    if (accessToken) {
-      await requestJson(`${baseUrl}/api/trading`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${accessToken}`,
-        },
-        body: JSON.stringify({ action: 'unkill', market }),
-      }).catch(() => undefined)
-    }
-
-    if (createdUserId) {
-      await fetch(`${supabaseUrl}/auth/v1/admin/users/${createdUserId}`, {
-        method: 'DELETE',
-        headers: {
-          apikey: serviceRoleKey,
-          Authorization: `Bearer ${serviceRoleKey}`,
-        },
-      }).catch(() => undefined)
-    }
-  }
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error))
-  process.exitCode = 1
-})

huggingface-space/nextjs-app/src/app/ai-analysis/page.tsx

@@ -6,7 +6,6 @@ import Link from 'next/link';
 
 import { fetchJson } from '@/lib/http';
 import { logger } from '@/lib/logger';
-import { useMarket } from '@/contexts/MarketContext';
 
 type TabType = 'market' | 'stock';
 
@@ -35,21 +34,16 @@ interface AnalysisResult {
 }
 
 export default function AIAnalysisPage() {
-  const { market } = useMarket();
-  const isUS = market === 'us';
-  const currencySymbol = isUS ? '$' : '₺';
   const [activeTab, setActiveTab] = useState<TabType>('stock');
   const [symbol, setSymbol] = useState('');
   const [analysis, setAnalysis] = useState<AnalysisResult | null>(null);
   const [loading, setLoading] = useState(false);
   const [marketOverview, setMarketOverview] = useState<Record<string, unknown> | null>(null);
   const [quickSymbols, setQuickSymbols] = useState<string[]>([]);
-  const t = (tr: string, en: string) => isUS ? en : tr;
 
   useEffect(() => {
     let mounted = true;
-    const universeName = isUS ? 'us_popular' : 'bist30';
-    fetchJson<Record<string, unknown>>(`/api/universe?name=${universeName}`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
+    fetchJson<Record<string, unknown>>(`/api/universe?name=bist30`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
       .then((data) => {
         const symbols = Array.isArray(data?.symbols) ? data.symbols : []
         if (mounted) setQuickSymbols(symbols.slice(0, 12))
@@ -60,15 +54,15 @@ export default function AIAnalysisPage() {
     return () => {
       mounted = false
     }
-  }, [isUS])
+  }, [])
 
   const handleMarketAnalysis = async () => {
     setLoading(true);
     try {
-      const data = await fetchJson<Record<string, unknown>>(`/api/market-overview?market=${market}`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
+      const data = await fetchJson<Record<string, unknown>>(`/api/market-overview`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
       setMarketOverview(data)
     } catch (error) {
-      console.error(t('Piyasa analizi başarısız:', 'Market analysis failed:'), error);
+      console.error('Market analysis failed:', error);
       setMarketOverview(null)
     } finally {
       setLoading(false);
@@ -84,12 +78,12 @@ export default function AIAnalysisPage() {
 
       const [stockRaw, techRaw, mlRaw] = await Promise.all([
         fetchJson<Record<string, unknown>>(
-          `/api/stock-data?symbol=${encodeURIComponent(sym)}&period=6mo&interval=1d&market=${market}`,
+          `/api/stock-data?symbol=${encodeURIComponent(sym)}&period=6mo&interval=1d`,
           { method: 'GET' },
           { timeoutMs: 20000, retries: 1 }
         ),
         fetchJson<Record<string, unknown>>(
-          `/api/technical-analysis?symbol=${encodeURIComponent(sym)}&market=${market}`,
+          `/api/technical-analysis?symbol=${encodeURIComponent(sym)}`,
           { method: 'GET' },
           { timeoutMs: 20000, retries: 1 }
         ).catch(() => null),
@@ -99,7 +93,7 @@ export default function AIAnalysisPage() {
           {
             timeoutMs: 30000,
             retries: 0,
-            jsonBody: { symbols: [sym], days_ahead: 7, model: 'ensemble', market },
+            jsonBody: { symbols: [sym], days_ahead: 7, model: 'ensemble' },
           }
         ).catch(() => null),
       ]);
@@ -109,30 +103,27 @@ export default function AIAnalysisPage() {
       let techSignal: 'BUY' | 'SELL' | 'HOLD' = 'HOLD'
       try {
         const scanResp = await fetchJson<Record<string, unknown>>(
-          isUS ? `/api/trading-signals` : `/api/scan-signals`,
+          `/api/scan-signals`,
           { method: 'POST' },
           {
             timeoutMs: 30000,
             retries: 0,
             jsonBody: {
               symbols: [sym],
-              ...(isUS ? { market } : { period: '6mo', interval: '1d', limit: 1 }),
+              period: '6mo',
+              interval: '1d',
+              limit: 1,
             },
           }
         )
 
-        const items: Record<string, unknown>[] = Array.isArray(isUS ? scanResp?.signals : scanResp?.data)
-          ? ((isUS ? scanResp.signals : scanResp.data) as Record<string, unknown>[])
-          : []
+        const items = Array.isArray(scanResp?.data) ? scanResp.data : []
         const item = items.find((x: Record<string, unknown>) => String(x?.symbol || '').toUpperCase() === sym)
-        const gates = item?.gates as Record<string, unknown> | undefined
-        if (isUS) {
-          requiredOk = String(item?.signal || '').toUpperCase() === 'BUY'
-        } else if (gates && typeof gates.required_ok === 'boolean') {
-          requiredOk = gates.required_ok as boolean
+        if (item?.gates && typeof item.gates.required_ok === 'boolean') {
+          requiredOk = item.gates.required_ok
         }
-        if (item?.technical_signal || item?.signal) {
-          const ts = String(item.technical_signal || item.signal).toUpperCase().trim()
+        if (item?.technical_signal) {
+          const ts = String(item.technical_signal).toUpperCase().trim()
           if (ts === 'BUY' || ts === 'SELL') techSignal = ts
         }
       } catch (e) {
@@ -211,8 +202,8 @@ export default function AIAnalysisPage() {
   };
 
   const tabs = [
-    { id: 'market', label: isUS ? 'Market Overview' : 'Piyasa Özeti', icon: Globe },
-    { id: 'stock', label: isUS ? 'Stock Analysis' : 'Hisse Analizi', icon: BarChart3 },
+    { id: 'market', label: 'Piyasa Özeti', icon: Globe },
+    { id: 'stock', label: 'Hisse Analizi', icon: BarChart3 },
   ];
 
   return (
@@ -222,10 +213,10 @@ export default function AIAnalysisPage() {
         <div className="mb-6">
           <div className="flex items-center gap-3 mb-2">
             <Brain className="w-8 h-8 text-purple-600" />
-            <h1 className="text-3xl font-bold text-gray-900">{isUS ? 'AI Analysis' : 'Yapay Zeka Analizleri'}</h1>
+            <h1 className="text-3xl font-bold text-gray-900">Yapay Zeka Analizleri</h1>
           </div>
           <p className="text-gray-600">
-            {isUS ? 'Technical analysis and stock insights (for informational purposes)' : 'Makine öğrenmesi destekli piyasa özeti ve hisse tahminleri (bilgi amaçlı)'}
+            Makine öğrenmesi destekli piyasa özeti ve hisse tahminleri (bilgi amaçlı)
           </p>
         </div>
 
@@ -256,9 +247,9 @@ export default function AIAnalysisPage() {
         {activeTab === 'market' && (
           <div className="space-y-6">
             <div className="bg-white p-6 rounded-lg shadow-sm">
-              <h2 className="text-xl font-bold text-gray-900 mb-4">{isUS ? '📈 Market Overview' : '📈 Piyasa Özeti'}</h2>
+              <h2 className="text-xl font-bold text-gray-900 mb-4">📈 Piyasa Özeti</h2>
               <p className="text-gray-600 mb-4">
-                {isUS ? 'Shows real market summary from backend.' : 'Bu bölüm, backend\'den gelen gerçek piyasa özetini gösterir.'}
+                Bu bölüm, backend&apos;den gelen gerçek piyasa özetini gösterir.
               </p>
               <button
                 onClick={handleMarketAnalysis}
@@ -266,7 +257,7 @@ export default function AIAnalysisPage() {
                 className="bg-purple-600 text-white px-6 py-3 rounded-md hover:bg-purple-700 disabled:opacity-50 font-semibold flex items-center gap-2"
               >
                 <Activity className="w-5 h-5" />
-                {loading ? (isUS ? 'Loading...' : 'Yükleniyor...') : (isUS ? 'Fetch Market Data' : 'Piyasa Verisini Getir')}
+                {loading ? 'Yükleniyor...' : 'Piyasa Verisini Getir'}
               </button>
             </div>
 
@@ -275,17 +266,17 @@ export default function AIAnalysisPage() {
                 <h3 className="font-semibold text-gray-900 mb-3">Market Overview</h3>
                 <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
                   <div className="p-4 bg-gray-50 rounded-lg">
-                    <p className="text-sm text-gray-600">{isUS ? 'Index' : 'Endeks'}</p>
-                    <p className="text-xl font-bold text-gray-900">{String(marketOverview.index || (isUS ? 'S&P 500' : 'BIST 100'))}</p>
+                    <p className="text-sm text-gray-600">Endeks</p>
+                    <p className="text-xl font-bold text-gray-900">{String(marketOverview.index || 'BIST 100')}</p>
                   </div>
                   <div className="p-4 bg-gray-50 rounded-lg">
-                    <p className="text-sm text-gray-600">{isUS ? 'Value' : 'Değer'}</p>
+                    <p className="text-sm text-gray-600">Değer</p>
                     <p className="text-xl font-bold text-gray-900">
-                      {typeof marketOverview.value === 'number' ? marketOverview.value.toLocaleString(isUS ? 'en-US' : 'tr-TR', { minimumFractionDigits: 2 }) : '—'}
+                      {typeof marketOverview.value === 'number' ? marketOverview.value.toLocaleString('tr-TR', { minimumFractionDigits: 2 }) : '—'}
                     </p>
                   </div>
                   <div className="p-4 bg-gray-50 rounded-lg">
-                    <p className="text-sm text-gray-600">{isUS ? 'Daily Change' : 'Günlük Değişim'}</p>
+                    <p className="text-sm text-gray-600">Günlük Değişim</p>
                     <p className={`text-xl font-bold ${(Number(marketOverview.change_percent) || 0) >= 0 ? 'text-green-600' : 'text-red-600'}`}>
                       {typeof marketOverview.change_percent === 'number' ? `${marketOverview.change_percent >= 0 ? '+' : ''}${marketOverview.change_percent.toFixed(2)}%` : '—'}
                     </p>
@@ -294,7 +285,7 @@ export default function AIAnalysisPage() {
               </div>
             ) : (
               <div className="bg-white p-6 rounded-lg shadow-sm">
-                <p className="text-gray-600">{isUS ? 'No data yet.' : 'Henüz veri yok.'}</p>
+                <p className="text-gray-600">Henüz veri yok.</p>
               </div>
             )}
           </div>
@@ -304,9 +295,9 @@ export default function AIAnalysisPage() {
         {activeTab === 'stock' && (
           <div className="space-y-6">
             <div className="bg-white p-6 rounded-lg shadow-sm">
-              <h2 className="text-xl font-bold text-gray-900 mb-4">{isUS ? '🧠 Stock Analysis' : '🧠 Hisse Senedi Analizi'}</h2>
+              <h2 className="text-xl font-bold text-gray-900 mb-4">🧠 Hisse Senedi Analizi</h2>
               <p className="text-gray-600 mb-4">
-                {isUS ? 'Shows technical analysis and summary metrics for your selected stock.' : 'Seçtiğiniz hisse senedi için model çıktısını ve özet metrikleri gösterir.'}
+                Seçtiğiniz hisse senedi için model çıktısını ve özet metrikleri gösterir.
               </p>
               <div className="flex gap-4">
                 <div className="flex-1">
@@ -314,7 +305,7 @@ export default function AIAnalysisPage() {
                     <Search className="absolute left-3 top-1/2 transform -translate-y-1/2 w-5 h-5 text-gray-400" />
                     <input
                       type="text"
-                      placeholder={isUS ? 'e.g. AAPL, MSFT, GOOGL' : 'Örn: THYAO, EREGL, AKBNK'}
+                      placeholder="Örn: THYAO, EREGL, AKBNK"
                       value={symbol}
                       onChange={(e) => setSymbol(e.target.value.toUpperCase())}
                       onKeyPress={(e) => e.key === 'Enter' && handleStockAnalyze()}
@@ -328,7 +319,7 @@ export default function AIAnalysisPage() {
                   className="bg-purple-600 text-white px-6 py-3 rounded-md hover:bg-purple-700 disabled:opacity-50 disabled:cursor-not-allowed font-semibold flex items-center gap-2"
                 >
                   <Brain className="w-5 h-5" />
-                  {loading ? (isUS ? 'Analyzing...' : 'Analiz Ediliyor...') : (isUS ? 'Analyze' : 'Analiz Et')}
+                  {loading ? 'Analiz Ediliyor...' : 'Analiz Et'}
                 </button>
               </div>
             </div>
@@ -344,7 +335,7 @@ export default function AIAnalysisPage() {
                     </div>
                     <div className="text-right">
                       <p className="text-3xl font-bold text-gray-900">
-                        {typeof analysis.stock.current_price === 'number' ? `${currencySymbol}${analysis.stock.current_price.toFixed(2)}` : '—'}
+                        {typeof analysis.stock.current_price === 'number' ? `₺${analysis.stock.current_price.toFixed(2)}` : '—'}
                       </p>
                       <p className={`text-lg font-semibold ${
                         (analysis.stock.change_percent ?? 0) >= 0 ? 'text-green-600' : 'text-red-600'
@@ -357,16 +348,16 @@ export default function AIAnalysisPage() {
                   </div>
                   <div className="grid grid-cols-3 gap-4 pt-4 border-t">
                     <div>
-                      <p className="text-sm text-gray-600">{isUS ? 'Volume' : 'Hacim'}</p>
+                      <p className="text-sm text-gray-600">Hacim</p>
                       <p className="font-semibold">{typeof analysis.stock.volume === 'number' ? `${(analysis.stock.volume / 1000000).toFixed(1)}M` : '—'}</p>
                     </div>
                     <div>
-                      <p className="text-sm text-gray-600">{isUS ? '52 Week Low' : '52 Hafta Düşük'}</p>
-                      <p className="font-semibold">{typeof analysis.stock.week_52_low === 'number' ? `${currencySymbol}${analysis.stock.week_52_low.toFixed(2)}` : '—'}</p>
+                      <p className="text-sm text-gray-600">52 Hafta Düşük</p>
+                      <p className="font-semibold">{typeof analysis.stock.week_52_low === 'number' ? `₺${analysis.stock.week_52_low.toFixed(2)}` : '—'}</p>
                     </div>
                     <div>
-                      <p className="text-sm text-gray-600">{isUS ? '52 Week High' : '52 Hafta Yüksek'}</p>
-                      <p className="font-semibold">{typeof analysis.stock.week_52_high === 'number' ? `${currencySymbol}${analysis.stock.week_52_high.toFixed(2)}` : '—'}</p>
+                      <p className="text-sm text-gray-600">52 Hafta Yüksek</p>
+                      <p className="font-semibold">{typeof analysis.stock.week_52_high === 'number' ? `₺${analysis.stock.week_52_high.toFixed(2)}` : '—'}</p>
                     </div>
                   </div>
                 </div>
@@ -376,7 +367,7 @@ export default function AIAnalysisPage() {
                   <div className="bg-gradient-to-r from-purple-600 to-purple-800 text-white p-6 rounded-lg shadow-lg">
                     <div className="flex items-center gap-2 mb-4">
                       <Zap className="w-6 h-6" />
-                      <h3 className="text-xl font-bold">{isUS ? 'Technical Signal' : 'ML Tahmini'}</h3>
+                      <h3 className="text-xl font-bold">ML Tahmini</h3>
                       {analysis.prediction.models_used != null && (
                         <span className="text-xs bg-white/20 px-2 py-1 rounded">
                           Ensemble ({String(analysis.prediction.models_used)} Model)
@@ -385,18 +376,18 @@ export default function AIAnalysisPage() {
                     </div>
                     <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
                       <div className="bg-white/10 backdrop-blur p-4 rounded-lg">
-                        <p className="text-sm opacity-75 mb-1">{isUS ? 'Signal' : 'Sinyal'}</p>
+                        <p className="text-sm opacity-75 mb-1">Sinyal</p>
                         <p className="text-2xl font-bold">{analysis.prediction.recommendation}</p>
                       </div>
                       <div className="bg-white/10 backdrop-blur p-4 rounded-lg">
-                        <p className="text-sm opacity-75 mb-1">{isUS ? 'Confidence' : 'Güven'}</p>
+                        <p className="text-sm opacity-75 mb-1">Güven</p>
                         <p className="text-2xl font-bold">{typeof analysis.prediction.confidence === 'number' ? `${analysis.prediction.confidence.toFixed(0)}%` : '—'}</p>
                       </div>
                       <div className="bg-white/10 backdrop-blur p-4 rounded-lg">
-                        <p className="text-sm opacity-75 mb-1">{isUS ? 'Predicted Price' : 'Tahmini Fiyat'}</p>
+                        <p className="text-sm opacity-75 mb-1">Tahmini Fiyat</p>
                         <p className="text-2xl font-bold">
                           {analysis.prediction.predicted_price !== undefined && analysis.prediction.predicted_price !== null
-                            ? `${currencySymbol}${Number(analysis.prediction.predicted_price).toFixed(2)}`
+                            ? `₺${Number(analysis.prediction.predicted_price).toFixed(2)}`
                             : '—'}
                         </p>
                       </div>
@@ -404,7 +395,7 @@ export default function AIAnalysisPage() {
                   </div>
                 ) : (
                   <div className="bg-white p-6 rounded-lg shadow-sm border">
-                    <p className="text-gray-700">{isUS ? 'Technical data not available for this stock.' : 'ML tahmini alınamadı (servis hata verdi veya veri yok).'}</p>
+                    <p className="text-gray-700">ML tahmini alınamadı (servis hata verdi veya veri yok).</p>
                   </div>
                 )}
 
@@ -413,13 +404,13 @@ export default function AIAnalysisPage() {
                   <div className="bg-white p-6 rounded-lg shadow-sm">
                     <h3 className="font-bold text-gray-900 mb-4 flex items-center gap-2">
                       <Target className="w-5 h-5 text-purple-600" />
-                      ML Model {isUS ? 'Quality' : 'Kalitesi'}
+                      ML Model Kalitesi
                     </h3>
-                    <p className="text-xs text-gray-500 mb-3">{isUS ? 'These values are ML model internal validation metrics, not technical indicators.' : 'Bu değerler teknik gösterge değil, ML modelinin iç doğrulama metrikleridir.'}</p>
+                    <p className="text-xs text-gray-500 mb-3">Bu değerler teknik gösterge değil, ML modelinin iç doğrulama metrikleridir.</p>
                     <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
                       {typeof analysis.prediction.trend_score === 'number' && (
                         <div className="p-4 bg-gray-50 rounded-lg">
-                          <p className="text-sm text-gray-600">{isUS ? 'Direction Accuracy' : 'Yön Doğruluğu (Direction Acc.)'}</p>
+                          <p className="text-sm text-gray-600">Yön Doğruluğu (Direction Acc.)</p>
                           <div className="flex items-center gap-2 mt-1">
                             <div className="flex-1 bg-gray-200 rounded-full h-2">
                               <div className="bg-purple-600 h-2 rounded-full" style={{ width: `${analysis.prediction.trend_score}%` }}></div>
@@ -449,13 +440,13 @@ export default function AIAnalysisPage() {
                     href={`/stocks/${symbol}`}
                     className="flex-1 bg-blue-600 text-white text-center py-3 px-6 rounded-md hover:bg-blue-700 font-semibold"
                   >
-                    {isUS ? 'Detailed Analysis' : 'Detaylı Analiz Sayfası'}
+                    Detaylı Analiz Sayfası
                   </Link>
                   <button
                     onClick={() => setAnalysis(null)}
                     className="px-6 py-3 border border-gray-300 rounded-md hover:bg-gray-50 font-semibold"
                   >
-                    {isUS ? 'New Analysis' : 'Yeni Analiz'}
+                    Yeni Analiz
                   </button>
                 </div>
               </div>
@@ -464,8 +455,8 @@ export default function AIAnalysisPage() {
             {!analysis && !loading && (
               <div className="bg-white rounded-lg shadow-sm p-12 text-center">
                 <Brain className="w-16 h-16 text-gray-400 mx-auto mb-4" />
-                <h3 className="text-lg font-semibold text-gray-900 mb-2">{isUS ? 'AI-Powered Analysis' : 'Yapay Zeka Destekli Analiz'}</h3>
-                <p className="text-gray-600 mb-6">{isUS ? 'Enter a stock symbol to start technical analysis' : 'Hisse sembolü girerek ML tahminleri ve AI analizi başlatın'}</p>
+                <h3 className="text-lg font-semibold text-gray-900 mb-2">Yapay Zeka Destekli Analiz</h3>
+                <p className="text-gray-600 mb-6">Hisse sembolü girerek ML tahminleri ve AI analizi başlatın</p>
                 <div className="flex flex-wrap justify-center gap-2">
                   {quickSymbols.map((s) => (
                     <button
@@ -478,7 +469,7 @@ export default function AIAnalysisPage() {
                   ))}
                 </div>
                 {quickSymbols.length === 0 && (
-                  <p className="text-xs text-gray-400 mt-3">{isUS ? 'Sample list not available.' : 'Örnek liste şu an alınamadı.'}</p>
+                  <p className="text-xs text-gray-400 mt-3">Örnek liste şu an alınamadı.</p>
                 )}
               </div>
             )}

huggingface-space/nextjs-app/src/app/announcements/page.tsx

@@ -4,7 +4,6 @@ import { useEffect, useMemo, useState } from 'react'
 import Link from 'next/link'
 import { Megaphone, Plus, Trash2, ExternalLink, RefreshCw } from 'lucide-react'
 import { useAuth } from '@/contexts/AuthContext'
-import { useMarket } from '@/contexts/MarketContext'
 import { addAnnouncement, deleteAnnouncement, loadAnnouncements, type Announcement } from '@/lib/announcements'
 
 type KapItem = {
@@ -20,8 +19,6 @@ type KapItem = {
 
 export default function AnnouncementsPage() {
   const { user } = useAuth()
-  const { market } = useMarket()
-  const isUS = market === 'us'
   const userKey = user?.id
 
   const [items, setItems] = useState<Announcement[]>([])
@@ -46,23 +43,22 @@ export default function AnnouncementsPage() {
       const json = await res.json().catch(() => null)
       if (!json?.ok) {
         setKapItems([])
-        setKapError(isUS ? 'KAP data is currently unavailable (best-effort).' : 'KAP verisi şu an alınamadı (best-effort).')
+        setKapError('KAP verisi şu an alınamadı (best-effort).')
         return
       }
       setKapItems(Array.isArray(json.data) ? json.data : [])
     } catch {
       setKapItems([])
-      setKapError(isUS ? 'KAP data is currently unavailable (best-effort).' : 'KAP verisi şu an alınamadı (best-effort).')
+      setKapError('KAP verisi şu an alınamadı (best-effort).')
     } finally {
       setKapLoading(false)
     }
   }
 
   useEffect(() => {
-    if (!isUS) fetchKap()
-    else setKapLoading(false)
+    fetchKap()
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isUS])
+  }, [])
 
   const hasItems = items.length > 0
 
@@ -92,7 +88,7 @@ export default function AnnouncementsPage() {
 
   const formatDate = (iso: string) => {
     const d = new Date(iso)
-    return d.toLocaleString(isUS ? 'en-US' : 'tr-TR', { year: 'numeric', month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
+    return d.toLocaleString('tr-TR', { year: 'numeric', month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
   }
 
   return (
@@ -101,30 +97,28 @@ export default function AnnouncementsPage() {
         <div className="mb-8">
           <div className="flex items-center gap-3 mb-2">
             <Megaphone className="w-8 h-8 text-blue-600" />
-            <h1 className="text-3xl font-bold text-gray-900">{isUS ? 'Announcements' : 'Duyurular'}</h1>
+            <h1 className="text-3xl font-bold text-gray-900">Duyurular</h1>
           </div>
           <p className="text-gray-600">
-            {isUS
-              ? 'Local announcement list (no-toy). KAP integration requires a separate backend.'
-              : 'Yerel duyuru listesi (no-toy). KAP entegrasyonu ayrı bir backend gerektirir.'}
+            Yerel duyuru listesi (no-toy). KAP entegrasyonu ayrı bir backend gerektirir.
           </p>
         </div>
 
         <div className="bg-white rounded-lg shadow p-4 mb-6">
-          <h2 className="font-semibold text-gray-900 mb-3">{isUS ? 'Add Announcement' : 'Duyuru Ekle'}</h2>
+          <h2 className="font-semibold text-gray-900 mb-3">Duyuru Ekle</h2>
           <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
             <div>
-              <label htmlFor="ann-title" className="block text-sm font-medium text-gray-700 mb-1">{isUS ? 'Title' : 'Başlık'}</label>
+              <label htmlFor="ann-title" className="block text-sm font-medium text-gray-700 mb-1">Başlık</label>
               <input
                 id="ann-title"
                 value={title}
                 onChange={(e) => setTitle(e.target.value)}
                 className="w-full px-3 py-2 border border-gray-300 rounded-md focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
-                placeholder={isUS ? 'E.g.: Data source updated' : 'Örn: Veri kaynağı güncellendi'}
+                placeholder="Örn: Veri kaynağı güncellendi"
               />
             </div>
             <div>
-              <label htmlFor="ann-url" className="block text-sm font-medium text-gray-700 mb-1">{isUS ? 'Link (optional)' : 'Link (opsiyonel)'}</label>
+              <label htmlFor="ann-url" className="block text-sm font-medium text-gray-700 mb-1">Link (opsiyonel)</label>
               <input
                 id="ann-url"
                 value={url}
@@ -134,14 +128,14 @@ export default function AnnouncementsPage() {
               />
             </div>
             <div className="md:col-span-2">
-              <label htmlFor="ann-content" className="block text-sm font-medium text-gray-700 mb-1">{isUS ? 'Content' : 'İçerik'}</label>
+              <label htmlFor="ann-content" className="block text-sm font-medium text-gray-700 mb-1">İçerik</label>
               <textarea
                 id="ann-content"
                 value={content}
                 onChange={(e) => setContent(e.target.value)}
                 className="w-full px-3 py-2 border border-gray-300 rounded-md focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
                 rows={4}
-                placeholder={isUS ? 'Announcement details...' : 'Duyuru detayları...'}
+                placeholder="Duyuru detayları..."
               />
             </div>
           </div>
@@ -149,7 +143,7 @@ export default function AnnouncementsPage() {
           <div className="flex items-center justify-between mt-4">
             <label className="inline-flex items-center gap-2 text-sm text-gray-700">
               <input type="checkbox" checked={important} onChange={(e) => setImportant(e.target.checked)} />
-              {isUS ? 'Important' : 'Önemli'}
+              Önemli
             </label>
 
             <button
@@ -157,21 +151,21 @@ export default function AnnouncementsPage() {
               className="inline-flex items-center gap-2 px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 font-semibold"
             >
               <Plus className="w-4 h-4" />
-              {isUS ? 'Add' : 'Ekle'}
+              Ekle
             </button>
           </div>
         </div>
 
         <div className="bg-white rounded-lg shadow p-4">
           <div className="flex items-center justify-between mb-3">
-            <h2 className="font-semibold text-gray-900">{isUS ? 'Announcement List' : 'Duyuru Listesi'}</h2>
+            <h2 className="font-semibold text-gray-900">Duyuru Listesi</h2>
             <Link href="/news" className="text-sm text-blue-600 hover:text-blue-800">
-              {isUS ? 'News →' : 'Haberler →'}
+              Haberler →
             </Link>
           </div>
 
           {!hasItems ? (
-            <div className="text-center py-10 text-gray-600">{isUS ? 'No announcements added yet.' : 'Henüz duyuru eklenmedi.'}</div>
+            <div className="text-center py-10 text-gray-600">Henüz duyuru eklenmedi.</div>
           ) : (
             <div className="space-y-3">
               {sorted.map((a) => (
@@ -193,12 +187,12 @@ export default function AnnouncementsPage() {
                           rel="noopener noreferrer"
                           className="inline-flex items-center gap-1 text-sm text-blue-600 hover:text-blue-800 mt-2"
                         >
-                          {isUS ? 'Source' : 'Kaynak'}
+                          Kaynak
                           <ExternalLink className="w-3 h-3" />
                         </a>
                       ) : null}
                     </div>
-                    <button onClick={() => onDelete(a.id)} className="text-red-600 hover:text-red-800" aria-label={isUS ? 'Delete announcement' : 'Duyuruyu sil'}>
+                    <button onClick={() => onDelete(a.id)} className="text-red-600 hover:text-red-800" aria-label="Duyuruyu sil">
                       <Trash2 className="w-5 h-5" />
                     </button>
                   </div>
@@ -208,7 +202,6 @@ export default function AnnouncementsPage() {
           )}
         </div>
 
-        {!isUS && (
         <div className="mt-6 bg-white rounded-lg shadow p-4">
           <div className="flex items-center justify-between gap-3">
             <h2 className="font-semibold text-gray-900">KAP</h2>
@@ -223,7 +216,7 @@ export default function AnnouncementsPage() {
           </div>
 
           <p className="text-sm text-gray-600 mt-1">
-            KAP &quot;light disclosure list&quot; üzerinden (anahtarsız) best-effort çekilir. Sembol bilgisi her zaman gelmeyebilir.
+            KAP “light disclosure list” üzerinden (anahtarsız) best-effort çekilir. Sembol bilgisi her zaman gelmeyebilir.
           </p>
 
           {kapError ? <div className="mt-3 text-sm text-amber-900">{kapError}</div> : null}
@@ -255,7 +248,6 @@ export default function AnnouncementsPage() {
             </div>
           )}
         </div>
-        )}
       </div>
     </div>
   )

huggingface-space/nextjs-app/src/app/api/eligible/route.ts

@@ -10,22 +10,6 @@ export const dynamic = 'force-dynamic'
  */
 const isProduction = !!API_BASE
 
-type MarketId = 'bist' | 'us'
-
-function parseMarket(value: string | null): MarketId {
-  return value === 'us' ? 'us' : 'bist'
-}
-
-function resolveProjectRoot(join: (...parts: string[]) => string): string {
-  const cwd = process.cwd()
-  return cwd.endsWith('/nextjs-app') ? join(cwd, '..') : cwd
-}
-
-function timestampOf(value: unknown): number {
-  const timestamp = Date.parse(String(value || ''))
-  return Number.isFinite(timestamp) ? timestamp : 0
-}
-
 interface ScanStage2 {
   eligible: boolean
   sharpe: number
@@ -47,8 +31,6 @@ interface ScanResults {
 export async function GET(request: Request) {
   const auth = await requireAuth(request)
   if (!auth.authenticated) return auth.response
-  const { searchParams } = new URL(request.url)
-  const market = parseMarket(searchParams.get('market'))
 
   // Production: proxy to HuggingFace Space
   if (isProduction) {
@@ -57,7 +39,7 @@ export async function GET(request: Request) {
       const timeout = setTimeout(() => controller.abort(), 30000)
 
       try {
-        const resp = await fetch(apiUrl(`/api/eligible?market=${market}`), {
+        const resp = await fetch(apiUrl('/api/eligible'), {
           headers: { accept: 'application/json' },
           signal: controller.signal,
         })
@@ -88,151 +70,37 @@ export async function GET(request: Request) {
     const { join } = require('path')
     /* eslint-enable */
 
-    const projectRoot = resolveProjectRoot(join)
-    const paperDir = join(projectRoot, 'paper_trading')
-    const marketDir = market === 'bist' ? paperDir : join(paperDir, 'markets', market)
-    const finalFile = market === 'bist' ? join(paperDir, 'bist100_scan_results.json') : join(marketDir, 'scan_results.json')
-    const workFile = market === 'bist' ? join(paperDir, 'bist100_scan_results_work.json') : join(marketDir, 'scan_results_work.json')
-
-    let finalRaw: string | null = null
-    let workRaw: string | null = null
+    const filePath = join(process.cwd(), '..', 'paper_trading', 'bist100_scan_results.json')
+    let raw: string
 
     try {
-      finalRaw = await readFile(finalFile, 'utf-8')
+      raw = await readFile(filePath, 'utf-8')
     } catch {
-      finalRaw = null
-    }
-
-    try {
-      workRaw = await readFile(workFile, 'utf-8')
-    } catch {
-      workRaw = null
-    }
-
-    if (!finalRaw && !workRaw) {
-      return NextResponse.json(
-        {
-          ok: false,
-          error: `Scan results not found. Run ${market.toUpperCase()} scan first.`,
-          scanRunning: false,
-          scanProgress: '',
-          scanCompleted: false,
-          universe: null,
-          market,
-          totalStocks: null,
-          stage1Done: null,
-          stage2Done: null,
-          updatedAt: null,
-          eligible: [],
-          excluded: [],
-          stage1Failures: [],
-          stage1PassedCount: 0,
-          summary: {
-            eligibleCount: 0,
-            excludedCount: 0,
-            stage1FailedCount: 0,
-            avgSharpe: 0,
-            avgReturn: 0,
-            avgHitRate: 0,
-          },
-        },
-        { status: 404 }
-      )
-    }
-
-    const finalData = finalRaw ? JSON.parse(finalRaw) as Record<string, unknown> : null
-    const workData = workRaw ? JSON.parse(workRaw) as Record<string, unknown> : null
-    const finalTimestamp = Math.max(
-      timestampOf(finalData?.updated_at),
-      timestampOf(finalData?.scan_finished),
-      timestampOf(finalData?.scan_started),
-      timestampOf(finalData?.timestamp),
-    )
-    const workTimestamp = Math.max(
-      timestampOf(workData?.updated_at),
-      timestampOf(workData?.scan_finished),
-      timestampOf(workData?.scan_started),
-      timestampOf(workData?.timestamp),
-    )
-    const usingWorkFile = Boolean(workData) && (!finalData || !workData?.completed || workTimestamp >= finalTimestamp)
-    const rawData = (usingWorkFile ? workData : finalData) as Record<string, unknown> | null
-
-    if (!rawData) {
-      throw new Error('Eligible scan payload is empty')
-    }
-
-    const stage1 = (rawData.stage1 ?? {}) as Record<string, Record<string, unknown>>
-    const stage2 = (rawData.stage2 ?? {}) as Record<string, Record<string, unknown>>
-    const completed = Boolean(rawData.completed && !usingWorkFile)
-
-    const stage1Failures: Array<{ symbol: string; reason: string }> = []
-    let stage1PassedCount = 0
-    let stage1Done = 0
-
-    for (const [sym, info] of Object.entries(stage1)) {
-      stage1Done += 1
-      if (info?.passed) {
-        stage1PassedCount += 1
-      } else {
-        stage1Failures.push({ symbol: sym, reason: String(info?.reason || 'FAIL') })
+      const altPath = join(process.cwd(), 'paper_trading', 'bist100_scan_results.json')
+      try {
+        raw = await readFile(altPath, 'utf-8')
+      } catch {
+        return NextResponse.json(
+          { ok: false, error: 'Scan results not found. Run BIST100 scan first.' },
+          { status: 404 }
+        )
       }
     }
 
-    if (usingWorkFile && Object.keys(stage2).length === 0) {
-      return NextResponse.json({
-        ok: false,
-        error: `Scan results not ready yet. Start/finish the ${market.toUpperCase()} scan first.`,
-        scanRunning: true,
-        scanProgress: stage1Done > 0
-          ? `Stage 1: ${stage1PassedCount}/${stage1Done || rawData.total_stocks || '?'} passed`
-          : `${market.toUpperCase()} scan is starting...`,
-        scanCompleted: false,
-        universe: rawData.universe ?? null,
-        market,
-        totalStocks: rawData.total_stocks ?? null,
-        stage1Done,
-        stage2Done: 0,
-        updatedAt: rawData.updated_at ?? null,
-        eligible: [],
-        excluded: [],
-        stage1Failures,
-        stage1PassedCount,
-        summary: {
-          eligibleCount: 0,
-          excludedCount: 0,
-          stage1FailedCount: stage1Failures.length,
-          avgSharpe: 0,
-          avgReturn: 0,
-          avgHitRate: 0,
-        },
-        timestamp: rawData.scan_started ?? rawData.updated_at ?? null,
-      })
-    }
+    const data: ScanResults = JSON.parse(raw)
+    const s2 = data.stage2 || {}
 
     const eligible: Array<ScanStage2 & { symbol: string }> = []
     const excluded: Array<{ symbol: string; reason: string; sharpe?: number }> = []
 
-    for (const [sym, info] of Object.entries(stage2)) {
-      const rawReturn = Number(info.annual_return ?? info.total_return_pct ?? 0)
-      const rawHitRate = Number(info.hit_rate ?? 0)
-      const normalizedReturn = Math.abs(rawReturn) > 1.5 ? rawReturn / 100 : rawReturn
-      const normalizedHitRate = rawHitRate > 1 ? rawHitRate / 100 : rawHitRate
-
+    for (const [sym, info] of Object.entries(s2)) {
       if (info.eligible) {
-        eligible.push({
-          symbol: sym,
-          eligible: true,
-          sharpe: Number(info.sharpe ?? 0),
-          annual_return: normalizedReturn,
-          hit_rate: normalizedHitRate,
-          quality: String(info.quality || ''),
-          reason: typeof info.reason === 'string' ? info.reason : undefined,
-        })
+        eligible.push({ symbol: sym, ...info })
       } else {
         excluded.push({
           symbol: sym,
-          reason: String(info.reason || info.quality || 'Insufficient quality'),
-          sharpe: Number(info.sharpe ?? 0),
+          reason: info.reason || info.quality || 'Yetersiz kalite',
+          sharpe: info.sharpe,
         })
       }
     }
@@ -240,6 +108,11 @@ export async function GET(request: Request) {
     eligible.sort((a, b) => (b.sharpe || 0) - (a.sharpe || 0))
     excluded.sort((a, b) => a.symbol.localeCompare(b.symbol))
 
+    const stage1Failures = Object.entries(data.stage1?.failed || {}).map(([sym, reason]) => ({
+      symbol: sym,
+      reason,
+    }))
+
     const avgSharpe = eligible.length
       ? eligible.reduce((sum, e) => sum + (e.sharpe || 0), 0) / eligible.length
       : 0
@@ -255,18 +128,7 @@ export async function GET(request: Request) {
       eligible,
       excluded,
       stage1Failures,
-      scanRunning: usingWorkFile && !completed,
-      scanProgress: usingWorkFile
-        ? `Stage 2: ${Object.keys(stage2).length}/${stage1PassedCount || '?'} stocks processed`
-        : '',
-      scanCompleted: completed,
-      universe: rawData.universe ?? null,
-      market,
-      totalStocks: rawData.total_stocks ?? null,
-      stage1Done,
-      stage2Done: Object.keys(stage2).length,
-      updatedAt: rawData.updated_at ?? null,
-      stage1PassedCount,
+      stage1PassedCount: data.stage1?.passed?.length || 0,
       summary: {
         eligibleCount: eligible.length,
         excludedCount: excluded.length,
@@ -275,7 +137,7 @@ export async function GET(request: Request) {
         avgReturn: Number(avgReturn.toFixed(2)),
         avgHitRate: Number(avgHitRate.toFixed(2)),
       },
-      timestamp: rawData.scan_finished ?? rawData.updated_at ?? rawData.timestamp ?? null,
+      timestamp: data.timestamp,
     })
   } catch (e: unknown) {
     return NextResponse.json(

huggingface-space/nextjs-app/src/app/api/health/route.ts

@@ -17,8 +17,8 @@ export async function GET() {
   const backendBase = API_BASE;
   if (!backendBase) {
     return NextResponse.json(
-      { ok: true, mode: 'local', ts: new Date().toISOString() },
-      { status: 200, headers: { 'Cache-Control': 'no-store' } }
+      { ok: false, error: 'Backend bağlantısı yapılandırılmamış.' },
+      { status: 500, headers: { 'Cache-Control': 'no-store' } }
     );
   }
 

huggingface-space/nextjs-app/src/app/api/ml-predictions/route.ts

@@ -1,64 +1,21 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { spawn } from 'child_process'
-import { resolve } from 'path'
 
 import { API_BASE } from '@/lib/runtime-config'
 import { requireAuth } from '@/lib/api-auth'
 
 export const dynamic = 'force-dynamic'
 
-type MarketId = 'bist' | 'us'
-
-function parseMarket(value: unknown): MarketId {
-  return String(value || '').trim().toLowerCase() === 'us' ? 'us' : 'bist'
-}
-
-function resolveProjectRoot() {
-  const cwd = process.cwd()
-  return cwd.endsWith('/nextjs-app') ? resolve(cwd, '..') : cwd
-}
-
-function runLocalPredictions(symbols: string[], daysAhead: number, model: string, market: MarketId) {
-  const projectRoot = resolveProjectRoot()
-  const script = [
-    'import json, math',
-    'from ai.predictions_api import predict_multiple_stocks_for_api',
-    'def clean(value):',
-    '    if isinstance(value, dict):',
-    '        return {k: clean(v) for k, v in value.items()}',
-    '    if isinstance(value, list):',
-    '        return [clean(v) for v in value]',
-    '    if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):',
-    '        return None',
-    '    return value',
-    `payload = predict_multiple_stocks_for_api(${JSON.stringify(symbols)}, days_ahead=${daysAhead}, model_type=${JSON.stringify(model)}, market_id=${JSON.stringify(market)})`,
-    `print("__JSON__" + json.dumps({"model": ${JSON.stringify(model)}, "days_ahead": ${daysAhead}, "market": ${JSON.stringify(market)}, "predictions": clean(payload)}, allow_nan=False))`,
-  ].join('\n')
-
-  return new Promise<{ code: number; stdout: string; stderr: string }>((resolveResult) => {
-    const proc = spawn('python3', ['-c', script], { cwd: projectRoot, env: { ...process.env } })
-    let stdout = ''
-    let stderr = ''
-
-    proc.stdout.on('data', (chunk) => {
-      stdout += chunk.toString()
-    })
-    proc.stderr.on('data', (chunk) => {
-      stderr += chunk.toString()
-    })
-    proc.on('close', (code) => {
-      resolveResult({ code: code ?? 1, stdout, stderr })
-    })
-    proc.on('error', (error) => {
-      resolveResult({ code: 1, stdout, stderr: error.message })
-    })
-  })
-}
-
 export async function POST(req: NextRequest) {
   const auth = await requireAuth(req)
   if (!auth.authenticated) return auth.response
 
+  if (!API_BASE) {
+    return NextResponse.json(
+      { ok: false, error: 'API URL yapılandırılmamış. NEXT_PUBLIC_API_URL tanımlayın.' },
+      { status: 500 }
+    )
+  }
+
   let body: Record<string, unknown> | null = null
   try {
     body = await req.json()
@@ -92,40 +49,6 @@ export async function POST(req: NextRequest) {
   }
 
   body.symbols = validSymbols
-  const market = parseMarket(body.market)
-  const model = typeof body.model === 'string' && body.model.trim() ? body.model.trim() : 'ensemble'
-  const daysAhead = Number.isFinite(Number(body.days_ahead)) ? Math.max(1, Math.min(30, Number(body.days_ahead))) : 7
-  body.market = market
-  body.model = model
-  body.days_ahead = daysAhead
-
-  if (!API_BASE) {
-    const local = await runLocalPredictions(validSymbols, daysAhead, model, market)
-    if (local.code !== 0) {
-      return NextResponse.json({ ok: false, error: local.stderr || 'Local ml-predictions failed' }, { status: 500 })
-    }
-
-    const payloadLine = local.stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .find((line) => line.startsWith('__JSON__'))
-
-    if (!payloadLine) {
-      return NextResponse.json(
-        { ok: false, error: 'Local ml-predictions returned no JSON payload', detail: local.stdout || local.stderr },
-        { status: 500 }
-      )
-    }
-
-    try {
-      return NextResponse.json(JSON.parse(payloadLine.slice('__JSON__'.length)), { status: 200 })
-    } catch (error: unknown) {
-      return NextResponse.json(
-        { ok: false, error: error instanceof Error ? error.message : 'Invalid local ml-predictions payload', detail: payloadLine },
-        { status: 500 }
-      )
-    }
-  }
 
   try {
     // Longer timeout for batch predictions (10+ stocks can take time)

huggingface-space/nextjs-app/src/app/api/trading/route.ts

@@ -119,45 +119,28 @@ interface EquityPoint { date: string; equity: number; drawdown?: number; cash?:
 interface SignalRecord { symbol: string; signal: string; price?: number; date?: string; strategy?: string; reason?: string; ml_signal?: string; tech_signal?: string; confidence?: number; predicted_return?: number; action_taken?: string }
 interface SymbolStat { trades: number; wins: number; pnl: number }
 interface BrokerPosition { qty?: number; avg_cost?: number; entry_date?: string }
-const SUPPORTED_MARKETS = ['bist', 'us'] as const
-type MarketId = (typeof SUPPORTED_MARKETS)[number]
 
-function resolveProjectRoot(resolvePath: (...parts: string[]) => string) {
-  const cwd = process.cwd()
-  return cwd.endsWith('/nextjs-app') ? resolvePath(cwd, '..') : cwd
-}
-
-function timestampOf(value: unknown) {
-  const timestamp = Date.parse(String(value || ''))
-  return Number.isFinite(timestamp) ? timestamp : 0
-}
-
-function getLocalPaths(marketId: MarketId = 'bist') {
+function getLocalPaths() {
   const { join, resolve } = require('path')
-  const PROJECT_ROOT = resolveProjectRoot(resolve)
+  const PROJECT_ROOT = resolve(process.cwd(), '..')
   const PAPER_DIR = join(PROJECT_ROOT, 'paper_trading')
-  const MARKET_DIR = marketId === 'bist' ? PAPER_DIR : join(PAPER_DIR, 'markets', marketId)
-  const AUTO_TRADER_DIR = marketId === 'bist' ? join(PAPER_DIR, 'auto_trader') : join(MARKET_DIR, 'auto_trader')
   return {
     PROJECT_ROOT,
     PAPER_DIR,
-    MARKET_DIR,
-    AUTO_TRADER_DIR,
-    STATE_FILE: join(AUTO_TRADER_DIR, 'state.json'),
-    STATUS_FILE: join(AUTO_TRADER_DIR, 'status.json'),
-    TRADES_FILE: join(MARKET_DIR, 'journal', 'trades.jsonl'),
-    EQUITY_FILE: join(MARKET_DIR, 'journal', 'daily_pnl.jsonl'),
-    SIGNALS_FILE: join(MARKET_DIR, 'journal', 'signals_log.jsonl'),
-    KILL_FILE: join(MARKET_DIR, '.kill_switch'),
-    SCAN_FILE: marketId === 'bist' ? join(PAPER_DIR, 'bist100_scan_results.json') : join(MARKET_DIR, 'scan_results.json'),
-    SCAN_WORK_FILE: marketId === 'bist' ? join(PAPER_DIR, 'bist100_scan_results_work.json') : join(MARKET_DIR, 'scan_results_work.json'),
-    PID_FILE: join(AUTO_TRADER_DIR, 'worker.pid'),
+    STATE_FILE: join(PAPER_DIR, 'auto_trader', 'state.json'),
+    STATUS_FILE: join(PAPER_DIR, 'auto_trader', 'status.json'),
+    TRADES_FILE: join(PAPER_DIR, 'journal', 'trades.jsonl'),
+    EQUITY_FILE: join(PAPER_DIR, 'journal', 'daily_pnl.jsonl'),
+    SIGNALS_FILE: join(PAPER_DIR, 'journal', 'signals_log.jsonl'),
+    KILL_FILE: join(PAPER_DIR, 'kill_switch.json'),
+    SCAN_FILE: join(PAPER_DIR, 'bist100_scan_results.json'),
+    PID_FILE: join(PAPER_DIR, 'auto_trader', 'worker.pid'),
   }
 }
 
-async function localIsWorkerRunning(marketId: MarketId = 'bist'): Promise<{ running: boolean; pid: number | null }> {
+async function localIsWorkerRunning(): Promise<{ running: boolean; pid: number | null }> {
   const { readFile } = getLocalModules()
-  const { PID_FILE } = getLocalPaths(marketId)
+  const { PID_FILE } = getLocalPaths()
   try {
     const pidStr = await readFile(PID_FILE, 'utf-8')
     const pid = parseInt(pidStr.trim())
@@ -194,7 +177,7 @@ function localSpawnPython(args: string[], timeoutMs = 120000): Promise<{ code: n
 
 function localSafePath(filePath: string): boolean {
   const { resolve: pathResolve } = require('path')
-  const { PAPER_DIR } = getLocalPaths('bist')
+  const { PAPER_DIR } = getLocalPaths()
   const resolved = pathResolve(filePath)
   return resolved.startsWith(PAPER_DIR)
 }
@@ -224,88 +207,23 @@ async function localReadJson(path: string): Promise<Record<string, unknown> | nu
   } catch { return null }
 }
 
-async function localReadPreferredScanJson(marketId: MarketId): Promise<Record<string, unknown> | null> {
-  const { SCAN_FILE, SCAN_WORK_FILE } = getLocalPaths(marketId)
-  const [finalData, workData] = await Promise.all([
-    localReadJson(SCAN_FILE),
-    localReadJson(SCAN_WORK_FILE),
-  ])
-
-  if (!workData) return finalData
-  if (!finalData) return workData
-
-  const finalTimestamp = Math.max(
-    timestampOf(finalData.updated_at),
-    timestampOf(finalData.scan_finished),
-    timestampOf(finalData.scan_started),
-    timestampOf(finalData.timestamp),
-  )
-  const workTimestamp = Math.max(
-    timestampOf(workData.updated_at),
-    timestampOf(workData.scan_finished),
-    timestampOf(workData.scan_started),
-    timestampOf(workData.timestamp),
-  )
-
-  return !workData.completed || workTimestamp >= finalTimestamp ? workData : finalData
-}
-
-function mapPyMarketSnapshot(snap: Record<string, unknown>) {
-  // Maps Python _build_market_snapshot() output (snake_case SQLite rows) to TS camelCase interfaces.
-  const rawOpen: Record<string, unknown>[] = (snap.openTrades ?? []) as Record<string, unknown>[]
-  const rawClosed: Record<string, unknown>[] = (snap.closedTrades ?? []) as Record<string, unknown>[]
-  const rawSignals: Record<string, unknown>[] = (snap.signals ?? []) as Record<string, unknown>[]
-  const rawEquity: Record<string, unknown>[] = (snap.equityCurve ?? []) as Record<string, unknown>[]
-  const perf: Record<string, unknown> = (snap.performance ?? {}) as Record<string, unknown>
-
-  return {
-    openTrades: rawOpen.map((t) => ({
-      symbol: t.symbol, quantity: t.quantity,
-      entryPrice: t.entry_price, entryDate: t.entry_date,
-      confidence: t.signal_confidence, predictedReturn: t.predicted_return,
-      commission: t.entry_commission,
-    })),
-    closedTrades: rawClosed.map((t) => ({
-      symbol: t.symbol, quantity: t.quantity,
-      entryPrice: t.entry_price, exitPrice: t.exit_price,
-      entryDate: t.entry_date, exitDate: t.exit_date,
-      netPnl: t.net_pnl, returnPct: t.return_pct,
-      holdingDays: t.holding_days, exitReason: t.exit_reason,
-    })),
-    signals: rawSignals.map((s) => ({
-      date: s.date, symbol: s.symbol, signal: s.signal,
-      mlSignal: s.ml_signal, techSignal: s.tech_signal,
-      confidence: s.confidence, predictedReturn: s.predicted_return,
-      actionTaken: s.action_taken,
-    })),
-    equityCurve: rawEquity.map((e) => ({
-      date: e.date, equity: e.equity, cash: e.cash,
-      positions: e.positions_count, realizedPnl: e.realized_pnl_today ?? 0,
-    })),
-    performance: {
-      totalPnl: Number(perf.total_pnl ?? 0),
-      closedTradesCount: Number(perf.total_trades ?? rawClosed.length),
-      openTradesCount: rawOpen.length,
-      winRate: Number(perf.win_rate_pct ?? 0),
-      profitFactor: perf.profit_factor === null ? 0 : Number(perf.profit_factor ?? 0),
-      avgWin: Number(perf.avg_win_pnl ?? 0),
-      avgLoss: Math.abs(Number(perf.avg_loss_pnl ?? 0)),
-      bestTrade: 0,
-      worstTrade: 0,
-      symbolBreakdown: [],
-    },
-  }
-}
-
-async function buildLocalMarketSummary(marketId: MarketId) {
-  const paths = getLocalPaths(marketId)
-  const [state, status, scanData, workerStatus] = await Promise.all([
+async function localGetHandler(): Promise<NextResponse> {
+  const paths = getLocalPaths()
+  const [state, status, rawTrades, equity, signals, killSwitch, scanData, workerStatus] = await Promise.all([
     localReadJson(paths.STATE_FILE),
     localReadJson(paths.STATUS_FILE),
-    localReadPreferredScanJson(marketId),
-    localIsWorkerRunning(marketId),
+    localReadJsonl(paths.TRADES_FILE),
+    localReadJsonl(paths.EQUITY_FILE),
+    localReadJsonl(paths.SIGNALS_FILE),
+    localReadJson(paths.KILL_FILE),
+    localReadJson(paths.SCAN_FILE),
+    localIsWorkerRunning(),
   ])
 
+  const lastWorkerStatus = (status as any)?.status ?? (status as any)?.last_result?.status ?? null
+  const lastWorkerReason = (status as any)?.reason ?? (status as any)?.last_result?.reason ?? null
+  const lastResult = (status as any)?.last_result ?? null
+
   let eligibleStocks: string[] = []
   try {
     const s2 = (scanData as Record<string, unknown>)?.stage2 as Record<string, { eligible?: boolean }> | undefined
@@ -314,97 +232,6 @@ async function buildLocalMarketSummary(marketId: MarketId) {
     }
   } catch { /* ignore */ }
 
-  const positions = (state?.broker_positions ?? {}) as Record<string, BrokerPosition>
-  const cash = Number(state?.broker_cash ?? 100000)
-  const stage1 = ((scanData as Record<string, unknown>)?.stage1 ?? {}) as Record<string, unknown>
-  const stage2 = ((scanData as Record<string, unknown>)?.stage2 ?? {}) as Record<string, unknown>
-
-  const baseSummary = {
-    marketId,
-    displayName: marketId === 'bist' ? 'Borsa Istanbul' : 'US Equities',
-    currency: marketId === 'bist' ? 'TRY' : 'USD',
-    status: {
-      isRunning: status?.is_running ?? false,
-      workerRunning: workerStatus.running,
-      workerPid: workerStatus.pid,
-      lastRunDate: state?.last_run_date ?? null,
-      totalDaysRun: state?.total_days_run ?? 0,
-      totalTrades: state?.total_trades ?? 0,
-      currentPhase: status?.current_phase ?? null,
-      lastWorkerStatus: status?.status ?? (status?.last_result as Record<string, unknown>)?.status ?? null,
-      lastWorkerReason: status?.reason ?? (status?.last_result as Record<string, unknown>)?.reason ?? null,
-      lastResult: status?.last_result ?? null,
-      updatedAt: status?.updated_at ?? null,
-    },
-    portfolio: {
-      cash: Math.round(cash * 100) / 100,
-      equity: Math.round(cash * 100) / 100,
-      positionCount: Object.keys(positions).length,
-      positions: (Object.entries(positions) as [string, BrokerPosition][]).map(([sym, pos]) => ({
-        symbol: sym, quantity: pos.qty, avgCost: pos.avg_cost, entryDate: pos.entry_date,
-        notional: (pos.qty || 0) * (pos.avg_cost || 0),
-      })),
-      pnlPct: 0,
-      unrealizedPnl: 0,
-    },
-    scan: {
-      universe: (scanData as Record<string, unknown>)?.universe ?? null,
-      completed: Boolean((scanData as Record<string, unknown>)?.completed ?? false),
-      stage1Count: Object.keys(stage1).length,
-      stage2Count: Object.keys(stage2).length,
-      updatedAt: (scanData as Record<string, unknown>)?.updated_at ?? null,
-    },
-    eligibleStocks,
-    openTrades: [] as unknown[],
-    closedTrades: [] as unknown[],
-    signals: [] as unknown[],
-    equityCurve: [] as unknown[],
-    performance: null as unknown,
-  }
-
-  // For non-BIST markets: call Python _build_market_snapshot to read SQLite data
-  if (marketId !== 'bist') {
-    try {
-      const pyResult = await localSpawnPython([
-        '-c',
-        `from trading.worker import _build_market_snapshot; import json; print(json.dumps(_build_market_snapshot('${marketId}'), default=str))`,
-      ], 25000)
-      if (pyResult.code === 0 && pyResult.stdout.trim()) {
-        const snap = JSON.parse(pyResult.stdout.trim()) as Record<string, unknown>
-        const mapped = mapPyMarketSnapshot(snap as Record<string, unknown[]>)
-        // Use Python-derived portfolio (has equity, pnlPct, unrealizedPnl)
-        const pyPortfolio = snap.portfolio as Record<string, unknown> | undefined
-        return {
-          ...baseSummary,
-          portfolio: pyPortfolio ? {
-            cash: pyPortfolio.cash as number ?? baseSummary.portfolio.cash,
-            equity: pyPortfolio.equity as number ?? baseSummary.portfolio.cash,
-            positionCount: pyPortfolio.positionCount as number ?? baseSummary.portfolio.positionCount,
-            positions: (pyPortfolio.positions as unknown[]) ?? baseSummary.portfolio.positions,
-            pnlPct: pyPortfolio.pnlPct as number ?? 0,
-            unrealizedPnl: pyPortfolio.unrealizedPnl as number ?? 0,
-          } : baseSummary.portfolio,
-          ...mapped,
-        }
-      }
-    } catch { /* fall through to base summary */ }
-  }
-
-  return baseSummary
-}
-
-async function localGetHandler(): Promise<NextResponse> {
-  const paths = getLocalPaths('bist')
-  const [defaultMarket, rawTrades, equity, signals, killSwitch, markets] = await Promise.all([
-    buildLocalMarketSummary('bist'),
-    localReadJsonl(paths.TRADES_FILE),
-    localReadJsonl(paths.EQUITY_FILE),
-    localReadJsonl(paths.SIGNALS_FILE),
-    localReadJson(paths.KILL_FILE),
-    Promise.all(SUPPORTED_MARKETS.map(async (marketId) => [marketId, await buildLocalMarketSummary(marketId)] as const)),
-  ])
-  const marketMap = Object.fromEntries(markets)
-
   const trades = rawTrades as unknown as TradeRecord[]
   const openTrades = trades.filter((t) => !t.is_closed)
   const closedTrades = trades.filter((t) => t.is_closed)
@@ -427,30 +254,34 @@ async function localGetHandler(): Promise<NextResponse> {
     if ((t.net_pnl || 0) > 0) symbolStats[t.symbol].wins++
   })
 
-  const cash = Number(defaultMarket.portfolio.cash ?? 100000)
-  const positionCount = defaultMarket.portfolio.positionCount
+  const cash = Number(state?.broker_cash ?? 100000)
+  const positions = (state?.broker_positions ?? {}) as Record<string, BrokerPosition>
+  const positionCount = Object.keys(positions).length
   const latestEquity = equity.length > 0 ? (equity[equity.length - 1] as unknown as EquityPoint) : null
 
   return NextResponse.json({
     status: {
-      isRunning: defaultMarket.status.isRunning,
-      lastRunDate: defaultMarket.status.lastRunDate,
-      totalDaysRun: defaultMarket.status.totalDaysRun,
-      totalTrades: defaultMarket.status.totalTrades,
-      currentPhase: defaultMarket.status.currentPhase,
+      isRunning: status?.is_running ?? false,
+      lastRunDate: state?.last_run_date ?? null,
+      totalDaysRun: state?.total_days_run ?? 0,
+      totalTrades: state?.total_trades ?? 0,
+      currentPhase: status?.current_phase ?? null,
       killSwitchActive: killSwitch?.active ?? false,
       killSwitchReason: killSwitch?.reason ?? null,
-      workerRunning: defaultMarket.status.workerRunning,
-      workerPid: defaultMarket.status.workerPid,
-      lastWorkerStatus: defaultMarket.status.lastWorkerStatus,
-      lastWorkerReason: defaultMarket.status.lastWorkerReason,
-      lastResult: defaultMarket.status.lastResult,
+      workerRunning: workerStatus.running,
+      workerPid: workerStatus.pid,
+      lastWorkerStatus,
+      lastWorkerReason,
+      lastResult,
     },
     portfolio: {
       cash: Math.round(cash * 100) / 100,
       equity: latestEquity?.equity ?? cash,
       positionCount,
-      positions: defaultMarket.portfolio.positions,
+      positions: (Object.entries(positions) as [string, BrokerPosition][]).map(([sym, pos]) => ({
+        symbol: sym, quantity: pos.qty, avgCost: pos.avg_cost, entryDate: pos.entry_date,
+        notional: (pos.qty || 0) * (pos.avg_cost || 0),
+      })),
       pnlPct: latestEquity ? Math.round(((latestEquity.equity / 100000 - 1) * 100) * 100) / 100 : 0,
       unrealizedPnl: latestEquity?.unrealized_pnl ?? 0,
     },
@@ -485,24 +316,21 @@ async function localGetHandler(): Promise<NextResponse> {
       date: s.date, symbol: s.symbol, signal: s.signal, mlSignal: s.ml_signal, techSignal: s.tech_signal,
       confidence: s.confidence, predictedReturn: s.predicted_return, actionTaken: s.action_taken,
     })),
-    eligibleStocks: defaultMarket.eligibleStocks,
-    markets: marketMap,
-    activeMarketId: SUPPORTED_MARKETS.find((m) => marketMap[m]?.status?.workerRunning) ?? Object.keys(marketMap)[0] ?? 'bist',
+    eligibleStocks,
     timestamp: new Date().toISOString(),
   })
 }
 
 async function localPostHandler(body: Record<string, unknown>): Promise<NextResponse> {
   const { writeFile, mkdir, unlink } = getLocalModules()
-  const marketId = body.market === 'us' ? 'us' : 'bist'
-  const paths = getLocalPaths(marketId)
+  const paths = getLocalPaths()
   const { spawn } = getLocalModules()
   const action = body.action as string
 
   if (!action) return NextResponse.json({ error: 'Missing action' }, { status: 400 })
 
   if (action === 'run') {
-    const result = await localSpawnPython(['-m', 'trading.worker', '--cycle', '--mode', 'paper', '--market', marketId], 120000)
+    const result = await localSpawnPython(['-m', 'trading.worker', '--cycle', '--mode', 'paper'], 120000)
     return NextResponse.json({
       success: result.code === 0, output: result.stdout,
       error: result.code !== 0 ? (result.stderr || 'Trading cycle failed') : undefined,
@@ -511,7 +339,7 @@ async function localPostHandler(body: Record<string, unknown>): Promise<NextResp
   }
 
   if (action === 'run_force') {
-    const result = await localSpawnPython(['-m', 'trading.worker', '--cycle', '--mode', 'paper', '--force', '--market', marketId], 120000)
+    const result = await localSpawnPython(['-m', 'trading.worker', '--cycle', '--mode', 'paper', '--force'], 120000)
     return NextResponse.json({
       success: result.code === 0, output: result.stdout,
       error: result.code !== 0 ? (result.stderr || 'Trading cycle failed') : undefined,
@@ -519,64 +347,41 @@ async function localPostHandler(body: Record<string, unknown>): Promise<NextResp
     })
   }
 
-  if (action === 'scan') {
-    const defaultUniverse = marketId === 'us' ? 'sp100' : 'bist30'
-    const requestedUniverse = String(body.universe || body.reason || defaultUniverse).trim().toLowerCase() || defaultUniverse
-    const scriptName = marketId === 'us' ? 'run_us_scan.py' : 'run_bist100_scan.py'
-    const args = [scriptName, '--universe', requestedUniverse]
-    if (body.force === true) args.push('--force')
-
-    const proc = spawn('python3', args, {
-      cwd: paths.PROJECT_ROOT,
-      detached: true,
-      stdio: 'ignore',
-      env: { ...process.env },
-    })
-    proc.unref()
-
-    return NextResponse.json({
-      success: true,
-      market: marketId,
-      universe: requestedUniverse,
-      message: `${marketId.toUpperCase()} ${requestedUniverse.toUpperCase()} scan started in background`,
-    })
-  }
-
   if (action === 'reset') {
     return NextResponse.json({
-      error: 'Portfolio reset requires CLI: python -m trading.auto_trader --reset',
-      hint: 'Portfolio reset is not available through the web interface for security reasons.',
+      error: 'Portföy sıfırlama CLI gerektirir: python -m trading.auto_trader --reset',
+      hint: 'Güvenlik nedeniyle portföy sıfırlama web arayüzünden yapılamaz.',
     }, { status: 403 })
   }
 
   if (action === 'start_worker') {
-    const ws = await localIsWorkerRunning(marketId)
-    if (ws.running) return NextResponse.json({ error: 'Worker is already running', pid: ws.pid }, { status: 409 })
-    const proc = spawn('python3', ['-m', 'trading.worker', '--daemon', '--mode', 'paper', '--market', marketId], {
+    const ws = await localIsWorkerRunning()
+    if (ws.running) return NextResponse.json({ error: 'Worker zaten çalışıyor', pid: ws.pid }, { status: 409 })
+    const proc = spawn('python3', ['-m', 'trading.worker', '--daemon', '--mode', 'paper'], {
       cwd: paths.PROJECT_ROOT, detached: true, stdio: 'ignore', env: { ...process.env },
     })
     proc.unref()
     await new Promise((r: (v: unknown) => void) => setTimeout(r, 3000))
-    const check = await localIsWorkerRunning(marketId)
+    const check = await localIsWorkerRunning()
     return NextResponse.json({ success: true, pid: proc.pid, workerRunning: check.running })
   }
 
   if (action === 'stop_worker') {
-    const ws = await localIsWorkerRunning(marketId)
-    if (!ws.running || !ws.pid) return NextResponse.json({ error: 'Worker is not running' }, { status: 404 })
+    const ws = await localIsWorkerRunning()
+    if (!ws.running || !ws.pid) return NextResponse.json({ error: 'Worker çalışmıyor' }, { status: 404 })
     try {
       process.kill(ws.pid, 'SIGTERM')
       await new Promise((r: (v: unknown) => void) => setTimeout(r, 2000))
-      return NextResponse.json({ success: true, message: 'Worker stopped' })
+      return NextResponse.json({ success: true, message: 'Worker durduruldu' })
     } catch {
-      return NextResponse.json({ error: 'Failed to stop worker' }, { status: 500 })
+      return NextResponse.json({ error: 'Worker durdurma hatası' }, { status: 500 })
     }
   }
 
   if (action === 'kill') {
     if (!localSafePath(paths.KILL_FILE)) return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
-    const { dirname } = require('path')
-    const dir = dirname(paths.KILL_FILE)
+    const { join } = require('path')
+    const dir = join(paths.PAPER_DIR, 'auto_trader')
     await mkdir(dir, { recursive: true })
     await writeFile(paths.KILL_FILE, JSON.stringify({
       active: true, reason: body.reason || 'Manual kill switch from UI',

huggingface-space/nextjs-app/src/app/auto-trading/page.tsx

@@ -2,7 +2,6 @@
 
 import { useState, useEffect, useCallback } from 'react'
 import { fetchJson } from '@/lib/http'
-import { useMarket } from '@/contexts/MarketContext'
 import PositionChart from '@/components/PositionChart'
 import {
   Play,
@@ -120,40 +119,6 @@ interface Signal {
   actionTaken: string
 }
 
-interface MarketSummary {
-  marketId: string
-  displayName: string
-  currency: string
-  status: {
-    isRunning: boolean
-    workerRunning: boolean
-    workerPid: number | null
-    lastRunDate: string | null
-    totalDaysRun: number
-    totalTrades: number
-    currentPhase: string | null
-    killSwitchActive?: boolean
-    killSwitchReason?: string | null
-    lastWorkerStatus?: string | null
-    lastWorkerReason?: string | null
-    lastResult?: { status?: string; reason?: string; date?: string } | null
-  }
-  portfolio: Portfolio
-  scan: {
-    universe: string | null
-    completed: boolean
-    stage1Count: number
-    stage2Count: number
-    updatedAt: string | null
-  }
-  openTrades?: OpenTrade[]
-  closedTrades?: ClosedTrade[]
-  equityCurve?: EquityPoint[]
-  signals?: Signal[]
-  performance?: Performance
-  eligibleStocks: string[]
-}
-
 interface TradingData {
   status: TradingStatus
   portfolio: Portfolio
@@ -163,102 +128,22 @@ interface TradingData {
   performance: Performance
   signals: Signal[]
   eligibleStocks: string[]
-  markets?: Record<string, MarketSummary>
-  activeMarketId?: string
   timestamp: string
   error?: string
 }
 
 // ─── Formatting Helpers ────────────────────
-function fmtMoney(n: number, isUS = false) {
-  const locale = isUS ? 'en-US' : 'tr-TR'
-  const currency = isUS ? 'USD' : 'TRY'
-  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(n)
-}
-
-function fmtMoneyByCurrency(n: number, currency: string, isUS = false) {
-  const locale = isUS ? 'en-US' : 'tr-TR'
-  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(n)
+function fmtMoney(n: number) {
+  return new Intl.NumberFormat('tr-TR', { style: 'currency', currency: 'TRY' }).format(n)
 }
-
 function fmtPct(n: number) {
   return `%${n >= 0 ? '+' : ''}${n.toFixed(2)}`
 }
 
-function describeSignalAction(action: string, isUS = false) {
-  const a = (action || '').toUpperCase()
-  const t = (tr: string, en: string) => isUS ? en : tr
-  switch (a) {
-    case 'BUY_EXECUTED':
-      return t('Alım yapıldı', 'Buy executed')
-    case 'BUY_REJECTED':
-      return t('Alım reddedildi', 'Buy rejected')
-    case 'BUY_SIGNAL':
-      return t('Alım adayı', 'Buy candidate')
-    case 'BUY_BELOW_CONFIDENCE':
-      return t('Alım, güven eşiği altında', 'Buy, below confidence')
-    case 'BUY_SKIPPED_NO_SLOT':
-      return t('Alım, slot yok', 'Buy, no slot')
-    case 'BUY_SKIPPED_LOW_PRIORITY':
-      return t('Alım, düşük öncelik', 'Buy, low priority')
-    case 'BUY_SKIPPED_ALREADY_HELD':
-      return t('Alım, zaten pozisyonda', 'Buy, already held')
-    case 'BUY_SKIPPED_INVALID_PRICE':
-      return t('Alım, fiyat geçersiz', 'Buy, invalid price')
-    case 'BUY_SKIPPED_CORRELATED':
-      return t('Alım, korelasyon nedeniyle atlandı', 'Buy, skipped (correlated)')
-    case 'BUY_SKIPPED_ZERO_QTY':
-      return t('Alım, adet sıfıra yuvarlandı', 'Buy, zero qty')
-    case 'BUY_BLOCKED_RISK_GATE':
-      return t('Alım, risk kapısında engellendi', 'Buy, blocked by risk gate')
-    case 'BUY_BLOCKED_CIRCUIT_BREAKER':
-      return t('Alım, circuit breaker engeli', 'Buy, circuit breaker')
-    case 'SELL_EXECUTED:ML_SELL_SIGNAL':
-      return t('Satış yapıldı, ML sell', 'Sell executed, ML signal')
-    case 'SELL_EXECUTED:STOP_LOSS':
-      return t('Satış yapıldı, stop-loss', 'Sell executed, stop-loss')
-    case 'SELL_EXECUTED:TAKE_PROFIT':
-      return t('Satış yapıldı, take-profit', 'Sell executed, take-profit')
-    case 'SELL_EXECUTED:HOLDING_PERIOD_EXPIRY':
-      return t('Satış yapıldı, süre doldu', 'Sell executed, holding expired')
-    case 'SELL_SIGNAL':
-      return t('Satış sinyali', 'Sell signal')
-    case 'SELL_NO_POSITION':
-      return t('Satış sinyali, pozisyon yok', 'Sell signal, no position')
-    case 'SELL_BLOCKED_RISK_GATE':
-      return t('Satış, risk kapısında engellendi', 'Sell, blocked by risk gate')
-    case 'SELL_REJECTED':
-      return t('Satış reddedildi', 'Sell rejected')
-    case 'HOLD':
-      return t('Bekle', 'Hold')
-    case 'PENDING':
-      return t('Eski kayıt, sonuç yazılmadı', 'Old record, no result')
-    default:
-      return action || '—'
-  }
-}
-
 // ─── Tab Type ──────────────────────────────
 type TabKey = 'portfolio' | 'trades' | 'signals' | 'performance'
 
-const EMPTY_PERFORMANCE: Performance = {
-  totalPnl: 0,
-  closedTradesCount: 0,
-  openTradesCount: 0,
-  winRate: 0,
-  profitFactor: 0,
-  avgWin: 0,
-  avgLoss: 0,
-  bestTrade: 0,
-  worstTrade: 0,
-  symbolBreakdown: [],
-}
-
 export default function AutoTradingPage() {
-  const { market } = useMarket()
-  const isUS = market === 'us'
-  const t = (tr: string, en: string) => isUS ? en : tr
-
   const [data, setData] = useState<TradingData | null>(null)
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
@@ -266,12 +151,6 @@ export default function AutoTradingPage() {
   const [actionMessage, setActionMessage] = useState<string | null>(null)
   const [activeTab, setActiveTab] = useState<TabKey>('portfolio')
   const [showEquity, setShowEquity] = useState(true)
-  const [selectedMarketId, setSelectedMarketId] = useState<string>(market)
-
-  // Sync selectedMarketId when global market context changes
-  useEffect(() => {
-    setSelectedMarketId(market)
-  }, [market])
 
   const loadData = useCallback(async () => {
     setLoading(true)
@@ -280,15 +159,12 @@ export default function AutoTradingPage() {
       const res = await fetchJson<TradingData>('/api/trading', undefined, { timeoutMs: 20000 })
       if (res.error) throw new Error(res.error)
       setData(res)
-      // Do NOT override selectedMarketId with a fallback market.
-      // The user's explicit market selection (from global context) takes
-      // priority even when the snapshot has no data for that market.
     } catch (e: unknown) {
-      setError(e instanceof Error ? e.message : t('Veriler alınamadı', 'Failed to load data'))
+      setError(e instanceof Error ? e.message : 'Veriler alınamadı')
     } finally {
       setLoading(false)
     }
-  }, [t])
+  }, [])
 
   useEffect(() => {
     loadData()
@@ -307,7 +183,7 @@ export default function AutoTradingPage() {
       }>('/api/trading', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ action, market: selectedMarketId }),
+        body: JSON.stringify({ action }),
       }, { timeoutMs: 130000 })
 
       // Handle 403 gracefully (run/reset moved to worker)
@@ -318,26 +194,26 @@ export default function AutoTradingPage() {
       if (res.error) throw new Error(res.error)
 
       if (action === 'kill') {
-        setActionMessage(t('Kill Switch aktif edildi — worker yeni trade açmayacak', 'Kill Switch activated — worker will not open new trades'))
+        setActionMessage('Kill Switch aktif edildi — worker yeni trade açmayacak')
       } else if (action === 'unkill') {
-        setActionMessage(t('Kill Switch kaldırıldı — worker normal çalışmaya devam edecek', 'Kill Switch removed — worker will resume normal operation'))
+        setActionMessage('Kill Switch kaldırıldı — worker normal çalışmaya devam edecek')
       } else if (action === 'start_worker') {
-        setActionMessage(t('Worker başlatıldı — seçili market saatlerinde otomatik trade yapacak', 'Worker started — will auto-trade during market hours'))
+        setActionMessage('Worker başlatıldı — BIST saatlerinde otomatik trade yapacak')
       } else if (action === 'stop_worker') {
-        setActionMessage(t('Worker durduruldu', 'Worker stopped'))
+        setActionMessage('Worker durduruldu')
       } else if (action === 'run') {
-        setActionMessage(t('Trading döngüsü tamamlandı — veriler güncellendi', 'Trading cycle completed — data refreshed'))
+        setActionMessage('Trading döngüsü tamamlandı — veriler güncellendi')
       } else if (action === 'run_force') {
-        setActionMessage(t('Zorla trading döngüsü tamamlandı — veriler güncellendi', 'Forced trading cycle completed — data refreshed'))
+        setActionMessage('Zorla trading döngüsü tamamlandı — veriler güncellendi')
       } else {
-        setActionMessage(t('İşlem tamamlandı', 'Action completed'))
+        setActionMessage('İşlem tamamlandı')
       }
 
       // Reload data after action
       await loadData()
     } catch (e: unknown) {
-      const msg = e instanceof Error ? e.message : t('İşlem başarısız', 'Action failed')
-      setActionMessage(`${t('Hata', 'Error')}: ${msg}`)
+      const msg = e instanceof Error ? e.message : 'İşlem başarısız'
+      setActionMessage(`Hata: ${msg}`)
     } finally {
       setActionLoading(null)
     }
@@ -349,7 +225,7 @@ export default function AutoTradingPage() {
       <div className="min-h-screen bg-gray-50 flex items-center justify-center">
         <div className="flex flex-col items-center gap-3">
           <RefreshCw className="w-8 h-8 text-blue-400 animate-spin" />
-          <p className="text-gray-500">{t('Trading verileri yükleniyor...', 'Loading trading data...')}</p>
+          <p className="text-gray-500">Trading verileri yükleniyor...</p>
         </div>
       </div>
     )
@@ -365,7 +241,7 @@ export default function AutoTradingPage() {
             onClick={loadData}
             className="px-4 py-2 bg-red-600 hover:bg-red-500 text-white rounded-lg text-sm"
           >
-            {t('Tekrar Dene', 'Retry')}
+            Tekrar Dene
           </button>
         </div>
       </div>
@@ -374,31 +250,9 @@ export default function AutoTradingPage() {
 
   if (!data) return null
 
-  const { status, portfolio, performance, openTrades, closedTrades, signals, equityCurve, eligibleStocks, markets } = data
-  const marketLookup = markets || {}
-  const marketSummaries = Object.values(marketLookup)
-  const selectedMarket = marketLookup[selectedMarketId]
-  const selectedStatus = selectedMarket
-    ? {
-        ...status,
-        ...selectedMarket.status,
-        killSwitchActive: selectedMarket.status?.killSwitchActive ?? status.killSwitchActive,
-        killSwitchReason: selectedMarket.status?.killSwitchReason ?? status.killSwitchReason ?? null,
-        lastResult: selectedMarket.status?.lastResult || null,
-      }
-    : status
-  const selectedPortfolio = selectedMarket?.portfolio ?? (selectedMarketId !== 'us' ? portfolio : { cash: 0, equity: 0, positionCount: 0, positions: [] as Portfolio['positions'], pnlPct: 0, unrealizedPnl: 0 })
-  const selectedPerformance = selectedMarket?.performance || EMPTY_PERFORMANCE
-  const selectedOpenTrades = selectedMarket?.openTrades || []
-  const selectedClosedTrades = selectedMarket?.closedTrades || []
-  const selectedSignals = selectedMarket?.signals || []
-  const selectedEquityCurve = selectedMarket?.equityCurve || []
-  const selectedEligibleStocks = selectedMarket?.eligibleStocks || []
-  const selectedCurrency = selectedMarket?.currency || (selectedMarketId === 'us' ? 'USD' : 'TRY')
-  const selectedMarketLabel = selectedMarket?.displayName || (selectedMarketId === 'us' ? 'US Equities' : 'Borsa Istanbul')
-  const lastStatus = selectedStatus.lastWorkerStatus || selectedStatus.lastResult?.status || null
-  const lastReason = selectedStatus.lastWorkerReason || selectedStatus.lastResult?.reason || null
-  const latestSignal = selectedSignals[0] || null
+  const { status, portfolio, performance, openTrades, closedTrades, signals, equityCurve, eligibleStocks } = data
+  const lastStatus = status.lastWorkerStatus || status.lastResult?.status || null
+  const lastReason = status.lastWorkerReason || status.lastResult?.reason || null
 
   // ─── Main Render ────────────────────────
   return (
@@ -408,32 +262,32 @@ export default function AutoTradingPage() {
         <div>
           <h1 className="text-2xl font-bold flex items-center gap-2">
             <Zap className="w-7 h-7 text-yellow-400" />
-            {t('Otomatik Trading', 'Auto Trading')}
+            Otomatik Trading
           </h1>
           <p className="text-gray-500 text-sm mt-1">
-            {t('ML destekli paper trading sistemi', 'ML-powered paper trading system')} · {selectedMarketLabel}
+            ML destekli paper trading sistemi
           </p>
         </div>
         <div className="flex items-center gap-2 flex-wrap">
           {/* Worker Status Indicator */}
           <div className="flex items-center gap-2 px-4 py-2 bg-gray-100 rounded-lg text-sm">
-            <Server className={`w-4 h-4 ${selectedStatus.workerRunning ? 'text-green-500' : 'text-gray-400'}`} />
-            <span className={selectedStatus.workerRunning ? 'text-green-600 font-medium' : 'text-gray-500'}>
-              {selectedStatus.workerRunning ? t('Worker Aktif', 'Worker Active') : t('Worker Bekliyor', 'Worker Idle')}
+            <Server className={`w-4 h-4 ${status.workerRunning ? 'text-green-500' : 'text-gray-400'}`} />
+            <span className={status.workerRunning ? 'text-green-600 font-medium' : 'text-gray-500'}>
+              {status.workerRunning ? 'Worker Aktif' : 'Worker Bekliyor'}
             </span>
           </div>
 
           {/* Kill Switch */}
-          {selectedMarketId === 'bist' && selectedStatus.killSwitchActive ? (
+          {status.killSwitchActive ? (
             <button
               onClick={() => runAction('unkill')}
               disabled={!!actionLoading}
               className="flex items-center gap-2 px-4 py-2 bg-yellow-600 hover:bg-yellow-500 text-white rounded-lg text-sm font-medium disabled:opacity-50"
             >
               <Shield className="w-4 h-4" />
-              {t('Kill Switch Kaldır', 'Remove Kill Switch')}
+              Kill Switch Kaldır
             </button>
-          ) : selectedMarketId === 'bist' ? (
+          ) : (
             <button
               onClick={() => runAction('kill')}
               disabled={!!actionLoading}
@@ -442,7 +296,7 @@ export default function AutoTradingPage() {
               <Square className="w-4 h-4" />
               Kill Switch
             </button>
-          ) : null}
+          )}
 
           {/* Refresh */}
           <button
@@ -454,27 +308,9 @@ export default function AutoTradingPage() {
         </div>
       </div>
 
-      {marketSummaries.length > 0 && (
-        <div className="flex flex-wrap gap-2 mb-6">
-          {marketSummaries.map((market) => (
-            <button
-              key={market.marketId}
-              onClick={() => setSelectedMarketId(market.marketId)}
-              className={`px-4 py-2 rounded-full text-sm font-medium border transition-colors ${
-                selectedMarketId === market.marketId
-                  ? 'bg-blue-600 border-blue-600 text-white'
-                  : 'bg-white border-gray-200 text-gray-600 hover:border-blue-300 hover:text-blue-600'
-              }`}
-            >
-              {market.displayName}
-            </button>
-          ))}
-        </div>
-      )}
-
       {actionMessage && (
         <div className={`border rounded-lg px-4 py-3 mb-6 text-sm ${
-          actionMessage.startsWith('Hata:') || actionMessage.startsWith('Error:') || actionMessage.includes('moved to')
+          actionMessage.startsWith('Hata:') || actionMessage.includes('moved to')
             ? 'bg-amber-900/30 border-amber-600/50 text-amber-200'
             : 'bg-white border-gray-200 text-gray-700'
         }`}>
@@ -487,23 +323,21 @@ export default function AutoTradingPage() {
       <div className="bg-white border border-gray-200 rounded-lg p-4 mb-6">
         <h3 className="font-semibold text-gray-700 mb-2 flex items-center gap-2">
           <Server className="w-5 h-5 text-blue-500" />
-          {t('Worker Yönetimi', 'Worker Management')}
+          Worker Yönetimi
         </h3>
         <p className="text-sm text-gray-500 mb-4">
-          {t(
-            'Worker, seçili market için eligible hisseler üzerinde ML sinyalleri üretir ve otomatik paper trade yapar. Günde bir kez çalışır. Stop-loss (%5), take-profit (%10) ve max tutma süresi (9 gün) ile pozisyonları yönetir.',
-            'Worker generates ML signals on eligible stocks for the selected market and paper trades automatically. Runs once daily. Manages positions with stop-loss (5%), take-profit (10%) and max holding period (9 days).'
-          )}
+          Worker, BIST saatlerinde (10:00-18:00) eligible hisseler için ML sinyalleri üretir ve otomatik paper trade yapar.
+          Günde bir kez çalışır. Stop-loss (%5), take-profit (%10) ve max tutma süresi (9 gün) ile pozisyonları yönetir.
         </p>
         <div className="flex flex-wrap gap-3">
-          {!selectedStatus.workerRunning ? (
+          {!status.workerRunning ? (
             <button
               onClick={() => runAction('start_worker')}
               disabled={!!actionLoading}
               className="flex items-center gap-2 px-4 py-2.5 bg-green-600 hover:bg-green-500 text-white rounded-lg text-sm font-medium disabled:opacity-50"
             >
               {actionLoading === 'start_worker' ? <RefreshCw className="w-4 h-4 animate-spin" /> : <Play className="w-4 h-4" />}
-              {t('Worker Başlat (Daemon)', 'Start Worker (Daemon)')}
+              Worker Başlat (Daemon)
             </button>
           ) : (
             <button
@@ -512,40 +346,40 @@ export default function AutoTradingPage() {
               className="flex items-center gap-2 px-4 py-2.5 bg-red-600 hover:bg-red-500 text-white rounded-lg text-sm font-medium disabled:opacity-50"
             >
               {actionLoading === 'stop_worker' ? <RefreshCw className="w-4 h-4 animate-spin" /> : <Square className="w-4 h-4" />}
-              {t('Worker Durdur', 'Stop Worker')}
+              Worker Durdur
             </button>
           )}
           <button
             onClick={() => runAction('run')}
-            disabled={!!actionLoading || selectedStatus.workerRunning}
+            disabled={!!actionLoading || status.workerRunning}
             className="flex items-center gap-2 px-4 py-2.5 bg-blue-600 hover:bg-blue-500 text-white rounded-lg text-sm font-medium disabled:opacity-50"
-            title={selectedStatus.workerRunning ? t('Worker çalışırken tek döngü çalıştırılamaz', 'Cannot run single cycle while worker is running') : t('Bir kez çalıştırıp durur (~10 sn)', 'Run once and stop (~10 sec)')}
+            title={status.workerRunning ? 'Worker çalışırken tek döngü çalıştırılamaz' : 'Bir kez çalıştırıp durur (~10 sn)'}
           >
             {actionLoading === 'run' ? <RefreshCw className="w-4 h-4 animate-spin" /> : <Zap className="w-4 h-4" />}
-            {t('Tek Döngü Çalıştır', 'Run Single Cycle')}
+            Tek Döngü Çalıştır
           </button>
           <button
             onClick={() => runAction('run_force')}
-            disabled={!!actionLoading || selectedStatus.workerRunning}
+            disabled={!!actionLoading || status.workerRunning}
             className="flex items-center gap-2 px-4 py-2.5 bg-yellow-600 hover:bg-yellow-500 text-white rounded-lg text-sm font-medium disabled:opacity-50"
-            title={selectedStatus.workerRunning ? t('Worker çalışırken tek döngü çalıştırılamaz', 'Cannot run single cycle while worker is running') : t('Aynı gün içinde tekrar çalıştırır (SKIPPED bypass)', 'Runs again same day (SKIPPED bypass)')}
+            title={status.workerRunning ? 'Worker çalışırken tek döngü çalıştırılamaz' : 'Aynı gün içinde tekrar çalıştırır (SKIPPED bypass)'}
           >
             {actionLoading === 'run_force' ? <RefreshCw className="w-4 h-4 animate-spin" /> : <RotateCcw className="w-4 h-4" />}
-            {t('Zorla Tek Döngü', 'Force Single Cycle')}
+            Zorla Tek Döngü
           </button>
         </div>
-        {selectedStatus.workerRunning && selectedStatus.workerPid && (
-          <p className="text-xs text-gray-400 mt-2">Worker PID: {selectedStatus.workerPid}</p>
+        {status.workerRunning && status.workerPid && (
+          <p className="text-xs text-gray-400 mt-2">Worker PID: {status.workerPid}</p>
         )}
       </div>
 
       {/* Kill Switch Warning */}
-      {selectedStatus.killSwitchActive && (
+      {status.killSwitchActive && (
         <div className="bg-red-900/40 border border-red-500/60 rounded-lg p-4 mb-6 flex items-center gap-3">
           <ShieldOff className="w-6 h-6 text-red-400 flex-shrink-0" />
           <div>
-            <p className="text-red-300 font-medium">{t('Kill Switch Aktif', 'Kill Switch Active')}</p>
-            <p className="text-red-400/70 text-sm">{selectedStatus.killSwitchReason || t('Manuel olarak durduruldu', 'Manually stopped')}</p>
+            <p className="text-red-300 font-medium">Kill Switch Aktif</p>
+            <p className="text-red-400/70 text-sm">{status.killSwitchReason || 'Manuel olarak durduruldu'}</p>
           </div>
         </div>
       )}
@@ -554,139 +388,62 @@ export default function AutoTradingPage() {
       <div className="grid grid-cols-2 md:grid-cols-4 lg:grid-cols-6 gap-3 mb-6">
         <StatusCard
           icon={<Activity className="w-5 h-5" />}
-          label={t('Durum', 'Status')}
-          value={selectedStatus.isRunning ? t('Çalışıyor', 'Running') : (lastStatus ? `${t('Bekliyor', 'Idle')} — ${lastStatus}` : t('Bekliyor', 'Idle'))}
-          color={selectedStatus.isRunning ? 'text-green-400' : 'text-gray-500'}
+          label="Durum"
+          value={status.isRunning ? 'Çalışıyor' : (lastStatus ? `Bekliyor — ${lastStatus}` : 'Bekliyor')}
+          color={status.isRunning ? 'text-green-400' : 'text-gray-500'}
         />
         <StatusCard
           icon={<Clock className="w-5 h-5" />}
-          label={t('Son Çalışma', 'Last Run')}
-          value={selectedStatus.lastRunDate || '—'}
+          label="Son Çalışma"
+          value={status.lastRunDate || '—'}
           color="text-blue-400"
         />
         <StatusCard
           icon={<Wallet className="w-5 h-5" />}
-          label={t('Nakit', 'Cash')}
-          value={fmtMoneyByCurrency(selectedPortfolio.cash, selectedCurrency, isUS)}
+          label="Nakit"
+          value={fmtMoney(portfolio.cash)}
           color="text-green-400"
         />
         <StatusCard
           icon={<DollarSign className="w-5 h-5" />}
-          label={t('Toplam Özkaynak', 'Total Equity')}
-          value={fmtMoneyByCurrency(selectedPortfolio.equity, selectedCurrency, isUS)}
+          label="Toplam Özkaynak"
+          value={fmtMoney(portfolio.equity)}
           color="text-blue-400"
         />
         <StatusCard
-          icon={selectedPortfolio.pnlPct >= 0 ? <TrendingUp className="w-5 h-5" /> : <TrendingDown className="w-5 h-5" />}
+          icon={portfolio.pnlPct >= 0 ? <TrendingUp className="w-5 h-5" /> : <TrendingDown className="w-5 h-5" />}
           label="P&L"
-          value={fmtPct(selectedPortfolio.pnlPct)}
-          color={selectedPortfolio.pnlPct >= 0 ? 'text-green-400' : 'text-red-400'}
+          value={fmtPct(portfolio.pnlPct)}
+          color={portfolio.pnlPct >= 0 ? 'text-green-400' : 'text-red-400'}
         />
         <StatusCard
           icon={<Target className="w-5 h-5" />}
-          label={t('Pozisyon', 'Positions')}
-          value={`${selectedPortfolio.positionCount} ${t('açık', 'open')}`}
+          label="Pozisyon"
+          value={`${portfolio.positionCount} açık`}
           color="text-yellow-400"
         />
       </div>
 
-      {latestSignal && (
-        <div className="bg-white border border-gray-200 rounded-lg p-4 mb-6">
-          <div className="flex flex-col lg:flex-row lg:items-center lg:justify-between gap-4">
-            <div>
-              <div className="text-xs uppercase tracking-wide text-gray-500 mb-1">{t('Son Sinyal', 'Latest Signal')}</div>
-              <div className="flex items-center gap-2 flex-wrap">
-                <span className="text-lg font-semibold text-gray-900">{latestSignal.symbol}</span>
-                <SignalBadge signal={latestSignal.signal} />
-                <ActionBadge action={latestSignal.actionTaken} isUS={isUS} />
-              </div>
-            </div>
-            <div className="grid grid-cols-2 md:grid-cols-4 gap-3 text-sm">
-              <MiniMetric label="ML" value={latestSignal.mlSignal || '—'} />
-              <MiniMetric label={t('Teknik', 'Technical')} value={latestSignal.techSignal || '—'} />
-              <MiniMetric label={t('Güven', 'Confidence')} value={`%${(latestSignal.confidence * 100).toFixed(0)}`} />
-              <MiniMetric label={t('Tahmin', 'Forecast')} value={`%${(latestSignal.predictedReturn * 100).toFixed(1)}`} />
-            </div>
-          </div>
-        </div>
-      )}
-
-      {marketSummaries.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg p-4 mb-6">
-          <h3 className="font-semibold text-gray-700 mb-3 flex items-center gap-2">
-            <Server className="w-5 h-5 text-indigo-500" />
-                        {t('Çoklu Market Durumu', 'Multi-Market Status')}
-          </h3>
-          <div className="grid grid-cols-1 lg:grid-cols-2 gap-3">
-            {marketSummaries.map((market) => {
-              const summaryStatus = market.status.lastWorkerStatus || (market.status.workerRunning ? 'RUNNING' : 'IDLE')
-              const summaryReason = market.status.lastWorkerReason || market.scan.universe || '—'
-              return (
-                <div key={market.marketId} className="rounded-lg border border-gray-200 bg-gray-50 p-4">
-                  <div className="flex items-start justify-between gap-3 mb-3">
-                    <div>
-                      <h4 className="font-semibold text-gray-900">{market.displayName}</h4>
-                      <p className="text-xs text-gray-500 uppercase tracking-wide">{market.marketId} · {market.currency}</p>
-                    </div>
-                    <span className={`px-2.5 py-1 rounded-full text-xs font-medium ${market.status.workerRunning ? 'bg-green-100 text-green-700' : 'bg-gray-200 text-gray-600'}`}>
-                      {market.status.workerRunning ? t('Worker Aktif', 'Worker Active') : t('Worker Pasif', 'Worker Inactive')}
-                    </span>
-                  </div>
-                  <div className="grid grid-cols-2 gap-3 text-sm mb-3">
-                    <MiniMetric label={t('Nakit', 'Cash')} value={fmtMoneyByCurrency(market.portfolio.cash, market.currency, isUS)} />
-                    <MiniMetric label={t('Pozisyon', 'Positions')} value={`${market.portfolio.positionCount}`} />
-                    <MiniMetric label="Eligible" value={`${market.eligibleStocks.length}`} />
-                    <MiniMetric label={t('Tarama', 'Scan')} value={`${market.scan.stage1Count}/${market.scan.stage2Count}`} />
-                  </div>
-                  <div className="text-xs text-gray-500 space-y-1">
-                    <div><span className="font-medium text-gray-700">{t('Durum', 'Status')}:</span> {summaryStatus}</div>
-                    <div><span className="font-medium text-gray-700">{t('Kaynak', 'Source')}:</span> {summaryReason}</div>
-                    <div><span className="font-medium text-gray-700">{t('Son Çalışma', 'Last Run')}:</span> {market.status.lastRunDate || '—'}</div>
-                  </div>
-                  {market.eligibleStocks.length > 0 && (
-                    <div className="mt-3 flex flex-wrap gap-2">
-                      {market.eligibleStocks.slice(0, 10).map((symbol) => (
-                        <span key={`${market.marketId}-${symbol}`} className="px-2.5 py-1 rounded-full border border-blue-200 bg-blue-50 text-blue-700 text-xs font-medium">
-                          {symbol}
-                        </span>
-                      ))}
-                      {market.eligibleStocks.length > 10 && (
-                        <span className="px-2.5 py-1 rounded-full border border-gray-300 bg-white text-gray-600 text-xs font-medium">
-                          +{market.eligibleStocks.length - 10}
-                        </span>
-                      )}
-                    </div>
-                  )}
-                </div>
-              )
-            })}
-          </div>
-        </div>
-      )}
-
-      {!selectedStatus.isRunning && (lastStatus || lastReason) && (
+      {!status.isRunning && (lastStatus || lastReason) && (
         <div className="bg-white border border-gray-200 rounded-lg px-4 py-3 mb-6 text-sm text-gray-600">
-          <span className="font-medium text-gray-700">{t('Son döngü', 'Last cycle')}:</span>{' '}
+          <span className="font-medium text-gray-700">Son döngü:</span>{' '}
           {lastStatus || '—'}
           {lastReason ? ` — ${lastReason}` : ''}
         </div>
       )}
 
       {/* Eligible Stocks (Trading Pool) */}
-      {selectedEligibleStocks && selectedEligibleStocks.length > 0 && (
+      {eligibleStocks && eligibleStocks.length > 0 && (
         <div className="bg-white border border-gray-200 rounded-lg p-4 mb-6">
           <h3 className="font-semibold text-gray-700 mb-2 flex items-center gap-2">
             <Target className="w-5 h-5 text-green-500" />
-            Trade {t('Havuzu', 'Pool')} ({selectedEligibleStocks.length} {t('hisse', 'stocks')})
+            Trade Havuzu ({eligibleStocks.length} hisse)
           </h3>
           <p className="text-sm text-gray-500 mb-3">
-            {t(
-              'ML tarama sonuçlarına göre alım yapılabilecek hisseler. Worker bu havuzdan günlük sinyal üretir ve uygun olanlara pozisyon açar.',
-              'Stocks eligible for buying based on ML scan results. Worker generates daily signals from this pool and opens positions on suitable ones.'
-            )}
+            ML tarama sonuçlarına göre alım yapılabilecek hisseler. Worker bu havuzdan günlük sinyal üretir ve uygun olanlara pozisyon açar.
           </p>
           <div className="flex flex-wrap gap-2">
-            {selectedEligibleStocks.map((sym: string) => (
+            {eligibleStocks.map((sym: string) => (
               <span key={sym} className="px-3 py-1.5 bg-green-50 text-green-700 border border-green-200 rounded-full text-sm font-medium">
                 {sym}
               </span>
@@ -696,7 +453,7 @@ export default function AutoTradingPage() {
       )}
 
       {/* Equity Curve (simple text-based) */}
-      {selectedEquityCurve.length > 0 && (
+      {equityCurve.length > 0 && (
         <div className="bg-white border border-gray-200 rounded-lg mb-6 overflow-hidden">
           <button
             onClick={() => setShowEquity(!showEquity)}
@@ -704,32 +461,32 @@ export default function AutoTradingPage() {
           >
             <span className="flex items-center gap-2 font-semibold">
               <BarChart3 className="w-5 h-5 text-blue-400" />
-                            {t('Özkaynak Eğrisi', 'Equity Curve')} ({selectedEquityCurve.length} {t('gün', 'days')})
+              Özkaynak Eğrisi ({equityCurve.length} gün)
             </span>
             {showEquity ? <ChevronUp className="w-5 h-5 text-gray-500" /> : <ChevronDown className="w-5 h-5 text-gray-500" />}
           </button>
           {showEquity && (
             <div className="px-4 pb-4">
               <div className="flex items-end gap-[2px] h-32">
-                {selectedEquityCurve.slice(-60).map((pt, i) => {
-                  const min = Math.min(...selectedEquityCurve.slice(-60).map(e => e.equity))
-                  const max = Math.max(...selectedEquityCurve.slice(-60).map(e => e.equity))
+                {equityCurve.slice(-60).map((pt, i) => {
+                  const min = Math.min(...equityCurve.slice(-60).map(e => e.equity))
+                  const max = Math.max(...equityCurve.slice(-60).map(e => e.equity))
                   const range = max - min || 1
                   const height = ((pt.equity - min) / range) * 100
-                  const isLast = i === selectedEquityCurve.slice(-60).length - 1
+                  const isLast = i === equityCurve.slice(-60).length - 1
                   return (
                     <div
                       key={pt.date}
                       className={`flex-1 rounded-t ${pt.equity >= 100000 ? 'bg-green-500/70' : 'bg-red-500/70'} ${isLast ? 'ring-1 ring-white/30' : ''}`}
                       style={{ height: `${Math.max(height, 2)}%` }}
-                      title={`${pt.date}: ${fmtMoneyByCurrency(pt.equity, selectedCurrency, isUS)}`}
+                      title={`${pt.date}: ${fmtMoney(pt.equity)}`}
                     />
                   )
                 })}
               </div>
               <div className="flex justify-between text-xs text-gray-500 mt-1">
-                <span>{selectedEquityCurve.slice(-60)[0]?.date}</span>
-                <span>{selectedEquityCurve[selectedEquityCurve.length - 1]?.date}</span>
+                <span>{equityCurve.slice(-60)[0]?.date}</span>
+                <span>{equityCurve[equityCurve.length - 1]?.date}</span>
               </div>
             </div>
           )}
@@ -739,10 +496,10 @@ export default function AutoTradingPage() {
       {/* Tab Navigation */}
       <div className="flex gap-1 mb-4 bg-white p-1 rounded-lg overflow-x-auto">
         {([
-          { key: 'portfolio' as TabKey, label: t('Portföy', 'Portfolio'), icon: <Wallet className="w-4 h-4" /> },
-          { key: 'trades' as TabKey, label: `${t("Trade'ler", 'Trades')} (${selectedClosedTrades.length})`, icon: <BarChart3 className="w-4 h-4" /> },
-          { key: 'signals' as TabKey, label: `${t('Sinyaller', 'Signals')} (${selectedSignals.length})`, icon: <Target className="w-4 h-4" /> },
-          { key: 'performance' as TabKey, label: t('Performans', 'Performance'), icon: <TrendingUp className="w-4 h-4" /> },
+          { key: 'portfolio' as TabKey, label: 'Portföy', icon: <Wallet className="w-4 h-4" /> },
+          { key: 'trades' as TabKey, label: `Trade\'ler (${closedTrades.length})`, icon: <BarChart3 className="w-4 h-4" /> },
+          { key: 'signals' as TabKey, label: `Sinyaller (${signals.length})`, icon: <Target className="w-4 h-4" /> },
+          { key: 'performance' as TabKey, label: 'Performans', icon: <TrendingUp className="w-4 h-4" /> },
         ]).map(t => (
           <button
             key={t.key}
@@ -763,20 +520,19 @@ export default function AutoTradingPage() {
           <div>
             {/* ─── Position Charts (Live) ──────── */}
             <div className="px-4 py-3 border-b border-gray-200 font-semibold">
-              {t('Açık Pozisyonlar — Canlı Grafik', 'Open Positions — Live Chart')}
+              Açık Pozisyonlar — Canlı Grafik
             </div>
-            {selectedPortfolio.positions.length === 0 ? (
-              <div className="px-4 py-8 text-center text-gray-500">{t('Açık pozisyon yok', 'No open positions')}</div>
+            {portfolio.positions.length === 0 ? (
+              <div className="px-4 py-8 text-center text-gray-500">Açık pozisyon yok</div>
             ) : (
               <div className="p-4 space-y-4">
-                {selectedPortfolio.positions.map(p => (
+                {portfolio.positions.map(p => (
                   <PositionChart
                     key={p.symbol}
                     symbol={p.symbol}
                     entryPrice={p.avgCost}
                     entryDate={p.entryDate}
                     quantity={p.quantity}
-                    market={market}
                     priceRefreshMs={10_000}
                     chartRefreshMs={60_000}
                   />
@@ -785,13 +541,13 @@ export default function AutoTradingPage() {
             )}
 
             {/* ─── Closed Trades with Charts ───── */}
-            {selectedClosedTrades.length > 0 && (
+            {closedTrades.length > 0 && (
               <>
                 <div className="px-4 py-3 border-t border-b border-gray-200 font-semibold">
-                  {t('Kapatılmış Pozisyonlar — Grafik', 'Closed Positions — Chart')}
+                  Kapatılmış Pozisyonlar — Grafik
                 </div>
                 <div className="p-4 space-y-4">
-                  {selectedClosedTrades.slice(0, 5).map((t, i) => (
+                  {closedTrades.slice(0, 5).map((t, i) => (
                     <PositionChart
                       key={`${t.symbol}-${t.entryDate}-${i}`}
                       symbol={t.symbol}
@@ -801,7 +557,6 @@ export default function AutoTradingPage() {
                       exitPrice={t.exitPrice}
                       exitDate={t.exitDate}
                       exitReason={t.exitReason}
-                      market={market}
                       priceRefreshMs={0}
                       chartRefreshMs={0}
                     />
@@ -811,27 +566,27 @@ export default function AutoTradingPage() {
             )}
 
             {/* Open Trades from signals */}
-            {selectedOpenTrades.length > 0 && (
+            {openTrades.length > 0 && (
               <>
-                <div className="px-4 py-3 border-t border-b border-gray-200 font-semibold">{t('Açık Trade\'ler', 'Open Trades')}</div>
+                <div className="px-4 py-3 border-t border-b border-gray-200 font-semibold">Açık Trade&apos;ler</div>
                 <div className="overflow-x-auto">
                   <table className="w-full text-sm">
                     <thead>
                       <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                        <th className="px-4 py-3 text-left">{t('Sembol', 'Symbol')}</th>
-                        <th className="px-4 py-3 text-right">{t('Adet', 'Qty')}</th>
-                        <th className="px-4 py-3 text-right">{t('Giriş Fiyat', 'Entry Price')}</th>
-                        <th className="px-4 py-3 text-right">{t('Güven', 'Confidence')}</th>
-                        <th className="px-4 py-3 text-right">{t('Tahmin Getiri', 'Est. Return')}</th>
-                        <th className="px-4 py-3 text-left">{t('Tarih', 'Date')}</th>
+                        <th className="px-4 py-3 text-left">Sembol</th>
+                        <th className="px-4 py-3 text-right">Adet</th>
+                        <th className="px-4 py-3 text-right">Giriş Fiyat</th>
+                        <th className="px-4 py-3 text-right">Güven</th>
+                        <th className="px-4 py-3 text-right">Tahmin Getiri</th>
+                        <th className="px-4 py-3 text-left">Tarih</th>
                       </tr>
                     </thead>
                     <tbody className="divide-y divide-gray-800/50">
-                      {selectedOpenTrades.map((t, i) => (
+                      {openTrades.map((t, i) => (
                         <tr key={`${t.symbol}-${t.entryDate}`} className="hover:bg-gray-100/30">
                           <td className="px-4 py-3 font-medium text-gray-900">{t.symbol}</td>
                           <td className="px-4 py-3 text-right">{t.quantity}</td>
-                          <td className="px-4 py-3 text-right">{fmtMoneyByCurrency(t.entryPrice, selectedCurrency, isUS)}</td>
+                          <td className="px-4 py-3 text-right">{fmtMoney(t.entryPrice)}</td>
                           <td className="px-4 py-3 text-right text-blue-400">
                             %{(t.confidence * 100).toFixed(0)}
                           </td>
@@ -852,32 +607,32 @@ export default function AutoTradingPage() {
         {activeTab === 'trades' && (
           <div>
             <div className="px-4 py-3 border-b border-gray-200 font-semibold">
-              {t('Kapatılmış Trade\'ler', 'Closed Trades')} ({selectedClosedTrades.length})
+              Kapatılmış Trade&apos;ler ({closedTrades.length})
             </div>
-            {selectedClosedTrades.length === 0 ? (
-              <div className="px-4 py-8 text-center text-gray-500">{t('Henüz kapatılmış trade yok', 'No closed trades yet')}</div>
+            {closedTrades.length === 0 ? (
+              <div className="px-4 py-8 text-center text-gray-500">Henüz kapatılmış trade yok</div>
             ) : (
               <div className="overflow-x-auto">
                 <table className="w-full text-sm">
                   <thead>
                     <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                      <th className="px-4 py-3 text-left">{t('Sembol', 'Symbol')}</th>
-                      <th className="px-4 py-3 text-right">{t('Giriş', 'Entry')}</th>
-                      <th className="px-4 py-3 text-right">{t('Çıkış', 'Exit')}</th>
+                      <th className="px-4 py-3 text-left">Sembol</th>
+                      <th className="px-4 py-3 text-right">Giriş</th>
+                      <th className="px-4 py-3 text-right">Çıkış</th>
                       <th className="px-4 py-3 text-right">P&L</th>
-                      <th className="px-4 py-3 text-right">{t('Getiri', 'Return')}</th>
-                      <th className="px-4 py-3 text-right">{t('Gün', 'Days')}</th>
-                      <th className="px-4 py-3 text-left">{t('Neden', 'Reason')}</th>
+                      <th className="px-4 py-3 text-right">Getiri</th>
+                      <th className="px-4 py-3 text-right">Gün</th>
+                      <th className="px-4 py-3 text-left">Neden</th>
                     </tr>
                   </thead>
                   <tbody className="divide-y divide-gray-800/50">
-                    {selectedClosedTrades.map((t, i) => (
+                    {closedTrades.map((t, i) => (
                       <tr key={`${t.symbol}-${t.entryDate}`} className="hover:bg-gray-100/30">
                         <td className="px-4 py-3 font-medium text-gray-900">{t.symbol}</td>
-                        <td className="px-4 py-3 text-right">{fmtMoneyByCurrency(t.entryPrice, selectedCurrency, isUS)}</td>
-                        <td className="px-4 py-3 text-right">{fmtMoneyByCurrency(t.exitPrice, selectedCurrency, isUS)}</td>
+                        <td className="px-4 py-3 text-right">{fmtMoney(t.entryPrice)}</td>
+                        <td className="px-4 py-3 text-right">{fmtMoney(t.exitPrice)}</td>
                         <td className={`px-4 py-3 text-right font-medium ${t.netPnl >= 0 ? 'text-green-400' : 'text-red-400'}`}>
-                          {fmtMoneyByCurrency(t.netPnl, selectedCurrency, isUS)}
+                          {fmtMoney(t.netPnl)}
                         </td>
                         <td className={`px-4 py-3 text-right ${t.returnPct >= 0 ? 'text-green-400' : 'text-red-400'}`}>
                           {fmtPct(t.returnPct)}
@@ -896,26 +651,26 @@ export default function AutoTradingPage() {
         {activeTab === 'signals' && (
           <div>
             <div className="px-4 py-3 border-b border-gray-200 font-semibold">
-              {t('Son Sinyaller', 'Recent Signals')} ({selectedSignals.length})
+              Son Sinyaller ({signals.length})
             </div>
-            {selectedSignals.length === 0 ? (
-              <div className="px-4 py-8 text-center text-gray-500">{t('Sinyal kaydı yok', 'No signals recorded')}</div>
+            {signals.length === 0 ? (
+              <div className="px-4 py-8 text-center text-gray-500">Sinyal kaydı yok</div>
             ) : (
               <div className="overflow-x-auto">
                 <table className="w-full text-sm">
                   <thead>
                     <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                      <th className="px-4 py-3 text-left">{t('Tarih', 'Date')}</th>
-                      <th className="px-4 py-3 text-left">{t('Sembol', 'Symbol')}</th>
-                      <th className="px-4 py-3 text-center">{t('Sinyal', 'Signal')}</th>
+                      <th className="px-4 py-3 text-left">Tarih</th>
+                      <th className="px-4 py-3 text-left">Sembol</th>
+                      <th className="px-4 py-3 text-center">Sinyal</th>
                       <th className="px-4 py-3 text-center">ML</th>
-                      <th className="px-4 py-3 text-center">{t('Teknik', 'Technical')}</th>
-                      <th className="px-4 py-3 text-right">{t('Güven', 'Confidence')}</th>
-                      <th className="px-4 py-3 text-left">{t('Eylem', 'Action')}</th>
+                      <th className="px-4 py-3 text-center">Teknik</th>
+                      <th className="px-4 py-3 text-right">Güven</th>
+                      <th className="px-4 py-3 text-left">Eylem</th>
                     </tr>
                   </thead>
                   <tbody className="divide-y divide-gray-800/50">
-                    {selectedSignals.map((s, i) => (
+                    {signals.map((s, i) => (
                       <tr key={`${s.symbol}-${s.date}-${i}`} className="hover:bg-gray-100/30">
                         <td className="px-4 py-3 text-gray-500 text-xs">{s.date}</td>
                         <td className="px-4 py-3 font-medium text-gray-900">{s.symbol}</td>
@@ -931,9 +686,7 @@ export default function AutoTradingPage() {
                         <td className="px-4 py-3 text-right text-blue-400">
                           %{(s.confidence * 100).toFixed(0)}
                         </td>
-                        <td className="px-4 py-3 text-xs text-gray-500">
-                          <ActionBadge action={s.actionTaken} isUS={isUS} />
-                        </td>
+                        <td className="px-4 py-3 text-xs text-gray-500">{s.actionTaken}</td>
                       </tr>
                     ))}
                   </tbody>
@@ -947,37 +700,37 @@ export default function AutoTradingPage() {
           <div className="p-4 space-y-6">
             {/* Stats Grid */}
             <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
-              <PerfCard label={t('Toplam P&L', 'Total P&L')} value={fmtMoneyByCurrency(selectedPerformance.totalPnl, selectedCurrency, isUS)} color={selectedPerformance.totalPnl >= 0 ? 'text-green-400' : 'text-red-400'} />
-              <PerfCard label="Win Rate" value={`%${selectedPerformance.winRate}`} color={selectedPerformance.winRate >= 50 ? 'text-green-400' : 'text-red-400'} />
-              <PerfCard label="Profit Factor" value={`${selectedPerformance.profitFactor}`} color="text-blue-400" />
-              <PerfCard label={t('Trade Sayısı', 'Trade Count')} value={`${selectedPerformance.closedTradesCount}`} color="text-gray-600" />
-              <PerfCard label={t('Ort. Kazanç', 'Avg Win')} value={fmtMoneyByCurrency(selectedPerformance.avgWin, selectedCurrency, isUS)} color="text-green-400" />
-              <PerfCard label={t('Ort. Kayıp', 'Avg Loss')} value={fmtMoneyByCurrency(selectedPerformance.avgLoss, selectedCurrency, isUS)} color="text-red-400" />
-              <PerfCard label={t('En İyi Trade', 'Best Trade')} value={fmtPct(selectedPerformance.bestTrade)} color="text-green-400" />
-              <PerfCard label={t('En Kötü Trade', 'Worst Trade')} value={fmtPct(selectedPerformance.worstTrade)} color="text-red-400" />
+              <PerfCard label="Toplam P&L" value={fmtMoney(performance.totalPnl)} color={performance.totalPnl >= 0 ? 'text-green-400' : 'text-red-400'} />
+              <PerfCard label="Win Rate" value={`%${performance.winRate}`} color={performance.winRate >= 50 ? 'text-green-400' : 'text-red-400'} />
+              <PerfCard label="Profit Factor" value={`${performance.profitFactor}`} color="text-blue-400" />
+              <PerfCard label="Trade Sayısı" value={`${performance.closedTradesCount}`} color="text-gray-600" />
+              <PerfCard label="Ort. Kazanç" value={fmtMoney(performance.avgWin)} color="text-green-400" />
+              <PerfCard label="Ort. Kayıp" value={fmtMoney(performance.avgLoss)} color="text-red-400" />
+              <PerfCard label="En İyi Trade" value={fmtPct(performance.bestTrade)} color="text-green-400" />
+              <PerfCard label="En Kötü Trade" value={fmtPct(performance.worstTrade)} color="text-red-400" />
             </div>
 
             {/* Symbol Breakdown */}
-            {selectedPerformance.symbolBreakdown.length > 0 && (
+            {performance.symbolBreakdown.length > 0 && (
               <div>
-                <h3 className="font-semibold mb-3 text-gray-600">{t('Sembol Bazlı Performans', 'Per-Symbol Performance')}</h3>
+                <h3 className="font-semibold mb-3 text-gray-600">Sembol Bazlı Performans</h3>
                 <div className="overflow-x-auto">
                   <table className="w-full text-sm">
                     <thead>
                       <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                        <th className="px-4 py-3 text-left">{t('Sembol', 'Symbol')}</th>
+                        <th className="px-4 py-3 text-left">Sembol</th>
                         <th className="px-4 py-3 text-right">Trade</th>
                         <th className="px-4 py-3 text-right">P&L</th>
                         <th className="px-4 py-3 text-right">Win Rate</th>
                       </tr>
                     </thead>
                     <tbody className="divide-y divide-gray-800/50">
-                      {selectedPerformance.symbolBreakdown.map(s => (
+                      {performance.symbolBreakdown.map(s => (
                         <tr key={s.symbol} className="hover:bg-gray-100/30">
                           <td className="px-4 py-3 font-medium text-gray-900">{s.symbol}</td>
                           <td className="px-4 py-3 text-right">{s.trades}</td>
                           <td className={`px-4 py-3 text-right font-medium ${s.pnl >= 0 ? 'text-green-400' : 'text-red-400'}`}>
-                            {fmtMoneyByCurrency(s.pnl, selectedCurrency, isUS)}
+                            {fmtMoney(s.pnl)}
                           </td>
                           <td className="px-4 py-3 text-right">%{s.winRate}</td>
                         </tr>
@@ -1020,15 +773,6 @@ function PerfCard({ label, value, color }: { label: string; value: string; color
   )
 }
 
-function MiniMetric({ label, value }: { label: string; value: string }) {
-  return (
-    <div className="rounded-lg border border-gray-200 bg-white px-3 py-2">
-      <div className="text-[11px] uppercase tracking-wide text-gray-500">{label}</div>
-      <div className="text-sm font-semibold text-gray-900">{value}</div>
-    </div>
-  )
-}
-
 function SignalBadge({ signal }: { signal: string }) {
   const s = signal?.toUpperCase()
   if (s === 'BUY') return <span className="text-xs px-2 py-0.5 rounded-full bg-green-600/30 text-green-400">BUY</span>
@@ -1036,24 +780,3 @@ function SignalBadge({ signal }: { signal: string }) {
   if (s === 'HOLD') return <span className="text-xs px-2 py-0.5 rounded-full bg-gray-600/30 text-gray-500">HOLD</span>
   return <span className="text-xs text-gray-500">{signal || '—'}</span>
 }
-
-function ActionBadge({ action, isUS = false }: { action: string; isUS?: boolean }) {
-  const normalized = (action || '').toUpperCase()
-
-  let className = 'bg-gray-100 text-gray-600 border border-gray-200'
-  if (normalized.startsWith('BUY_EXECUTED') || normalized.startsWith('SELL_EXECUTED')) {
-    className = 'bg-green-50 text-green-700 border border-green-200'
-  } else if (normalized.includes('BLOCKED') || normalized.includes('REJECTED')) {
-    className = 'bg-red-50 text-red-700 border border-red-200'
-  } else if (normalized.startsWith('BUY_SIGNAL') || normalized.startsWith('SELL_SIGNAL')) {
-    className = 'bg-blue-50 text-blue-700 border border-blue-200'
-  } else if (normalized.startsWith('BUY_SKIPPED') || normalized === 'SELL_NO_POSITION' || normalized === 'PENDING') {
-    className = 'bg-amber-50 text-amber-700 border border-amber-200'
-  }
-
-  return (
-    <span className={`inline-flex items-center rounded-full px-2.5 py-1 text-[11px] font-medium ${className}`}>
-      {describeSignalAction(action, isUS)}
-    </span>
-  )
-}

huggingface-space/nextjs-app/src/app/eligible/page.tsx

@@ -2,7 +2,6 @@
 
 import { useState, useEffect, useMemo, useCallback } from 'react'
 import { fetchJson } from '@/lib/http'
-import { useMarket } from '@/contexts/MarketContext'
 import {
   Shield,
   ShieldOff,
@@ -222,10 +221,6 @@ function GaugeIndicator({ value, min, max, label, unit = '', invertColor = false
 // ─── Main Component ────────────────────────
 
 export default function EligiblePage() {
-  const { market } = useMarket()
-  const isUS = market === 'us'
-  const currencySymbol = isUS ? '$' : '₺'
-  const t = (tr: string, en: string) => isUS ? en : tr
   const [data, setData] = useState<EligibleData | null>(null)
   const [signals, setSignals] = useState<SignalsData | null>(null)
   const [loading, setLoading] = useState(true)
@@ -249,7 +244,7 @@ export default function EligiblePage() {
     setLoading(true)
     setError(null)
     try {
-      const res = await fetchJson<EligibleData>(`/api/eligible?market=${market}`, undefined, { timeoutMs: 15000 })
+      const res = await fetchJson<EligibleData>('/api/eligible', undefined, { timeoutMs: 15000 })
       // ok: false means no scan results yet — treat as empty data, not error
       setData(res)
       return res
@@ -259,7 +254,7 @@ export default function EligiblePage() {
     } finally {
       setLoading(false)
     }
-  }, [market])
+  }, [])
 
   const loadSignals = useCallback(async (symbols: string[]) => {
     if (!symbols.length) return
@@ -267,7 +262,7 @@ export default function EligiblePage() {
     try {
       const res = await fetchJson<SignalsData>(
         '/api/trading-signals',
-        { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ symbols, market }) },
+        { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ symbols }) },
         { timeoutMs: 60000 }
       )
       if (res.ok) setSignals(res)
@@ -276,20 +271,20 @@ export default function EligiblePage() {
     } finally {
       setSignalsLoading(false)
     }
-  }, [market])
+  }, [])
 
-  const startScan = useCallback(async (universe: string = isUS ? 'sp100' : 'bist30') => {
+  const startScan = useCallback(async (universe: string = 'bist30') => {
     setScanLoading(true)
     try {
       await fetchJson('/api/trading', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ action: 'scan', reason: universe, universe, market }),
+        body: JSON.stringify({ action: 'scan', reason: universe }),
       })
       // Poll for results every 15 seconds
       const poll = setInterval(async () => {
         try {
-          const res = await fetchJson<EligibleData>(`/api/eligible?market=${market}`, undefined, { timeoutMs: 10000 })
+          const res = await fetchJson<EligibleData>('/api/eligible', undefined, { timeoutMs: 10000 })
           setData(res) // always update UI with latest progress
           // Stop polling when: scan finished, or ok:true with results, or scan manually ended
           const scanDone = res.scanCompleted || (!res.scanRunning && !scanLoading)
@@ -313,13 +308,11 @@ export default function EligiblePage() {
       }, 90 * 60 * 1000)
     } catch (e: unknown) {
       setScanLoading(false)
-      setError(e instanceof Error ? e.message : t('Tarama başlatılamadı', 'Failed to start scan'))
+      setError(e instanceof Error ? e.message : 'Tarama başlatılamadı')
     }
-  }, [isUS, loadEligible, loadSignals, market, t])
+  }, [loadEligible, loadSignals])
 
   useEffect(() => {
-    setData(null)
-    setSignals(null)
     loadEligible().then((res) => {
       if (res?.eligible?.length) loadSignals(res.eligible.map((e) => e.symbol))
     })
@@ -382,7 +375,7 @@ export default function EligiblePage() {
       <div className="min-h-screen bg-gray-50 flex items-center justify-center">
         <div className="flex flex-col items-center gap-3">
           <RefreshCw className="w-8 h-8 text-blue-400 animate-spin" />
-          <p className="text-gray-500">Loading eligible stocks...</p>
+          <p className="text-gray-500">Eligible hisseler yükleniyor...</p>
         </div>
       </div>
     )
@@ -485,7 +478,7 @@ export default function EligiblePage() {
             </p>
           )}
           <p className="text-gray-400 text-xs mt-0.5 flex items-center gap-1">
-            <Clock className="w-3 h-3" /> {isUS ? 'Scheduled scan: after US market close' : 'Otomatik tarama: Her gün 19:00 (TR) — Tüm BIST'}
+            <Clock className="w-3 h-3" /> Otomatik tarama: Her gün 19:00 (TR) — Tüm BIST
           </p>
         </div>
         <div className="flex items-center gap-2">
@@ -509,33 +502,33 @@ export default function EligiblePage() {
             {showScanMenu && !isScanRunning && (
               <div className="absolute right-0 top-full mt-1 bg-white border border-gray-200 rounded-lg shadow-lg z-20 py-1 min-w-[200px]">
                 <button
-                  onClick={() => { setShowScanMenu(false); startScan(isUS ? 'sp100' : 'bist30') }}
+                  onClick={() => { setShowScanMenu(false); startScan('bist30') }}
                   className="w-full px-4 py-2.5 text-left text-sm hover:bg-gray-50 flex items-center gap-2"
                 >
                   <Zap className="w-4 h-4 text-blue-500" />
                   <div>
-                    <div className="font-medium">{isUS ? 'S&P 100 Quick Scan' : 'BIST30 Hızlı Tara'}</div>
-                    <div className="text-xs text-gray-400">{isUS ? '~20-40 minutes' : '~15-30 dakika'}</div>
+                    <div className="font-medium">BIST30 Hızlı Tara</div>
+                    <div className="text-xs text-gray-400">~15-30 dakika</div>
                   </div>
                 </button>
                 <button
-                  onClick={() => { setShowScanMenu(false); startScan(isUS ? 'sp500' : 'bist100') }}
+                  onClick={() => { setShowScanMenu(false); startScan('bist100') }}
                   className="w-full px-4 py-2.5 text-left text-sm hover:bg-gray-50 flex items-center gap-2"
                 >
                   <BarChart3 className="w-4 h-4 text-green-500" />
                   <div>
-                    <div className="font-medium">{isUS ? 'S&P 500 Full Scan' : 'BIST100 Tam Tara'}</div>
-                    <div className="text-xs text-gray-400">{isUS ? '~60-120 minutes' : '~60-90 dakika'}</div>
+                    <div className="font-medium">BIST100 Tam Tara</div>
+                    <div className="text-xs text-gray-400">~60-90 dakika</div>
                   </div>
                 </button>
                 <button
-                  onClick={() => { setShowScanMenu(false); startScan(isUS ? 'nasdaq100' : 'all') }}
+                  onClick={() => { setShowScanMenu(false); startScan('all') }}
                   className="w-full px-4 py-2.5 text-left text-sm hover:bg-gray-50 flex items-center gap-2 border-t border-gray-100"
                 >
                   <Activity className="w-4 h-4 text-purple-500" />
                   <div>
-                    <div className="font-medium">{isUS ? 'Nasdaq 100 Scan' : 'Tüm BIST Tara'}</div>
-                    <div className="text-xs text-gray-400">{isUS ? '~45-90 minutes' : '~2-4 saat'}</div>
+                    <div className="font-medium">Tüm BIST Tara</div>
+                    <div className="text-xs text-gray-400">~2-4 saat</div>
                   </div>
                 </button>
               </div>
@@ -657,15 +650,15 @@ export default function EligiblePage() {
                       <div className="flex items-center justify-between mb-3">
                         <div>
                           <div className="text-xs text-gray-500">Son Fiyat</div>
-                          <div className="text-lg font-bold text-gray-900">{currencySymbol}{sig.lastPrice.toFixed(2)}</div>
+                          <div className="text-lg font-bold text-gray-900">₺{sig.lastPrice.toFixed(2)}</div>
                         </div>
                         <ScoreBar score={sig.signalScore} />
                       </div>
                       {(sig.entryPrice || sig.targetPrice || sig.stopLoss) && (
                         <div className="grid grid-cols-3 gap-2 mb-3">
-                          <PriceBox label="Giriş" value={sig.entryPrice} color="text-blue-400" currencySymbol={currencySymbol} />
-                          <PriceBox label="Hedef" value={sig.targetPrice} color="text-green-400" currencySymbol={currencySymbol} />
-                          <PriceBox label="Stop" value={sig.stopLoss} color="text-red-400" currencySymbol={currencySymbol} />
+                          <PriceBox label="Giriş" value={sig.entryPrice} color="text-blue-400" />
+                          <PriceBox label="Hedef" value={sig.targetPrice} color="text-green-400" />
+                          <PriceBox label="Stop" value={sig.stopLoss} color="text-red-400" />
                         </div>
                       )}
                       <div className="flex items-center justify-between text-xs">
@@ -720,10 +713,10 @@ export default function EligiblePage() {
                         {sig ? <span className={`inline-flex items-center gap-1 text-xs px-2 py-0.5 rounded-full font-bold ${signalColor(sig.signal)}`}>{signalIcon(sig.signal)} {sig.signal}</span>
                           : signalsLoading ? <RefreshCw className="w-3 h-3 text-gray-600 animate-spin" /> : '—'}
                       </td>
-                      <td className="px-3 py-2.5 text-right font-mono">{sig ? `${currencySymbol}${sig.lastPrice.toFixed(2)}` : '—'}</td>
-                      <td className="px-3 py-2.5 text-right font-mono text-blue-400">{sig?.entryPrice ? `${currencySymbol}${sig.entryPrice.toFixed(2)}` : '—'}</td>
-                      <td className="px-3 py-2.5 text-right font-mono text-green-400">{sig?.targetPrice ? `${currencySymbol}${sig.targetPrice.toFixed(2)}` : '—'}</td>
-                      <td className="px-3 py-2.5 text-right font-mono text-red-400">{sig?.stopLoss ? `${currencySymbol}${sig.stopLoss.toFixed(2)}` : '—'}</td>
+                      <td className="px-3 py-2.5 text-right font-mono">{sig ? `₺${sig.lastPrice.toFixed(2)}` : '—'}</td>
+                      <td className="px-3 py-2.5 text-right font-mono text-blue-400">{sig?.entryPrice ? `₺${sig.entryPrice.toFixed(2)}` : '—'}</td>
+                      <td className="px-3 py-2.5 text-right font-mono text-green-400">{sig?.targetPrice ? `₺${sig.targetPrice.toFixed(2)}` : '—'}</td>
+                      <td className="px-3 py-2.5 text-right font-mono text-red-400">{sig?.stopLoss ? `₺${sig.stopLoss.toFixed(2)}` : '—'}</td>
                       <td className="px-3 py-2.5 text-right">
                         {sig?.potentialReturn != null ? <span className={sig.potentialReturn > 0 ? 'text-green-400 font-semibold' : 'text-red-400'}>%{sig.potentialReturn.toFixed(1)}</span> : '—'}
                       </td>
@@ -752,7 +745,7 @@ export default function EligiblePage() {
       )}
 
       {/* ─── DETAIL MODAL ─── */}
-      {selectedSignal && <DetailModal stock={selectedSignal} onClose={() => setSelectedStock(null)} currencySymbol={currencySymbol} />}
+      {selectedSignal && <DetailModal stock={selectedSignal} onClose={() => setSelectedStock(null)} />}
 
       {/* Excluded & Stage-1 sections */}
       <div className="space-y-4 mt-6">
@@ -813,11 +806,11 @@ function SummaryCard({ icon, value, label, color }: { icon: React.ReactNode; val
   )
 }
 
-function PriceBox({ label, value, color, currencySymbol }: { label: string; value: number | null; color: string; currencySymbol: string }) {
+function PriceBox({ label, value, color }: { label: string; value: number | null; color: string }) {
   return (
     <div className="bg-gray-50 rounded p-2 text-center">
       <div className="text-[10px] text-gray-500">{label}</div>
-      <div className={`text-sm font-mono font-semibold ${color}`}>{value ? `${currencySymbol}${value.toFixed(2)}` : '—'}</div>
+      <div className={`text-sm font-mono font-semibold ${color}`}>{value ? `₺${value.toFixed(2)}` : '—'}</div>
     </div>
   )
 }
@@ -848,10 +841,9 @@ function CollapsibleSection({ title, icon, open, onToggle, children }: {
 
 // ─── Detail Modal ──────────────────────────
 
-function DetailModal({ stock, onClose, currencySymbol }: {
+function DetailModal({ stock, onClose }: {
   stock: { symbol: string; sharpe: number; annual_return: number; hit_rate: number; quality: string; signal: TradingSignal | null }
   onClose: () => void
-  currencySymbol: string
 }) {
   const sig = stock.signal
 
@@ -898,10 +890,10 @@ function DetailModal({ stock, onClose, currencySymbol }: {
               <div>
                 <h3 className="text-sm font-semibold text-gray-500 mb-3 flex items-center gap-2"><Target className="w-4 h-4" /> Trading Planı</h3>
                 <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
-                  <TradingPlanCard label="Son Fiyat" value={`${currencySymbol}${sig.lastPrice.toFixed(2)}`} color="text-white" />
-                  <TradingPlanCard label="Giriş Fiyatı" value={sig.entryPrice ? `${currencySymbol}${sig.entryPrice.toFixed(2)}` : '—'} color="text-blue-400" subtitle={sig.entryPrice ? `Güncel fiyattan %${(((sig.entryPrice - sig.lastPrice) / sig.lastPrice) * 100).toFixed(1)}` : undefined} />
-                  <TradingPlanCard label="Hedef Fiyat" value={sig.targetPrice ? `${currencySymbol}${sig.targetPrice.toFixed(2)}` : '—'} color="text-green-400" subtitle={sig.potentialReturn ? `Potansiyel: %${sig.potentialReturn.toFixed(1)}` : undefined} />
-                  <TradingPlanCard label="Stop Loss" value={sig.stopLoss ? `${currencySymbol}${sig.stopLoss.toFixed(2)}` : '—'} color="text-red-400" subtitle={sig.stopLoss && sig.entryPrice ? `Risk: %${(((sig.entryPrice - sig.stopLoss) / sig.entryPrice) * 100).toFixed(1)}` : undefined} />
+                  <TradingPlanCard label="Son Fiyat" value={`₺${sig.lastPrice.toFixed(2)}`} color="text-white" />
+                  <TradingPlanCard label="Giriş Fiyatı" value={sig.entryPrice ? `₺${sig.entryPrice.toFixed(2)}` : '—'} color="text-blue-400" subtitle={sig.entryPrice ? `Güncel fiyattan %${(((sig.entryPrice - sig.lastPrice) / sig.lastPrice) * 100).toFixed(1)}` : undefined} />
+                  <TradingPlanCard label="Hedef Fiyat" value={sig.targetPrice ? `₺${sig.targetPrice.toFixed(2)}` : '—'} color="text-green-400" subtitle={sig.potentialReturn ? `Potansiyel: %${sig.potentialReturn.toFixed(1)}` : undefined} />
+                  <TradingPlanCard label="Stop Loss" value={sig.stopLoss ? `₺${sig.stopLoss.toFixed(2)}` : '—'} color="text-red-400" subtitle={sig.stopLoss && sig.entryPrice ? `Risk: %${(((sig.entryPrice - sig.stopLoss) / sig.entryPrice) * 100).toFixed(1)}` : undefined} />
                 </div>
                 {sig.riskReward && <div className="mt-2 text-xs text-gray-500 text-center">Risk : Ödül = 1 : {sig.riskReward.toFixed(1)}</div>}
               </div>
@@ -930,18 +922,18 @@ function DetailModal({ stock, onClose, currencySymbol }: {
                 </div>
                 {/* Moving Averages */}
                 <div className="mt-3 grid grid-cols-3 md:grid-cols-5 gap-2">
-                  {sig.indicators.sma20 && <MABadge label="SMA20" value={sig.indicators.sma20} lastPrice={sig.lastPrice} currencySymbol={currencySymbol} />}
-                  {sig.indicators.sma50 && <MABadge label="SMA50" value={sig.indicators.sma50} lastPrice={sig.lastPrice} currencySymbol={currencySymbol} />}
-                  {sig.indicators.sma200 && <MABadge label="SMA200" value={sig.indicators.sma200} lastPrice={sig.lastPrice} currencySymbol={currencySymbol} />}
-                  {sig.indicators.ema12 && <MABadge label="EMA12" value={sig.indicators.ema12} lastPrice={sig.lastPrice} currencySymbol={currencySymbol} />}
-                  {sig.indicators.ema26 && <MABadge label="EMA26" value={sig.indicators.ema26} lastPrice={sig.lastPrice} currencySymbol={currencySymbol} />}
+                  {sig.indicators.sma20 && <MABadge label="SMA20" value={sig.indicators.sma20} lastPrice={sig.lastPrice} />}
+                  {sig.indicators.sma50 && <MABadge label="SMA50" value={sig.indicators.sma50} lastPrice={sig.lastPrice} />}
+                  {sig.indicators.sma200 && <MABadge label="SMA200" value={sig.indicators.sma200} lastPrice={sig.lastPrice} />}
+                  {sig.indicators.ema12 && <MABadge label="EMA12" value={sig.indicators.ema12} lastPrice={sig.lastPrice} />}
+                  {sig.indicators.ema26 && <MABadge label="EMA26" value={sig.indicators.ema26} lastPrice={sig.lastPrice} />}
                 </div>
                 {/* Bollinger */}
                 {sig.indicators.bollinger && (
                   <div className="mt-3 flex items-center gap-4 justify-center text-xs">
-                    <span className="text-red-400">BB Alt: {currencySymbol}{sig.indicators.bollinger.lower.toFixed(2)}</span>
-                    <span className="text-yellow-400">BB Orta: {currencySymbol}{sig.indicators.bollinger.middle.toFixed(2)}</span>
-                    <span className="text-green-400">BB Üst: {currencySymbol}{sig.indicators.bollinger.upper.toFixed(2)}</span>
+                    <span className="text-red-400">BB Alt: ₺{sig.indicators.bollinger.lower.toFixed(2)}</span>
+                    <span className="text-yellow-400">BB Orta: ₺{sig.indicators.bollinger.middle.toFixed(2)}</span>
+                    <span className="text-green-400">BB Üst: ₺{sig.indicators.bollinger.upper.toFixed(2)}</span>
                   </div>
                 )}
               </div>
@@ -992,12 +984,12 @@ function TradingPlanCard({ label, value, color, subtitle }: { label: string; val
   )
 }
 
-function MABadge({ label, value, lastPrice, currencySymbol }: { label: string; value: number; lastPrice: number; currencySymbol: string }) {
+function MABadge({ label, value, lastPrice }: { label: string; value: number; lastPrice: number }) {
   const above = lastPrice > value
   return (
     <div className={`text-center rounded px-2 py-1.5 ${above ? 'bg-green-900/30' : 'bg-red-900/30'}`}>
       <div className="text-[10px] text-gray-500">{label}</div>
-      <div className="text-xs font-mono">{currencySymbol}{value.toFixed(2)}</div>
+      <div className="text-xs font-mono">₺{value.toFixed(2)}</div>
       <div className={`text-[9px] ${above ? 'text-green-500' : 'text-red-500'}`}>{above ? '▲ Üstünde' : '▼ Altında'}</div>
     </div>
   )

huggingface-space/nextjs-app/src/app/ml-scan/page.tsx

@@ -6,7 +6,6 @@ import Link from 'next/link';
 
 import { fetchJson } from '@/lib/http';
 import { logger } from '@/lib/logger';
-import { useMarket } from '@/contexts/MarketContext';
 
 // Force dynamic rendering
 export const dynamic = 'force-dynamic';
@@ -74,19 +73,13 @@ interface MLScanResult {
   models_used?: number;
 }
 
-const BIST_UNIVERSE: Record<string, { name: string; expected: number }> = {
+const MARKET_UNIVERSE: Record<'BIST 30' | 'BIST 50' | 'BIST 100' | 'Tüm BIST', { name: 'bist30' | 'bist50' | 'bist100' | 'all'; expected: number }> = {
   'BIST 30': { name: 'bist30', expected: 30 },
   'BIST 50': { name: 'bist50', expected: 50 },
   'BIST 100': { name: 'bist100', expected: 100 },
   'Tüm BIST': { name: 'all', expected: 500 },
 };
 
-const US_UNIVERSE: Record<string, { name: string; expected: number }> = {
-  'Popular 30': { name: 'us_popular', expected: 30 },
-  'S&P 500 Top 50': { name: 'us_sp500', expected: 50 },
-  'Tech 30': { name: 'us_tech', expected: 30 },
-};
-
 function chunkArray<T>(arr: T[], size: number): T[][] {
   const out: T[][] = [];
   const n = Math.max(1, Math.floor(size));
@@ -114,15 +107,10 @@ export default function MLScanPage() {
   const [loading, setLoading] = useState(false);
   const [filter, setFilter] = useState<'all' | 'BUY' | 'SELL' | 'HOLD'>('all');
   const [minConfidence, setMinConfidence] = useState(10);
-  const { market } = useMarket();
-  const isUS = market === 'us';
-  const currencySymbol = isUS ? '$' : '₺';
-  const MARKET_UNIVERSE = isUS ? US_UNIVERSE : BIST_UNIVERSE;
-  const defaultSelection = isUS ? 'Popular 30' : 'Popüler';
   
   // Gelişmiş Ayarlar
   const [showAdvanced, setShowAdvanced] = useState(false);
-  const [marketSelection, setMarketSelection] = useState<string>(defaultSelection);
+  const [marketSelection, setMarketSelection] = useState<'BIST 30' | 'BIST 50' | 'BIST 100' | 'Tüm BIST' | 'Popüler'>('Popüler');
   const [modelType, setModelType] = useState<'ensemble' | 'xgboost' | 'lightgbm' | 'rf'>('ensemble');
   const [predictionDays, setPredictionDays] = useState(7);
   const [scanStatus, setScanStatus] = useState<string>('');
@@ -158,24 +146,18 @@ export default function MLScanPage() {
 
   const handleScan = async () => {
     setLoading(true);
-    setScanStatus(isUS ? 'Fetching stocks...' : 'Hisseler alınıyor...');
+    setScanStatus('Hisseler alınıyor...');
     
     try {
       // Piyasa seçimine göre hisse listesi al
       let symbols: string[] = [];
       
-      if (marketSelection === 'Popüler' || marketSelection === 'Popular 30') {
-        if (isUS) {
-          const uniData = await fetchJson<Record<string, unknown>>(`/api/universe?name=us_popular`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 });
-          symbols = Array.isArray(uniData?.symbols) ? uniData.symbols : [];
-        } else {
-          const stocksData = await fetchJson<Record<string, unknown>>(`/api/popular-stocks`, { method: 'GET' }, { timeoutMs: 12000, retries: 1 });
-          symbols = Array.isArray(stocksData.stocks) ? stocksData.stocks as string[] : [];
-        }
+      if (marketSelection === 'Popüler') {
+        const stocksData = await fetchJson<Record<string, unknown>>(`/api/popular-stocks`, { method: 'GET' }, { timeoutMs: 12000, retries: 1 });
+        symbols = Array.isArray(stocksData.stocks) ? stocksData.stocks as string[] : [];
       } else {
         const uni = MARKET_UNIVERSE[marketSelection];
-        if (!uni) throw new Error(`Unknown market selection: ${marketSelection}`);
-        setScanStatus(isUS ? `Fetching ${marketSelection} list...` : `${marketSelection} listesi alınıyor (resmi kaynak)...`);
+        setScanStatus(`${marketSelection} listesi alınıyor (resmi kaynak)...`);
         const universeData = await fetchJson<Record<string, unknown>>(
           `/api/universe?name=${encodeURIComponent(uni.name)}`,
           { method: 'GET' },
@@ -183,143 +165,17 @@ export default function MLScanPage() {
         );
         symbols = Array.isArray(universeData?.symbols) ? universeData.symbols : [];
 
+        // Safety: if backend cannot provide a real list, fail loudly (no toy fallbacks).
         if (symbols.length < Math.floor(uni.expected * 0.9)) {
-          throw new Error(isUS
-            ? `${marketSelection} list unavailable (expected ~${uni.expected}, got ${symbols.length})`
-            : `${marketSelection} listesi alınamadı (beklenen ~${uni.expected}, gelen ${symbols.length}). Backend /api/universe çalışmıyor olabilir.`);
+          throw new Error(`${marketSelection} listesi alınamadı (beklenen ~${uni.expected}, gelen ${symbols.length}). Backend /api/universe çalışmıyor olabilir.`);
         }
       }
 
       if (symbols.length === 0) {
-        throw new Error(isUS ? 'No stocks found to scan' : 'Taranacak hisse bulunamadı');
+        throw new Error('Taranacak hisse bulunamadı');
       }
 
-      const batchSize = symbols.length >= 80 ? 10 : symbols.length >= 40 ? 15 : symbols.length;
-      const batches = chunkArray(symbols, batchSize);
-
-      if (isUS) {
-        setScanStatus(`${symbols.length} stocks — ML projection + technical scan starting...`);
-        const predictions: Record<string, unknown>[] = [];
-        const allSignals: Record<string, unknown>[] = [];
-
-        for (let i = 0; i < batches.length; i++) {
-          const batch = batches[i];
-          const done = Math.min((i + 1) * batchSize, symbols.length);
-          setScanStatus(`ML predictions: ${done}/${symbols.length}...`);
-
-          try {
-            const predictionsData = await fetchJson<Record<string, unknown>>(
-              `/api/ml-predictions`,
-              { method: 'POST' },
-              {
-                timeoutMs: 45000,
-                retries: 0,
-                jsonBody: {
-                  symbols: batch,
-                  days_ahead: predictionDays,
-                  model: modelType,
-                  market: 'us',
-                },
-              }
-            );
-            const batchPreds = Array.isArray(predictionsData?.predictions) ? predictionsData.predictions : [];
-            predictions.push(...batchPreds);
-          } catch (e) {
-            logger.warn('US ML prediction batch failed:', e);
-          }
-
-          setScanStatus(`Technical signals: ${done}/${symbols.length}...`);
-
-          try {
-            const resp = await fetchJson<Record<string, unknown>>(
-              `/api/trading-signals`,
-              { method: 'POST' },
-              {
-                timeoutMs: 45000,
-                retries: 0,
-                jsonBody: { symbols: batch, market: 'us' },
-              }
-            );
-            const items = Array.isArray(resp?.signals) ? resp.signals as Record<string, unknown>[] : [];
-            allSignals.push(...items);
-          } catch (e) {
-            logger.warn('US trading-signals batch failed:', e);
-          }
-        }
-
-        if (predictions.length === 0) {
-          throw new Error('US ML scan returned 0 predictions. The local ML pipeline may be unavailable.');
-        }
-
-        if (allSignals.length === 0) {
-          throw new Error('Technical scan returned 0 results. Yahoo Finance may be rate-limiting.');
-        }
-
-        const predictionsBySymbol = new Map<string, Record<string, unknown>>();
-        predictions.forEach((item) => {
-          if (item?.symbol) predictionsBySymbol.set(String(item.symbol).toUpperCase(), item);
-        });
-
-        const mappedResults: MLScanResult[] = allSignals.map((item) => {
-          const symbol = String(item?.symbol || '').toUpperCase();
-          const pred = predictionsBySymbol.get(symbol) || null;
-          const techSignal = String(item?.signal || 'HOLD').toUpperCase() as 'BUY' | 'SELL' | 'HOLD';
-          const mlSignal = String(pred?.signal || 'HOLD').toUpperCase() as 'BUY' | 'SELL' | 'HOLD';
-          const indicators = (item?.indicators || {}) as Record<string, unknown>;
-          const mlConfidenceRaw = Number(pred?.confidence) || 0;
-          const mlConfidence = mlConfidenceRaw > 0 && mlConfidenceRaw <= 1 ? mlConfidenceRaw * 100 : mlConfidenceRaw;
-          const techScore = Math.max(0, Math.min(100, ((Number(item?.signalScore) || 0) + 100) / 2));
-          const combinedScore = Math.round((mlConfidence + techScore) / 2);
-
-          let finalRecommendation: 'BUY' | 'SELL' | 'HOLD' = 'HOLD';
-          if (mlSignal === 'SELL' || techSignal === 'SELL') {
-            finalRecommendation = mlSignal === 'BUY' && techSignal === 'SELL'
-              ? 'HOLD'
-              : mlSignal === 'SELL' && techSignal === 'BUY'
-                ? 'HOLD'
-                : 'SELL';
-          } else if (mlSignal === 'BUY') {
-            finalRecommendation = 'BUY';
-          } else if (techSignal === 'BUY' && mlSignal === 'HOLD') {
-            finalRecommendation = 'BUY';
-          }
-
-          return {
-            symbol,
-            current_price: Number(pred?.current_price ?? item?.lastPrice) || 0,
-            change_percent: Number(pred?.predicted_change_pct ?? pred?.prediction_change ?? 0),
-            recommendation: finalRecommendation,
-            ml_recommendation: mlSignal,
-            confidence: mlConfidence,
-            total_score: combinedScore,
-            technical_signal: techSignal,
-            indicators: {
-              rsi: indicators?.rsi as number | null ?? null,
-              macd_trend: typeof indicators?.macd === 'object' && indicators.macd
-                ? ((indicators.macd as Record<string, unknown>).histogram as number > 0 ? 'bullish' : 'bearish')
-                : null,
-              bollinger_position: null,
-              volume_ratio_20d: indicators?.volume_ratio as number | null ?? null,
-            },
-            prediction_7d: Number(pred?.predicted_price) || undefined,
-            r2_score: pred?.r2_score as number | undefined,
-            mae: pred?.mae as number | undefined,
-            direction_accuracy: pred?.direction_accuracy as number | undefined,
-            models_used: pred?.models_used as number | undefined,
-            model_source: String(pred?.model || modelType || '').toUpperCase(),
-          };
-        });
-
-        setResults(mappedResults);
-        const listedNow = mappedResults.filter((r) => {
-          const matchesFilter = filter === 'all' || r.recommendation === filter;
-          const effectiveScore = Math.max(r.confidence, r.total_score);
-          return matchesFilter && effectiveScore >= minConfidence;
-        }).length;
-        setScanStatus(`✅ Scan complete! ${mappedResults.length} stocks analyzed, ${listedNow} listed after filter.`);
-      } else {
-        // BIST mode: original ML + scan-signals flow
-        setScanStatus(`${symbols.length} hisse için ML projeksiyonu + teknik tarama başlıyor (${modelType.toUpperCase()})...`);
+      setScanStatus(`${symbols.length} hisse için ML projeksiyonu + teknik tarama başlıyor (${modelType.toUpperCase()})...`);
 
       const batchSize = symbols.length >= 80 ? 10 : symbols.length >= 40 ? 15 : symbols.length;
       const batches = chunkArray(symbols, batchSize);
@@ -341,7 +197,6 @@ export default function MLScanPage() {
                 symbols: batch,
                 days_ahead: predictionDays,
                 model: modelType,
-                  market: 'bist',
               },
             }
           );
@@ -505,11 +360,10 @@ export default function MLScanPage() {
       setScanStatus(
         `✅ Tarama tamamlandı! ${mappedResults.length} hisse analiz edildi, filtre sonrası ${listedNow} hisse listeleniyor.`
       );
-      } // end BIST else block
     } catch (error) {
       console.error('ML scan failed:', error);
-      const errorMessage = error instanceof Error ? error.message : (isUS ? 'Unknown error' : 'Bilinmeyen hata');
-      setScanStatus(`❌ ${isUS ? 'Error' : 'Hata'}: ${errorMessage}`);
+      const errorMessage = error instanceof Error ? error.message : 'Bilinmeyen hata';
+      setScanStatus(`❌ Hata: ${errorMessage}`);
     } finally {
       setLoading(false);
     }
@@ -534,7 +388,7 @@ export default function MLScanPage() {
         <div className="mb-6">
           <div className="flex items-center gap-3 mb-2">
             <Zap className="w-8 h-8 text-purple-600" />
-            <h1 className="text-3xl font-bold text-gray-900">{isUS ? 'US ML Projection + Technical Scan' : 'ML Projeksiyonu + Teknik Tarama'}</h1>
+            <h1 className="text-3xl font-bold text-gray-900">ML Projeksiyonu + Teknik Tarama</h1>
             {apiHealth === 'healthy' && (
               <span className="flex items-center gap-1 text-xs text-green-600 bg-green-50 px-2 py-1 rounded-full">
                 <CheckCircle className="w-3 h-3" /> API Aktif
@@ -547,17 +401,13 @@ export default function MLScanPage() {
             )}
           </div>
           <p className="text-gray-600">
-            {isUS
-              ? 'Scans US stocks with ML projections and technical indicators together. BUY appears when ML direction and technical structure align; conflicts are downgraded to HOLD.'
-              : <>ML projeksiyonu (deneysel) ile teknik taramayı birleştirir. <strong>AL</strong> sinyali:
+            ML projeksiyonu (deneysel) ile teknik taramayı birleştirir. <strong>AL</strong> sinyali:
             ML yönü BUY ise teknik kapılar geçmese bile (HOLD dahil) görünebilir.
-            Çakışma (ML BUY ↔ Teknik SELL) durumunda HOLD verilir.</>
-            }
+            Çakışma (ML BUY ↔ Teknik SELL) durumunda HOLD verilir.
           </p>
         </div>
 
         {/* Model Bilgi Kartı */}
-        {!isUS && (
         <div className="bg-gradient-to-r from-purple-50 to-blue-50 border border-purple-200 rounded-lg p-4 mb-6">
           <h3 className="font-semibold text-purple-800 mb-2">🆕 Gelişmiş ML Modelleri</h3>
           <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
@@ -579,7 +429,6 @@ export default function MLScanPage() {
             </div>
           </div>
         </div>
-        )}
 
         {/* Control Panel */}
         <div className="bg-white p-6 rounded-lg shadow-sm mb-6">
@@ -593,7 +442,7 @@ export default function MLScanPage() {
                   className="bg-purple-600 text-white px-6 py-3 rounded-md hover:bg-purple-700 disabled:opacity-50 font-semibold flex items-center gap-2"
                 >
                   {loading ? <RefreshCw className="w-5 h-5 animate-spin" /> : <Zap className="w-5 h-5" />}
-                  {loading ? (isUS ? 'Scanning...' : 'Taranıyor...') : (isUS ? 'Start Scan' : 'Tarama Başlat')}
+                  {loading ? 'Taranıyor...' : 'Tarama Başlat'}
                 </button>
 
                 <button
@@ -601,12 +450,12 @@ export default function MLScanPage() {
                   className="flex items-center gap-2 px-4 py-2 border border-gray-300 rounded-md hover:bg-gray-50 text-sm"
                 >
                   <Settings className="w-4 h-4" />
-                  {isUS ? 'Advanced' : 'Gelişmiş Ayarlar'}
+                  Gelişmiş Ayarlar
                 </button>
 
                 {results.length > 0 && (
                   <p className="text-gray-600 text-sm">
-                    {filteredResults.length} / {results.length} {isUS ? 'stocks' : 'hisse'}
+                    {filteredResults.length} / {results.length} hisse
                   </p>
                 )}
               </div>
@@ -619,15 +468,15 @@ export default function MLScanPage() {
                     onChange={(e) => setFilter(e.target.value as 'all' | 'BUY' | 'SELL' | 'HOLD')}
                     className="px-3 py-2 border border-gray-300 rounded-md text-sm"
                   >
-                    <option value="all">{isUS ? 'All Signals' : 'Tüm Öneriler'}</option>
-                    <option value="BUY">{isUS ? 'BUY Only' : 'Sadece AL'}</option>
-                    <option value="SELL">{isUS ? 'SELL Only' : 'Sadece SAT'}</option>
-                    <option value="HOLD">{isUS ? 'HOLD Only' : 'Sadece TUT'}</option>
+                    <option value="all">Tüm Öneriler</option>
+                    <option value="BUY">Sadece AL</option>
+                    <option value="SELL">Sadece SAT</option>
+                    <option value="HOLD">Sadece TUT</option>
                   </select>
                 </div>
 
                 <div className="flex items-center gap-2">
-                  <span className="text-sm text-gray-600">{isUS ? 'Min Confidence:' : 'Min Güven:'}</span>
+                  <span className="text-sm text-gray-600">Min Güven:</span>
                   <input
                     type="number"
                     min="0"
@@ -644,36 +493,24 @@ export default function MLScanPage() {
             {/* Gelişmiş Ayarlar Paneli */}
             {showAdvanced && (
               <div className="border-t pt-4 mt-2">
-                <h4 className="font-medium text-gray-700 mb-3">⚙️ {isUS ? 'Scan Parameters' : 'Tarama Parametreleri'}</h4>
+                <h4 className="font-medium text-gray-700 mb-3">⚙️ Tarama Parametreleri</h4>
                 <div className="grid grid-cols-1 md:grid-cols-4 gap-4">
                   <div>
-                    <label htmlFor="ml-market" className="block text-sm font-medium text-gray-600 mb-1">{isUS ? 'Market' : 'Piyasa Seçimi'}</label>
+                    <label htmlFor="ml-market" className="block text-sm font-medium text-gray-600 mb-1">Piyasa Seçimi</label>
                     <select
                       id="ml-market"
                       value={marketSelection}
-                      onChange={(e) => setMarketSelection(e.target.value)}
+                      onChange={(e) => setMarketSelection(e.target.value as typeof marketSelection)}
                       className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm"
                     >
-                      {isUS ? (
-                        <>
-                          <option value="Popular 30">Popular 30</option>
-                          {Object.keys(US_UNIVERSE).map((k) => (
-                            <option key={k} value={k}>{k}</option>
-                          ))}
-                        </>
-                      ) : (
-                        <>
-                          <option value="Popüler">Popüler Hisseler</option>
-                          <option value="BIST 30">BIST 30</option>
-                          <option value="BIST 50">BIST 50</option>
-                          <option value="BIST 100">BIST 100</option>
-                          <option value="Tüm BIST">Tüm BIST Hisseleri</option>
-                        </>
-                      )}
+                      <option value="Popüler">Popüler Hisseler</option>
+                      <option value="BIST 30">BIST 30</option>
+                      <option value="BIST 50">BIST 50</option>
+                      <option value="BIST 100">BIST 100</option>
+                      <option value="Tüm BIST">Tüm BIST Hisseleri</option>
                     </select>
                   </div>
                   
-                  {!isUS && (
                   <div>
                     <label htmlFor="ml-model" className="block text-sm font-medium text-gray-600 mb-1">ML Model</label>
                     <select
@@ -688,9 +525,7 @@ export default function MLScanPage() {
                       <option value="rf">RandomForest</option>
                     </select>
                   </div>
-                  )}
                   
-                  {!isUS && (
                   <div>
                     <label htmlFor="ml-days" className="block text-sm font-medium text-gray-600 mb-1">Tahmin Süresi</label>
                     <select
@@ -707,15 +542,12 @@ export default function MLScanPage() {
                       <option value={30}>30 Gün (1 Ay)</option>
                     </select>
                   </div>
-                  )}
                   
-                  {!isUS && (
                   <div className="flex items-end">
                     <div className="text-xs text-gray-500 bg-gray-50 p-2 rounded">
                       <strong>Ensemble:</strong> XGBoost + LightGBM + RF modellerinin ortalaması
                     </div>
                   </div>
-                  )}
                 </div>
               </div>
             )}
@@ -737,19 +569,19 @@ export default function MLScanPage() {
         {results.length > 0 && (
           <div className="grid grid-cols-1 md:grid-cols-4 gap-4 mb-6">
             <div className="bg-white p-4 rounded-lg shadow-sm">
-              <p className="text-sm text-gray-600">{isUS ? 'Listed' : 'Listelenen'}</p>
+              <p className="text-sm text-gray-600">Listelenen</p>
               <p className="text-2xl font-bold text-gray-900">{filteredResults.length}</p>
             </div>
             <div className="bg-green-50 p-4 rounded-lg shadow-sm">
-              <p className="text-sm text-green-700">{isUS ? 'BUY' : 'AL Önerisi'}</p>
+              <p className="text-sm text-green-700">AL Önerisi</p>
               <p className="text-2xl font-bold text-green-800">{buyCount}</p>
             </div>
             <div className="bg-yellow-50 p-4 rounded-lg shadow-sm">
-              <p className="text-sm text-yellow-700">{isUS ? 'HOLD' : 'TUT Önerisi'}</p>
+              <p className="text-sm text-yellow-700">TUT Önerisi</p>
               <p className="text-2xl font-bold text-yellow-800">{holdCount}</p>
             </div>
             <div className="bg-red-50 p-4 rounded-lg shadow-sm">
-              <p className="text-sm text-red-700">{isUS ? 'SELL' : 'SAT Önerisi'}</p>
+              <p className="text-sm text-red-700">SAT Önerisi</p>
               <p className="text-2xl font-bold text-red-800">{sellCount}</p>
             </div>
           </div>
@@ -759,20 +591,17 @@ export default function MLScanPage() {
         {loading && (
           <div className="bg-white rounded-lg shadow-sm p-12 text-center">
             <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-purple-600 mx-auto mb-4"></div>
-            <p className="text-gray-600">{isUS ? 'Scanning stocks with technical signals...' : 'Hisseler ML + teknik sinyaller ile taranıyor...'}</p>
-            <p className="text-sm text-gray-500 mt-2">{isUS ? 'This may take a few minutes' : 'Bu işlem bir kaç dakika sürebilir'}</p>
+            <p className="text-gray-600">Hisseler ML + teknik sinyaller ile taranıyor...</p>
+            <p className="text-sm text-gray-500 mt-2">Bu işlem bir kaç dakika sürebilir</p>
           </div>
         )}
 
         {!loading && results.length === 0 && (
           <div className="bg-white rounded-lg shadow-sm p-12 text-center">
             <Zap className="w-16 h-16 text-gray-400 mx-auto mb-4" />
-            <h3 className="text-lg font-semibold text-gray-900 mb-2">{isUS ? 'Batch Scan' : 'Toplu Tarama'}</h3>
+            <h3 className="text-lg font-semibold text-gray-900 mb-2">Toplu Tarama</h3>
             <p className="text-gray-600">
-              {isUS
-                ? 'Click the button to scan US stocks with technical indicators'
-                : 'BIST hisselerini ML projeksiyonu + teknik kapılar ile taramak için butona tıklayın'
-              }
+              BIST hisselerini ML projeksiyonu + teknik kapılar ile taramak için butona tıklayın
             </p>
           </div>
         )}
@@ -815,11 +644,11 @@ export default function MLScanPage() {
 
                   <div className="flex items-center justify-between mb-3">
                     <div>
-                      <p className="text-sm text-gray-600">{isUS ? 'Price' : 'Fiyat'}</p>
-                      <p className="font-semibold">{currencySymbol}{(stock.current_price ?? 0).toFixed(2)}</p>
+                      <p className="text-sm text-gray-600">Fiyat</p>
+                      <p className="font-semibold">₺{(stock.current_price ?? 0).toFixed(2)}</p>
                     </div>
                     <div className="text-right">
-                      <p className="text-sm text-gray-600">{isUS ? 'Change' : 'Değişim'}</p>
+                      <p className="text-sm text-gray-600">Değişim</p>
                       <p
                         className={`font-semibold ${
                           (stock.change_percent ?? 0) >= 0 ? 'text-green-600' : 'text-red-600'
@@ -834,7 +663,7 @@ export default function MLScanPage() {
                   <div className="space-y-2">
                     <div>
                       <div className="flex items-center justify-between text-sm mb-1">
-                        <span className="text-gray-600">{isUS ? 'Confidence' : 'Güven Skoru'}</span>
+                        <span className="text-gray-600">Güven Skoru</span>
                         <span className="font-semibold">{stock.confidence}%</span>
                       </div>
                       <div className="w-full bg-gray-200 rounded-full h-2">
@@ -848,7 +677,7 @@ export default function MLScanPage() {
                     {/* Data Quality Badge */}
                     {stock.data_quality && (
                       <div className="flex items-center gap-2 text-xs">
-                        <span className="text-gray-600">{isUS ? 'Data Quality:' : 'Veri Kalitesi:'}</span>
+                        <span className="text-gray-600">Veri Kalitesi:</span>
                         <span className={`font-semibold ${
                           stock.data_quality.score >= 0.8 ? 'text-green-600' : 
                           stock.data_quality.score >= 0.6 ? 'text-yellow-600' : 'text-red-600'
@@ -898,7 +727,7 @@ export default function MLScanPage() {
                     {/* Technical gates */}
                     {stock.gates && (
                       <div className="pt-2 border-t">
-                        <p className="text-xs text-gray-600 mb-1">{isUS ? 'Gates (required for BUY):' : 'Kapılar (AL için gerekli):'}</p>
+                        <p className="text-xs text-gray-600 mb-1">Kapılar (AL için gerekli):</p>
                         <div className="flex flex-wrap gap-1" title={(stock.gates.reasons || []).join('\n')}>
                           <span className={`text-xs px-2 py-0.5 rounded-full ${stock.gates.trend_ok ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
                             Trend
@@ -907,16 +736,16 @@ export default function MLScanPage() {
                             Momentum
                           </span>
                           <span className={`text-xs px-2 py-0.5 rounded-full ${stock.gates.volume_ok ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
-                            {isUS ? 'Volume' : 'Hacim'}
+                            Hacim
                           </span>
                           <span className={`text-xs px-2 py-0.5 rounded-full ${stock.gates.volatility_ok ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
-                            {isUS ? 'Volatility' : 'Volatilite'}
+                            Volatilite
                           </span>
                         </div>
 
                         {(stock.gates.reasons || []).includes('backend_endpoint_missing:scan-signals') && (
                           <p className="mt-2 text-xs text-amber-700">
-                            {isUS ? 'Technical scores unavailable (backend endpoint missing).' : 'Teknik skorlar şu an alınamıyor (backend /api/scan-signals yok).'}
+                            Teknik skorlar şu an alınamıyor (backend <span className="font-mono">/api/scan-signals</span> yok).
                           </p>
                         )}
                       </div>
@@ -924,11 +753,11 @@ export default function MLScanPage() {
 
                     <div className="grid grid-cols-2 gap-2 pt-2 border-t">
                       <div>
-                        <p className="text-xs text-gray-600">{isUS ? 'Tech Trend' : 'Teknik Trend'}</p>
+                        <p className="text-xs text-gray-600">Teknik Trend</p>
                         <p className="font-semibold text-sm">{formatScorePct(stock.trend_score)}</p>
                       </div>
                       <div>
-                        <p className="text-xs text-gray-600">{isUS ? 'Tech Momentum' : 'Teknik Momentum'}</p>
+                        <p className="text-xs text-gray-600">Teknik Momentum</p>
                         <p className="font-semibold text-sm">{formatScorePct(stock.momentum_score)}</p>
                       </div>
                     </div>
@@ -1044,21 +873,21 @@ export default function MLScanPage() {
                       <div className="pt-2 border-t text-xs space-y-1">
                         {stock.prediction_7d !== undefined && stock.prediction_7d !== null && (
                           <div className="flex justify-between">
-                            <span className="text-gray-600">{isUS ? '7d forecast:' : '7g tahmini:'}</span>
+                            <span className="text-gray-600">7g tahmini:</span>
                             <span className={`font-semibold ${
                               (stock.prediction_7d ?? 0) > (stock.current_price ?? 0) ? 'text-green-600' : 'text-red-600'
                             }`}>
-                              {currencySymbol}{(stock.prediction_7d ?? 0).toFixed(2)}
+                              ₺{(stock.prediction_7d ?? 0).toFixed(2)}
                             </span>
                           </div>
                         )}
                         {stock.prediction_30d !== undefined && stock.prediction_30d !== null && (
                           <div className="flex justify-between">
-                            <span className="text-gray-600">{isUS ? '30d forecast:' : '30g tahmini:'}</span>
+                            <span className="text-gray-600">30g tahmini:</span>
                             <span className={`font-semibold ${
                               (stock.prediction_30d ?? 0) > (stock.current_price ?? 0) ? 'text-green-600' : 'text-red-600'
                             }`}>
-                              {currencySymbol}{(stock.prediction_30d ?? 0).toFixed(2)}
+                              ₺{(stock.prediction_30d ?? 0).toFixed(2)}
                             </span>
                           </div>
                         )}

huggingface-space/nextjs-app/src/app/page.tsx

@@ -5,7 +5,7 @@ import TopMLPredictions from '@/components/TopMLPredictions'
 import Link from 'next/link'
 import { 
   TrendingUp, BarChart3, Brain, Zap, Target, Search, 
-  Activity, Newspaper, Building2, Briefcase, ArrowRight, Globe
+  Activity, Newspaper, Building2, Briefcase, ArrowRight 
 } from 'lucide-react'
 
 export default function Home() {
@@ -59,12 +59,6 @@ export default function Home() {
           title="BIST100" 
           color="indigo"
         />
-        <QuickAccessCard 
-          href="/us-market" 
-          icon={<Globe className="h-5 w-5" />} 
-          title="US Equities" 
-          color="teal"
-        />
       </div>
 
       <MarketOverview />
@@ -165,7 +159,6 @@ function QuickAccessCard({
     pink: 'bg-pink-50 text-pink-600 hover:bg-pink-100 border-pink-200',
     orange: 'bg-orange-50 text-orange-600 hover:bg-orange-100 border-orange-200',
     indigo: 'bg-indigo-50 text-indigo-600 hover:bg-indigo-100 border-indigo-200',
-    teal: 'bg-teal-50 text-teal-600 hover:bg-teal-100 border-teal-200',
   }
   
   return (

huggingface-space/nextjs-app/src/app/stocks/page.tsx

@@ -7,7 +7,6 @@ import Link from 'next/link';
 import { fetchJson } from '@/lib/http';
 import { appendAnalysisRecord } from '@/lib/analysis-history';
 import { useAuth } from '@/contexts/AuthContext';
-import { useMarket } from '@/contexts/MarketContext';
 import { logger } from '@/lib/logger';
 
 
@@ -68,7 +67,6 @@ interface StockAnalysis {
 
 export default function StocksPage() {
   const { user } = useAuth();
-  const { market } = useMarket();
   const [symbol, setSymbol] = useState('');
   const [analysis, setAnalysis] = useState<StockAnalysis | null>(null);
   const [loading, setLoading] = useState(false);
@@ -77,28 +75,25 @@ export default function StocksPage() {
   const [period, setPeriod] = useState('6mo');
   const [quickSymbols, setQuickSymbols] = useState<string[]>([]);
 
-  const isUS = market === 'us';
-  const currencySymbol = isUS ? '$' : '₺';
-  const universeName = isUS ? 'us_popular' : 'bist30';
-
   useEffect(() => {
     let mounted = true;
-    fetchJson<Record<string, unknown>>(`/api/universe?name=${universeName}`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
+    fetchJson<Record<string, unknown>>(`/api/universe?name=bist30`, { method: 'GET' }, { timeoutMs: 20000, retries: 1 })
       .then((data) => {
         const symbols = Array.isArray(data?.symbols) ? data.symbols : []
         if (mounted) setQuickSymbols(symbols.slice(0, 10))
       })
       .catch(() => {
+        // No toy fallback
         if (mounted) setQuickSymbols([])
       })
     return () => {
       mounted = false
     }
-  }, [universeName])
+  }, [])
 
   const handleAnalyze = async () => {
     if (!symbol.trim()) {
-      setError(isUS ? 'Please enter a stock symbol' : 'Lütfen hisse kodu girin');
+      setError('Lütfen hisse kodu girin');
       return;
     }
     
@@ -116,14 +111,14 @@ export default function StocksPage() {
 
       // Hisse verisini al (gerçek kaynak: /api/stock-data)
       const stockRaw = await fetchJson<Record<string, unknown>>(
-        `/api/stock-data?symbol=${encodeURIComponent(sym)}&period=${encodeURIComponent(period)}&interval=1d&market=${market}`,
+        `/api/stock-data?symbol=${encodeURIComponent(sym)}&period=${encodeURIComponent(period)}&interval=1d`,
         { method: 'GET' },
         { timeoutMs: 20000, retries: 1 }
       );
 
       // Teknik göstergeleri al (best-effort)
       const techRaw = await fetchJson<Record<string, unknown>>(
-        `/api/technical-analysis?symbol=${encodeURIComponent(sym)}&market=${market}`,
+        `/api/technical-analysis?symbol=${encodeURIComponent(sym)}`,
         { method: 'GET' },
         { timeoutMs: 20000, retries: 1 }
       ).catch(() => null);
@@ -141,7 +136,6 @@ export default function StocksPage() {
               symbols: [symbol.toUpperCase()],
               days_ahead: predictionDays,
               model: 'ensemble',
-              market,
             },
           }
         );
@@ -179,29 +173,26 @@ export default function StocksPage() {
       let techSignal: 'BUY' | 'SELL' | 'HOLD' = 'HOLD'
       try {
         const scanResp = await fetchJson<Record<string, unknown>>(
-          isUS ? `/api/trading-signals` : `/api/scan-signals`,
+          `/api/scan-signals`,
           { method: 'POST' },
           {
             timeoutMs: 30000,
             retries: 0,
             jsonBody: {
               symbols: [sym],
-              ...(isUS ? { market } : { period, interval: '1d', limit: 1 }),
+              period,
+              interval: '1d',
+              limit: 1,
             },
           }
         )
-        const items: Record<string, unknown>[] = Array.isArray(isUS ? scanResp?.signals : scanResp?.data)
-          ? ((isUS ? scanResp.signals : scanResp.data) as Record<string, unknown>[])
-          : []
+        const items = Array.isArray(scanResp?.data) ? scanResp.data : []
         const item = items.find((x: Record<string, unknown>) => String(x?.symbol || '').toUpperCase() === sym)
-        const gates = item?.gates as Record<string, unknown> | undefined
-        if (isUS) {
-          requiredOk = String(item?.signal || '').toUpperCase() === 'BUY'
-        } else if (gates && typeof gates.required_ok === 'boolean') {
-          requiredOk = gates.required_ok as boolean
+        if (item?.gates && typeof item.gates.required_ok === 'boolean') {
+          requiredOk = item.gates.required_ok
         }
-        if (item?.technical_signal || item?.signal) {
-          const ts = String(item.technical_signal || item.signal).toUpperCase().trim()
+        if (item?.technical_signal) {
+          const ts = String(item.technical_signal).toUpperCase().trim()
           if (ts === 'BUY' || ts === 'SELL') techSignal = ts
         }
       } catch (e) {
@@ -337,7 +328,7 @@ export default function StocksPage() {
       setAnalysis(analysisResult);
     } catch (err) {
       console.error('Analysis error:', err);
-      setError(err instanceof Error ? err.message : isUS ? 'Error occurred during analysis' : 'Analiz yapılırken hata oluştu');
+      setError(err instanceof Error ? err.message : 'Analiz yapılırken hata oluştu');
     } finally {
       setLoading(false);
     }
@@ -363,12 +354,10 @@ export default function StocksPage() {
         <div className="mb-6">
           <div className="flex items-center gap-3 mb-2">
             <BarChart3 className="w-8 h-8 text-blue-600" />
-            <h1 className="text-3xl font-bold text-gray-900">
-              {isUS ? 'Stock Technical Analysis' : 'Hisse Senedi Teknik Analizi'}
-            </h1>
+            <h1 className="text-3xl font-bold text-gray-900">Hisse Senedi Teknik Analizi</h1>
           </div>
           <p className="text-gray-600">
-            {isUS ? 'Detailed technical analysis, indicators, and ML predictions' : 'Hisse senedi detaylı teknik analizi, göstergeler ve ML tahminleri'}
+            Hisse senedi detaylı teknik analizi, göstergeler ve ML tahminleri
           </p>
         </div>
 
@@ -376,9 +365,7 @@ export default function StocksPage() {
         <div className="bg-white rounded-lg shadow-sm p-6 mb-6">
           <div className="grid grid-cols-1 md:grid-cols-5 gap-4">
             <div className="md:col-span-2">
-              <label htmlFor="stock-symbol" className="block text-sm font-medium text-gray-700 mb-1">
-                {isUS ? 'Stock Symbol' : 'Hisse Kodu'}
-              </label>
+              <label htmlFor="stock-symbol" className="block text-sm font-medium text-gray-700 mb-1">Hisse Kodu</label>
               <div className="relative">
                 <input
                   id="stock-symbol"
@@ -386,29 +373,28 @@ export default function StocksPage() {
                   value={symbol}
                   onChange={(e) => setSymbol(e.target.value.toUpperCase())}
                   onKeyPress={(e) => e.key === 'Enter' && handleAnalyze()}
-                  placeholder={isUS ? 'e.g. AAPL, MSFT, GOOGL' : 'Örn: THYAO, GARAN, ASELS'}
+                  placeholder="Örn: THYAO, GARAN, ASELS"
                   className="w-full px-4 py-2 border border-gray-300 rounded-md focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
                 />
               </div>
             </div>
             
             <div>
-              <label htmlFor="stock-period" className="block text-sm font-medium text-gray-700 mb-1">{isUS ? 'Data Period' : 'Veri Periyodu'}</label>
+              <label htmlFor="stock-period" className="block text-sm font-medium text-gray-700 mb-1">Veri Periyodu</label>
               <select
                 id="stock-period"
                 value={period}
                 onChange={(e) => setPeriod(e.target.value)}
                 className="w-full px-3 py-2 border border-gray-300 rounded-md"
               >
-                <option value="1mo">{isUS ? '1 Month' : '1 Ay'}</option>
-                <option value="3mo">{isUS ? '3 Months' : '3 Ay'}</option>
-                <option value="6mo">{isUS ? '6 Months' : '6 Ay'}</option>
-                <option value="1y">{isUS ? '1 Year' : '1 Yıl'}</option>
-                <option value="2y">{isUS ? '2 Years' : '2 Yıl'}</option>
+                <option value="1mo">1 Ay</option>
+                <option value="3mo">3 Ay</option>
+                <option value="6mo">6 Ay</option>
+                <option value="1y">1 Yıl</option>
+                <option value="2y">2 Yıl</option>
               </select>
             </div>
             
-            {!isUS && (
             <div>
               <label htmlFor="stock-prediction" className="block text-sm font-medium text-gray-700 mb-1">Tahmin Süresi</label>
               <select
@@ -425,7 +411,6 @@ export default function StocksPage() {
                 <option value={30}>30 Gün</option>
               </select>
             </div>
-            )}
             
             <div className="flex items-end">
               <button
@@ -436,12 +421,12 @@ export default function StocksPage() {
                 {loading ? (
                   <>
                     <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
-                    {isUS ? 'Analyzing...' : 'Analiz Ediliyor...'}
+                    Analiz Ediliyor...
                   </>
                 ) : (
                   <>
                     <Search className="w-4 h-4" />
-                    {isUS ? 'Analyze' : 'Analiz Et'}
+                    Analiz Et
                   </>
                 )}
               </button>
@@ -460,18 +445,14 @@ export default function StocksPage() {
         {!analysis && !loading && (
           <div className="bg-white rounded-lg shadow-sm p-12 text-center">
             <BarChart3 className="w-16 h-16 text-gray-400 mx-auto mb-4" />
-            <h3 className="text-lg font-semibold text-gray-900 mb-2">
-              {isUS ? 'Stock Analysis' : 'Hisse Analizi'}
-            </h3>
+            <h3 className="text-lg font-semibold text-gray-900 mb-2">Hisse Analizi</h3>
             <p className="text-gray-600 mb-4">
-              {isUS ? 'Enter a stock symbol to view detailed technical analysis and ML predictions' : 'Hisse kodunu girerek detaylı teknik analiz ve ML tahminlerini gör��ntüleyin'}
+              Hisse kodunu girerek detaylı teknik analiz ve ML tahminlerini görüntüleyin
             </p>
             
             {/* Hızlı Erişim */}
             <div className="mt-6">
-              <p className="text-sm text-gray-500 mb-3">
-                {isUS ? 'Popular Stocks:' : 'Popüler Hisseler:'}
-              </p>
+              <p className="text-sm text-gray-500 mb-3">Popüler Hisseler:</p>
               <div className="flex flex-wrap justify-center gap-2">
                 {quickSymbols.map((s) => (
                   <button
@@ -487,7 +468,7 @@ export default function StocksPage() {
                 ))}
               </div>
               {quickSymbols.length === 0 && (
-                <p className="text-xs text-gray-400 mt-2">{isUS ? 'Quick list unavailable.' : 'Hızlı liste şu an alınamadı.'}</p>
+                <p className="text-xs text-gray-400 mt-2">Hızlı liste şu an alınamadı.</p>
               )}
             </div>
           </div>
@@ -496,8 +477,8 @@ export default function StocksPage() {
         {loading && (
           <div className="bg-white rounded-lg shadow-sm p-12 text-center">
             <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
-            <p className="text-gray-600">{symbol} {isUS ? 'analyzing...' : 'analiz ediliyor...'}</p>
-            <p className="text-sm text-gray-500 mt-2">{isUS ? 'Calculating technical indicators...' : 'Teknik göstergeler hesaplanıyor ve ML tahminleri alınıyor...'}</p>
+            <p className="text-gray-600">{symbol} analiz ediliyor...</p>
+            <p className="text-sm text-gray-500 mt-2">Teknik göstergeler hesaplanıyor ve ML tahminleri alınıyor...</p>
           </div>
         )}
 
@@ -521,13 +502,13 @@ export default function StocksPage() {
                       analysis.risk_level === 'high' ? 'bg-red-50 text-red-700' :
                       'bg-yellow-50 text-yellow-700'
                     }`}>
-                      Risk: {analysis.risk_level === 'low' ? (isUS ? 'Low' : 'Düşük') : analysis.risk_level === 'high' ? (isUS ? 'High' : 'Yüksek') : (isUS ? 'Medium' : 'Orta')}
+                      Risk: {analysis.risk_level === 'low' ? 'Düşük' : analysis.risk_level === 'high' ? 'Yüksek' : 'Orta'}
                     </span>
                   </div>
                   <p className="text-gray-600">{analysis.company_name}</p>
                 </div>
                 <div className="text-right">
-                  <p className="text-3xl font-bold text-gray-900">{currencySymbol}{(analysis.current_price ?? 0).toFixed(2)}</p>
+                  <p className="text-3xl font-bold text-gray-900">₺{(analysis.current_price ?? 0).toFixed(2)}</p>
                   <p className={`text-lg font-semibold ${
                     (analysis.change_percent ?? 0) >= 0 ? 'text-green-600' : 'text-red-600'
                   }`}>
@@ -539,29 +520,29 @@ export default function StocksPage() {
               {/* Temel Metrikler */}
               <div className="grid grid-cols-2 md:grid-cols-6 gap-4">
                 <div className="bg-gray-50 p-3 rounded-lg">
-                  <p className="text-xs text-gray-500">{isUS ? '52W High' : '52H Yüksek'}</p>
-                  <p className="text-lg font-semibold">{currencySymbol}{(analysis.high_52w ?? 0).toFixed(2)}</p>
+                  <p className="text-xs text-gray-500">52H Yüksek</p>
+                  <p className="text-lg font-semibold">₺{(analysis.high_52w ?? 0).toFixed(2)}</p>
                 </div>
                 <div className="bg-gray-50 p-3 rounded-lg">
-                  <p className="text-xs text-gray-500">{isUS ? '52W Low' : '52H Düşük'}</p>
-                  <p className="text-lg font-semibold">{currencySymbol}{(analysis.low_52w ?? 0).toFixed(2)}</p>
+                  <p className="text-xs text-gray-500">52H Düşük</p>
+                  <p className="text-lg font-semibold">₺{(analysis.low_52w ?? 0).toFixed(2)}</p>
                 </div>
                 <div className="bg-gray-50 p-3 rounded-lg">
-                  <p className="text-xs text-gray-500">{isUS ? 'Volume' : 'Hacim'}</p>
+                  <p className="text-xs text-gray-500">Hacim</p>
                   <p className="text-lg font-semibold">{((analysis.volume ?? 0) / 1000000).toFixed(2)}M</p>
                 </div>
                 <div className="bg-gray-50 p-3 rounded-lg">
-                  <p className="text-xs text-gray-500">{isUS ? 'Volatility' : 'Volatilite'}</p>
+                  <p className="text-xs text-gray-500">Volatilite</p>
                   <p className="text-lg font-semibold">{(analysis.volatility ?? 0).toFixed(2)}%</p>
                 </div>
                 {analysis.pe_ratio && (
                   <div className="bg-gray-50 p-3 rounded-lg">
-                    <p className="text-xs text-gray-500">{isUS ? 'P/E Ratio' : 'F/K Oranı'}</p>
+                    <p className="text-xs text-gray-500">F/K Oranı</p>
                     <p className="text-lg font-semibold">{(analysis.pe_ratio ?? 0).toFixed(2)}</p>
                   </div>
                 )}
                 <div className="bg-gray-50 p-3 rounded-lg">
-                  <p className="text-xs text-gray-500">{isUS ? 'Signal Strength' : 'Sinyal Gücu'}</p>
+                  <p className="text-xs text-gray-500">Sinyal Gücü</p>
                   <p className="text-lg font-semibold">{typeof analysis.signals?.signal_strength === 'number' ? `${analysis.signals.signal_strength.toFixed(0)}%` : '—'}</p>
                 </div>
               </div>
@@ -569,24 +550,19 @@ export default function StocksPage() {
 
             {/* ML Tahmin ve Teknik Göstergeler */}
             <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-              {/* ML Prediction */}
+              {/* ML Tahmin */}
               <div className="bg-gradient-to-br from-purple-50 to-blue-50 rounded-lg p-6 border border-purple-200">
                 <div className="flex items-center gap-2 mb-4">
                   <Zap className="w-5 h-5 text-purple-600" />
-                  <h3 className="font-semibold text-gray-900">{isUS ? 'ML Prediction' : `ML Tahmin (${predictionDays} Gün)`}</h3>
+                  <h3 className="font-semibold text-gray-900">ML Tahmin ({predictionDays} Gün)</h3>
                 </div>
                 
-                {isUS ? (
-                  <div className="text-center py-4">
-                    <p className="text-gray-500 text-sm">ML predictions are not available for US stocks.</p>
-                    <p className="text-gray-400 text-xs mt-1">Use the ML Scanner for US signal scoring.</p>
-                  </div>
-                ) : analysis.ml_prediction ? (
+                {analysis.ml_prediction ? (
                   <div className="space-y-4">
                     <div className="flex items-center justify-between">
                       <span className="text-gray-600">Tahmin Edilen Fiyat:</span>
                       <span className="text-xl font-bold text-gray-900">
-                        {currencySymbol}{(analysis.ml_prediction.predicted_price ?? 0).toFixed(2)}
+                        ₺{(analysis.ml_prediction.predicted_price ?? 0).toFixed(2)}
                       </span>
                     </div>
                     <div className="flex items-center justify-between">
@@ -625,7 +601,7 @@ export default function StocksPage() {
                     </div>
                   </div>
                 ) : (
-                  <p className="text-gray-500">{isUS ? 'ML prediction unavailable' : 'ML tahmini alınamadı'}</p>
+                  <p className="text-gray-500">ML tahmini alınamadı</p>
                 )}
               </div>
 
@@ -633,48 +609,48 @@ export default function StocksPage() {
               <div className="bg-white rounded-lg shadow-sm p-6">
                 <div className="flex items-center gap-2 mb-4">
                   <TrendingUp className="w-5 h-5 text-blue-600" />
-                  <h3 className="font-semibold text-gray-900">{isUS ? 'Trend Analysis' : 'Trend Analizi'}</h3>
+                  <h3 className="font-semibold text-gray-900">Trend Analizi</h3>
                 </div>
                 
                 <div className="space-y-4">
                   <div className="flex items-center justify-between">
-                    <span className="text-gray-600">{isUS ? 'Short-term (SMA20):' : 'Kısa Vadeli (SMA20):'}</span>
+                    <span className="text-gray-600">Kısa Vadeli (SMA20):</span>
                     <div className="flex items-center gap-2">
                       {getTrendIcon(analysis.signals.trend_short)}
                       <span className={`font-semibold ${
                         analysis.signals.trend_short === 'up' ? 'text-green-600' : 
                         analysis.signals.trend_short === 'down' ? 'text-red-600' : 'text-yellow-600'
                       }`}>
-                        {analysis.signals.trend_short === 'up' ? (isUS ? 'Uptrend' : 'Yükseliş') : 
-                         analysis.signals.trend_short === 'down' ? (isUS ? 'Downtrend' : 'Düşüş') : (isUS ? 'Sideways' : 'Yatay')}
+                        {analysis.signals.trend_short === 'up' ? 'Yükseliş' : 
+                         analysis.signals.trend_short === 'down' ? 'Düşüş' : 'Yatay'}
                       </span>
                     </div>
                   </div>
                   
                   <div className="flex items-center justify-between">
-                    <span className="text-gray-600">{isUS ? 'Medium-term (SMA50):' : 'Orta Vadeli (SMA50):'}</span>
+                    <span className="text-gray-600">Orta Vadeli (SMA50):</span>
                     <div className="flex items-center gap-2">
                       {getTrendIcon(analysis.signals.trend_medium)}
                       <span className={`font-semibold ${
                         analysis.signals.trend_medium === 'up' ? 'text-green-600' : 
                         analysis.signals.trend_medium === 'down' ? 'text-red-600' : 'text-yellow-600'
                       }`}>
-                        {analysis.signals.trend_medium === 'up' ? (isUS ? 'Uptrend' : 'Yükseliş') : 
-                         analysis.signals.trend_medium === 'down' ? (isUS ? 'Downtrend' : 'Düşüş') : (isUS ? 'Sideways' : 'Yatay')}
+                        {analysis.signals.trend_medium === 'up' ? 'Yükseliş' : 
+                         analysis.signals.trend_medium === 'down' ? 'Düşüş' : 'Yatay'}
                       </span>
                     </div>
                   </div>
                   
                   <div className="flex items-center justify-between">
-                    <span className="text-gray-600">{isUS ? 'Long-term (SMA200):' : 'Uzun Vadeli (SMA200):'}</span>
+                    <span className="text-gray-600">Uzun Vadeli (SMA200):</span>
                     <div className="flex items-center gap-2">
                       {getTrendIcon(analysis.signals.trend_long)}
                       <span className={`font-semibold ${
                         analysis.signals.trend_long === 'up' ? 'text-green-600' : 
                         analysis.signals.trend_long === 'down' ? 'text-red-600' : 'text-yellow-600'
                       }`}>
-                        {analysis.signals.trend_long === 'up' ? (isUS ? 'Uptrend' : 'Yükseliş') : 
-                         analysis.signals.trend_long === 'down' ? (isUS ? 'Downtrend' : 'Düşüş') : (isUS ? 'Sideways' : 'Yatay')}
+                        {analysis.signals.trend_long === 'up' ? 'Yükseliş' : 
+                         analysis.signals.trend_long === 'down' ? 'Düşüş' : 'Yatay'}
                       </span>
                     </div>
                   </div>
@@ -684,7 +660,7 @@ export default function StocksPage() {
 
             {/* Teknik Göstergeler Detay */}
             <div className="bg-white rounded-lg shadow-sm p-6">
-              <h3 className="font-semibold text-gray-900 mb-4">{isUS ? 'Technical Indicators' : 'Teknik Göstergeler'}</h3>
+              <h3 className="font-semibold text-gray-900 mb-4">Teknik Göstergeler</h3>
               
               <div className="grid grid-cols-2 md:grid-cols-4 lg:grid-cols-6 gap-4">
                 <div className="p-3 rounded-lg border">
@@ -693,8 +669,8 @@ export default function StocksPage() {
                     {typeof analysis.indicators?.rsi === 'number' ? analysis.indicators.rsi.toFixed(1) : '—'}
                   </p>
                   <p className="text-xs text-gray-500">
-                    {analysis.signals?.rsi_signal === 'oversold' ? (isUS ? 'Oversold' : 'Aşırı Satım') :
-                     analysis.signals?.rsi_signal === 'overbought' ? (isUS ? 'Overbought' : 'Aşırı Alım') : (isUS ? 'Neutral' : 'Nötr')}
+                    {analysis.signals?.rsi_signal === 'oversold' ? 'Aşırı Satım' :
+                     analysis.signals?.rsi_signal === 'overbought' ? 'Aşırı Alım' : 'Nötr'}
                   </p>
                 </div>
                 
@@ -706,18 +682,18 @@ export default function StocksPage() {
                     {typeof analysis.indicators?.macd === 'number' ? analysis.indicators.macd.toFixed(3) : '—'}
                   </p>
                   <p className="text-xs text-gray-500">
-                    {analysis.signals?.macd_signal === 'bullish' ? (isUS ? 'Bullish' : 'Yükseliş') : analysis.signals?.macd_signal === 'bearish' ? (isUS ? 'Bearish' : 'Düşüş') : (isUS ? 'Neutral' : 'Nötr')}
+                    {analysis.signals?.macd_signal === 'bullish' ? 'Yükseliş' : analysis.signals?.macd_signal === 'bearish' ? 'Düşüş' : 'Nötr'}
                   </p>
                 </div>
                 
                 <div className="p-3 rounded-lg border">
                   <p className="text-xs text-gray-500 mb-1">SMA 20</p>
-                  <p className="text-lg font-bold">{typeof analysis.indicators?.sma_20 === 'number' ? `${currencySymbol}${analysis.indicators.sma_20.toFixed(2)}` : '—'}</p>
+                  <p className="text-lg font-bold">{typeof analysis.indicators?.sma_20 === 'number' ? `₺${analysis.indicators.sma_20.toFixed(2)}` : '—'}</p>
                 </div>
                 
                 <div className="p-3 rounded-lg border">
                   <p className="text-xs text-gray-500 mb-1">SMA 50</p>
-                  <p className="text-lg font-bold">{typeof analysis.indicators?.sma_50 === 'number' ? `${currencySymbol}${analysis.indicators.sma_50.toFixed(2)}` : '—'}</p>
+                  <p className="text-lg font-bold">{typeof analysis.indicators?.sma_50 === 'number' ? `₺${analysis.indicators.sma_50.toFixed(2)}` : '—'}</p>
                 </div>
                 
                 <div className="p-3 rounded-lg border">
@@ -729,7 +705,7 @@ export default function StocksPage() {
                   <p className="text-xs text-gray-500 mb-1">ADX</p>
                   <p className="text-lg font-bold">{typeof analysis.indicators?.adx === 'number' ? analysis.indicators.adx.toFixed(1) : '—'}</p>
                   <p className="text-xs text-gray-500">
-                    {typeof analysis.indicators?.adx === 'number' ? (analysis.indicators.adx > 25 ? (isUS ? 'Strong Trend' : 'Güçlü Trend') : (isUS ? 'Weak Trend' : 'Zayıf Trend')) : '—'}
+                    {typeof analysis.indicators?.adx === 'number' ? (analysis.indicators.adx > 25 ? 'Güçlü Trend' : 'Zayıf Trend') : '—'}
                   </p>
                 </div>
               </div>
@@ -739,11 +715,11 @@ export default function StocksPage() {
                 typeof analysis.indicators?.bollinger_middle === 'number' &&
                 typeof analysis.indicators?.bollinger_upper === 'number' && (
                   <div className="mt-4 p-4 bg-gray-50 rounded-lg">
-                    <p className="text-sm font-medium text-gray-700 mb-2">{isUS ? 'Bollinger Bands' : 'Bollinger Bantları'}</p>
+                    <p className="text-sm font-medium text-gray-700 mb-2">Bollinger Bantları</p>
                     <div className="flex items-center justify-between text-sm">
-                      <span className="text-red-600">{isUS ? 'Low' : 'Alt'}: {currencySymbol}{analysis.indicators.bollinger_lower.toFixed(2)}</span>
-                      <span className="text-gray-600">{isUS ? 'Mid' : 'Orta'}: {currencySymbol}{analysis.indicators.bollinger_middle.toFixed(2)}</span>
-                      <span className="text-green-600">{isUS ? 'High' : 'Üst'}: {currencySymbol}{analysis.indicators.bollinger_upper.toFixed(2)}</span>
+                      <span className="text-red-600">Alt: ₺{analysis.indicators.bollinger_lower.toFixed(2)}</span>
+                      <span className="text-gray-600">Orta: ₺{analysis.indicators.bollinger_middle.toFixed(2)}</span>
+                      <span className="text-green-600">Üst: ₺{analysis.indicators.bollinger_upper.toFixed(2)}</span>
                     </div>
                     <div className="mt-2 h-2 bg-gray-200 rounded-full relative">
                       <div
@@ -772,7 +748,7 @@ export default function StocksPage() {
                 className="inline-flex items-center gap-2 bg-blue-600 text-white px-6 py-3 rounded-lg hover:bg-blue-700 font-semibold"
               >
                 <BarChart3 className="w-5 h-5" />
-                {isUS ? 'Detailed Chart & Price History' : 'Detaylı Grafik ve Fiyat Geçmişi'}
+                Detaylı Grafik ve Fiyat Geçmişi
               </Link>
             </div>
           </div>

huggingface-space/nextjs-app/src/app/us-market/page.tsx

@@ -1,556 +0,0 @@
-'use client'
-
-import { useState, useEffect, useCallback } from 'react'
-import { fetchJson } from '@/lib/http'
-import Link from 'next/link'
-import {
-  TrendingUp,
-  TrendingDown,
-  DollarSign,
-  BarChart3,
-  Activity,
-  Target,
-  Clock,
-  RefreshCw,
-  Zap,
-  ChevronDown,
-  ChevronUp,
-  Bot,
-  Globe,
-  ArrowRight,
-} from 'lucide-react'
-
-// ─── Types ─────────────────────────────────
-interface Portfolio {
-  cash: number
-  equity: number
-  positionCount: number
-  positions: Array<{
-    symbol: string
-    quantity: number
-    avgCost: number
-    entryDate: string
-    notional: number
-  }>
-  pnlPct: number
-  unrealizedPnl: number
-}
-
-interface EquityPoint {
-  date: string
-  equity: number
-  cash: number
-  positions: number
-  realizedPnl: number
-}
-
-interface OpenTrade {
-  symbol: string
-  quantity: number
-  entryPrice: number
-  entryDate: string
-  confidence: number
-  predictedReturn: number
-  commission: number
-}
-
-interface ClosedTrade {
-  symbol: string
-  quantity: number
-  entryPrice: number
-  exitPrice: number
-  entryDate: string
-  exitDate: string
-  netPnl: number
-  returnPct: number
-  holdingDays: number
-  exitReason: string
-}
-
-interface Performance {
-  totalPnl: number
-  closedTradesCount: number
-  openTradesCount: number
-  winRate: number
-  profitFactor: number | string
-  avgWin: number
-  avgLoss: number
-  bestTrade: number
-  worstTrade: number
-}
-
-interface Signal {
-  date: string
-  symbol: string
-  signal: string
-  mlSignal: string
-  techSignal: string
-  confidence: number
-  predictedReturn: number
-  actionTaken: string
-}
-
-interface MarketSummary {
-  marketId: string
-  displayName: string
-  currency: string
-  status: {
-    isRunning: boolean
-    workerRunning: boolean
-    workerPid: number | null
-    lastRunDate: string | null
-    totalDaysRun: number
-    totalTrades: number
-    currentPhase: string | null
-    lastWorkerStatus?: string | null
-    lastWorkerReason?: string | null
-  }
-  portfolio: Portfolio
-  scan: {
-    universe: string | null
-    completed: boolean
-    stage1Count: number
-    stage2Count: number
-    updatedAt: string | null
-  }
-  openTrades?: OpenTrade[]
-  closedTrades?: ClosedTrade[]
-  equityCurve?: EquityPoint[]
-  signals?: Signal[]
-  performance?: Performance
-  eligibleStocks: string[]
-}
-
-interface TradingApiResponse {
-  markets?: Record<string, MarketSummary>
-  error?: string
-}
-
-// ─── Helpers ───────────────────────────────
-function fmtUSD(n: number | undefined | null): string {
-  if (n == null) return '—'
-  return new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 2 }).format(n)
-}
-
-function fmtPct(n: number | undefined | null): string {
-  if (n == null) return '—'
-  return `${n >= 0 ? '+' : ''}${n.toFixed(2)}%`
-}
-
-function fmtDate(d: string | undefined | null): string {
-  if (!d) return '—'
-  const date = new Date(d)
-  if (isNaN(date.getTime())) return d
-  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
-}
-
-function signalBadgeClass(signal: string): string {
-  const s = signal?.toUpperCase() ?? ''
-  if (s.includes('BUY') || s === 'LONG') return 'bg-green-100 text-green-700 border-green-200'
-  if (s.includes('SELL') || s === 'SHORT') return 'bg-red-100 text-red-700 border-red-200'
-  return 'bg-gray-100 text-gray-600 border-gray-200'
-}
-
-function actionBadgeClass(action: string): string {
-  const a = action?.toUpperCase() ?? ''
-  if (a.includes('EXECUTED')) return 'bg-blue-100 text-blue-700 border-blue-200'
-  if (a.includes('REJECTED') || a.includes('NO_POSITION') || a.includes('SKIP')) return 'bg-amber-100 text-amber-700 border-amber-200'
-  return 'bg-gray-100 text-gray-600 border-gray-200'
-}
-
-// ─── Sub-components ─────────────────────────
-function StatCard({ label, value, sub, positive }: { label: string; value: string; sub?: string; positive?: boolean }) {
-  return (
-    <div className="bg-white border border-gray-200 rounded-lg p-4">
-      <p className="text-xs text-gray-500 uppercase tracking-wide mb-1">{label}</p>
-      <p className={`text-xl font-bold ${positive === true ? 'text-green-600' : positive === false ? 'text-red-600' : 'text-gray-900'}`}>
-        {value}
-      </p>
-      {sub && <p className="text-xs text-gray-500 mt-0.5">{sub}</p>}
-    </div>
-  )
-}
-
-// ─── Main Page ─────────────────────────────
-export default function USMarketPage() {
-  const [market, setMarket] = useState<MarketSummary | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [lastRefresh, setLastRefresh] = useState<Date | null>(null)
-  const [showEquity, setShowEquity] = useState(false)
-
-  const load = useCallback(async () => {
-    setLoading(true)
-    setError(null)
-    try {
-      const data = await fetchJson<TradingApiResponse>('/api/trading')
-      const us = data?.markets?.us ?? null
-      if (!us) {
-        setError('US market data not available')
-      } else {
-        setMarket(us)
-        setLastRefresh(new Date())
-      }
-    } catch (e) {
-      setError(e instanceof Error ? e.message : 'Failed to load US market data')
-    } finally {
-      setLoading(false)
-    }
-  }, [])
-
-  useEffect(() => { load() }, [load])
-
-  // ── Loading ──
-  if (loading) {
-    return (
-      <div className="container mx-auto px-4 py-8 max-w-5xl">
-        <div className="animate-pulse space-y-4">
-          <div className="h-8 bg-gray-200 rounded w-64" />
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-            {[...Array(4)].map((_, i) => <div key={i} className="h-24 bg-gray-200 rounded-lg" />)}
-          </div>
-          <div className="h-48 bg-gray-200 rounded-lg" />
-        </div>
-      </div>
-    )
-  }
-
-  // ── Error ──
-  if (error || !market) {
-    return (
-      <div className="container mx-auto px-4 py-8 max-w-5xl">
-        <div className="flex items-center gap-3 mb-6">
-          <Globe className="w-7 h-7 text-blue-600" />
-          <h1 className="text-2xl font-bold text-gray-900">US Equities</h1>
-        </div>
-        <div className="bg-red-50 border border-red-200 rounded-lg p-6 text-center">
-          <p className="text-red-700 font-medium">{error ?? 'No data'}</p>
-          <button onClick={load} className="mt-3 px-4 py-2 bg-red-600 text-white rounded-lg text-sm hover:bg-red-700">
-            Retry
-          </button>
-        </div>
-      </div>
-    )
-  }
-
-  const perf = market.performance
-  const openTrades = market.openTrades ?? []
-  const closedTrades = market.closedTrades ?? []
-  const signals = market.signals ?? []
-  const equityCurve = market.equityCurve ?? []
-  const equity = market.portfolio.equity ?? market.portfolio.cash
-  const initialCapital = 100000
-  const totalReturn = ((equity - initialCapital) / initialCapital) * 100
-
-  return (
-    <div className="container mx-auto px-4 py-6 max-w-5xl">
-
-      {/* Header */}
-      <div className="flex items-center justify-between mb-6 flex-wrap gap-3">
-        <div className="flex items-center gap-3">
-          <Globe className="w-7 h-7 text-blue-600" />
-          <div>
-            <h1 className="text-2xl font-bold text-gray-900">US Equities</h1>
-            <p className="text-sm text-gray-500">S&amp;P 100 · NYSE · Paper Trading</p>
-          </div>
-          <span className={`ml-2 px-3 py-1 rounded-full text-xs font-semibold border ${market.status.workerRunning ? 'bg-green-100 text-green-700 border-green-200' : 'bg-gray-100 text-gray-500 border-gray-200'}`}>
-            {market.status.workerRunning ? 'Worker Active' : 'Worker Idle'}
-          </span>
-        </div>
-        <div className="flex items-center gap-2">
-          {lastRefresh && (
-            <span className="text-xs text-gray-400">
-              Updated {lastRefresh.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })}
-            </span>
-          )}
-          <button
-            onClick={load}
-            className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg border border-gray-200 bg-white text-gray-600 text-sm hover:bg-gray-50"
-          >
-            <RefreshCw className="w-3.5 h-3.5" />
-            Refresh
-          </button>
-          <Link
-            href="/auto-trading"
-            className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg bg-blue-600 text-white text-sm hover:bg-blue-700"
-          >
-            <Bot className="w-3.5 h-3.5" />
-            Trading Panel
-            <ArrowRight className="w-3.5 h-3.5" />
-          </Link>
-        </div>
-      </div>
-
-      {/* Portfolio Stats */}
-      <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
-        <StatCard label="Portfolio Equity" value={fmtUSD(equity)} />
-        <StatCard
-          label="Total Return"
-          value={fmtPct(totalReturn)}
-          positive={totalReturn >= 0}
-        />
-        <StatCard label="Cash" value={fmtUSD(market.portfolio.cash)} />
-        <StatCard label="Open Positions" value={`${market.portfolio.positionCount}`} sub={market.portfolio.positionCount === 1 ? 'position' : 'positions'} />
-      </div>
-
-      {/* Performance row */}
-      {perf && (
-        <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
-          <StatCard
-            label="Realized P&L"
-            value={fmtUSD(perf.totalPnl)}
-            positive={perf.totalPnl >= 0}
-          />
-          <StatCard label="Closed Trades" value={`${perf.closedTradesCount}`} />
-          <StatCard label="Win Rate" value={perf.closedTradesCount > 0 ? `${perf.winRate.toFixed(1)}%` : '—'} />
-          <StatCard label="Profit Factor" value={typeof perf.profitFactor === 'number' ? (perf.profitFactor === 0 ? '—' : perf.profitFactor.toFixed(2)) : String(perf.profitFactor)} />
-        </div>
-      )}
-
-      {/* Worker Status bar */}
-      <div className="bg-white border border-gray-200 rounded-lg px-4 py-3 mb-6 text-sm text-gray-600 flex flex-wrap gap-4">
-        <span><span className="font-semibold text-gray-800">Last Run:</span> {fmtDate(market.status.lastRunDate)}</span>
-        <span><span className="font-semibold text-gray-800">Days Run:</span> {market.status.totalDaysRun}</span>
-        <span><span className="font-semibold text-gray-800">Total Trades:</span> {market.status.totalTrades}</span>
-        {market.status.lastWorkerStatus && (
-          <span><span className="font-semibold text-gray-800">Status:</span> {market.status.lastWorkerStatus}</span>
-        )}
-        {market.scan.universe && (
-          <span><span className="font-semibold text-gray-800">Universe:</span> {market.scan.universe}</span>
-        )}
-        {market.scan.stage1Count > 0 && (
-          <span><span className="font-semibold text-gray-800">Scan:</span> {market.scan.stage1Count} → {market.scan.stage2Count} stocks</span>
-        )}
-      </div>
-
-      {/* Eligible Stocks (Trade Pool) */}
-      {market.eligibleStocks.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg p-4 mb-6">
-          <h2 className="font-semibold text-gray-700 mb-2 flex items-center gap-2">
-            <Target className="w-5 h-5 text-green-500" />
-            Trade Pool ({market.eligibleStocks.length} {market.eligibleStocks.length === 1 ? 'stock' : 'stocks'})
-          </h2>
-          <p className="text-sm text-gray-500 mb-3">
-            Stocks eligible for trading based on ML scan results.
-          </p>
-          <div className="flex flex-wrap gap-2">
-            {market.eligibleStocks.map((sym) => (
-              <span key={sym} className="px-3 py-1.5 bg-green-50 text-green-700 border border-green-200 rounded-full text-sm font-semibold">
-                {sym}
-              </span>
-            ))}
-          </div>
-        </div>
-      )}
-
-      {/* Open Positions */}
-      {openTrades.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg mb-6 overflow-hidden">
-          <div className="px-4 py-3 border-b border-gray-100 flex items-center gap-2">
-            <Activity className="w-5 h-5 text-blue-500" />
-            <h2 className="font-semibold text-gray-700">Open Positions ({openTrades.length})</h2>
-          </div>
-          <div className="overflow-x-auto">
-            <table className="w-full text-sm">
-              <thead>
-                <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                  <th className="px-4 py-2 text-left">Symbol</th>
-                  <th className="px-4 py-2 text-right">Qty</th>
-                  <th className="px-4 py-2 text-right">Entry Price</th>
-                  <th className="px-4 py-2 text-left">Entry Date</th>
-                  <th className="px-4 py-2 text-right">Confidence</th>
-                  <th className="px-4 py-2 text-right">Predicted Ret.</th>
-                </tr>
-              </thead>
-              <tbody>
-                {openTrades.map((t, i) => (
-                  <tr key={i} className="border-t border-gray-100 hover:bg-gray-50">
-                    <td className="px-4 py-2.5 font-semibold text-gray-900">{t.symbol}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{t.quantity}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{fmtUSD(t.entryPrice)}</td>
-                    <td className="px-4 py-2.5 text-gray-600">{fmtDate(t.entryDate)}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{t.confidence != null ? `${(t.confidence * 100).toFixed(0)}%` : '—'}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{t.predictedReturn != null ? fmtPct(t.predictedReturn * 100) : '—'}</td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-        </div>
-      )}
-
-      {/* Recent Signals */}
-      {signals.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg mb-6 overflow-hidden">
-          <div className="px-4 py-3 border-b border-gray-100 flex items-center gap-2">
-            <Zap className="w-5 h-5 text-amber-500" />
-            <h2 className="font-semibold text-gray-700">Recent Signals ({signals.length})</h2>
-          </div>
-          <div className="overflow-x-auto">
-            <table className="w-full text-sm">
-              <thead>
-                <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                  <th className="px-4 py-2 text-left">Date</th>
-                  <th className="px-4 py-2 text-left">Symbol</th>
-                  <th className="px-4 py-2 text-center">Signal</th>
-                  <th className="px-4 py-2 text-center">ML</th>
-                  <th className="px-4 py-2 text-center">Tech</th>
-                  <th className="px-4 py-2 text-right">Confidence</th>
-                  <th className="px-4 py-2 text-center">Action Taken</th>
-                </tr>
-              </thead>
-              <tbody>
-                {signals.slice(0, 20).map((s, i) => (
-                  <tr key={i} className="border-t border-gray-100 hover:bg-gray-50">
-                    <td className="px-4 py-2.5 text-gray-500 text-xs">{fmtDate(s.date)}</td>
-                    <td className="px-4 py-2.5 font-semibold text-gray-900">{s.symbol}</td>
-                    <td className="px-4 py-2.5 text-center">
-                      <span className={`px-2 py-0.5 rounded-full text-xs font-medium border ${signalBadgeClass(s.signal)}`}>
-                        {s.signal}
-                      </span>
-                    </td>
-                    <td className="px-4 py-2.5 text-center text-xs text-gray-600">{s.mlSignal ?? '—'}</td>
-                    <td className="px-4 py-2.5 text-center text-xs text-gray-600">{s.techSignal ?? '—'}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">
-                      {s.confidence != null ? `${(s.confidence * 100).toFixed(0)}%` : '—'}
-                    </td>
-                    <td className="px-4 py-2.5 text-center">
-                      <span className={`px-2 py-0.5 rounded-full text-xs font-medium border ${actionBadgeClass(s.actionTaken)}`}>
-                        {s.actionTaken ?? '—'}
-                      </span>
-                    </td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-        </div>
-      )}
-
-      {/* Closed Trades */}
-      {closedTrades.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg mb-6 overflow-hidden">
-          <div className="px-4 py-3 border-b border-gray-100 flex items-center gap-2">
-            <Clock className="w-5 h-5 text-purple-500" />
-            <h2 className="font-semibold text-gray-700">Closed Trades ({closedTrades.length})</h2>
-          </div>
-          <div className="overflow-x-auto">
-            <table className="w-full text-sm">
-              <thead>
-                <tr className="bg-gray-50 text-gray-500 text-xs uppercase">
-                  <th className="px-4 py-2 text-left">Symbol</th>
-                  <th className="px-4 py-2 text-right">Qty</th>
-                  <th className="px-4 py-2 text-right">Entry</th>
-                  <th className="px-4 py-2 text-right">Exit</th>
-                  <th className="px-4 py-2 text-right">Net P&L</th>
-                  <th className="px-4 py-2 text-right">Return</th>
-                  <th className="px-4 py-2 text-right">Days</th>
-                  <th className="px-4 py-2 text-left">Exit Reason</th>
-                </tr>
-              </thead>
-              <tbody>
-                {closedTrades.map((t, i) => (
-                  <tr key={i} className="border-t border-gray-100 hover:bg-gray-50">
-                    <td className="px-4 py-2.5 font-semibold text-gray-900">{t.symbol}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{t.quantity}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{fmtUSD(t.entryPrice)}</td>
-                    <td className="px-4 py-2.5 text-right text-gray-700">{fmtUSD(t.exitPrice)}</td>
-                    <td className={`px-4 py-2.5 text-right font-semibold ${t.netPnl >= 0 ? 'text-green-600' : 'text-red-600'}`}>
-                      {fmtUSD(t.netPnl)}
-                    </td>
-                    <td className={`px-4 py-2.5 text-right font-medium ${t.returnPct >= 0 ? 'text-green-600' : 'text-red-600'}`}>
-                      {fmtPct(t.returnPct)}
-                    </td>
-                    <td className="px-4 py-2.5 text-right text-gray-600">{t.holdingDays ?? '—'}</td>
-                    <td className="px-4 py-2.5 text-gray-500 text-xs capitalize">{t.exitReason?.replace(/_/g, ' ') ?? '—'}</td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-          {perf && (
-            <div className="px-4 py-3 border-t border-gray-100 bg-gray-50 flex flex-wrap gap-4 text-sm">
-              <span className={`font-semibold ${perf.totalPnl >= 0 ? 'text-green-700' : 'text-red-700'}`}>
-                Net P&amp;L: {fmtUSD(perf.totalPnl)}
-              </span>
-              {perf.closedTradesCount > 0 && (
-                <>
-                  <span className="text-gray-600">Avg Win: <span className="text-green-600 font-medium">{fmtUSD(perf.avgWin)}</span></span>
-                  <span className="text-gray-600">Avg Loss: <span className="text-red-600 font-medium">-{fmtUSD(perf.avgLoss)}</span></span>
-                </>
-              )}
-            </div>
-          )}
-        </div>
-      )}
-
-      {/* Equity Curve */}
-      {equityCurve.length > 0 && (
-        <div className="bg-white border border-gray-200 rounded-lg mb-6 overflow-hidden">
-          <button
-            onClick={() => setShowEquity(!showEquity)}
-            className="w-full px-4 py-3 flex items-center justify-between hover:bg-gray-50"
-          >
-            <span className="flex items-center gap-2 font-semibold text-gray-700">
-              <BarChart3 className="w-5 h-5 text-blue-500" />
-              Equity Curve ({equityCurve.length} days)
-            </span>
-            {showEquity ? <ChevronUp className="w-5 h-5 text-gray-400" /> : <ChevronDown className="w-5 h-5 text-gray-400" />}
-          </button>
-          {showEquity && (
-            <div className="px-4 pb-4">
-              <div className="flex items-end gap-[2px] h-32">
-                {equityCurve.slice(-60).map((pt, i) => {
-                  const slice = equityCurve.slice(-60)
-                  const min = Math.min(...slice.map((e) => e.equity))
-                  const max = Math.max(...slice.map((e) => e.equity))
-                  const range = max - min || 1
-                  const height = ((pt.equity - min) / range) * 100
-                  const isLast = i === slice.length - 1
-                  const isUp = pt.equity >= initialCapital
-                  return (
-                    <div
-                      key={i}
-                      title={`${pt.date}: ${fmtUSD(pt.equity)}`}
-                      style={{ height: `${Math.max(4, height)}%` }}
-                      className={`flex-1 rounded-t transition-all ${isLast ? 'opacity-100' : 'opacity-70'} ${isUp ? 'bg-green-400' : 'bg-red-400'}`}
-                    />
-                  )
-                })}
-              </div>
-              <div className="flex justify-between text-xs text-gray-400 mt-1">
-                <span>{equityCurve.slice(-60)[0]?.date}</span>
-                <span>{equityCurve.slice(-1)[0]?.date}</span>
-              </div>
-            </div>
-          )}
-        </div>
-      )}
-
-      {/* Empty state */}
-      {openTrades.length === 0 && closedTrades.length === 0 && signals.length === 0 && (
-        <div className="bg-gray-50 border border-gray-200 rounded-lg p-8 text-center text-gray-500 mb-6">
-          <DollarSign className="w-10 h-10 mx-auto mb-3 text-gray-300" />
-          <p className="font-medium">No trading activity yet</p>
-          <p className="text-sm mt-1">Run the US market worker to generate signals and trades.</p>
-          <Link href="/auto-trading" className="inline-flex items-center gap-2 mt-4 px-4 py-2 bg-blue-600 text-white rounded-lg text-sm hover:bg-blue-700">
-            <Bot className="w-4 h-4" />
-            Go to Trading Panel
-          </Link>
-        </div>
-      )}
-
-      {/* Footer link */}
-      <div className="flex justify-center">
-        <Link
-          href="/auto-trading"
-          className="flex items-center gap-2 px-5 py-2.5 rounded-lg border border-blue-200 bg-blue-50 text-blue-700 text-sm font-medium hover:bg-blue-100"
-        >
-          <Bot className="w-4 h-4" />
-          Manage US Worker in Trading Panel
-          <ArrowRight className="w-4 h-4" />
-        </Link>
-      </div>
-    </div>
-  )
-}

huggingface-space/nextjs-app/src/components/MLPredictionCard.tsx

@@ -4,7 +4,6 @@ import { useCallback, useEffect, useState } from 'react';
 import { TrendingUp, TrendingDown, Minus, Brain, Target, Activity } from 'lucide-react';
 
 import { fetchJson } from '@/lib/http';
-import { useMarket } from '@/contexts/MarketContext';
 
 interface PredictionData {
   symbol: string;
@@ -21,8 +20,6 @@ interface MLPredictionCardProps {
 }
 
 export default function MLPredictionCard({ symbol }: MLPredictionCardProps) {
-  const { market } = useMarket();
-  const isUS = market === 'us';
   const [prediction, setPrediction] = useState<PredictionData | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -43,7 +40,7 @@ export default function MLPredictionCard({ symbol }: MLPredictionCardProps) {
         {
           timeoutMs: 30000,
           retries: 0,
-          jsonBody: { symbols: [String(symbol || '').toUpperCase()], days_ahead: 7, model: 'ensemble', market },
+          jsonBody: { symbols: [String(symbol || '').toUpperCase()], days_ahead: 7, model: 'ensemble' },
         }
       );
 
@@ -81,7 +78,7 @@ export default function MLPredictionCard({ symbol }: MLPredictionCardProps) {
     } finally {
       setLoading(false);
     }
-  }, [market, symbol]);
+  }, [symbol]);
 
   useEffect(() => {
     fetchPrediction();
@@ -180,7 +177,7 @@ export default function MLPredictionCard({ symbol }: MLPredictionCardProps) {
           <div>
             <div className="text-sm opacity-75">Mevcut Fiyat</div>
             <div className="text-xl font-semibold">
-              {typeof prediction.current_price === 'number' ? `${isUS ? '$' : '₺'}${prediction.current_price.toFixed(2)}` : '-'}
+              {typeof prediction.current_price === 'number' ? `₺${prediction.current_price.toFixed(2)}` : '-'}
             </div>
           </div>
           <div>

huggingface-space/nextjs-app/src/components/Navigation.tsx

@@ -5,7 +5,7 @@ import { useState, useRef, useEffect } from 'react'
 import { 
   TrendingUp, BarChart3, Brain, Sparkles, Briefcase, LogIn, LogOut, 
   Activity, Search, Zap, Building2, History, Newspaper, Target, Menu, X, Star, Megaphone,
-  ChevronDown, Bot, Crosshair, Wrench, Globe
+  ChevronDown, Bot, Crosshair, Wrench
 } from 'lucide-react'
 import { useAuth } from '@/contexts/AuthContext'
 
@@ -55,9 +55,6 @@ export function Navigation() {
               <DropdownLink href="/auto-trading" icon={<Bot className="h-4 w-4" />}>
                 Otomatik Trading
               </DropdownLink>
-              <DropdownLink href="/us-market" icon={<Globe className="h-4 w-4" />}>
-                US Equities
-              </DropdownLink>
               <DropdownLink href="/backtest" icon={<Target className="h-4 w-4" />}>
                 Backtest
               </DropdownLink>
@@ -151,9 +148,6 @@ export function Navigation() {
             <MobileNavLink href="/auto-trading" icon={<Bot className="h-5 w-5" />} onClick={() => setMobileMenuOpen(false)}>
               Otomatik Trading
             </MobileNavLink>
-            <MobileNavLink href="/us-market" icon={<Globe className="h-5 w-5" />} onClick={() => setMobileMenuOpen(false)}>
-              US Equities
-            </MobileNavLink>
             <MobileNavLink href="/backtest" icon={<Target className="h-5 w-5" />} onClick={() => setMobileMenuOpen(false)}>
               Backtest
             </MobileNavLink>

huggingface-space/nextjs-app/src/components/TopMLPredictions.tsx

@@ -5,7 +5,6 @@ import { Brain, TrendingUp, TrendingDown, Loader2 } from 'lucide-react';
 import Link from 'next/link';
 
 import { fetchJson } from '@/lib/http';
-import { useMarket } from '@/contexts/MarketContext';
 
 interface TopPrediction {
   symbol: string;
@@ -27,8 +26,6 @@ function fmt2(value: unknown): string {
 }
 
 export default function TopMLPredictions() {
-  const { market } = useMarket();
-  const isUS = market === 'us';
   const [predictions, setPredictions] = useState<TopPrediction[]>([]);
   const [loading, setLoading] = useState(true);
 
@@ -40,29 +37,19 @@ export default function TopMLPredictions() {
     try {
       setLoading(true);
       
-      const symbols = isUS
-        ? (() => {
-            const universe = fetchJson<Record<string, unknown>>(
-              `/api/universe?name=us_popular`,
-              { method: 'GET' },
-              { timeoutMs: 20000, retries: 1 }
-            );
-            return universe;
-          })()
-        : fetchJson<Record<string, unknown>>(
-            `/api/popular-stocks`,
-            { method: 'GET' },
-            { timeoutMs: 12000, retries: 1 }
-          );
-      const stocksData = await symbols;
-      const symbolList = (Array.isArray(stocksData.symbols) ? stocksData.symbols : Array.isArray(stocksData.stocks) ? stocksData.stocks : []) as string[];
-      const selectedSymbols = symbolList.slice(0, 10);
+      // Get popular stocks from HF
+      const stocksData = await fetchJson<Record<string, unknown>>(
+        `/api/popular-stocks`,
+        { method: 'GET' },
+        { timeoutMs: 12000, retries: 1 }
+      );
+      const symbols = (Array.isArray(stocksData.stocks) ? stocksData.stocks as string[] : []).slice(0, 10);
       
       // Get predictions from HF
       const data = await fetchJson<Record<string, unknown>>(
         `/api/ml-predictions`,
         { method: 'POST' },
-        { timeoutMs: 30000, retries: 0, jsonBody: { symbols: selectedSymbols, days_ahead: 7, model: 'ensemble', market } }
+        { timeoutMs: 30000, retries: 0, jsonBody: { symbols, days_ahead: 7, model: 'ensemble' } }
       );
 
       const preds = Array.isArray(data.predictions) ? data.predictions as Record<string, unknown>[] : [];
@@ -190,7 +177,7 @@ export default function TopMLPredictions() {
             </div>
             
             <div className="mt-3 pt-3 border-t border-gray-100 flex justify-between text-xs text-gray-500">
-              <span>Mevcut: {isUS ? '$' : '₺'}{fmt2(pred.current_price)}</span>
+              <span>Mevcut: ₺{fmt2(pred.current_price)}</span>
               <span>Tahmin: ₺{fmt2(pred.predicted_price)}</span>
             </div>
           </Link>

huggingface-space/nextjs-app/src/lib/api-auth.ts

@@ -13,27 +13,6 @@ interface AuthError {
   response: NextResponse
 }
 
-async function getUserFromBearerToken(
-  supabaseUrl: string,
-  supabaseAnonKey: string,
-  token: string,
-) {
-  const response = await fetch(`${supabaseUrl}/auth/v1/user`, {
-    headers: {
-      apikey: supabaseAnonKey,
-      Authorization: `Bearer ${token}`,
-    },
-    cache: 'no-store',
-  })
-
-  if (!response.ok) {
-    return { data: { user: null }, error: new Error('Invalid bearer token') }
-  }
-
-  const user = await response.json()
-  return { data: { user }, error: null }
-}
-
 /**
  * Verify that the incoming request belongs to an authenticated Supabase user.
  *
@@ -50,7 +29,6 @@ async function getUserFromBearerToken(
 export async function requireAuth(request?: Request): Promise<AuthResult | AuthError> {
   try {
     const cookieStore = await cookies()
-    const authHeader = request?.headers.get('authorization') ?? null
 
     const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
     const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
@@ -94,11 +72,11 @@ export async function requireAuth(request?: Request): Promise<AuthResult | AuthE
 
     // Fallback: try Authorization header (for API clients)
     if (request) {
+      const authHeader = request.headers.get('authorization')
       if (authHeader?.startsWith('Bearer ')) {
         const token = authHeader.slice(7)
         const { data: { user: tokenUser }, error: tokenError } =
-          await getUserFromBearerToken(supabaseUrl, supabaseAnonKey, token)
-
+          await supabase.auth.getUser(token)
         if (tokenUser && !tokenError) {
           return { authenticated: true, userId: tokenUser.id, email: tokenUser.email }
         }

huggingface-space/requirements.txt

@@ -3,23 +3,23 @@ fastapi==0.109.0
 uvicorn[standard]==0.27.0
 pydantic==2.5.3
 
-# Data & ML
-yfinance>=0.2.28
-pandas>=2.0.0
-numpy>=1.24.0
-scikit-learn>=1.3.0
-xgboost>=2.0.0
-lightgbm>=4.0.0
+# Data & ML (pinned to prevent surprise breakage on rebuild)
+yfinance>=0.2.28,<1.0
+pandas>=2.0.0,<3.0
+numpy>=1.24.0,<3.0
+scikit-learn>=1.3.0,<2.0
+xgboost>=2.0.0,<3.0
+lightgbm>=4.0.0,<5.0
 
 # Utilities
 requests>=2.31.0
 python-dateutil>=2.8.2
 pytz>=2023.3
+lxml>=5.0.0
 
-# Real sentiment model (no toy heuristics)
-transformers>=4.41.0
-torch>=2.2.0
-sentencepiece>=0.2.0
+# NOTE: torch, transformers, sentencepiece removed — not imported anywhere
+# Sentiment analysis uses VADER + TextBlob, not HuggingFace models.
+# Removing ~3 GB of unused dependencies fixes container OOM / disk issues.
 
 # For local smoke tests via FastAPI/Starlette TestClient.
 # Starlette 0.35.x is not compatible with httpx 0.28+.

huggingface-space/run_bist100_scan.py

@@ -1,45 +1,17 @@
 #!/usr/bin/env python3
-"""BIST100 Batch Stock Scanner — 2-Stage ML Eligibility Filter.
+"""BIST batch stock scanner.
 
-Stage 1: Quick liquidity & data quality pre-filter via yfinance
-  - Minimum 1 year of daily data
-  - Minimum average daily volume (configurable)
-  - Eliminates stocks that would waste backtest time
-
-Stage 2: Full ML walk-forward backtest (only for Stage 1 passers)
-  - Uses the v3 classification ensemble
-  - Evaluates direction accuracy, Sharpe, hit rate
-  - Determines ML eligibility
-
-Features:
-  - Resume support: saves after each stock, can continue from where it left off
-  - Memory management: gc.collect() between stocks
-  - Progress tracking with ETA
-  - Results saved to paper_trading/bist100_scan_results.json
-
-Usage:
-  python3 run_bist100_scan.py                    # Scan BIST100
-  python3 run_bist100_scan.py --universe bist50  # Scan BIST50 only
-  python3 run_bist100_scan.py --resume            # Resume interrupted scan
-  python3 run_bist100_scan.py --report            # Show results only
-  python3 run_bist100_scan.py --force             # Force re-scan all
+Thin wrapper around the shared scanner engine.
 """
 
 from __future__ import annotations
 
 import argparse
-import gc
-import json
 import logging
-import sys
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
 
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
+from trading.scanner_engine import ScanConfig, print_report, run_scan
+
+
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(message)s",
@@ -47,488 +19,32 @@ logging.basicConfig(
 )
 logger = logging.getLogger("bist100_scan")
 
-# ---------------------------------------------------------------------------
-# Config
-# ---------------------------------------------------------------------------
-# Write progress to a work file and only publish the final file when the scan completes.
-# This allows trading to keep using the last completed results while a new scan is running.
-FINAL_RESULTS_FILE = Path("paper_trading/bist100_scan_results.json")
-WORK_RESULTS_FILE = Path("paper_trading/bist100_scan_results_work.json")
-MIN_DATA_DAYS = 252          # At least 1 year of data required
-MIN_AVG_VOLUME = 500_000     # Min avg daily volume (shares, not TL)
-BACKTEST_START = "2023-01-01"
-BACKTEST_END = "2025-12-31"
-
-
-def _as_float(value: Any, default: float = 0.0) -> float:
-    """Convert pandas/yfinance scalar-like results into a plain float."""
-    try:
-        current = value
-        while hasattr(current, "iloc"):
-            if len(current) == 0:
-                return default
-            current = current.iloc[0]
-        return float(current)
-    except Exception:
-        return default
-TRAIN_WINDOW = 252           # 1 year train for eligibility scan
-DAYS_AHEAD = 7
-
-# Eligibility thresholds
-MIN_DIR_ACC = 0.53
-MIN_SHARPE = 0.0
-MIN_HIT_RATE = 40.0
-MIN_TRADES = 3
-
-
-# ---------------------------------------------------------------------------
-# Result persistence
-# ---------------------------------------------------------------------------
-def _load_results() -> Dict[str, Any]:
-    src = None
-    if WORK_RESULTS_FILE.exists():
-        src = WORK_RESULTS_FILE
-    elif FINAL_RESULTS_FILE.exists():
-        src = FINAL_RESULTS_FILE
-
-    if src is not None and src.exists():
-        try:
-            return json.loads(src.read_text())
-        except Exception:
-            pass
-    return {
-        "scan_started": None,
-        "universe": None,
-        "stage1": {},    # {symbol: {passed, reason, avg_volume, data_days}}
-        "stage2": {},    # {symbol: {eligible, dir_acc, sharpe, ...}}
-        "completed": False,
-    }
-
-
-def _save_results(data: Dict[str, Any]) -> None:
-    WORK_RESULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
-    data["updated_at"] = datetime.now(timezone.utc).isoformat()
-    tmp = WORK_RESULTS_FILE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, indent=2, default=str))
-    tmp.rename(WORK_RESULTS_FILE)
-
-
-def _publish_final_if_complete(data: Dict[str, Any]) -> None:
-    """Publish a completed scan to the final results file atomically."""
-    if not data.get("completed", False):
-        return
-    FINAL_RESULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
-    tmp = FINAL_RESULTS_FILE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, indent=2, default=str))
-    tmp.rename(FINAL_RESULTS_FILE)
-
-
-# ---------------------------------------------------------------------------
-# Stage 1: Liquidity & Data Quality Pre-Filter
-# ---------------------------------------------------------------------------
-def stage1_prefilter(symbol: str) -> Dict[str, Any]:
-    """Quick check: does this stock have enough data and liquidity?
-    
-    Returns dict with:
-      - passed: bool
-      - reason: str
-      - avg_volume: float
-      - data_days: int
-      - last_price: float
-    """
-    import yfinance as yf
-
-    ticker = f"{symbol}.IS"
-    result: Dict[str, Any] = {
-        "symbol": symbol,
-        "passed": False,
-        "reason": "",
-        "avg_volume": 0.0,
-        "data_days": 0,
-        "last_price": 0.0,
-        "checked_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-    try:
-        df = yf.download(ticker, period="2y", progress=False, auto_adjust=True)
-        if df is None or df.empty:
-            result["reason"] = "no_data"
-            return result
-
-        data_days = len(df)
-        result["data_days"] = data_days
-
-        if data_days < MIN_DATA_DAYS:
-            result["reason"] = f"insufficient_data ({data_days} < {MIN_DATA_DAYS} days)"
-            return result
-
-        # Average daily volume
-        avg_vol = _as_float(df["Volume"].mean()) if "Volume" in df.columns else 0.0
-        result["avg_volume"] = round(avg_vol, 0)
-
-        if avg_vol < MIN_AVG_VOLUME:
-            result["reason"] = f"low_volume ({avg_vol:,.0f} < {MIN_AVG_VOLUME:,.0f})"
-            return result
-
-        # Last price (sanity check)
-        last_price = _as_float(df["Close"].iloc[-1])
-        result["last_price"] = round(last_price, 2)
-
-        if last_price < 1.0:
-            result["reason"] = f"penny_stock (price={last_price:.2f})"
-            return result
-
-        result["passed"] = True
-        result["reason"] = "OK"
-        return result
-
-    except Exception as e:
-        result["reason"] = f"error: {e}"
-        return result
-
-
-# ---------------------------------------------------------------------------
-# Stage 2: ML Backtest Eligibility
-# ---------------------------------------------------------------------------
-def stage2_backtest(symbol: str) -> Dict[str, Any]:
-    """Full walk-forward backtest to evaluate ML eligibility."""
-    from analysis.walk_forward_backtest import walk_forward_backtest
-
-    result: Dict[str, Any] = {
-        "symbol": symbol,
-        "eligible": False,
-        "reason": "",
-        "evaluated_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-    try:
-        _, m = walk_forward_backtest(
-            symbol=symbol,
-            start_date=BACKTEST_START,
-            end_date=BACKTEST_END,
-            days_ahead=DAYS_AHEAD,
-            train_window=TRAIN_WINDOW,
-            model_type="rf",
-            use_technical_gate=True,
-            initial_capital=100_000.0,
-            commission_bps=10.0,
-            slippage_bps=10.0,
-            exit_rule="signal_or_fixed",
-            max_hold_days=DAYS_AHEAD,
-            stop_loss_pct=0.05,
-            take_profit_pct=0.10,
-            trailing_stop_pct=0.07,
-            max_position_pct=0.50,
-            max_risk_per_trade_pct=0.02,
-        )
-
-        dir_acc = m["direction_accuracy"]
-        sharpe = m["sharpe"]
-        hit_rate = m.get("hit_rate_pct", 0.0)
-        total_ret = m["total_return_pct"]
-        trades = m["trades_count"]
-        max_dd = m.get("max_drawdown_pct", 0.0)
-
-        result.update({
-            "dir_acc": round(dir_acc, 4),
-            "sharpe": round(sharpe, 3),
-            "hit_rate": round(hit_rate, 1),
-            "total_return_pct": round(total_ret, 1),
-            "trades": trades,
-            "max_drawdown_pct": round(max_dd, 1),
-        })
-
-        reasons: List[str] = []
-        if dir_acc < MIN_DIR_ACC:
-            reasons.append(f"dir_acc={dir_acc:.1%}<{MIN_DIR_ACC:.0%}")
-        if sharpe < MIN_SHARPE:
-            reasons.append(f"sharpe={sharpe:.3f}<{MIN_SHARPE}")
-        if hit_rate < MIN_HIT_RATE:
-            reasons.append(f"hit_rate={hit_rate:.1f}%<{MIN_HIT_RATE}%")
-        if trades < MIN_TRADES:
-            reasons.append(f"trades={trades}<{MIN_TRADES}")
-
-        result["eligible"] = len(reasons) == 0
-        result["reason"] = "; ".join(reasons) if reasons else "OK"
-
-        return result
-
-    except Exception as e:
-        result["reason"] = f"backtest_error: {e}"
-        logger.warning("Stage 2 failed for %s: %s", symbol, e)
-        return result
-
-
-# ---------------------------------------------------------------------------
-# Fetch BIST universe
-# ---------------------------------------------------------------------------
-def get_universe(name: str) -> List[str]:
-    """Get stock list from official Borsa Istanbul CSV."""
-    from data.index_constituents import get_index_constituents
-
-    try:
-        result = get_index_constituents(name)
-        symbols = result.symbols
-        logger.info("Fetched %d stocks from %s", len(symbols), name)
-        return symbols
-    except Exception as e:
-        logger.error("Failed to fetch universe %s: %s", name, e)
-        # Fallback: hardcoded BIST30 for testing
-        return [
-            "THYAO", "AKBNK", "GARAN", "EREGL", "SISE",
-            "TUPRS", "KCHOL", "ASELS", "BIMAS", "SAHOL",
-            "YKBNK", "HALKB", "VAKBN", "TCELL", "ARCLK",
-            "PETKM", "TOASO", "KOZAA", "KOZAL", "SASA",
-            "TAVHL", "TTKOM", "ENKAI", "FROTO", "EKGYO",
-            "PGSUS", "SOKM", "DOHOL", "GUBRF", "ISCTR",
-        ]
-
-
-# ---------------------------------------------------------------------------
-# Main scan orchestrator
-# ---------------------------------------------------------------------------
-def run_scan(
-    universe: str = "bist100",
-    force: bool = False,
-    stage1_only: bool = False,
-) -> Dict[str, Any]:
-    """Run the 2-stage scan on the given universe."""
-
-    symbols = get_universe(universe)
-    if not symbols:
-        logger.error("No symbols found for universe: %s", universe)
-        return {}
-
-    data = _load_results()
-
-    # Check if we should start fresh or resume
-    is_same_universe = data.get("universe") == universe
-    if not is_same_universe or force:
-        logger.info("Starting fresh scan for %s (%d stocks)", universe, len(symbols))
-        data = {
-            "scan_started": datetime.now(timezone.utc).isoformat(),
-            "universe": universe,
-            "total_stocks": len(symbols),
-            "stage1": {},
-            "stage2": {},
-            "completed": False,
-        }
-        _save_results(data)
-    else:
-        s1_done = len(data.get("stage1", {}))
-        s2_done = len(data.get("stage2", {}))
-        logger.info(
-            "Resuming scan: %d/%d Stage1, %d Stage2 done",
-            s1_done, len(symbols), s2_done,
-        )
-
-    # ===== STAGE 1: Liquidity Pre-Filter =====
-    logger.info("=" * 60)
-    logger.info("STAGE 1: Liquidity & Data Quality Pre-Filter")
-    logger.info("=" * 60)
-
-    s1_todo = [s for s in symbols if s not in data.get("stage1", {})]
-    total_s1 = len(symbols)
-    done_s1 = total_s1 - len(s1_todo)
-
-    for i, sym in enumerate(s1_todo, start=done_s1 + 1):
-        t0 = time.time()
-        result = stage1_prefilter(sym)
-        elapsed = time.time() - t0
-
-        status = "PASS" if result["passed"] else f"FAIL ({result['reason']})"
-        logger.info(
-            "[Stage1 %d/%d] %s: %s (%.1fs)",
-            i, total_s1, sym, status, elapsed,
-        )
-
-        data.setdefault("stage1", {})[sym] = result
-        _save_results(data)
-        gc.collect()
-
-    # Summary
-    s1_passed = [s for s, v in data["stage1"].items() if v.get("passed")]
-    s1_failed = [s for s, v in data["stage1"].items() if not v.get("passed")]
-    logger.info("")
-    logger.info("Stage 1 Results: %d PASS / %d FAIL out of %d", 
-                len(s1_passed), len(s1_failed), total_s1)
-    logger.info("Passed: %s", ", ".join(sorted(s1_passed)))
-    logger.info("")
-
-    if stage1_only:
-        data["completed"] = True
-        _save_results(data)
-        _publish_final_if_complete(data)
-        return data
-
-    # ===== STAGE 2: ML Backtest =====
-    logger.info("=" * 60)
-    logger.info("STAGE 2: ML Walk-Forward Backtest")
-    logger.info("=" * 60)
-
-    s2_todo = [s for s in s1_passed if s not in data.get("stage2", {})]
-    total_s2 = len(s1_passed)
-    done_s2 = total_s2 - len(s2_todo)
-
-    times_s2: List[float] = []
-
-    for i, sym in enumerate(s2_todo, start=done_s2 + 1):
-        t0 = time.time()
-        result = stage2_backtest(sym)
-        elapsed = time.time() - t0
-        times_s2.append(elapsed)
-
-        if result["eligible"]:
-            status = (
-                f"ELIGIBLE (ret={result.get('total_return_pct', 0):.1f}%, "
-                f"sharpe={result.get('sharpe', 0):.3f}, "
-                f"hit={result.get('hit_rate', 0):.0f}%)"
-            )
-        else:
-            status = f"EXCLUDED ({result['reason']})"
-
-        # ETA
-        avg_time = sum(times_s2) / len(times_s2)
-        remaining = total_s2 - i
-        eta_min = (remaining * avg_time) / 60
-
-        logger.info(
-            "[Stage2 %d/%d] %s: %s (%.1fs, ETA: %.0f min)",
-            i, total_s2, sym, status, elapsed, eta_min,
-        )
-
-        data.setdefault("stage2", {})[sym] = result
-        _save_results(data)
-        gc.collect()
-
-    # ===== Final Report =====
-    data["completed"] = True
-    data["scan_finished"] = datetime.now(timezone.utc).isoformat()
-    _save_results(data)
-    _publish_final_if_complete(data)
-
-    print_report(data)
-    return data
-
-
-# ---------------------------------------------------------------------------
-# Report
-# ---------------------------------------------------------------------------
-def print_report(data: Optional[Dict[str, Any]] = None) -> None:
-    """Print a formatted scan report."""
-    if data is None:
-        data = _load_results()
-
-    s2 = data.get("stage2", {})
-    if not s2:
-        logger.info("No Stage 2 results found. Run scan first.")
-        return
-
-    eligible = {s: v for s, v in s2.items() if v.get("eligible")}
-    excluded = {s: v for s, v in s2.items() if not v.get("eligible")}
-
-    print("\n" + "=" * 70)
-    print(f"  BIST STOCK SCAN RESULTS — {data.get('universe', '?').upper()}")
-    print("=" * 70)
-
-    # Stage 1 stats
-    s1 = data.get("stage1", {})
-    s1_pass = sum(1 for v in s1.values() if v.get("passed"))
-    s1_fail = sum(1 for v in s1.values() if not v.get("passed"))
-    print(f"\nStage 1 (Liquidity Filter):  {s1_pass} pass / {s1_fail} fail / {len(s1)} total")
-    print(f"Stage 2 (ML Backtest):       {len(eligible)} eligible / {len(excluded)} excluded / {len(s2)} tested")
-
-    # Eligible stocks sorted by Sharpe
-    if eligible:
-        print(f"\n{'─' * 70}")
-        print(f"  ELIGIBLE STOCKS ({len(eligible)})")
-        print(f"{'─' * 70}")
-        print(f"  {'Symbol':<10} {'Return%':>9} {'Sharpe':>8} {'HitRate%':>9} {'MaxDD%':>8} {'Trades':>7}")
-        print(f"  {'─'*10} {'─'*9} {'─'*8} {'─'*9} {'─'*8} {'─'*7}")
-
-        sorted_eligible = sorted(
-            eligible.items(),
-            key=lambda kv: kv[1].get("sharpe", -999),
-            reverse=True,
-        )
-        for sym, m in sorted_eligible:
-            print(
-                f"  {sym:<10} {m.get('total_return_pct', 0):>+8.1f}% "
-                f"{m.get('sharpe', 0):>8.3f} "
-                f"{m.get('hit_rate', 0):>8.1f}% "
-                f"{m.get('max_drawdown_pct', 0):>7.1f}% "
-                f"{m.get('trades', 0):>7d}"
-            )
-
-        # Portfolio summary
-        avg_ret = sum(m.get("total_return_pct", 0) for m in eligible.values()) / len(eligible)
-        avg_sharpe = sum(m.get("sharpe", 0) for m in eligible.values()) / len(eligible)
-        avg_hit = sum(m.get("hit_rate", 0) for m in eligible.values()) / len(eligible)
-        print(f"\n  Average:   {avg_ret:>+8.1f}%  {avg_sharpe:>8.3f}  {avg_hit:>8.1f}%")
-
-    # Excluded stocks summary
-    if excluded:
-        print(f"\n{'─' * 70}")
-        print(f"  EXCLUDED STOCKS ({len(excluded)})")
-        print(f"{'─' * 70}")
-        for sym, m in sorted(excluded.items()):
-            ret = m.get("total_return_pct", "?")
-            reason = m.get("reason", "?")
-            ret_str = f"{ret:>+.1f}%" if isinstance(ret, (int, float)) else "N/A"
-            print(f"  {sym:<10} {ret_str:>9}  {reason}")
-
-    # Stage 1 failures
-    s1_failures = {s: v for s, v in s1.items() if not v.get("passed")}
-    if s1_failures:
-        print(f"\n{'─' * 70}")
-        print(f"  STAGE 1 FAILURES — Skipped ({len(s1_failures)})")
-        print(f"{'─' * 70}")
-        for sym, v in sorted(s1_failures.items()):
-            print(f"  {sym:<10} {v.get('reason', '?')}")
-
-    print(f"\n{'=' * 70}")
-    print(f"  Scan: {data.get('scan_started', '?')} → {data.get('scan_finished', 'in progress')}")
-    print(f"{'=' * 70}\n")
 
+CONFIGS = {
+    "bist30": ScanConfig(market_id="bist", universe_name="bist30", title="BIST"),
+    "bist50": ScanConfig(market_id="bist", universe_name="bist50", title="BIST"),
+    "bist100": ScanConfig(market_id="bist", universe_name="bist100", title="BIST"),
+}
 
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-def main():
-    parser = argparse.ArgumentParser(description="BIST Stock Scanner")
-    parser.add_argument(
-        "--universe", default="bist100",
-        help="Universe to scan: bist30, bist50, bist100, all (default: bist100)",
-    )
-    parser.add_argument(
-        "--resume", action="store_true",
-        help="Resume interrupted scan (default behavior if same universe)",
-    )
-    parser.add_argument(
-        "--force", action="store_true",
-        help="Force re-scan all stocks (ignore cache)",
-    )
-    parser.add_argument(
-        "--report", action="store_true",
-        help="Show results only, don't scan",
-    )
-    parser.add_argument(
-        "--stage1-only", action="store_true",
-        help="Run only Stage 1 (liquidity filter) — fast",
-    )
 
+def main() -> int:
+    parser = argparse.ArgumentParser(description="BIST batch stock scanner")
+    parser.add_argument("--universe", default="bist100", choices=sorted(CONFIGS))
+    parser.add_argument("--resume", action="store_true", help="Resume interrupted scan")
+    parser.add_argument("--report", action="store_true", help="Show latest report only")
+    parser.add_argument("--force", action="store_true", help="Force a fresh scan")
+    parser.add_argument("--stage1-only", action="store_true", help="Run only liquidity pre-filter")
     args = parser.parse_args()
 
+    config = CONFIGS[args.universe]
     if args.report:
-        print_report()
-        return
+        print_report(config, logger)
+        return 0
 
-    run_scan(
-        universe=args.universe,
-        force=args.force,
-        stage1_only=args.stage1_only,
-    )
+    force = args.force or not args.resume
+    run_scan(config, logger, force=force, stage1_only=args.stage1_only)
+    return 0
 
 
 if __name__ == "__main__":
-    main()
+    raise SystemExit(main())

huggingface-space/run_us_scan.py

@@ -1,44 +1,15 @@
 #!/usr/bin/env python3
-"""US Equities Batch Stock Scanner — 2-Stage ML Eligibility Filter.
-
-Stage 1: Quick liquidity & data quality pre-filter via yfinance
-  - Minimum 1 year of daily data
-  - Minimum average daily volume (configurable)
-  - Minimum share price ($5+)
-  - Eliminates stocks that would waste backtest time
-
-Stage 2: Full ML walk-forward backtest (only for Stage 1 passers)
-  - Uses the v3 classification ensemble
-  - Evaluates direction accuracy, Sharpe, hit rate
-  - Determines ML eligibility
-
-Features:
-  - Resume support: saves after each stock, can continue from where it left off
-  - Memory management: gc.collect() between stocks
-  - Progress tracking with ETA
-  - Results saved to paper_trading/markets/us/scan_results.json
-
-Usage:
-  python3 run_us_scan.py                     # Scan SP100
-  python3 run_us_scan.py --universe sp500    # Scan SP500
-  python3 run_us_scan.py --force             # Force re-scan all
-"""
+"""US equities batch scanner using the shared scanner engine."""
 
 from __future__ import annotations
 
-import gc
-import json
+import argparse
+from dataclasses import replace
 import logging
-import time
-from datetime import datetime, timezone
-from io import StringIO
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.request import Request, urlopen
 
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
+from trading.scanner_engine import ScanConfig, print_report, run_scan
+
+
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(message)s",
@@ -46,425 +17,38 @@ logging.basicConfig(
 )
 logger = logging.getLogger("us_scan")
 
-# ---------------------------------------------------------------------------
-# Config
-# ---------------------------------------------------------------------------
-FINAL_RESULTS_FILE = Path("paper_trading/markets/us/scan_results.json")
-WORK_RESULTS_FILE = Path("paper_trading/markets/us/scan_results_work.json")
-
-MIN_DATA_DAYS = 252       # At least 1 year of data
-MIN_AVG_VOLUME = 1_000_000  # Min avg daily volume (shares)
-MIN_PRICE = 5.0           # Min share price in USD
-BACKTEST_START = "2023-01-01"
-BACKTEST_END = "2025-12-31"
-TRAIN_WINDOW = 252
-DAYS_AHEAD = 7
 
-# Eligibility thresholds (same as BIST)
-MIN_DIR_ACC = 0.53
-MIN_SHARPE = 0.0
-MIN_HIT_RATE = 40.0
-MIN_TRADES = 3
-
-_DEFAULT_HTML_HEADERS = {
-    "User-Agent": (
-        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
-        "AppleWebKit/537.36 (KHTML, like Gecko) "
-        "Chrome/123.0.0.0 Safari/537.36"
-    ),
-    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-    "Accept-Language": "en-US,en;q=0.9",
+CONFIGS = {
+    "sp100": ScanConfig(market_id="us", universe_name="sp100", title="US", min_avg_volume=1_000_000, min_price=5.0),
+    "sp500": ScanConfig(market_id="us", universe_name="sp500", title="US", min_avg_volume=1_500_000, min_price=5.0),
+    "nasdaq100": ScanConfig(market_id="us", universe_name="nasdaq100", title="US", min_avg_volume=1_000_000, min_price=5.0),
 }
 
-# Hardcoded SP100 fallback in case Wikipedia scraping fails
-_SP100_FALLBACK = [
-    "AAPL", "MSFT", "AMZN", "NVDA", "GOOGL", "GOOG", "META", "TSLA", "BRK-B",
-    "UNH", "XOM", "JNJ", "JPM", "V", "PG", "MA", "HD", "CVX", "LLY", "ABBV",
-    "MRK", "PEP", "COST", "KO", "AVGO", "TMO", "WMT", "MCD", "BAC", "ABT",
-    "PM", "CRM", "ACN", "NEE", "NKE", "LIN", "DHR", "TXN", "ORCL", "VZ",
-    "ADBE", "BMY", "QCOM", "T", "UPS", "RTX", "AMGN", "LOW", "INTU", "HON",
-    "IBM", "SBUX", "ELV", "MDT", "GE", "CAT", "GS", "MS", "NFLX", "NOW",
-    "AXP", "BKNG", "ISRG", "DE", "CVS", "GILD", "AMD", "AMAT", "PYPL", "TGT",
-    "MDLZ", "CI", "BLK", "ADP", "VRTX", "SYK", "TJX", "CB", "LMT", "C",
-    "MMC", "REGN", "SO", "DUK", "BSX", "EOG", "NOC", "FDX", "MU", "PLD",
-    "WM", "SLB", "ADI", "ETN", "APD", "ZTS", "HCA", "EMR", "AON", "USB",
-]
-
-# ---------------------------------------------------------------------------
-# Universe fetching
-# ---------------------------------------------------------------------------
-def _clean_us_symbol(raw: str) -> str:
-    token = str(raw or "").strip().upper()
-    return token.replace(".", "-")
-
-
-def _fetch_universe_from_wikipedia(name: str) -> List[str]:
-    """Fetch US stock universe from Wikipedia. Returns [] on failure."""
-    source_map = {
-        "sp100": ("https://en.wikipedia.org/wiki/S%26P_100", "Symbol"),
-        "sp500": ("https://en.wikipedia.org/wiki/List_of_S%26P_500_companies", "Symbol"),
-        "nasdaq100": ("https://en.wikipedia.org/wiki/Nasdaq-100", "Ticker"),
-    }
-    if name not in source_map:
-        return []
-
-    url, col_name = source_map[name]
-    try:
-        import pandas as pd
-        request = Request(url, headers=_DEFAULT_HTML_HEADERS)
-        with urlopen(request, timeout=20) as response:
-            charset = response.headers.get_content_charset() or "utf-8"
-            html = response.read().decode(charset, errors="replace")
-        tables = pd.read_html(StringIO(html))
-        for table in tables:
-            columns = {str(c).strip() for c in table.columns}
-            if col_name in columns:
-                symbols = []
-                seen: set = set()
-                for item in table[col_name].tolist():
-                    sym = _clean_us_symbol(item)
-                    if sym and sym not in seen:
-                        seen.add(sym)
-                        symbols.append(sym)
-                logger.info("Fetched %d symbols for %s from Wikipedia", len(symbols), name)
-                return symbols
-    except Exception as e:
-        logger.warning("Wikipedia fetch failed for %s: %s", name, e)
-    return []
-
-
-def get_universe(name: str) -> List[str]:
-    """Get US stock universe by name, with Wikipedia as primary and hardcoded fallback."""
-    name = (name or "sp100").strip().lower()
-    symbols = _fetch_universe_from_wikipedia(name)
-    if symbols:
-        return symbols
-
-    # Fallback
-    if name in ("sp100", "sp500", "nasdaq100", "all"):
-        logger.warning("Using hardcoded SP100 fallback for universe: %s", name)
-        return _SP100_FALLBACK[:]
-
-    logger.error("Unknown US universe: %s", name)
-    return _SP100_FALLBACK[:]
-
-
-# ---------------------------------------------------------------------------
-# Result persistence
-# ---------------------------------------------------------------------------
-def _load_results() -> Dict[str, Any]:
-    src = None
-    if WORK_RESULTS_FILE.exists():
-        src = WORK_RESULTS_FILE
-    elif FINAL_RESULTS_FILE.exists():
-        src = FINAL_RESULTS_FILE
-
-    if src is not None:
-        try:
-            return json.loads(src.read_text())
-        except Exception:
-            pass
-    return {
-        "scan_started": None,
-        "universe": None,
-        "market_id": "us",
-        "stage1": {},
-        "stage2": {},
-        "completed": False,
-    }
-
-
-def _save_results(data: Dict[str, Any]) -> None:
-    WORK_RESULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
-    data["updated_at"] = datetime.now(timezone.utc).isoformat()
-    tmp = WORK_RESULTS_FILE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, indent=2, default=str))
-    tmp.rename(WORK_RESULTS_FILE)
-
-
-def _publish_final_if_complete(data: Dict[str, Any]) -> None:
-    if not data.get("completed", False):
-        return
-    FINAL_RESULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
-    tmp = FINAL_RESULTS_FILE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, indent=2, default=str))
-    tmp.rename(FINAL_RESULTS_FILE)
-
-
-# ---------------------------------------------------------------------------
-# Stage 1: Liquidity & Data Quality Pre-Filter
-# ---------------------------------------------------------------------------
-def stage1_prefilter(symbol: str) -> Dict[str, Any]:
-    """Quick check: does this US stock have enough data and liquidity?"""
-    import yfinance as yf
-
-    result: Dict[str, Any] = {
-        "symbol": symbol,
-        "passed": False,
-        "reason": "",
-        "avg_volume": 0.0,
-        "data_days": 0,
-        "last_price": 0.0,
-        "checked_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-    try:
-        df = yf.download(symbol, period="2y", progress=False, auto_adjust=True)
-        if df is None or df.empty:
-            result["reason"] = "no_data"
-            return result
-
-        # Newer yfinance (>=0.2.x) returns multi-level columns for single-ticker downloads.
-        # Flatten them so df["Volume"] / df["Close"] return plain Series.
-        if hasattr(df.columns, "nlevels") and df.columns.nlevels > 1:
-            df.columns = df.columns.get_level_values(0)
-
-        data_days = len(df)
-        result["data_days"] = data_days
-
-        if data_days < MIN_DATA_DAYS:
-            result["reason"] = f"insufficient_data ({data_days} < {MIN_DATA_DAYS} days)"
-            return result
-
-        try:
-            avg_vol = float(df["Volume"].mean()) if "Volume" in df.columns else 0.0
-        except (TypeError, ValueError):
-            avg_vol = 0.0
-        result["avg_volume"] = round(avg_vol, 0)
-
-        if avg_vol < MIN_AVG_VOLUME:
-            result["reason"] = f"low_volume ({avg_vol:,.0f} < {MIN_AVG_VOLUME:,.0f})"
-            return result
-
-        try:
-            last_price = float(df["Close"].iloc[-1])
-        except (TypeError, ValueError, IndexError):
-            last_price = 0.0
-        result["last_price"] = round(last_price, 2)
-
-        if last_price < MIN_PRICE:
-            result["reason"] = f"low_price (price={last_price:.2f} < {MIN_PRICE})"
-            return result
 
-        result["passed"] = True
-        result["reason"] = "OK"
-        return result
-
-    except Exception as e:
-        result["reason"] = f"error: {e}"
-        return result
-
-
-# ---------------------------------------------------------------------------
-# Stage 2: ML Backtest Eligibility
-# ---------------------------------------------------------------------------
-def stage2_backtest(symbol: str) -> Dict[str, Any]:
-    """Full walk-forward backtest to evaluate ML eligibility for US stock."""
-    from analysis.walk_forward_backtest import walk_forward_backtest
-
-    result: Dict[str, Any] = {
-        "symbol": symbol,
-        "eligible": False,
-        "reason": "",
-        "evaluated_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-    try:
-        _, m = walk_forward_backtest(
-            symbol=symbol,
-            start_date=BACKTEST_START,
-            end_date=BACKTEST_END,
-            market_id="us",
-            days_ahead=DAYS_AHEAD,
-            train_window=TRAIN_WINDOW,
-            model_type="rf",
-            use_technical_gate=True,
-            initial_capital=100_000.0,
-            commission_bps=5.0,    # Lower US commission
-            slippage_bps=5.0,
-            exit_rule="signal_or_fixed",
-            max_hold_days=DAYS_AHEAD,
-            stop_loss_pct=0.05,
-            take_profit_pct=0.10,
-            trailing_stop_pct=0.07,
-            max_position_pct=0.50,
-            max_risk_per_trade_pct=0.02,
-        )
-
-        dir_acc = m["direction_accuracy"]
-        sharpe = m["sharpe"]
-        hit_rate = m.get("hit_rate_pct", 0.0)
-        total_ret = m["total_return_pct"]
-        trades = m["trades_count"]
-        max_dd = m.get("max_drawdown_pct", 0.0)
-
-        result.update({
-            "dir_acc": round(dir_acc, 4),
-            "sharpe": round(sharpe, 3),
-            "hit_rate": round(hit_rate, 1),
-            "total_return_pct": round(total_ret, 1),
-            "trades": trades,
-            "max_drawdown_pct": round(max_dd, 1),
-        })
-
-        reasons: List[str] = []
-        if dir_acc < MIN_DIR_ACC:
-            reasons.append(f"dir_acc={dir_acc:.1%}<{MIN_DIR_ACC:.0%}")
-        if sharpe < MIN_SHARPE:
-            reasons.append(f"sharpe={sharpe:.3f}<{MIN_SHARPE}")
-        if hit_rate < MIN_HIT_RATE:
-            reasons.append(f"hit_rate={hit_rate:.1f}%<{MIN_HIT_RATE}%")
-        if trades < MIN_TRADES:
-            reasons.append(f"trades={trades}<{MIN_TRADES}")
-
-        result["eligible"] = len(reasons) == 0
-        result["reason"] = "; ".join(reasons) if reasons else "OK"
-        return result
-
-    except Exception as e:
-        result["reason"] = f"backtest_error: {e}"
-        logger.warning("Stage 2 failed for %s: %s", symbol, e)
-        return result
-
-
-# ---------------------------------------------------------------------------
-# Main scan orchestrator
-# ---------------------------------------------------------------------------
-def run_scan(
-    universe: str = "sp100",
-    force: bool = False,
-    stage1_only: bool = False,
-) -> Dict[str, Any]:
-    """Run the 2-stage US scan on the given universe.
-
-    This function is called from app.py background scheduler and the scan action endpoint.
-    """
-    symbols = get_universe(universe)
-    if not symbols:
-        logger.error("No symbols found for universe: %s", universe)
-        return {}
-
-    data = _load_results()
-
-    is_same_universe = data.get("universe") == universe
-    if not is_same_universe or force:
-        logger.info("Starting fresh US scan for %s (%d stocks)", universe, len(symbols))
-        data = {
-            "scan_started": datetime.now(timezone.utc).isoformat(),
-            "universe": universe,
-            "market_id": "us",
-            "total_stocks": len(symbols),
-            "stage1": {},
-            "stage2": {},
-            "completed": False,
-        }
-        _save_results(data)
-    else:
-        s1_done = len(data.get("stage1", {}))
-        s2_done = len(data.get("stage2", {}))
-        logger.info(
-            "Resuming US scan: %d/%d Stage1, %d Stage2 done",
-            s1_done, len(symbols), s2_done,
-        )
-
-    # ===== STAGE 1: Liquidity Pre-Filter =====
-    logger.info("=" * 60)
-    logger.info("STAGE 1: US Liquidity & Data Quality Pre-Filter")
-    logger.info("=" * 60)
-
-    s1_todo = [s for s in symbols if s not in data.get("stage1", {})]
-    total_s1 = len(symbols)
-    done_s1 = total_s1 - len(s1_todo)
-
-    for i, sym in enumerate(s1_todo, start=done_s1 + 1):
-        t0 = time.time()
-        result = stage1_prefilter(sym)
-        elapsed = time.time() - t0
-        status = "PASS" if result["passed"] else f"FAIL ({result['reason']})"
-        logger.info("[Stage1 %d/%d] %s: %s (%.1fs)", i, total_s1, sym, status, elapsed)
-        data.setdefault("stage1", {})[sym] = result
-        _save_results(data)
-        gc.collect()
-
-    s1_passed = [s for s, v in data["stage1"].items() if v.get("passed")]
-    s1_failed = [s for s, v in data["stage1"].items() if not v.get("passed")]
-    logger.info("")
-    logger.info(
-        "Stage 1 Results: %d PASS / %d FAIL out of %d",
-        len(s1_passed), len(s1_failed), total_s1,
-    )
-    logger.info("Passed: %s", ", ".join(sorted(s1_passed)))
-    logger.info("")
-
-    if stage1_only:
-        data["completed"] = True
-        _save_results(data)
-        _publish_final_if_complete(data)
-        return data
-
-    # ===== STAGE 2: ML Backtest =====
-    logger.info("=" * 60)
-    logger.info("STAGE 2: US ML Walk-Forward Backtest")
-    logger.info("=" * 60)
-
-    s2_todo = [s for s in s1_passed if s not in data.get("stage2", {})]
-    total_s2 = len(s1_passed)
-    done_s2 = total_s2 - len(s2_todo)
-    times_s2: List[float] = []
-
-    for i, sym in enumerate(s2_todo, start=done_s2 + 1):
-        t0 = time.time()
-        result = stage2_backtest(sym)
-        elapsed = time.time() - t0
-        times_s2.append(elapsed)
-
-        if result["eligible"]:
-            status = (
-                f"ELIGIBLE (ret={result.get('total_return_pct', 0):.1f}%, "
-                f"sharpe={result.get('sharpe', 0):.3f}, "
-                f"hit={result.get('hit_rate', 0):.0f}%)"
-            )
-        else:
-            status = f"EXCLUDED ({result['reason']})"
-
-        avg_time = sum(times_s2) / len(times_s2)
-        remaining = total_s2 - i
-        eta_min = (remaining * avg_time) / 60
-
-        logger.info(
-            "[Stage2 %d/%d] %s: %s (%.1fs, ETA: %.0f min)",
-            i, total_s2, sym, status, elapsed, eta_min,
-        )
-
-        data.setdefault("stage2", {})[sym] = result
-        _save_results(data)
-        gc.collect()
+def main() -> int:
+    parser = argparse.ArgumentParser(description="US equities batch scanner")
+    parser.add_argument("--universe", default="sp100", choices=sorted(CONFIGS))
+    parser.add_argument("--symbols", nargs="*", help="Run scan for an explicit symbol subset")
+    parser.add_argument("--max-symbols", type=int, help="Limit fetched universe to the first N symbols")
+    parser.add_argument("--resume", action="store_true", help="Resume interrupted scan")
+    parser.add_argument("--report", action="store_true", help="Show latest report only")
+    parser.add_argument("--force", action="store_true", help="Force a fresh scan")
+    parser.add_argument("--stage1-only", action="store_true", help="Run only liquidity pre-filter")
+    args = parser.parse_args()
 
-    eligible = [s for s, v in data["stage2"].items() if v.get("eligible")]
-    excluded = [s for s, v in data["stage2"].items() if not v.get("eligible")]
-    logger.info("")
-    logger.info(
-        "Stage 2 Results: %d ELIGIBLE / %d EXCLUDED out of %d",
-        len(eligible), len(excluded), total_s2,
+    config = replace(
+        CONFIGS[args.universe],
+        symbols=[str(symbol).strip().upper() for symbol in (args.symbols or []) if str(symbol).strip()] or None,
+        max_symbols=args.max_symbols,
     )
-    logger.info("Eligible: %s", ", ".join(sorted(eligible)))
-
-    data["completed"] = True
-    data["scan_finished"] = datetime.now(timezone.utc).isoformat()
-    data["eligible_count"] = len(eligible)
-    data["eligible_symbols"] = sorted(eligible)
-    _save_results(data)
-    _publish_final_if_complete(data)
+    if args.report:
+        print_report(config, logger)
+        return 0
 
-    logger.info("US scan complete. Results saved to %s", FINAL_RESULTS_FILE)
-    return data
+    force = args.force or not args.resume
+    run_scan(config, logger, force=force, stage1_only=args.stage1_only)
+    return 0
 
 
 if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="US equities batch scanner")
-    parser.add_argument("--universe", default="sp100", choices=["sp100", "sp500", "nasdaq100"])
-    parser.add_argument("--force", action="store_true", help="Force fresh scan")
-    parser.add_argument("--stage1-only", action="store_true", help="Run only Stage 1")
-    args = parser.parse_args()
-    run_scan(universe=args.universe, force=args.force, stage1_only=args.stage1_only)
+    raise SystemExit(main())

huggingface-space/start.sh

@@ -1,95 +1,43 @@
 #!/bin/bash
 set -e
 
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-APP_ROOT="${APP_ROOT:-$SCRIPT_DIR}"
-PERSIST_ROOT="${PERSIST_ROOT:-/data}"
-PYTHON_BIN="${PYTHON_BIN:-python3}"
-
-cd "$APP_ROOT"
-
 echo "[start.sh] Başlatılıyor..."
 
-# ─── Persistent storage: /data HF Space restart'larında korunur ───
-# HF Docker Spaces /data dizinini kalıcı volume olarak sunar.
-# paper_trading/ ve logs/ buraya symlink'lenir — container rebuild'de veri kaybolmaz.
-if mkdir -p "$PERSIST_ROOT/paper_trading/auto_trader" \
-            "$PERSIST_ROOT/paper_trading/markets/us/auto_trader" \
-            "$PERSIST_ROOT/paper_trading/markets/us" \
-            "$PERSIST_ROOT/paper_trading/journal" \
-            "$PERSIST_ROOT/paper_trading/incidents" \
-            "$PERSIST_ROOT/logs"; then
-    if [ -d "$APP_ROOT/paper_trading" ] && [ ! -L "$APP_ROOT/paper_trading" ]; then
-        rm -rf "$APP_ROOT/paper_trading"
-    fi
-    if [ -d "$APP_ROOT/logs" ] && [ ! -L "$APP_ROOT/logs" ]; then
-        rm -rf "$APP_ROOT/logs"
-    fi
-    ln -snf "$PERSIST_ROOT/paper_trading" "$APP_ROOT/paper_trading"
-    ln -snf "$PERSIST_ROOT/logs" "$APP_ROOT/logs"
-    echo "[start.sh] Persistent storage aktif: $PERSIST_ROOT/paper_trading → $APP_ROOT/paper_trading"
-else
-    echo "[start.sh] UYARI: $PERSIST_ROOT yazılabilir değil, local klasörlerle devam ediliyor."
-    mkdir -p "$APP_ROOT/paper_trading/auto_trader" \
-             "$APP_ROOT/paper_trading/markets/us/auto_trader" \
-             "$APP_ROOT/paper_trading/markets/us" \
-             "$APP_ROOT/paper_trading/journal" \
-             "$APP_ROOT/paper_trading/incidents" \
-             "$APP_ROOT/logs"
-fi
+# Stale Python bytecode temizle (eski .pyc syntax hatalarını önler)
+find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+echo "[start.sh] __pycache__ temizlendi"
 
-# ─── Telegram DNS fix: HF Space api.telegram.org DNS'ini blokluyor ───
-# Cloudflare DoH (1.1.1.1) üzerinden IP çözüp /etc/hosts'a ekle
-echo "[start.sh] Telegram API DNS çözümleniyor..."
-TELEGRAM_IP=$($PYTHON_BIN -c "
-import urllib.request, json, ssl
-ctx = ssl.create_default_context()
-req = urllib.request.Request(
-    'https://1.1.1.1/dns-query?name=api.telegram.org&type=A',
-    headers={'Accept': 'application/dns-json'}
-)
-try:
-    resp = urllib.request.urlopen(req, timeout=10, context=ctx)
-    data = json.loads(resp.read())
-    for ans in data.get('Answer', []):
-        if ans.get('type') == 1:
-            print(ans['data'])
-            break
-except Exception as e:
-    print('')
-" 2>/dev/null)
-if [ -z "$TELEGRAM_IP" ]; then
-    TELEGRAM_IP="149.154.167.220"
-    echo "[start.sh] DoH failed — fallback IP kullanılıyor: $TELEGRAM_IP"
-fi
-if [ -w /etc/hosts ]; then
-    if ! grep -q "api.telegram.org" /etc/hosts; then
-        echo "$TELEGRAM_IP api.telegram.org" >> /etc/hosts
-    fi
-    echo "[start.sh] /etc/hosts'a eklendi: $TELEGRAM_IP api.telegram.org"
-else
-    echo "[start.sh] UYARI: /etc/hosts yazılamıyor, DNS fix atlandı."
-fi
+# Gerekli dizinleri oluştur
+mkdir -p paper_trading/auto_trader paper_trading/journal paper_trading/incidents logs
+mkdir -p paper_trading_us/auto_trader paper_trading_us/journal paper_trading_us/incidents
 
-# NOT: Boot scan start.sh'den kaldırıldı — app.py scheduler yönetiyor (çift scan çakışması önlendi)
+# Boot scan ownership tek yerde olmalı.
+# app.py içindeki scheduler eksik/stale sonuçta tek bir boot scan başlatır.
+echo "[start.sh] Boot scan scheduler tarafından yönetilecek"
 
-# Trading workers — BIST + US crash olursa otomatik restart (daemon mode)
-start_worker_wrapper() {
-    local market="$1"
-    (
-        while true; do
-            echo "[worker-wrapper:${market}] Worker başlatılıyor..."
-            "$PYTHON_BIN" -m trading.worker --daemon --mode paper --market "$market" --interval 3600 2>&1 || true
-            echo "[worker-wrapper:${market}] Worker durdu, 30 saniye sonra restart..."
-            sleep 30
-        done
-    ) &
-    echo "[start.sh] ${market} worker wrapper PID=$!"
-}
+# Trading worker BIST — crash olursa otomatik restart (daemon mode)
+echo "[start.sh] BIST Trading worker başlatılıyor..."
+(
+    while true; do
+        echo "[worker-bist] Worker başlatılıyor..."
+        python -m trading.worker --daemon --mode paper --interval 3600 --market bist 2>&1 || true
+        echo "[worker-bist] Worker durdu, 30 saniye sonra restart..."
+        sleep 30
+    done
+) &
+echo "[start.sh] BIST worker wrapper PID=$!"
 
-echo "[start.sh] Trading workers başlatılıyor (bist + us)..."
-start_worker_wrapper bist
-start_worker_wrapper us
+# Trading worker US — crash olursa otomatik restart (daemon mode)
+echo "[start.sh] US Trading worker başlatılıyor..."
+(
+    while true; do
+        echo "[worker-us] Worker başlatılıyor..."
+        python -m trading.worker --daemon --mode paper --interval 3600 --market us 2>&1 || true
+        echo "[worker-us] Worker durdu, 30 saniye sonra restart..."
+        sleep 30
+    done
+) &
+echo "[start.sh] US worker wrapper PID=$!"
 
 # Telegram bot — token varsa başlat (7/24 çalışır, crash olursa restart)
 if [ -n "$TELEGRAM_BOT_TOKEN" ] && [ -n "$TELEGRAM_CHAT_ID" ]; then
@@ -97,7 +45,7 @@ if [ -n "$TELEGRAM_BOT_TOKEN" ] && [ -n "$TELEGRAM_CHAT_ID" ]; then
     (
         while true; do
             echo "[telegram-bot-wrapper] Bot başlatılıyor..."
-            "$PYTHON_BIN" telegram_bot.py 2>&1 || true
+            python telegram_bot.py 2>&1 || true
             echo "[telegram-bot-wrapper] Bot durdu, 5 saniye sonra restart..."
             sleep 5
         done
@@ -107,27 +55,6 @@ else
     echo "[start.sh] TELEGRAM_BOT_TOKEN/CHAT_ID eksik — bot atlandı."
 fi
 
-# ─── Keepalive: HF Space'in uykuya dalmasını önle ───
-# HF free tier, gelen HTTP trafiği olmazsa Space'i uyutur.
-# Bu loop kendi dış URL'sine ping atarak "aktif" tutar.
-(
-    sleep 180  # uvicorn'un ayağa kalkmasını bekle
-    SPACE_URL="${SPACE_HOST:-https://veteroner-borsa.hf.space}"
-    echo "[keepalive] Başlatıldı — her 5 dk $SPACE_URL ping"
-    while true; do
-        sleep 300
-        $PYTHON_BIN -c "
-import urllib.request
-try:
-    urllib.request.urlopen('${SPACE_URL}/', timeout=15)
-    print('[keepalive] ping OK')
-except Exception as e:
-    print(f'[keepalive] ping failed: {e}')
-" 2>&1 || true
-    done
-) &
-echo "[start.sh] Keepalive wrapper PID=$!"
-
 # uvicorn ön planda (HF Spaces 7860'ı izler)
 echo "[start.sh] uvicorn başlatılıyor (port 7860)..."
-exec "$PYTHON_BIN" -m uvicorn app:app --host 0.0.0.0 --port 7860
+exec uvicorn app:app --host 0.0.0.0 --port 7860

huggingface-space/sync_eligibility.py

@@ -1,33 +1,53 @@
 #!/usr/bin/env python3
 """Sync BIST100 scan results into stock_eligibility.json."""
+import argparse
 import json
 from datetime import datetime, timezone
+from pathlib import Path
 
-scan = json.loads(open('paper_trading/bist100_scan_results.json').read())
-s2 = scan.get('stage2', {})
-
-eligibility = {
-    'stocks': {},
-    'last_refresh': datetime.now(timezone.utc).isoformat(),
-    'source': 'bist100_scan',
-}
-
-for sym, v in s2.items():
-    eligibility['stocks'][sym] = {
-        'symbol': sym,
-        'eligible': v.get('eligible', False),
-        'dir_acc': v.get('dir_acc', 0),
-        'sharpe': v.get('sharpe', 0),
-        'hit_rate': v.get('hit_rate', 0),
-        'total_return_pct': v.get('total_return_pct', 0),
-        'trades': v.get('trades', 0),
-        'reason': v.get('reason', 'unknown'),
-        'evaluated_at': v.get('evaluated_at', ''),
+from trading.market_registry import DEFAULT_MARKET_ID, get_eligibility_path, get_scan_results_path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Sync scan results into eligibility cache")
+    parser.add_argument("--market", default=DEFAULT_MARKET_ID, choices=["bist", "us"])
+    parser.add_argument("--scan-file")
+    args = parser.parse_args()
+
+    scan_file = Path(args.scan_file) if args.scan_file else get_scan_results_path(args.market, completed=True)
+    scan = json.loads(scan_file.read_text())
+    s2 = scan.get('stage2', {})
+
+    eligibility = {
+        'market_id': args.market,
+        'stocks': {},
+        'last_refresh': datetime.now(timezone.utc).isoformat(),
+        'source': f'{args.market}_scan',
     }
 
-with open('paper_trading/stock_eligibility.json', 'w') as f:
-    json.dump(eligibility, f, indent=2, default=str)
+    for sym, v in s2.items():
+        eligibility['stocks'][sym] = {
+            'market_id': args.market,
+            'symbol': sym,
+            'eligible': v.get('eligible', False),
+            'dir_acc': v.get('dir_acc', 0),
+            'sharpe': v.get('sharpe', 0),
+            'hit_rate': v.get('hit_rate', 0),
+            'total_return_pct': v.get('total_return_pct', 0),
+            'trades': v.get('trades', 0),
+            'reason': v.get('reason', 'unknown'),
+            'evaluated_at': v.get('evaluated_at', ''),
+        }
+
+    out_file = get_eligibility_path(args.market)
+    out_file.parent.mkdir(parents=True, exist_ok=True)
+    out_file.write_text(json.dumps(eligibility, indent=2, default=str))
+
+    elig = [s for s, v in eligibility['stocks'].items() if v['eligible']]
+    print(f'Updated {out_file} with {len(eligibility["stocks"])} stocks')
+    print(f'Eligible: {len(elig)} - {sorted(elig)}')
+    return 0
+
 
-elig = [s for s, v in eligibility['stocks'].items() if v['eligible']]
-print(f'Updated stock_eligibility.json with {len(eligibility["stocks"])} stocks')
-print(f'Eligible: {len(elig)} - {sorted(elig)}')
+if __name__ == '__main__':
+    raise SystemExit(main())

huggingface-space/telegram_bot.py

@@ -1,52 +1,31 @@
-"""Borsanova Telegram Bot — Komut cevaplama + Proaktif bildirimler.
+"""Bağımsız Telegram Bot — Worker çalışmasa da yanıt verir.
 
-Hem komutlara cevap verir hem de worker tarafından çağrılarak
-otomatik bildirimler gönderir (alım, satım, tarama, sinyal, hata).
+Dosya ve DB'den okuyarak komutlara yanıt verir.
 
 Kullanım:
     python telegram_bot.py          # Foreground (test)
     python telegram_bot.py &        # Arka planda
 
-Komutlar:
-    /durum      — Sistem durumu (detaylı)
-    /portfoy    — Portföy + güncel fiyatlar
-    /hisseler   — Eligible hisse listesi (gerçek metrikler)
+Desteklenen komutlar:
+    /durum      — Sistem durumu
+    /portfoy    — Portföy özeti
+    /hisseler   — Eligible hisse listesi
     /sinyaller  — Bugünkü BUY/SELL sinyalleri
-    /hisse SYM  — Tek hisse detaylı analiz (canlı göstergeler)
-    /islemler   — Son işlemler (alım/satım geçmişi)
-    /tarama     — Tarama durumu ve ilerlemesi
     /yardim     — Komut listesi
-
-Proaktif bildirimler (worker tarafından çağrılır):
-    notify_scan_started()
-    notify_scan_complete(results)
-    notify_signals_generated(signals_summary)
-    notify_trade_executed(trade)
-    notify_cycle_complete(result)
-    notify_error(msg)
 """
 from __future__ import annotations
 
-# --- HF Space DNS fix: api.telegram.org DNS çözümü engellenmiş ---
-import socket as _socket
-_orig_getaddrinfo = _socket.getaddrinfo
-def _tg_dns_fix(host, port, family=0, type=0, proto=0, flags=0):
-    if host == "api.telegram.org":
-        return _orig_getaddrinfo("149.154.167.220", port, family, type, proto, flags)
-    return _orig_getaddrinfo(host, port, family, type, proto, flags)
-_socket.getaddrinfo = _tg_dns_fix
-
 import json
 import logging
 import os
+import socket as _socket
 import sys
 import time
-import traceback
+import urllib.parse
 import urllib.request
 import urllib.error
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional
 
 logging.basicConfig(
     level=logging.INFO,
@@ -58,6 +37,7 @@ BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "")
 CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "")
 
 if not BOT_TOKEN or not CHAT_ID:
+    # .env dosyasından oku
     env_file = Path(__file__).parent / ".env"
     if env_file.exists():
         for line in env_file.read_text().splitlines():
@@ -71,113 +51,130 @@ if not BOT_TOKEN:
     print("HATA: TELEGRAM_BOT_TOKEN bulunamadı. .env dosyasını kontrol edin.")
     sys.exit(1)
 
-# HF Spaces bazen api.telegram.org'a erişimi engelliyor → proxy üzerinden git
-# Proxy başarısız olursa doğrudan Telegram API'sine düşülür (fallback)
+# HF Spaces içinde api.telegram.org DNS çözümlemesi kararsız olabiliyor.
+# Doğrudan Telegram çağrılarında sabit IP fallback kullan.
+_orig_getaddrinfo = _socket.getaddrinfo
+
+
+def _tg_dns_fix(host, port, family=0, type=0, proto=0, flags=0):
+    if host == "api.telegram.org":
+        return _orig_getaddrinfo("149.154.167.220", port, family, type, proto, flags)
+    return _orig_getaddrinfo(host, port, family, type, proto, flags)
+
+
+_socket.getaddrinfo = _tg_dns_fix
+
+# HF Spaces api.telegram.org'a doğrudan erişimi engelliyor.
+# TELEGRAM_PROXY_URL ayarlıysa proxy dene; olmazsa direct API fallback var.
 _PROXY_URL = os.environ.get(
     "TELEGRAM_PROXY_URL",
-    "https://telegram-proxy-vercel-neon.vercel.app/tgproxy",
+    "https://borsanova.netlify.app/api/tgproxy",
 )
-_DIRECT_BASE = f"https://api.telegram.org/bot{BOT_TOKEN}"
 if _PROXY_URL:
-    API_BASE = f"{_PROXY_URL.rstrip('/')}/bot{BOT_TOKEN}"
-    logger.info("Telegram API proxy: %s", _PROXY_URL)
-else:
-    API_BASE = _DIRECT_BASE
-
-# Kaç kez üst üste proxy başarısız oldu?
-_proxy_fail_count = 0
-_proxy_disabled = False  # Proxy devre dışı bırakıldı mı?
+    _PROXY_URL = _PROXY_URL.strip()
+if _PROXY_URL in {"", "none", "null"}:
+    _PROXY_URL = ""
+if "telegram-proxy-vercel-neon.vercel.app" in (_PROXY_URL or ""):
+    logger.warning("Ignoring legacy dead TELEGRAM_PROXY_URL override: %s", _PROXY_URL)
+    _PROXY_URL = ""
+
+_DIRECT_API_BASE = f"https://api.telegram.org/bot{BOT_TOKEN}"
+_API_BASE_CANDIDATES = []
+if _PROXY_URL:
+    _API_BASE_CANDIDATES.append(f"{_PROXY_URL.rstrip('/')}/bot{BOT_TOKEN}")
+_API_BASE_CANDIDATES.append(_DIRECT_API_BASE)
+API_BASE = ""
+_NOPROXY_OPENER = urllib.request.build_opener(
+    urllib.request.ProxyHandler({}),
+    urllib.request.HTTPSHandler(),
+)
 
-# paper_trading dizini
+# paper_trading dizini huggingface-space'in bir üstünde olabilir
 _SCRIPT_DIR = Path(__file__).parent
-_PAPER_DIR = (
+_PAPER_DIR  = (
     _SCRIPT_DIR / "paper_trading"
     if (_SCRIPT_DIR / "paper_trading").exists()
     else _SCRIPT_DIR.parent / "paper_trading"
 )
 
 _STATUS_FILE = _PAPER_DIR / "auto_trader" / "status.json"
-_STATE_FILE = _PAPER_DIR / "auto_trader" / "state.json"
-_SCAN_FILE = _PAPER_DIR / "bist100_scan_results.json"
-_DB_PATH = _PAPER_DIR / "trading.db"
+_STATE_FILE  = _PAPER_DIR / "auto_trader" / "state.json"
+_SCAN_FILE   = _PAPER_DIR / "bist100_scan_results.json"
+_DB_PATH     = _PAPER_DIR / "trading.db"
+
+# US market paths
+_US_DIR = (
+    _SCRIPT_DIR / "paper_trading_us"
+    if (_SCRIPT_DIR / "paper_trading_us").exists()
+    else _SCRIPT_DIR.parent / "paper_trading_us"
+)
+_US_STATUS_FILE = _US_DIR / "auto_trader" / "status.json"
+_US_STATE_FILE  = _US_DIR / "auto_trader" / "state.json"
+_US_SCAN_FILE   = _US_DIR / "us_scan_results.json"
+_US_DB_PATH     = _US_DIR / "trading.db"
 
 
-# ═══════════════════════════════════════════════════════════════════════════
+# ---------------------------------------------------------------------------
 # Telegram API helpers
-# ═══════════════════════════════════════════════════════════════════════════
+# ---------------------------------------------------------------------------
 
-# No-proxy opener — HF Space HTTPS_PROXY'yi bypass eder
-_noproxy_opener = urllib.request.build_opener(
-    urllib.request.ProxyHandler({}),
-    urllib.request.HTTPSHandler(),
-)
+def _probe_api_base(base: str) -> bool:
+    try:
+        req = urllib.request.Request(f"{base}/getMe")
+        with _NOPROXY_OPENER.open(req, timeout=10) as resp:
+            payload = json.loads(resp.read().decode())
+        return bool(payload.get("ok"))
+    except Exception as e:
+        logger.warning("Telegram API base probe failed: %s (%s)", base, e)
+        return False
 
-def _api(method: str, payload: dict) -> dict:
-    """Telegram API çağrısı. Proxy başarısız olursa doğrudan API'ye düşer."""
-    global _proxy_fail_count, _proxy_disabled
-    data = json.dumps(payload).encode()
-    sock_timeout = 30 if "getUpdates" in method else 15
 
-    # Proxy aktifse ve devre dışı bırakılmadıysa önce proxy'yi dene
-    if _PROXY_URL and not _proxy_disabled:
-        proxy_url = f"{API_BASE}/{method}"
-        try:
-            req = urllib.request.Request(
-                proxy_url, data=data,
-                headers={"Content-Type": "application/json"},
-            )
-            with _noproxy_opener.open(req, timeout=sock_timeout) as resp:
-                result = json.loads(resp.read().decode())
-                # Proxy çalıştı — hata sayacını sıfırla
-                if _proxy_fail_count > 0:
-                    logger.info("Proxy tekrar aktif, hata sayacı sıfırlandı")
-                    _proxy_fail_count = 0
-                return result
-        except urllib.error.HTTPError as e:
-            if e.code in (402, 403, 503):
-                _proxy_fail_count += 1
-                logger.warning(
-                    "Proxy HTTP %d (%s) — doğrudan API'ye geçiliyor (hata #%d)",
-                    e.code, e.reason, _proxy_fail_count,
-                )
-                if _proxy_fail_count >= 3:
-                    _proxy_disabled = True
-                    logger.error(
-                        "Proxy %d kez başarısız — kalıcı olarak devre dışı bırakıldı. "
-                        "Vercel proxy'sini yeniden deploy edin: TELEGRAM_PROXY_URL env'i güncelleyin.",
-                        _proxy_fail_count,
-                    )
-            else:
-                logger.debug("Proxy HTTP %d — doğrudan API deneniyor", e.code)
-        except Exception as e:
-            logger.debug("Proxy hatası (%s) — doğrudan API deneniyor: %s", type(e).__name__, e)
+def _resolve_api_base(force: bool = False) -> str:
+    global API_BASE
+    if API_BASE and not force:
+        return API_BASE
+
+    for base in _API_BASE_CANDIDATES:
+        if _probe_api_base(base):
+            API_BASE = base
+            logger.info("Telegram API base selected: %s", base)
+            return API_BASE
+
+    raise RuntimeError("No reachable Telegram API base found")
 
-    # Doğrudan Telegram API (fallback veya proxy yoksa)
-    direct_url = f"{_DIRECT_BASE}/{method}"
+def _api(method: str, payload: dict) -> dict:
+    base = _resolve_api_base()
+    data = json.dumps(payload).encode()
     req = urllib.request.Request(
-        direct_url, data=data,
+        f"{base}/{method}",
+        data=data,
         headers={"Content-Type": "application/json"},
     )
-    with _noproxy_opener.open(req, timeout=sock_timeout) as resp:
-        return json.loads(resp.read().decode())
+    # getUpdates long-poll 20s bekleyebilir → urllib timeout daha yüksek olmalı
+    sock_timeout = 30 if "getUpdates" in method else 15
+    try:
+        with _NOPROXY_OPENER.open(req, timeout=sock_timeout) as resp:
+            return json.loads(resp.read().decode())
+    except Exception:
+        retry_base = _resolve_api_base(force=True)
+        retry_req = urllib.request.Request(
+            f"{retry_base}/{method}",
+            data=data,
+            headers={"Content-Type": "application/json"},
+        )
+        with _NOPROXY_OPENER.open(retry_req, timeout=sock_timeout) as resp:
+            return json.loads(resp.read().decode())
 
 
-def send(text: str, parse_mode: str = "HTML") -> bool:
-    """Tek mesaj gönder. Uzun mesajları otomatik böler."""
-    MAX_LEN = 4000  # Telegram limit 4096, güvenli margin
-    chunks = [text[i:i + MAX_LEN] for i in range(0, len(text), MAX_LEN)]
-    ok = True
-    for chunk in chunks:
-        try:
-            _api("sendMessage", {
-                "chat_id": CHAT_ID,
-                "text": chunk,
-                "parse_mode": parse_mode,
-            })
-        except Exception as e:
-            logger.error("Send failed: %s", e)
-            ok = False
-    return ok
+def send(text: str, parse_mode: str = "HTML") -> None:
+    try:
+        _api("sendMessage", {
+            "chat_id": CHAT_ID,
+            "text": text,
+            "parse_mode": parse_mode,
+        })
+    except Exception as e:
+        logger.error("Send failed: %s", e)
 
 
 def get_updates(offset: int) -> list:
@@ -189,16 +186,16 @@ def get_updates(offset: int) -> list:
         })
         return result.get("result", [])
     except urllib.error.URLError as e:
-        logger.debug("getUpdates URLError: %s", e)
+        logger.warning("getUpdates network error: %s", e)
         return []
     except Exception as e:
-        logger.debug("getUpdates error: %s", e)
+        logger.warning("getUpdates error: %s", e)
         return []
 
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Veri okuma yardımcıları
-# ═══════════════════════════════════════════════════════════════════════════
+# ---------------------------------------------------------------------------
+# Data readers
+# ---------------------------------------------------------------------------
 
 def _read_json(path: Path) -> dict:
     try:
@@ -209,150 +206,144 @@ def _read_json(path: Path) -> dict:
     return {}
 
 
-def _db_query(sql: str, params: tuple = ()) -> list:
-    """SQLite sorgusu çalıştır, dict listesi döndür."""
+def _db_get_signals(date: str, limit: int = 50) -> list:
     try:
         import sqlite3
         if not _DB_PATH.exists():
             return []
         conn = sqlite3.connect(str(_DB_PATH))
         conn.row_factory = sqlite3.Row
-        rows = conn.execute(sql, params).fetchall()
+        rows = conn.execute(
+            "SELECT * FROM signals_log WHERE date = ? ORDER BY confidence DESC LIMIT ?",
+            (date, limit),
+        ).fetchall()
         conn.close()
         return [dict(r) for r in rows]
-    except Exception as e:
-        logger.debug("DB query error: %s", e)
+    except Exception:
         return []
 
 
-def _db_get_signals(date: str, limit: int = 100) -> list:
-    return _db_query(
-        "SELECT * FROM signals_log WHERE date = ? ORDER BY confidence DESC LIMIT ?",
-        (date, limit),
-    )
+def _db_state_map() -> dict:
+    try:
+        import sqlite3
+        if not _DB_PATH.exists():
+            return {}
+        conn = sqlite3.connect(str(_DB_PATH))
+        rows = conn.execute("SELECT key, value FROM state").fetchall()
+        conn.close()
+        parsed = {}
+        for key, value in rows:
+            try:
+                parsed[key] = json.loads(value)
+            except Exception:
+                parsed[key] = value
+        return parsed
+    except Exception:
+        return {}
 
 
-def _db_get_recent_trades(limit: int = 20) -> list:
-    return _db_query(
-        "SELECT * FROM trades ORDER BY id DESC LIMIT ?",
-        (limit,),
-    )
+def _api_get_json(url: str) -> dict:
+    try:
+        req = urllib.request.Request(url, headers={"Accept": "application/json"})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode())
+    except Exception:
+        return {}
+
+
+def _load_best_scan_payload() -> dict:
+    candidates = []
+    for path in [_PAPER_DIR / "bist100_scan_results_work.json", _PAPER_DIR / "bist100_scan_results.json"]:
+        if not path.exists():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+            payload["_path"] = str(path)
+            candidates.append(payload)
+        except Exception:
+            continue
+    if not candidates:
+        return {}
+
+    def _ts(item: dict) -> str:
+        return str(item.get("updated_at") or item.get("scan_finished") or item.get("scan_started") or "")
+
+    candidates.sort(key=_ts, reverse=True)
+    return candidates[0]
 
 
 def _db_get_portfolio() -> dict:
+    """Önce state.json, yoksa sqlite state tablosundan portföy bilgisi."""
     state = _read_json(_STATE_FILE)
+    if not state:
+        state = _db_state_map()
     return {
-        "cash": state.get("broker_cash", 0),
+        "cash": state.get("broker_cash", 100_000),
         "positions": state.get("broker_positions", {}),
     }
 
 
 def _is_worker_running() -> bool:
-    pid_file = Path("paper_trading/auto_trader/worker.pid")
+    pid_file = _PAPER_DIR / "auto_trader" / "worker.pid"
     if not pid_file.exists():
         return False
     try:
         pid = int(pid_file.read_text().strip())
-        os.kill(pid, 0)
+        import os as _os
+        _os.kill(pid, 0)
         return True
     except Exception:
         return False
 
 
-def _get_live_price(symbol: str) -> Optional[float]:
-    """yfinance ile güncel fiyat çek."""
-    try:
-        from data.stock_data_api import get_stock_data_for_api
-        ticker = symbol if symbol.endswith(".IS") else f"{symbol}.IS"
-        df = get_stock_data_for_api(ticker, period="5d", interval="1d")
-        if df is not None and not df.empty:
-            return float(df["Close"].iloc[-1])
-    except Exception:
-        pass
-    return None
-
-
-def _get_live_indicators(symbol: str) -> Optional[Dict[str, Any]]:
-    """Tek hisse için canlı analiz çalıştır."""
-    try:
-        from data.stock_data_api import get_stock_data_for_api
-        from analysis.scan_signals_api import compute_scan_signals_for_df
-
-        ticker = symbol if symbol.endswith(".IS") else f"{symbol}.IS"
-        df = get_stock_data_for_api(ticker, period="1y", interval="1d")
-        if df is None or df.empty:
-            return None
-        result = compute_scan_signals_for_df(symbol.replace(".IS", ""), df)
-        return result.to_dict()
-    except Exception as e:
-        logger.debug("Live indicator error for %s: %s", symbol, e)
-        return None
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Komut işleyicileri
-# ═══════════════════════════════════════════════════════════════════════════
+# ---------------------------------------------------------------------------
+# Command handlers
+# ---------------------------------------------------------------------------
 
 def cmd_durum() -> str:
     status = _read_json(_STATUS_FILE)
-    state = _read_json(_STATE_FILE)
+    state  = _read_json(_STATE_FILE)
+    if not state:
+        state = _db_state_map()
 
     worker_running = _is_worker_running()
     is_running = status.get("is_running", False)
-    mode = status.get("mode", state.get("mode", "?"))
+    mode = status.get("mode") or state.get("mode") or status.get("market_id") or "bist"
     last_run = state.get("last_run_date", "—")
     total_trades = state.get("total_trades", 0)
     total_days = state.get("total_days_run", 0)
-    phase = status.get("current_phase", "—")
-    cash = state.get("broker_cash", 0)
-    updated = status.get("updated_at", "—")
-    if isinstance(updated, str) and len(updated) > 16:
-        updated = updated[:16].replace("T", " ")
-
-    # Kill switch
-    ks_icon = "✅ Kapalı"
+    phase = status.get("current_phase") or status.get("status", "—")
+    cash = state.get("broker_cash", 100_000)
+
+    ks_icon = "✅"
     ks_file = _PAPER_DIR / "kill_switch.json"
-    if not ks_file.exists():
-        ks_file = Path("paper_trading/kill_switch.json")
     if ks_file.exists():
         try:
             ks = json.loads(ks_file.read_text())
             if ks.get("active"):
-                ks_icon = f"🔴 AKTİF — {ks.get('reason', '?')[:50]}"
+                ks_icon = f"🔴 AKTİF — {ks.get('reason','?')[:50]}"
         except Exception:
             pass
 
-    # Scan info
-    scan = _read_json(_SCAN_FILE)
-    scan_status = "✅ Tamamlandı" if scan.get("completed") else "🔄 Devam ediyor" if scan else "❌ Yok"
-    scan_date = scan.get("scan_date", "—")[:10] if scan else "—"
-
-    # Positions
-    positions = state.get("broker_positions", {})
-    pos_count = len(positions)
-
-    # Last result
-    last_result = status.get("last_result", {})
-    last_status = last_result.get("status", "—")
-    last_trades = last_result.get("trades_executed", 0)
-
     now_str = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    return (
-        f"📊 <b>Sistem Durumu</b> [{now_str}]\n\n"
-        f"🤖 Worker: {'🟢 Çalışıyor' if worker_running else '🔴 Durdu'}\n"
-        f"⚡ Aktif Döngü: {'✅ Evet' if is_running else '❌ Hayır'}\n"
-        f"📌 Mod: <code>{mode}</code>\n"
-        f"🛑 Kill Switch: {ks_icon}\n"
-        f"📅 Son Çalışma: <code>{last_run}</code>\n"
-        f"🔄 Faz: <code>{phase}</code>\n"
-        f"🕐 Güncelleme: <code>{updated}</code>\n\n"
-        f"💰 Nakit: <code>{cash:,.0f} TL</code>\n"
-        f"📦 Açık Pozisyon: <code>{pos_count}</code>\n"
-        f"📈 Toplam İşlem: <code>{total_trades}</code>\n"
-        f"📅 Çalışılan Gün: <code>{total_days}</code>\n\n"
-        f"🔍 Tarama: {scan_status} [{scan_date}]\n"
-        f"📋 Son Döngü: <code>{last_status}</code> ({last_trades} işlem)"
-    )
+    lines = [
+        f"📊 <b>Sistem Durumu</b> [{now_str}]",
+        "",
+        f"Worker: {'🟢 Çalışıyor' if worker_running else '🔴 Durdu'}",
+        f"Aktif Döngü: {'✅ Evet' if is_running else '—'}",
+        f"Mod: <code>{mode}</code>",
+        f"Kill Switch: {ks_icon}",
+        f"Son Çalışma: <code>{last_run}</code>",
+        f"Faz: <code>{phase}</code>",
+        "",
+    ]
+    if isinstance(cash, (int, float)):
+        lines.append(f"💰 Nakit: <code>{cash:,.0f} TL</code>")
+    else:
+        lines.append("💰 Nakit: <code>bilinmiyor</code>")
+    lines.append(f"📈 Toplam İşlem: <code>{total_trades}</code>")
+    lines.append(f"📅 Çalışılan Gün: <code>{total_days}</code>")
+    return "\n".join(lines)
 
 
 def cmd_portfoy() -> str:
@@ -368,102 +359,96 @@ def cmd_portfoy() -> str:
         )
 
     lines = [f"💼 <b>Portföy</b> ({len(positions)} pozisyon)\n"]
-    total_value = 0.0
-    for sym, pos in list(positions.items())[:20]:
-        qty = pos.get("qty", 0)
+    total_notional = 0.0
+    for sym, pos in list(positions.items())[:15]:
+        qty  = pos.get("qty", 0)
         cost = pos.get("avg_cost", 0)
-        entry_date = str(pos.get("entry_date", "?"))[:10]
-
-        # Güncel fiyat çek
-        live_px = _get_live_price(sym)
-        if live_px:
-            pnl_pct = (live_px / cost - 1) * 100 if cost else 0
-            notional = qty * live_px
-            pnl_emoji = "📈" if pnl_pct >= 0 else "📉"
-            lines.append(
-                f"• <code>{sym}</code>  {qty} adet\n"
-                f"  Maliyet: {cost:.2f}  Güncel: {live_px:.2f}\n"
-                f"  {pnl_emoji} P&L: <b>{pnl_pct:+.1f}%</b>  Değer: {notional:,.0f} TL\n"
-                f"  Giriş: {entry_date}"
-            )
-        else:
-            notional = qty * cost
-            lines.append(
-                f"• <code>{sym}</code>  {qty} adet @ {cost:.2f} TL"
-                f"  ({notional:,.0f} TL) Giriş: {entry_date}"
-            )
-        total_value += notional if live_px else qty * cost
+        notional = qty * cost
+        total_notional += notional
+        lines.append(f"• <code>{sym}</code>  {qty} adet @ {cost:.2f} TL  ({notional:,.0f} TL)")
 
-    if len(positions) > 20:
-        lines.append(f"\n  ... ve {len(positions) - 20} pozisyon daha")
+    if len(positions) > 15:
+        lines.append(f"  ... ve {len(positions) - 15} pozisyon daha")
 
-    equity = cash + total_value
+    equity = cash + total_notional
     lines.append(f"\n💰 Nakit: <code>{cash:,.0f} TL</code>")
     lines.append(f"📊 Toplam Değer: <code>{equity:,.0f} TL</code>")
     return "\n".join(lines)
 
 
 def cmd_hisseler() -> str:
-    """Eligible hisseler — gerçek stage2 metrikleri ile."""
-    if not _SCAN_FILE.exists():
-        return "❌ Tarama sonuçları bulunamadı. Scanner henüz çalışmamış."
-
-    try:
-        scan = json.loads(_SCAN_FILE.read_text())
-    except Exception as e:
-        return f"❌ Tarama dosyası okunamadı: {e}"
-
-    stage2 = scan.get("stage2", {})
-    eligible = sorted(
-        [(sym, v) for sym, v in stage2.items() if v.get("eligible")],
-        key=lambda x: x[1].get("dir_acc", 0),
-        reverse=True,
-    )
-    scan_date = scan.get("scan_date", "?")[:10]
-    completed = scan.get("completed", False)
-    status_icon = "✅" if completed else "🔄 Devam ediyor"
+    data = _api_get_json("http://localhost:7860/api/eligible?market=bist")
+    if not data:
+        scan = _load_best_scan_payload()
+        if not scan:
+            return "❌ Eligible API yanıt vermiyor ve scan dosyası bulunamadı."
+
+        stage2 = scan.get("stage2", {}) or {}
+        eligible_pairs = [(sym, info) for sym, info in stage2.items() if isinstance(info, dict) and info.get("eligible")]
+        stage1 = scan.get("stage1", {}) or {}
+        stage1_done = len(stage1) if isinstance(stage1, dict) else 0
+        stage1_passed = sum(1 for v in stage1.values() if isinstance(v, dict) and v.get("passed")) if isinstance(stage1, dict) else 0
+        updated_at = str(scan.get("updated_at") or scan.get("scan_started") or "?")[:16]
+
+        if not eligible_pairs:
+            return (
+                "🔄 <b>BIST Tarama durumu</b>\n\n"
+                f"Stage 1: {stage1_passed}/{stage1_done or '?'} gecti\n"
+                f"Stage 2: {len(stage2)} tamamlandi\n"
+                f"Güncelleme: <code>{updated_at} UTC</code>"
+            )
 
-    # Stage2 toplam istatistik
-    total_scanned = len(stage2)
+        lines = [
+            f"📋 <b>Eligible Hisseler</b> [{updated_at}]",
+            f"Toplam: <b>{len(eligible_pairs)}</b> hisse",
+            "",
+        ]
+        for sym, item in eligible_pairs[:20]:
+            sharpe = float(item.get("sharpe", 0) or 0)
+            hit_rate = float(item.get("hit_rate", 0) or 0)
+            total_return = float(item.get("total_return_pct", 0) or 0)
+            lines.append(f"• <code>{sym:<8}</code> Sharpe:{sharpe:>5.2f}  Hit:%{hit_rate:>4.0f}  Ret:{total_return:>+5.1f}%")
+        return "\n".join(lines)
+
+    scan_running = bool(data.get("scanRunning"))
+    progress = data.get("scanProgress", "")
+    updated_at = str(data.get("updatedAt") or data.get("timestamp") or "?")[:16]
+    eligible = data.get("eligible", []) or []
+
+    if scan_running and not eligible:
+        return (
+            "🔄 <b>BIST Tarama devam ediyor</b>\n\n"
+            f"{progress}\n"
+            f"Güncelleme: <code>{updated_at} UTC</code>"
+        )
 
     if not eligible:
         return (
-            f"📋 <b>Eligible Hisseler</b> [{scan_date}] {status_icon}\n"
-            f"Stage2 taranan: {total_scanned}\n\n"
-            "Uygun hisse bulunamadı."
+            "📋 <b>Eligible Hisseler</b>\n\n"
+            "Uygun hisse bulunamadı.\n"
+            f"Durum: <code>{progress or 'hazır değil'}</code>"
         )
 
     lines = [
-        f"📋 <b>Eligible Hisseler</b> [{scan_date}] {status_icon}\n"
-        f"Toplam: <b>{len(eligible)}</b> / {total_scanned} hisse\n"
+        f"📋 <b>Eligible Hisseler</b> [{updated_at}]\n"
+        f"Toplam: <b>{len(eligible)}</b> hisse\n"
     ]
-    for sym, v in eligible[:25]:
-        dir_acc = v.get("dir_acc", 0)
-        sharpe = v.get("sharpe", 0)
-        hit = v.get("hit_rate", 0)
-        ret = v.get("total_return_pct", 0)
-        trades = v.get("trades", 0)
-        mdd = v.get("max_drawdown_pct", 0)
-
-        ret_emoji = "📈" if ret >= 0 else "📉"
+    for item in eligible[:20]:
+        sym = item.get("symbol", "?")
+        sharpe = float(item.get("sharpe", 0) or 0)
+        hit_rate = float(item.get("hit_rate", 0) or 0) * 100
+        annual_return = float(item.get("annual_return", 0) or 0) * 100
         lines.append(
-            f"\n• <b>{sym}</b>\n"
-            f"  🎯 Doğruluk: <code>{dir_acc:.1%}</code>  "
-            f"📊 Sharpe: <code>{sharpe:.2f}</code>\n"
-            f"  🏹 İsabet: <code>{hit:.0f}%</code>  "
-            f"🔄 İşlem: <code>{trades}</code>\n"
-            f"  {ret_emoji} Getiri: <code>{ret:+.1f}%</code>  "
-            f"📉 MDD: <code>{mdd:.1f}%</code>"
+            f"• <code>{sym:<8}</code> Sharpe:{sharpe:>5.2f}  Hit:%{hit_rate:>4.0f}  Ret:{annual_return:>+5.1f}%"
         )
 
-    if len(eligible) > 25:
-        lines.append(f"\n  ... ve {len(eligible) - 25} hisse daha")
+    if scan_running:
+        lines.append(f"\n🔄 {progress}")
 
     return "\n".join(lines)
 
 
 def cmd_sinyaller() -> str:
-    """Bugünkü sinyaller — signals_log tablosundan."""
     today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
     signals = _db_get_signals(today)
 
@@ -471,514 +456,400 @@ def cmd_sinyaller() -> str:
         return (
             f"📡 <b>Bugünkü Sinyaller</b> [{today}]\n\n"
             "Henüz sinyal üretilmedi.\n"
-            "Sinyaller işlem günlerinde ~10:30'da üretilir."
+            "Sinyaller sabah 10:30'da üretilir."
         )
 
-    buys = [s for s in signals if s.get("signal") == "BUY"]
+    buys  = [s for s in signals if s.get("signal") == "BUY"]
     sells = [s for s in signals if s.get("signal") == "SELL"]
     holds = [s for s in signals if s.get("signal") == "HOLD"]
 
     lines = [
         f"📡 <b>Sinyaller</b> [{today}]\n"
-        f"🟢 BUY: {len(buys)}  🔴 SELL: {len(sells)}  ⚪ HOLD: {len(holds)}\n"
+        f"🟢 BUY:{len(buys)}  🔴 SELL:{len(sells)}  ⚪ HOLD:{len(holds)}\n"
     ]
 
     if buys:
         lines.append("🟢 <b>BUY Sinyalleri:</b>")
-        for s in buys[:15]:
-            conf = float(s.get("confidence", 0))
+        for s in buys[:10]:
+            conf = float(s.get("confidence", 0)) * 100
             pred = float(s.get("predicted_return", 0))
-            ml_sig = s.get("ml_signal", "?")
-            tech_sig = s.get("tech_signal", "?")
-            action = s.get("action_taken", "?")
             lines.append(
                 f"  <code>{s['symbol']:<8}</code> "
-                f"Güven: <b>{conf:.0f}%</b>  Tahmin: {pred:+.1f}%\n"
-                f"    ML: {ml_sig}  Teknik: {tech_sig}  Aksiyon: {action}"
+                f"Güven:%{conf:>4.0f}  Tahmin:{pred:>+5.1f}%"
             )
 
     if sells:
         lines.append("\n🔴 <b>SELL Sinyalleri:</b>")
-        for s in sells[:10]:
-            conf = float(s.get("confidence", 0))
-            ml_sig = s.get("ml_signal", "?")
-            tech_sig = s.get("tech_signal", "?")
-            lines.append(
-                f"  <code>{s['symbol']:<8}</code> "
-                f"Güven: <b>{conf:.0f}%</b>  ML: {ml_sig}  Teknik: {tech_sig}"
-            )
+        for s in sells[:5]:
+            conf = float(s.get("confidence", 0)) * 100
+            lines.append(f"  <code>{s['symbol']:<8}</code> Güven:%{conf:>4.0f}")
 
     return "\n".join(lines)
 
 
-def cmd_hisse(symbol: str) -> str:
-    """Tek hisse detaylı analiz — canlı göstergeler."""
-    sym = symbol.upper().replace(".IS", "")
-    send(f"🔍 <code>{sym}</code> analiz ediliyor...")
+def cmd_yardim() -> str:
+    return (
+        "🤖 <b>Borsanova Komutları</b>\n\n"
+        "<b>BIST:</b>\n"
+        "/durum       — Sistem ve worker durumu\n"
+        "/portfoy     — Açık pozisyonlar\n"
+        "/hisseler    — Eligible hisse listesi (scanner)\n"
+        "/sinyaller   — Bugünkü BUY/SELL sinyalleri\n\n"
+        "<b>ABD Borsası:</b>\n"
+        "/us_durum    — US worker durumu\n"
+        "/us_portfoy  — US açık pozisyonlar\n"
+        "/us_hisseler — US eligible hisseler\n"
+        "/us_sinyaller — US sinyalleri\n\n"
+        "/yardim      — Bu mesaj\n\n"
+        "<i>Bu bot worker bağımsız çalışır.</i>"
+    )
 
-    data = _get_live_indicators(sym)
-    if not data:
-        return f"❌ <code>{sym}</code> için veri alınamadı."
 
-    price = data.get("current_price")
-    change = data.get("change_percent")
-    vol = data.get("volume")
-    sig = data.get("technical_signal", "?")
-    ind = data.get("indicators", {})
-    scores = data.get("scores", {})
-    gates = data.get("gates", {})
+# ---------------------------------------------------------------------------
+# US Market Commands
+# ---------------------------------------------------------------------------
 
-    change_emoji = "📈" if (change or 0) >= 0 else "📉"
-    sig_emoji = "🟢" if sig == "BUY" else "🔴" if sig == "SELL" else "⚪"
+def _us_db_get_signals(date: str, limit: int = 50) -> list:
+    try:
+        import sqlite3
+        if not _US_DB_PATH.exists():
+            return []
+        conn = sqlite3.connect(str(_US_DB_PATH))
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            "SELECT * FROM signals_log WHERE date = ? ORDER BY confidence DESC LIMIT ?",
+            (date, limit),
+        ).fetchall()
+        conn.close()
+        return [dict(r) for r in rows]
+    except Exception:
+        return []
 
-    lines = [
-        f"📊 <b>{sym} Detaylı Analiz</b>\n",
-        f"💰 Fiyat: <code>{price:.2f} TL</code>  "
-        f"{change_emoji} <code>{change:+.2f}%</code>" if price and change is not None else "",
-        f"📦 Hacim: <code>{vol:,.0f}</code>" if vol else "",
-        f"{sig_emoji} Teknik Sinyal: <b>{sig}</b>\n",
-    ]
 
-    # Göstergeler
-    rsi = ind.get("rsi")
-    macd_trend = ind.get("macd_trend")
-    bollinger_pos = ind.get("bollinger_position")
-    sma20 = ind.get("sma_20")
-    sma50 = ind.get("sma_50")
-    sma200 = ind.get("sma_200")
-    volatility = ind.get("annualized_volatility_pct")
-    vol_ratio = ind.get("volume_ratio_20d")
-
-    lines.append("📉 <b>Göstergeler:</b>")
-    if rsi is not None:
-        rsi_zone = "Aşırı Alım" if rsi > 70 else "Aşırı Satım" if rsi < 30 else "Normal"
-        lines.append(f"  RSI: <code>{rsi:.1f}</code> ({rsi_zone})")
-    if macd_trend:
-        lines.append(f"  MACD: <code>{macd_trend}</code>")
-    if bollinger_pos is not None:
-        lines.append(f"  Bollinger: <code>{bollinger_pos:.2f}</code>")
-    if sma20:
-        lines.append(f"  SMA20: <code>{sma20:.2f}</code>")
-    if sma50:
-        lines.append(f"  SMA50: <code>{sma50:.2f}</code>")
-    if sma200:
-        lines.append(f"  SMA200: <code>{sma200:.2f}</code>")
-    if volatility:
-        lines.append(f"  Volatilite: <code>{volatility:.1f}%</code>")
-    if vol_ratio:
-        lines.append(f"  Hacim Oranı (20g): <code>{vol_ratio:.2f}x</code>")
-
-    # Skorlar
-    lines.append("\n📊 <b>Skorlar (0-100):</b>")
-    score_names = {
-        "total": "Toplam", "trend": "Trend", "momentum": "Momentum",
-        "volume": "Hacim", "volatility": "Volatilite", "pattern": "Pattern",
-    }
-    for key, label in score_names.items():
-        val = scores.get(key)
-        if val is not None:
-            bar = "█" * int(val / 10) + "░" * (10 - int(val / 10))
-            lines.append(f"  {label}: <code>{bar} {val:.0f}</code>")
-
-    # Kapılar
-    lines.append("\n🚦 <b>Kapılar:</b>")
-    gate_names = {
-        "trend_ok": "Trend", "momentum_ok": "Momentum",
-        "volume_ok": "Hacim", "volatility_ok": "Volatilite",
-        "pattern_ok": "Pattern", "required_ok": "GENEL",
-    }
-    for key, label in gate_names.items():
-        val = gates.get(key)
-        if val is not None:
-            icon = "✅" if val else "❌"
-            lines.append(f"  {icon} {label}")
-
-    # Scan stage2 info if available
-    scan = _read_json(_SCAN_FILE)
-    stage2 = scan.get("stage2", {}).get(sym, {})
-    if stage2.get("eligible"):
-        lines.append(f"\n✅ <b>Stage2 Eligible</b>")
-        lines.append(f"  Doğruluk: {stage2.get('dir_acc', 0):.1%}")
-        lines.append(f"  Sharpe: {stage2.get('sharpe', 0):.2f}")
-        lines.append(f"  Getiri: {stage2.get('total_return_pct', 0):+.1f}%")
-
-    return "\n".join(l for l in lines if l)
-
-
-def cmd_islemler() -> str:
-    """Son işlemler."""
-    trades = _db_get_recent_trades(15)
-    if not trades:
-        return "📒 <b>Son İşlemler</b>\n\nHenüz işlem gerçekleşmedi."
-
-    lines = [f"📒 <b>Son İşlemler</b> ({len(trades)} kayıt)\n"]
-    for t in trades:
-        side = t.get("side", "?")
-        side_emoji = "🟢" if side == "BUY" else "🔴"
-        sym = t.get("symbol", "?")
-        qty = t.get("quantity", 0)
-        entry_px = t.get("entry_price", 0)
-        exit_px = t.get("exit_price")
-        pnl = t.get("pnl")
-        pnl_pct = t.get("pnl_pct")
-        status_t = t.get("status", "?")
-        entry_date = str(t.get("entry_date", ""))[:10]
-        exit_date = str(t.get("exit_date", ""))[:10] if t.get("exit_date") else ""
-        reason = t.get("exit_reason", "")
-
-        line = f"{side_emoji} <code>{sym}</code> {qty} adet @ {entry_px:.2f}"
-        if exit_px and pnl is not None:
-            pnl_emoji = "📈" if pnl >= 0 else "📉"
-            line += (
-                f"\n  Çıkış: {exit_px:.2f}  {pnl_emoji} P&L: <b>{pnl:+.2f} TL</b>"
-                f" ({pnl_pct:+.1f}%)" if pnl_pct else ""
-            )
-            if reason:
-                line += f"\n  Sebep: {reason}"
-            line += f"\n  {entry_date} → {exit_date}"
-        else:
-            line += f"\n  Durum: {status_t}  Tarih: {entry_date}"
-        lines.append(line)
+def _us_db_state_map() -> dict:
+    try:
+        import sqlite3
+        if not _US_DB_PATH.exists():
+            return {}
+        conn = sqlite3.connect(str(_US_DB_PATH))
+        rows = conn.execute("SELECT key, value FROM state").fetchall()
+        conn.close()
+        parsed = {}
+        for key, value in rows:
+            try:
+                parsed[key] = json.loads(value)
+            except Exception:
+                parsed[key] = value
+        return parsed
+    except Exception:
+        return {}
 
-    return "\n".join(lines)
 
+def _us_db_get_portfolio() -> dict:
+    state = _read_json(_US_STATE_FILE)
+    if not state:
+        state = _us_db_state_map()
+    return {
+        "cash": state.get("broker_cash", 100_000),
+        "positions": state.get("broker_positions", {}),
+    }
 
-def cmd_tarama() -> str:
-    """Tarama durumu ve detayları."""
-    if not _SCAN_FILE.exists():
-        return "🔍 <b>Tarama Durumu</b>\n\nTarama dosyası bulunamadı."
 
+def _us_is_worker_running() -> bool:
+    pid_file = _US_DIR / "auto_trader" / "worker.pid"
+    if not pid_file.exists():
+        return False
     try:
-        scan = json.loads(_SCAN_FILE.read_text())
-    except Exception as e:
-        return f"❌ Tarama dosyası okunamadı: {e}"
-
-    scan_date = scan.get("scan_date", "?")[:10]
-    completed = scan.get("completed", False)
-    started = scan.get("scan_started", "?")
-    finished = scan.get("scan_finished", "")
-    if isinstance(started, str) and len(started) > 16:
-        started = started[:16].replace("T", " ")
-    if isinstance(finished, str) and len(finished) > 16:
-        finished = finished[:16].replace("T", " ")
-
-    stage1 = scan.get("stage1", {})
-    stage2 = scan.get("stage2", {})
-
-    # Stage1 stats
-    s1_pass = sum(1 for v in stage1.values() if v.get("pass"))
-    s1_fail = sum(1 for v in stage1.values() if not v.get("pass"))
-    s1_total = len(stage1)
-
-    # Stage2 stats
-    s2_total = len(stage2)
-    s2_eligible = sum(1 for v in stage2.values() if v.get("eligible"))
-    s2_filtered = sum(1 for v in stage2.values() if not v.get("eligible"))
+        pid = int(pid_file.read_text().strip())
+        os.kill(pid, 0)
+        return True
+    except Exception:
+        return False
+
+
+def cmd_us_durum() -> str:
+    status = _read_json(_US_STATUS_FILE)
+    state = _read_json(_US_STATE_FILE)
+    if not state:
+        state = _us_db_state_map()
+
+    worker_running = _us_is_worker_running()
+    is_running = status.get("is_running", False)
+    last_run = state.get("last_run_date", "—")
+    total_trades = state.get("total_trades", 0)
+    total_days = state.get("total_days_run", 0)
+    phase = status.get("current_phase") or status.get("status", "—")
+    cash = state.get("broker_cash", 100_000)
 
+    now_str = datetime.now(timezone.utc).strftime("%H:%M UTC")
     lines = [
-        f"🔍 <b>Tarama Durumu</b> [{scan_date}]\n",
-        f"Durum: {'✅ Tamamlandı' if completed else '🔄 Devam ediyor'}",
-        f"Başlangıç: <code>{started}</code>",
+        f"🇺🇸 <b>US Sistem Durumu</b> [{now_str}]",
+        "",
+        f"Worker: {'🟢 Çalışıyor' if worker_running else '🔴 Durdu'}",
+        f"Aktif Döngü: {'✅ Evet' if is_running else '—'}",
+        f"Son Çalışma: <code>{last_run}</code>",
+        f"Faz: <code>{phase}</code>",
+        "",
+        f"💰 Nakit: <code>${cash:,.0f}</code>",
+        f"📈 Toplam İşlem: <code>{total_trades}</code>",
+        f"📅 Çalışılan Gün: <code>{total_days}</code>",
     ]
-    if finished:
-        lines.append(f"Bitiş: <code>{finished}</code>")
+    return "\n".join(lines)
 
-    lines.append(f"\n📊 <b>Stage 1</b> (Filtre):")
-    lines.append(f"  Toplam: {s1_total}  ✅ Geçen: {s1_pass}  ❌ Elenen: {s1_fail}")
 
-    lines.append(f"\n📊 <b>Stage 2</b> (Backtest):")
-    lines.append(f"  Taranan: {s2_total} / {s1_pass}")
-    lines.append(f"  ✅ Eligible: {s2_eligible}  ❌ Elenen: {s2_filtered}")
+def cmd_us_portfoy() -> str:
+    data = _us_db_get_portfolio()
+    cash = data["cash"]
+    positions = data["positions"]
 
-    if s2_eligible > 0:
-        lines.append(f"\n🏆 <b>Eligible Hisseler:</b>")
-        eligible_list = sorted(
-            [(s, v) for s, v in stage2.items() if v.get("eligible")],
-            key=lambda x: x[1].get("dir_acc", 0), reverse=True,
+    if not positions:
+        return (
+            f"🇺🇸 <b>US Portföy</b>\n\n"
+            f"Açık pozisyon yok.\n"
+            f"💰 Nakit: <code>${cash:,.0f}</code>"
         )
-        for sym, v in eligible_list[:10]:
-            lines.append(
-                f"  <code>{sym}</code> — "
-                f"Doğruluk: {v.get('dir_acc', 0):.0%}  "
-                f"Sharpe: {v.get('sharpe', 0):.2f}  "
-                f"Getiri: {v.get('total_return_pct', 0):+.1f}%"
-            )
 
-    return "\n".join(lines)
-
-
-def cmd_yardim() -> str:
-    return (
-        "🤖 <b>Borsanova Bot Komutları</b>\n\n"
-        "/durum          — Sistem durumu (detaylı)\n"
-        "/portfoy        — Portföy + güncel fiyatlar\n"
-        "/hisseler       — Eligible hisse listesi\n"
-        "/sinyaller      — Bugünkü BUY/SELL sinyalleri\n"
-        "/hisse THYAO    — Tek hisse detaylı analiz\n"
-        "/islemler       — Son alım/satım işlemleri\n"
-        "/tarama         — Tarama durumu ve ilerlemesi\n"
-        "/yardim         — Bu mesaj\n\n"
-        "📌 <i>Bot otomatik bildirim gönderir:</i>\n"
-        "  • Tarama başladığında/bittiğinde\n"
-        "  • Sinyal üretildiğinde\n"
-        "  • Alım/satım yapıldığında\n"
-        "  • Hata oluştuğunda"
-    )
+    lines = [f"🇺🇸 <b>US Portföy</b> ({len(positions)} pozisyon)\n"]
+    total_notional = 0.0
+    for sym, pos in list(positions.items())[:15]:
+        qty = pos.get("qty", 0)
+        cost = pos.get("avg_cost", 0)
+        notional = qty * cost
+        total_notional += notional
+        lines.append(f"• <code>{sym}</code>  {qty} adet @ ${cost:.2f}  (${notional:,.0f})")
 
+    if len(positions) > 15:
+        lines.append(f"  ... ve {len(positions) - 15} pozisyon daha")
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Proaktif bildirim fonksiyonları (worker tarafından çağrılır)
-# ═══════════════════════════════════════════════════════════════════════════
+    equity = cash + total_notional
+    lines.append(f"\n💰 Nakit: <code>${cash:,.0f}</code>")
+    lines.append(f"📊 Toplam Değer: <code>${equity:,.0f}</code>")
+    return "\n".join(lines)
 
-def notify_scan_started() -> None:
-    """Tarama başladığında bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    send(f"🔍 <b>BIST Tarama başladı</b> [{now}]\n\nStage1 + Stage2 çalışıyor...")
 
+def cmd_us_hisseler() -> str:
+    data = _api_get_json("http://localhost:7860/api/eligible?market=us")
+    if not data:
+        # Fallback: read scan file directly
+        if _US_SCAN_FILE.exists():
+            try:
+                scan = json.loads(_US_SCAN_FILE.read_text())
+                stage2 = scan.get("stage2", {}) or {}
+                eligible_pairs = [(sym, info) for sym, info in stage2.items()
+                                  if isinstance(info, dict) and info.get("eligible")]
+                updated_at = str(scan.get("updated_at") or scan.get("scan_finished") or "?")[:16]
+
+                if not eligible_pairs:
+                    return "🇺🇸 <b>US Eligible</b>\n\nHenüz eligible hisse yok."
+
+                lines = [
+                    f"🇺🇸 <b>US Eligible Hisseler</b> [{updated_at}]",
+                    f"Toplam: <b>{len(eligible_pairs)}</b> hisse\n",
+                ]
+                for sym, item in eligible_pairs[:20]:
+                    sharpe = float(item.get("sharpe", 0) or 0)
+                    hit_rate = float(item.get("hit_rate", 0) or 0)
+                    total_return = float(item.get("total_return_pct", 0) or 0)
+                    lines.append(f"• <code>{sym:<8}</code> Sharpe:{sharpe:>5.2f}  Hit:%{hit_rate:>4.0f}  Ret:{total_return:>+5.1f}%")
+                return "\n".join(lines)
+            except Exception:
+                pass
+        return "🇺🇸 <b>US Eligible</b>\n\nHenüz US taraması yapılmadı veya veri yok."
+
+    eligible = data.get("eligible", []) or []
+    updated_at = str(data.get("updatedAt") or data.get("timestamp") or "?")[:16]
 
-def notify_scan_complete(results: Dict[str, Any]) -> None:
-    """Tarama tamamlandığında bildirim."""
-    stage2 = results.get("stage2", {})
-    eligible = [(s, v) for s, v in stage2.items() if v.get("eligible")]
-    total = len(stage2)
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
+    if not eligible:
+        return "🇺🇸 <b>US Eligible</b>\n\nUygun hisse bulunamadı."
 
     lines = [
-        f"✅ <b>BIST Tarama tamamlandı</b> [{now}]\n",
-        f"Stage2 taranan: <b>{total}</b>",
-        f"Eligible: <b>{len(eligible)}</b> hisse\n",
+        f"🇺🇸 <b>US Eligible Hisseler</b> [{updated_at}]\n"
+        f"Toplam: <b>{len(eligible)}</b> hisse\n"
     ]
+    for item in eligible[:20]:
+        sym = item.get("symbol", "?")
+        sharpe = float(item.get("sharpe", 0) or 0)
+        hit_rate = float(item.get("hit_rate", 0) or 0) * 100
+        annual_return = float(item.get("annual_return", 0) or 0) * 100
+        lines.append(f"• <code>{sym:<8}</code> Sharpe:{sharpe:>5.2f}  Hit:%{hit_rate:>4.0f}  Ret:{annual_return:>+5.1f}%")
+    return "\n".join(lines)
 
-    if eligible:
-        eligible.sort(key=lambda x: x[1].get("dir_acc", 0), reverse=True)
-        for sym, v in eligible[:10]:
-            lines.append(
-                f"  ✅ <code>{sym}</code> — "
-                f"Doğruluk: {v.get('dir_acc', 0):.0%}  "
-                f"Sharpe: {v.get('sharpe', 0):.2f}  "
-                f"Getiri: {v.get('total_return_pct', 0):+.1f}%"
-            )
-    else:
-        lines.append("  ⚠️ Uygun hisse bulunamadı.")
 
-    send("\n".join(lines))
+def cmd_us_sinyaller() -> str:
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    signals = _us_db_get_signals(today)
 
+    if not signals:
+        return (
+            f"🇺🇸 <b>US Sinyaller</b> [{today}]\n\n"
+            "Henüz sinyal üretilmedi."
+        )
 
-def notify_signals_generated(
-    buy_count: int,
-    sell_count: int,
-    hold_count: int,
-    details: List[Dict[str, Any]],
-) -> None:
-    """Sinyal üretimi tamamlandığında bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    total = buy_count + sell_count + hold_count
+    buys = [s for s in signals if s.get("signal") == "BUY"]
+    sells = [s for s in signals if s.get("signal") == "SELL"]
+    holds = [s for s in signals if s.get("signal") == "HOLD"]
 
     lines = [
-        f"📡 <b>Sinyaller üretildi</b> [{now}]\n",
-        f"Toplam: <b>{total}</b> hisse",
-        f"🟢 BUY: {buy_count}  🔴 SELL: {sell_count}  ⚪ HOLD: {hold_count}\n",
+        f"🇺🇸 <b>US Sinyaller</b> [{today}]\n"
+        f"🟢 BUY:{len(buys)}  🔴 SELL:{len(sells)}  ⚪ HOLD:{len(holds)}\n"
     ]
 
-    buys = [d for d in details if d.get("signal") == "BUY"]
     if buys:
-        lines.append("🟢 <b>Alım sinyali:</b>")
-        for b in buys[:10]:
-            lines.append(
-                f"  <code>{b['symbol']:<8}</code> "
-                f"Güven: {b.get('confidence', 0):.0f}%  "
-                f"ML: {b.get('ml_signal', '?')}  "
-                f"Teknik: {b.get('tech_signal', '?')}"
-            )
-
-    send("\n".join(lines))
+        lines.append("🟢 <b>BUY Sinyalleri:</b>")
+        for s in buys[:10]:
+            conf = float(s.get("confidence", 0)) * 100
+            pred = float(s.get("predicted_return", 0))
+            lines.append(f"  <code>{s['symbol']:<8}</code> Güven:%{conf:>4.0f}  Tahmin:{pred:>+5.1f}%")
 
+    if sells:
+        lines.append("\n🔴 <b>SELL Sinyalleri:</b>")
+        for s in sells[:5]:
+            conf = float(s.get("confidence", 0)) * 100
+            lines.append(f"  <code>{s['symbol']:<8}</code> Güven:%{conf:>4.0f}")
 
-def notify_trade_executed(trade: Dict[str, Any]) -> None:
-    """Alım veya satım gerçekleştiğinde bildirim."""
-    side = trade.get("side", "?")
-    sym = trade.get("symbol", "?")
-    qty = trade.get("qty", 0)
-    price = trade.get("price", 0)
-    pnl = trade.get("pnl")
-    reason = trade.get("reason", "")
-    confidence = trade.get("confidence")
+    return "\n".join(lines)
 
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
 
-    if side == "BUY":
-        text = (
-            f"🟢 <b>ALIM GERÇEKLEŞTİ</b> [{now}]\n\n"
-            f"Hisse: <b>{sym}</b>\n"
-            f"Adet: <code>{qty}</code>\n"
-            f"Fiyat: <code>{price:.2f} TL</code>\n"
-            f"Tutar: <code>{qty * price:,.0f} TL</code>"
-        )
-        if confidence:
-            text += f"\nGüven: <code>{confidence:.0f}%</code>"
-    else:
-        text = (
-            f"🔴 <b>SATIM GERÇEKLEŞTİ</b> [{now}]\n\n"
-            f"Hisse: <b>{sym}</b>\n"
-            f"Adet: <code>{qty}</code>\n"
-            f"Fiyat: <code>{price:.2f} TL</code>"
-        )
-        if pnl is not None:
-            pnl_emoji = "📈" if pnl >= 0 else "📉"
-            text += f"\n{pnl_emoji} P&L: <b>{pnl:+.2f} TL</b>"
-        if reason:
-            reason_tr = {
-                "stop_loss": "🛑 Stop Loss",
-                "take_profit": "🎯 Take Profit",
-                "ml_sell_signal": "🤖 ML Satış Sinyali",
-                "holding_period_expiry": "⏰ Süre Dolumu",
-            }.get(reason, reason)
-            text += f"\nSebep: {reason_tr}"
-
-    send(text)
-
-
-def notify_cycle_complete(result: Dict[str, Any]) -> None:
-    """İşlem döngüsü tamamlandığında bildirim."""
-    trades = result.get("trades_executed", 0)
-    pnl = result.get("realized_pnl_today", 0)
-    portfolio = result.get("portfolio", {})
-    equity = portfolio.get("equity", 0)
-    cash = portfolio.get("cash", 0)
-    status = result.get("status", "?")
-    mode = result.get("mode", "paper")
-    elapsed = result.get("elapsed_sec", 0)
-    model_risk = result.get("model_risk", {})
-
-    pnl_emoji = "📈" if pnl >= 0 else "📉"
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-
-    text = (
-        f"📊 <b>İşlem Döngüsü Tamamlandı</b> [{now}]\n\n"
-        f"Durum: <code>{status}</code>\n"
-        f"Mod: <code>{mode}</code>\n"
-        f"Süre: <code>{elapsed:.0f}s</code>\n\n"
-        f"🔄 İşlem Sayısı: <b>{trades}</b>\n"
-        f"{pnl_emoji} Günlük P&L: <b>{pnl:+,.2f} TL</b>\n"
-        f"💰 Nakit: <code>{cash:,.0f} TL</code>\n"
-        f"📊 Toplam Değer: <code>{equity:,.0f} TL</code>"
-    )
+# ---------------------------------------------------------------------------
+# Scan watcher — proaktif bildirim (tarama başladı / tamamlandı)
+# ---------------------------------------------------------------------------
 
-    if model_risk:
-        safe = model_risk.get("model_safe", True)
-        if not safe:
-            text += "\n\n⚠️ <b>Model güvensiz — degraded mod aktif</b>"
-
-    details = result.get("trade_details", [])
-    if details:
-        text += "\n\n<b>İşlem Detayları:</b>"
-        for t in details[:10]:
-            side_emoji = "🟢" if t.get("side") == "BUY" else "🔴"
-            pnl_str = f" P&L: {t['pnl']:+.2f}" if "pnl" in t else ""
-            text += f"\n{side_emoji} {t['symbol']} {t['qty']}x @ {t['price']}{pnl_str}"
-
-    send(text)
-
-
-def notify_error(title: str, error_msg: str) -> None:
-    """Hata oluştuğunda bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    send(
-        f"🚨 <b>HATA</b> [{now}]\n\n"
-        f"<b>{title}</b>\n"
-        f"<code>{error_msg[:500]}</code>"
-    )
+def _scan_watcher() -> None:
+    """Arka planda çalışır: scan başlayınca ve bitince Telegram mesajı atar."""
+    LOCAL_API = "http://localhost:7860/api/eligible?market=bist"
+    CHECK_INTERVAL = 60  # saniye
 
+    was_running = False
+    initialized = False
+    logger.info("[scan_watcher] Başlatıldı — %ds aralıkla kontrol", CHECK_INTERVAL)
 
-def notify_degraded_mode(reason: str) -> None:
-    """Degraded moda geçildiğinde bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    send(
-        f"⚠️ <b>Degraded Mod Aktif</b> [{now}]\n\n"
-        f"ML modeli güvensiz — sadece teknik sinyallerle çalışılıyor.\n"
-        f"Sebep: <code>{reason[:200]}</code>"
-    )
+    while True:
+        try:
+            req = urllib.request.Request(LOCAL_API, headers={"Accept": "application/json"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read().decode())
 
+            is_running = bool(data.get("scanRunning", False))
 
-def notify_no_eligible() -> None:
-    """Eligible hisse bulunamadığında bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    send(
-        f"⚠️ <b>Uygun Hisse Yok</b> [{now}]\n\n"
-        f"Tarama tamamlandı ama kriterleri geçen hisse bulunamadı."
-    )
+            if not initialized:
+                was_running = is_running
+                initialized = True
+                time.sleep(CHECK_INTERVAL)
+                continue
 
+            if not was_running and is_running:
+                # Tarama başladı
+                universe = data.get("universe", "BIST100")
+                send(f"🔍 <b>BIST Tarama başladı</b>\nEvren: <code>{universe.upper()}</code>\n⏳ Tamamlanması birkaç saat sürebilir.")
+                logger.info("[scan_watcher] Tarama başladı bildirimi gönderildi")
+
+            elif was_running and not is_running:
+                # Tarama bitti
+                eligible_count = data.get("eligibleCount") or 0
+                progress = data.get("scanProgress", "")
+                if "hata" in progress.lower() or "error" in progress.lower():
+                    send(f"❌ <b>BIST Tarama hatası</b>\n<code>{progress}</code>")
+                    logger.info("[scan_watcher] Tarama hata bildirimi: %s", progress)
+                else:
+                    updated = data.get("updatedAt", "")[:16] if data.get("updatedAt") else "?"
+                    send(
+                        f"✅ <b>BIST Tarama tamamlandı</b>\n"
+                        f"Eligible: <b>{eligible_count}</b> hisse\n"
+                        f"Tamamlandı: <code>{updated} UTC</code>\n"
+                        f"/hisseler — listeyi görmek için"
+                    )
+                    logger.info("[scan_watcher] Tarama bitti bildirimi: %d eligible", eligible_count)
 
-def notify_no_signals() -> None:
-    """Sinyal üretilemediğinde bildirim."""
-    now = datetime.now(timezone.utc).strftime("%H:%M UTC")
-    send(
-        f"⚠️ <b>Sinyal Üretilemedi</b> [{now}]\n\n"
-        f"Eligible hisseler için sinyal üretilemedi."
-    )
+            was_running = is_running
 
+        except Exception as e:
+            logger.debug("[scan_watcher] API hatası (normal başlangıçta): %s", e)
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Komut dağıtıcı
-# ═══════════════════════════════════════════════════════════════════════════
+        time.sleep(CHECK_INTERVAL)
 
-SIMPLE_COMMANDS = {
-    "/durum": cmd_durum,
-    "/portfoy": cmd_portfoy,
-    "/hisseler": cmd_hisseler,
-    "/sinyaller": cmd_sinyaller,
-    "/islemler": cmd_islemler,
-    "/tarama": cmd_tarama,
-    "/yardim": cmd_yardim,
-    "/help": cmd_yardim,
-    "/start": cmd_yardim,
-}
 
+def _us_scan_watcher() -> None:
+    """US market scan watcher — proactive notifications."""
+    LOCAL_API = "http://localhost:7860/api/eligible?market=us"
+    CHECK_INTERVAL = 60
 
-def _handle_message(text: str) -> None:
-    """Gelen mesajı parse edip uygun handler'ı çağır."""
-    parts = text.strip().split()
-    cmd = parts[0].lower()
+    was_running = False
+    initialized = False
+    logger.info("[us_scan_watcher] Started — %ds interval", CHECK_INTERVAL)
 
-    # /hisse SYMBOL komutu
-    if cmd == "/hisse":
-        if len(parts) < 2:
-            send("Kullanım: /hisse THYAO\nÖrnek: /hisse ASELS")
-            return
+    while True:
         try:
-            reply = cmd_hisse(parts[1])
-            send(reply)
-        except Exception as e:
-            logger.error("cmd_hisse error: %s", e)
-            send(f"❌ Hisse analizi hatası: {e}")
-        return
+            req = urllib.request.Request(LOCAL_API, headers={"Accept": "application/json"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read().decode())
+
+            is_running = bool(data.get("scanRunning", False))
+
+            if not initialized:
+                was_running = is_running
+                initialized = True
+                time.sleep(CHECK_INTERVAL)
+                continue
+
+            if not was_running and is_running:
+                send("🇺🇸🔍 <b>US Tarama başladı</b>\n⏳ Tamamlanması birkaç saat sürebilir.")
+                logger.info("[us_scan_watcher] US scan started notification sent")
+
+            elif was_running and not is_running:
+                eligible_count = data.get("eligibleCount") or 0
+                progress = data.get("scanProgress", "")
+                if "hata" in progress.lower() or "error" in progress.lower():
+                    send(f"🇺🇸❌ <b>US Tarama hatası</b>\n<code>{progress}</code>")
+                else:
+                    updated = data.get("updatedAt", "")[:16] if data.get("updatedAt") else "?"
+                    send(
+                        f"🇺🇸✅ <b>US Tarama tamamlandı</b>\n"
+                        f"Eligible: <b>{eligible_count}</b> hisse\n"
+                        f"Tamamlandı: <code>{updated} UTC</code>\n"
+                        f"/us_hisseler — listeyi görmek için"
+                    )
+                    logger.info("[us_scan_watcher] US scan done: %d eligible", eligible_count)
+
+            was_running = is_running
 
-    handler = SIMPLE_COMMANDS.get(cmd)
-    if handler:
-        try:
-            reply = handler()
-            send(reply)
         except Exception as e:
-            logger.error("Handler hatası (%s): %s", cmd, e)
-            send(f"❌ Komut işlenirken hata: {e}")
-    else:
-        send(
-            f"❓ Bilinmeyen komut: <code>{cmd}</code>\n"
-            "/yardim — komut listesi"
-        )
+            logger.debug("[us_scan_watcher] API error: %s", e)
+
+        time.sleep(CHECK_INTERVAL)
 
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Ana polling döngüsü
-# ═══════════════════════════════════════════════════════════════════════════
+# ---------------------------------------------------------------------------
+# Main polling loop
+# ---------------------------------------------------------------------------
+
+COMMANDS = {
+    "/durum":    cmd_durum,
+    "/portfoy":  cmd_portfoy,
+    "/hisseler": cmd_hisseler,
+    "/sinyaller": cmd_sinyaller,
+    "/us_durum":    cmd_us_durum,
+    "/us_portfoy":  cmd_us_portfoy,
+    "/us_hisseler": cmd_us_hisseler,
+    "/us_sinyaller": cmd_us_sinyaller,
+    "/yardim":   cmd_yardim,
+    "/help":     cmd_yardim,
+    "/start":    cmd_yardim,
+}
+
 
 def main() -> None:
+    import threading
+    _resolve_api_base(force=True)
     logger.info("Telegram bot başlatıldı (chat_id=%s)", CHAT_ID)
-    send(
-        "🤖 <b>Borsanova Bot açık!</b>\n\n"
-        "Otomatik bildirimler aktif.\n"
-        "/yardim — komut listesi"
-    )
+    send("🤖 Borsanova Bot aktif!\n/yardim — komutları görmek için")
+
+    # Scan watcher arka planda başlat
+    watcher = threading.Thread(target=_scan_watcher, daemon=True, name="scan-watcher")
+    watcher.start()
+
+    # US scan watcher
+    us_watcher = threading.Thread(target=_us_scan_watcher, daemon=True, name="us-scan-watcher")
+    us_watcher.start()
 
     offset = 0
     while True:
@@ -991,12 +862,24 @@ def main() -> None:
             if str(msg.get("chat", {}).get("id", "")) != str(CHAT_ID):
                 continue
 
-            text = msg.get("text", "").strip()
+            text = msg.get("text", "").strip().lower().split()[0] if msg.get("text") else ""
             if not text:
                 continue
 
             logger.info("Komut: %s", text)
-            _handle_message(text)
+            handler = COMMANDS.get(text)
+            if handler:
+                try:
+                    reply = handler()
+                    send(reply)
+                except Exception as e:
+                    logger.error("Handler hatası (%s): %s", text, e)
+                    send(f"❌ Komut işlenirken hata: {e}")
+            else:
+                send(
+                    f"❓ Bilinmeyen komut: <code>{text}</code>\n"
+                    "/yardim — komut listesi"
+                )
 
         if not updates:
             time.sleep(1)

huggingface-space/test_smoke.py

@@ -155,7 +155,7 @@ def main() -> int:
         from trading.security import LogSanitizer, check_env_safety, get_production_config
         sanitizer = LogSanitizer()
         # Test redaction
-        test_msg = "key=" + "sk-" + "abc123def456ghi789jkl012mno345pqr678"
+        test_msg = "key=sk-abc123def456ghi789jkl012mno345pqr678"
         sanitized = sanitizer._sanitize(test_msg)
         assert "sk-abc123" not in sanitized, f"Key not redacted: {sanitized}"
         assert "REDACTED" in sanitized

huggingface-space/trading/__init__.py

@@ -7,6 +7,7 @@ from trading.broker_base import (  # noqa: F401
     OrderType,
     PaperBroker,
     SlippageModel,
+    make_slippage_model,
 )
 from trading.monitoring import (  # noqa: F401
     AlertLevel,

huggingface-space/trading/auto_trader.py

@@ -45,20 +45,19 @@ from trading.broker_base import (
     OrderType,
     PaperBroker,
     SlippageModel,
-    make_slippage_model_for_market,
+    make_slippage_model,
 )
 from trading.trade_journal import TradeJournal
 from trading.monitoring import KillSwitch
 
 # New production modules
-from trading.risk_gate import RiskGate, RiskLimits, make_risk_limits_for_market
+from trading.risk_gate import RiskGate, RiskLimits
 from trading.circuit_breaker import CircuitBreaker
 from trading.db_store import TradingStore
 from trading.model_risk import ModelRiskManager
 from trading.market_registry import (
     DEFAULT_MARKET_ID,
     describe_market_window,
-    get_market_config,
     get_market_storage_dir,
     get_scan_results_path,
     get_trading_db_path,
@@ -90,7 +89,7 @@ def _status_file(market_id: str = DEFAULT_MARKET_ID) -> Path:
 DEFAULT_INITIAL_CASH = 100_000.0
 MAX_POSITIONS = 5
 POSITION_SIZE_PCT = 15.0          # % of equity per position
-MIN_CONFIDENCE = 15               # 0-100 scale — lowered from 30; BIST models typically score 25-45
+MIN_CONFIDENCE = 40               # 0-100 scale — minimum quality gate for trade entry
 DAYS_AHEAD = 7
 STOP_LOSS_PCT = 5.0               # -5% stop loss
 TAKE_PROFIT_PCT = 10.0            # +10% take profit
@@ -237,7 +236,6 @@ def run_trading_cycle(
     """
     today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
     cycle_start = time.time()
-    _currency = get_market_config(market_id).currency
 
     journal = TradeJournal()
     kill_switch = KillSwitch(path=get_market_storage_dir(market_id) / ".kill_switch")
@@ -247,7 +245,7 @@ def run_trading_cycle(
     store = TradingStore(db_path=str(get_trading_db_path(market_id)))
     model_risk = ModelRiskManager()
     risk_gate = RiskGate(
-        limits=make_risk_limits_for_market(market_id),
+        limits=RiskLimits(),
         monitor=None,
         kill_switch=kill_switch,
         alert_manager=None,
@@ -287,17 +285,13 @@ def run_trading_cycle(
     effective_cash = saved_cash if saved_cash is not None else initial_cash
     broker = PaperBroker(
         initial_cash=effective_cash,
-        slippage_model=make_slippage_model_for_market(market_id),
+        slippage_model=make_slippage_model(market_id),
         market_id=market_id,
     )
     if saved_cash is not None:
         broker._cash = saved_cash
         broker._positions = state.get("broker_positions", {})
 
-    # Seed peak equity so drawdown protection is active from the start
-    _initial_account = broker.get_account_info()
-    risk_gate.record_equity(_initial_account["equity"])
-
     # Get eligible symbols
     symbols = _get_eligible_symbols(market_id=market_id)
     if not symbols:
@@ -310,7 +304,7 @@ def run_trading_cycle(
     logger.info("=" * 60)
     logger.info("AUTO TRADER — Trading Cycle %s", today)
     logger.info("Eligible stocks: %s", symbols)
-    logger.info("Cash: %.2f TL, Positions: %d", broker._cash, len(broker._positions))
+    logger.info("Cash: %.2f, Positions: %d, Market: %s", broker._cash, len(broker._positions), market_id)
     logger.info("=" * 60)
 
     # Update status
@@ -397,6 +391,7 @@ def run_trading_cycle(
     for sym, pos in list(broker._positions.items()):
         try:
             from data.stock_data_api import get_stock_data_for_api
+            ticker = to_provider_symbol(sym, market_id=market_id)
             df_px = get_stock_data_for_api(sym, period="5d", interval="1d", market_id=market_id)
             if df_px is None or df_px.empty:
                 continue
@@ -494,9 +489,9 @@ def run_trading_cycle(
                         "commission": round(fill.commission, 2),
                     })
                     logger.info(
-                        "SOLD %s: %d @ %.2f %s, PnL: %+.2f %s (%+.1f%%) [%s]",
+                        "SOLD %s: %d @ %.2f TL, PnL: %+.2f TL (%+.1f%%) [%s]",
                         sym, fill.filled_qty, fill.avg_fill_price,
-                        _currency, pnl, _currency, pnl_pct, reason,
+                        pnl, pnl_pct, reason,
                     )
                 else:
                     signal_actions[sym] = "SELL_REJECTED"
@@ -555,6 +550,7 @@ def run_trading_cycle(
         from data.stock_data_api import get_stock_data_for_api as _fetch_px
         for _ex_sym in broker._positions:
             try:
+                _ex_tk = to_provider_symbol(_ex_sym, market_id=market_id)
                 _ex_df = _fetch_px(_ex_sym, period="6mo", interval="1d", market_id=market_id)
                 if _ex_df is not None and not _ex_df.empty:
                     _position_returns[_ex_sym] = _ex_df["Close"].pct_change().dropna()
@@ -563,6 +559,8 @@ def run_trading_cycle(
         if _position_returns:
             logger.info("Correlation check: cached returns for %d positions", len(_position_returns))
 
+    _fetch_px2 = None
+
     for _, row in buy_signals.head(slots_available).iterrows():
         sym = row["symbol"]
         if sym in broker._positions:
@@ -578,6 +576,7 @@ def run_trading_cycle(
         if _position_returns:
             try:
                 from data.stock_data_api import get_stock_data_for_api as _fetch_px2
+                _new_tk = to_provider_symbol(sym, market_id=market_id)
                 _new_df = _fetch_px2(sym, period="6mo", interval="1d", market_id=market_id)
                 _too_corr = False
                 if _new_df is not None and not _new_df.empty:
@@ -594,7 +593,6 @@ def run_trading_cycle(
                                 )
                                 break
                 if _too_corr:
-                    signal_actions[sym] = "BUY_SKIPPED_CORRELATED"
                     continue
             except Exception as exc:
                 logger.warning("Correlation check failed for %s: %s", sym, exc)
@@ -606,7 +604,6 @@ def run_trading_cycle(
         qty = int(max_notional / close_px)
 
         if qty <= 0:
-            signal_actions[sym] = "BUY_SKIPPED_ZERO_QTY"
             continue
 
         if not dry_run:
@@ -643,6 +640,7 @@ def run_trading_cycle(
 
                 # Update correlation cache so next candidates check against this too
                 try:
+                    _new_tk2 = to_provider_symbol(sym, market_id=market_id)
                     _new_df2 = _fetch_px(sym, period="6mo", interval="1d", market_id=market_id)
                     if _new_df2 is not None and not _new_df2.empty:
                         _position_returns[sym] = _new_df2["Close"].pct_change().dropna()
@@ -681,9 +679,9 @@ def run_trading_cycle(
                     "commission": round(fill.commission, 2),
                 })
                 logger.info(
-                    "BOUGHT %s: %d @ %.2f %s (conf=%.2f, pred=%.1f%%)",
+                    "BOUGHT %s: %d @ %.2f TL (conf=%.2f, pred=%.1f%%)",
                     sym, fill.filled_qty, fill.avg_fill_price,
-                    _currency, row.get("confidence", 0), row.get("predicted_return_pct", 0),
+                    row.get("confidence", 0), row.get("predicted_return_pct", 0),
                 )
             else:
                 signal_actions[sym] = "BUY_REJECTED"
@@ -744,6 +742,7 @@ def run_trading_cycle(
     # Final status
     result = {
         "date": today,
+        "market_id": market_id,
         "status": "OK",
         "elapsed_sec": round(elapsed, 1),
         "signals_generated": len(df_signals),
@@ -800,10 +799,7 @@ def run_trading_cycle(
 # Continuous mode
 # ---------------------------------------------------------------------------
 
-def run_continuous(
-    initial_cash: float = DEFAULT_INITIAL_CASH,
-    market_id: str = DEFAULT_MARKET_ID,
-) -> None:
+def run_continuous(initial_cash: float = DEFAULT_INITIAL_CASH, market_id: str = DEFAULT_MARKET_ID) -> None:
     """Run auto-trader in continuous loop.
 
     Checks every hour, trades once per day.
@@ -811,15 +807,13 @@ def run_continuous(
     """
     logger.info("Starting continuous auto-trader...")
     logger.info("Will check every hour, trade once per day")
+    logger.info("Market window: %s", describe_market_window(market_id))
     logger.info("Press Ctrl+C to stop")
 
     while True:
         try:
             now = datetime.now(timezone.utc)
-            hour = now.hour
-
-            # Trade between 07:00-16:00 UTC (10:00-19:00 Istanbul)
-            if is_market_open_window(market_id):
+            if is_market_open_window(market_id, now_utc=now):
                 state = _load_state(market_id)
                 today = now.strftime("%Y-%m-%d")
 
@@ -830,7 +824,7 @@ def run_continuous(
                 else:
                     logger.debug("Already ran today, waiting...")
             else:
-                logger.debug("Outside market window: %s", describe_market_window(market_id))
+                logger.debug("Outside market hours for %s, sleeping...", market_id)
 
             # Sleep 1 hour
             time.sleep(3600)
@@ -847,12 +841,10 @@ def run_continuous(
 # Reset
 # ---------------------------------------------------------------------------
 
-def reset_portfolio(
-    initial_cash: float = DEFAULT_INITIAL_CASH,
-    market_id: str = DEFAULT_MARKET_ID,
-) -> None:
+def reset_portfolio(initial_cash: float = DEFAULT_INITIAL_CASH, market_id: str = DEFAULT_MARKET_ID) -> None:
     """Reset all auto-trader state for a fresh start."""
     state = {
+        "market_id": market_id,
         "created_at": datetime.now(timezone.utc).isoformat(),
         "initial_cash": initial_cash,
         "broker_cash": initial_cash,
@@ -865,8 +857,9 @@ def reset_portfolio(
     }
     _save_state(state, market_id=market_id)
 
-    # Clear journal files
-    journal_dir = Path("paper_trading/journal")
+    # Clear journal files for the correct market
+    from trading.trade_journal import _journal_dir_for
+    journal_dir = _journal_dir_for(market_id)
     for f in journal_dir.glob("*.jsonl"):
         try:
             f.unlink()
@@ -875,7 +868,7 @@ def reset_portfolio(
             # appear/disappear; ignore missing file errors during cleanup.
             continue
 
-    logger.info("Portfolio reset: %.0f TL initial cash", initial_cash)
+    logger.info("Portfolio reset for %s: %.0f initial cash", market_id, initial_cash)
 
 
 # ---------------------------------------------------------------------------
@@ -895,12 +888,12 @@ def main() -> int:
     p.add_argument("--reset", action="store_true", help="Reset portfolio to fresh start")
     p.add_argument("--initial-cash", type=float, default=DEFAULT_INITIAL_CASH)
     p.add_argument("--dry-run", action="store_true", help="Generate signals but don't trade")
-    p.add_argument("--market", default=DEFAULT_MARKET_ID, choices=["bist", "us"])
+    p.add_argument("--market", choices=["bist", "us"], default=DEFAULT_MARKET_ID)
 
     args = p.parse_args()
 
     if args.status:
-        status = get_auto_trader_status(args.market)
+        status = get_auto_trader_status(market_id=args.market)
         print(json.dumps(status, indent=2, default=str))
 
         # Also show performance
@@ -913,7 +906,7 @@ def main() -> int:
 
     if args.reset:
         reset_portfolio(args.initial_cash, market_id=args.market)
-        print(f"Portfolio reset with {args.initial_cash:,.0f} TL")
+        print(f"Portfolio reset for {args.market} with {args.initial_cash:,.0f}")
         return 0
 
     if args.continuous:
@@ -930,7 +923,7 @@ def main() -> int:
         return 0
 
     # Default: show status
-    status = get_auto_trader_status(args.market)
+    status = get_auto_trader_status(market_id=args.market)
     print(json.dumps(status, indent=2, default=str))
     return 0
 

huggingface-space/trading/broker_base.py

@@ -98,7 +98,7 @@ class FillResult:
 # ---------------------------------------------------------------------------
 
 class SlippageModel:
-    """Realistic slippage and commission estimation for BIST equities.
+    """Realistic slippage and commission estimation.
 
     Parameters
     ----------
@@ -106,6 +106,7 @@ class SlippageModel:
         Round-trip commission as fraction (e.g. 0.001 = 0.1% = 10 bps).
     bsmv_rate : float
         "Banka ve Sigorta Muameleleri Vergisi" (BSMV) applied on commission.
+        Only applies to BIST (Turkey). Set to 0.0 for other markets.
     min_slippage_bps : float
         Minimum market-impact slippage in basis points.
     vol_slippage_coeff : float
@@ -161,16 +162,26 @@ class SlippageModel:
         return round(mid_price * (1 - slip_frac), 4)
 
 
-def make_slippage_model_for_market(market_id: str) -> "SlippageModel":
-    """Return a SlippageModel calibrated for the given market.
+def make_slippage_model(market_id: str = "bist") -> SlippageModel:
+    """Create a market-appropriate SlippageModel.
 
-    BIST: 10 bps commission + 5% BSMV Turkish banking tax.
-    US / others: 5 bps commission, no BSMV.
+    BIST: 10 bps commission + 5% BSMV tax on commission.
+    US:   3 bps commission, no BSMV (US has no such tax).
     """
-    if str(market_id).lower() == "bist":
-        return SlippageModel(commission_rate=0.001, bsmv_rate=0.05, min_slippage_bps=5.0)
-    # US equities (Interactive Brokers-like: ~0.5–1 bps flat, no BSMV)
-    return SlippageModel(commission_rate=0.0005, bsmv_rate=0.0, min_slippage_bps=2.0)
+    if market_id == "us":
+        return SlippageModel(
+            commission_rate=0.0003,     # ~3 bps (typical US retail)
+            bsmv_rate=0.0,              # No BSMV in US
+            min_slippage_bps=2.0,       # US large-caps are more liquid
+            vol_slippage_coeff=0.2,
+        )
+    # Default: BIST
+    return SlippageModel(
+        commission_rate=0.001,
+        bsmv_rate=0.05,
+        min_slippage_bps=5.0,
+        vol_slippage_coeff=0.3,
+    )
 
 
 # ---------------------------------------------------------------------------

huggingface-space/trading/circuit_breaker.py

@@ -188,6 +188,7 @@ class CircuitBreaker:
 
         if old != new_state:
             logger.warning("Circuit breaker: %s → %s", old.value, new_state.value)
+            self._save_state()
 
     def get_status(self) -> Dict[str, Any]:
         """Current status for dashboard."""

huggingface-space/trading/daily_signals.py

@@ -51,6 +51,7 @@ from trading.market_registry import (
     normalize_symbol,
     to_provider_symbol,
 )
+from trading.universe_provider import get_market_universe
 
 warnings.filterwarnings("ignore")
 
@@ -113,10 +114,15 @@ def generate_signals(
 
     def _process_one(sym: str) -> Optional[Dict[str, Any]]:
         """V3 Classification Ensemble — matches walk-forward backtest approach."""
+        symbol = normalize_symbol(sym, market_id=market.market_id)
+        provider_symbol = to_provider_symbol(symbol, market_id=market.market_id)
         try:
-            symbol = normalize_symbol(sym, market_id=market.market_id)
-            provider_symbol = to_provider_symbol(symbol, market_id=market.market_id)
-            df = get_stock_data_for_api(symbol, period="5y", interval="1d", market_id=market.market_id)
+            df = get_stock_data_for_api(
+                symbol,
+                period="5y",
+                interval="1d",
+                market_id=market.market_id,
+            )
             if df is None or df.empty:
                 logger.info("%s: no data returned from API — skipped", symbol)
                 return None
@@ -312,15 +318,15 @@ def generate_signals(
                 "top_features": json.dumps(top_features),
             }
         except Exception as e:
-            logger.warning("Signal generation FAILED for %s: %s", sym, e)
-            logger.debug("Traceback for %s:\n%s", sym, traceback.format_exc())
+            logger.warning("Signal generation FAILED for %s: %s", symbol, e)
+            logger.debug("Traceback for %s:\n%s", symbol, traceback.format_exc())
             # Return a minimal error-HOLD so the symbol still shows up in
             # signals_log and we can diagnose which symbols keep crashing.
             return {
                 "market_id": market.market_id,
                 "currency": market.currency,
-                "provider_symbol": to_provider_symbol(sym, market_id=market.market_id),
-                "symbol": normalize_symbol(sym, market_id=market.market_id),
+                "provider_symbol": provider_symbol,
+                "symbol": symbol,
                 "date": today,
                 "data_age_days": -1,
                 "data_stale": True,
@@ -345,11 +351,17 @@ def generate_signals(
 
     results: List[Dict[str, Any]] = []
     failed_symbols: List[str] = []
+    _SIGNAL_TIMEOUT_SEC = 120  # max seconds per stock before giving up
     with ThreadPoolExecutor(max_workers=4) as ex:
         futs = {ex.submit(_process_one, s): s for s in symbols}
-        for i, f in enumerate(as_completed(futs)):
+        for i, f in enumerate(as_completed(futs, timeout=_SIGNAL_TIMEOUT_SEC * len(symbols))):
             sym_name = futs[f]
-            r = f.result()
+            try:
+                r = f.result(timeout=_SIGNAL_TIMEOUT_SEC)
+            except Exception as exc:
+                logger.warning("Signal generation TIMEOUT/ERROR for %s: %s", sym_name, exc)
+                failed_symbols.append(sym_name)
+                continue
             if r:
                 results.append(r)
                 if r.get("ml_signal") == "ERROR":
@@ -374,6 +386,8 @@ def generate_signals(
     error_count = int((df["ml_signal"] == "ERROR").sum()) if "ml_signal" in df.columns else 0
     summary = {
         "date": today,
+        "market_id": market.market_id,
+        "currency": market.currency,
         "symbols_processed": len(results),
         "symbols_total": len(symbols),
         "symbols_failed": len(failed_symbols),
@@ -384,7 +398,7 @@ def generate_signals(
         "actionable_signals": int(df["actionable"].sum()),
         "avg_confidence": round(float(df["confidence"].mean()), 3),
         "top_picks": df[df["actionable"] & (df["final_signal"] == "BUY")].head(top_n)[
-            ["symbol", "predicted_return_pct", "confidence", "final_signal"]
+            ["market_id", "symbol", "predicted_return_pct", "confidence", "final_signal"]
         ].to_dict("records"),
     }
 
@@ -393,23 +407,26 @@ def generate_signals(
 
 def main() -> int:
     p = argparse.ArgumentParser(description="Daily signal generator")
-    p.add_argument("--universe", default="bist30", choices=["bist30", "bist50", "bist100", "custom"])
+    p.add_argument(
+        "--universe",
+        default="bist30",
+        choices=["bist30", "bist50", "bist100", "sp100", "sp500", "nasdaq100", "custom"],
+    )
     p.add_argument("--symbols", nargs="*")
     p.add_argument("--days-ahead", type=int, default=7)
     p.add_argument("--train-window", type=int, default=504)
     p.add_argument("--top", type=int, default=10)
-    p.add_argument("--min-confidence", type=float, default=0.3)
-    p.add_argument("--out-dir")
+    p.add_argument("--min-confidence", type=float, default=15.0)
     p.add_argument("--market", default=DEFAULT_MARKET_ID, choices=["bist", "us"])
+    p.add_argument("--out-dir", default="")
     args = p.parse_args()
 
     if args.universe == "custom" and args.symbols:
         symbols = [s.strip().upper() for s in args.symbols]
     else:
-        from data.index_constituents import get_index_constituents
-        result = get_index_constituents(args.universe)
+        result = get_market_universe(args.market, args.universe)
         symbols = result.symbols
-        print(f"Universe {args.universe}: {len(symbols)} symbols")
+        print(f"Universe {args.market}/{args.universe}: {len(symbols)} symbols")
 
     print(f"Generating signals for {len(symbols)} symbols...")
     df, summary = generate_signals(

huggingface-space/trading/db_store.py

@@ -137,9 +137,50 @@ CREATE TABLE IF NOT EXISTS schema_version (
     version    INTEGER PRIMARY KEY,
     applied_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
+
+-- Daily run log — tracks every worker invocation to detect gaps
+CREATE TABLE IF NOT EXISTS daily_run_log (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    date           TEXT NOT NULL,
+    market_id      TEXT NOT NULL DEFAULT 'bist',
+    status         TEXT NOT NULL,
+    trades_executed INTEGER NOT NULL DEFAULT 0,
+    elapsed_sec    REAL DEFAULT 0,
+    equity         REAL DEFAULT 0,
+    cash           REAL DEFAULT 0,
+    model_safe     INTEGER DEFAULT 0,
+    cycle_detail   TEXT DEFAULT '{}',
+    created_at     TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_run_log_date ON daily_run_log(date);
+CREATE INDEX IF NOT EXISTS idx_run_log_market ON daily_run_log(market_id);
+
+-- Scorecard history — periodic readiness assessment snapshots
+CREATE TABLE IF NOT EXISTS scorecard_history (
+    id                    INTEGER PRIMARY KEY AUTOINCREMENT,
+    date                  TEXT NOT NULL,
+    market_id             TEXT NOT NULL DEFAULT 'bist',
+    verdict               TEXT NOT NULL DEFAULT 'NO_GO',
+    checks_passed         INTEGER NOT NULL DEFAULT 0,
+    checks_total          INTEGER NOT NULL DEFAULT 0,
+    closed_trades         INTEGER NOT NULL DEFAULT 0,
+    win_rate_pct          REAL DEFAULT 0,
+    profit_factor         REAL DEFAULT 0,
+    max_drawdown_pct      REAL DEFAULT 0,
+    total_return_pct      REAL DEFAULT 0,
+    consecutive_run_days  INTEGER DEFAULT 0,
+    predictions_completed INTEGER DEFAULT 0,
+    predictions_needed    INTEGER DEFAULT 10,
+    bootstrap_unlocked    INTEGER DEFAULT 0,
+    detail_json           TEXT DEFAULT '{}',
+    created_at            TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_scorecard_date ON scorecard_history(date);
 """
 
-_CURRENT_SCHEMA_VERSION = 1
+_CURRENT_SCHEMA_VERSION = 2
 
 
 # ---------------------------------------------------------------------------
@@ -195,12 +236,63 @@ class TradingStore:
         current = row[0] if row and row[0] else 0
 
         if current < _CURRENT_SCHEMA_VERSION:
+            self._run_migrations(current)
             conn.execute(
                 "INSERT OR REPLACE INTO schema_version (version) VALUES (?)",
                 (_CURRENT_SCHEMA_VERSION,),
             )
             conn.commit()
 
+    def _run_migrations(self, from_version: int) -> None:
+        """Run incremental schema migrations."""
+        conn = self._get_conn()
+        if from_version < 2:
+            # v2: add daily_run_log and scorecard_history (idempotent via IF NOT EXISTS in _SCHEMA_SQL)
+            tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
+            if "daily_run_log" not in tables:
+                conn.executescript("""
+                    CREATE TABLE IF NOT EXISTS daily_run_log (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        date TEXT NOT NULL,
+                        market_id TEXT NOT NULL DEFAULT 'bist',
+                        status TEXT NOT NULL,
+                        trades_executed INTEGER NOT NULL DEFAULT 0,
+                        elapsed_sec REAL DEFAULT 0,
+                        equity REAL DEFAULT 0,
+                        cash REAL DEFAULT 0,
+                        model_safe INTEGER DEFAULT 0,
+                        cycle_detail TEXT DEFAULT '{}',
+                        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+                    );
+                    CREATE INDEX IF NOT EXISTS idx_run_log_date ON daily_run_log(date);
+                    CREATE INDEX IF NOT EXISTS idx_run_log_market ON daily_run_log(market_id);
+                """)
+            if "scorecard_history" not in tables:
+                conn.executescript("""
+                    CREATE TABLE IF NOT EXISTS scorecard_history (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        date TEXT NOT NULL,
+                        market_id TEXT NOT NULL DEFAULT 'bist',
+                        verdict TEXT NOT NULL DEFAULT 'NO_GO',
+                        checks_passed INTEGER NOT NULL DEFAULT 0,
+                        checks_total INTEGER NOT NULL DEFAULT 0,
+                        closed_trades INTEGER NOT NULL DEFAULT 0,
+                        win_rate_pct REAL DEFAULT 0,
+                        profit_factor REAL DEFAULT 0,
+                        max_drawdown_pct REAL DEFAULT 0,
+                        total_return_pct REAL DEFAULT 0,
+                        consecutive_run_days INTEGER DEFAULT 0,
+                        predictions_completed INTEGER DEFAULT 0,
+                        predictions_needed INTEGER DEFAULT 10,
+                        bootstrap_unlocked INTEGER DEFAULT 0,
+                        detail_json TEXT DEFAULT '{}',
+                        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+                    );
+                    CREATE INDEX IF NOT EXISTS idx_scorecard_date ON scorecard_history(date);
+                """)
+            conn.commit()
+            logger.info("Schema migrated to v2 (daily_run_log + scorecard_history)")
+
     # -----------------------------------------------------------------------
     # State (key-value)
     # -----------------------------------------------------------------------
@@ -623,6 +715,117 @@ class TradingStore:
         logger.info("JSONL→SQLite migration: %s", counts)
         return counts
 
+    # -----------------------------------------------------------------------
+    # Daily run log
+    # -----------------------------------------------------------------------
+
+    def record_run(
+        self,
+        date: str,
+        market_id: str,
+        status: str,
+        trades_executed: int = 0,
+        elapsed_sec: float = 0.0,
+        equity: float = 0.0,
+        cash: float = 0.0,
+        model_safe: bool = False,
+        cycle_detail: Optional[Dict] = None,
+    ) -> None:
+        with self._transaction() as cur:
+            cur.execute("""
+                INSERT INTO daily_run_log
+                    (date, market_id, status, trades_executed, elapsed_sec,
+                     equity, cash, model_safe, cycle_detail)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (date, market_id, status, trades_executed, round(elapsed_sec, 1),
+                  round(equity, 2), round(cash, 2), 1 if model_safe else 0,
+                  json.dumps(cycle_detail or {}, default=str)))
+
+    def get_run_log(self, market_id: str = "bist", limit: int = 200) -> List[Dict[str, Any]]:
+        conn = self._get_conn()
+        rows = conn.execute(
+            "SELECT * FROM daily_run_log WHERE market_id = ? ORDER BY date DESC LIMIT ?",
+            (market_id, limit),
+        ).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_consecutive_run_days(self, market_id: str = "bist") -> int:
+        """Count consecutive trading days with at least one run, going back from today."""
+        conn = self._get_conn()
+        rows = conn.execute(
+            "SELECT DISTINCT date FROM daily_run_log WHERE market_id = ? ORDER BY date DESC",
+            (market_id,),
+        ).fetchall()
+        if not rows:
+            return 0
+        dates = [r[0] for r in rows]
+        from datetime import datetime as _dt, timedelta
+        streak = 0
+        # Start from the most recent run date (today may not have run yet)
+        expected = _dt.strptime(dates[0], "%Y-%m-%d").date()
+        today = _dt.now().date()
+        # Only accept if the most recent run is today or the previous trading day
+        days_since_last = (today - expected).days
+        if days_since_last > 3:  # More than a long weekend gap
+            return 0
+        for d in dates:
+            run_date = _dt.strptime(d, "%Y-%m-%d").date()
+            # Allow weekend gaps (Sat/Sun are not trading days)
+            while expected.weekday() in (5, 6):  # skip weekends
+                expected -= timedelta(days=1)
+            if run_date == expected:
+                streak += 1
+                expected -= timedelta(days=1)
+            elif run_date < expected:
+                break  # gap found
+        return streak
+
+    # -----------------------------------------------------------------------
+    # Scorecard history
+    # -----------------------------------------------------------------------
+
+    def record_scorecard(
+        self,
+        date: str,
+        market_id: str,
+        verdict: str,
+        checks_passed: int,
+        checks_total: int,
+        closed_trades: int = 0,
+        win_rate_pct: float = 0.0,
+        profit_factor: float = 0.0,
+        max_drawdown_pct: float = 0.0,
+        total_return_pct: float = 0.0,
+        consecutive_run_days: int = 0,
+        predictions_completed: int = 0,
+        predictions_needed: int = 10,
+        bootstrap_unlocked: bool = False,
+        detail_json: Optional[Dict] = None,
+    ) -> None:
+        with self._transaction() as cur:
+            cur.execute("""
+                INSERT INTO scorecard_history
+                    (date, market_id, verdict, checks_passed, checks_total,
+                     closed_trades, win_rate_pct, profit_factor, max_drawdown_pct,
+                     total_return_pct, consecutive_run_days,
+                     predictions_completed, predictions_needed, bootstrap_unlocked,
+                     detail_json)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (date, market_id, verdict, checks_passed, checks_total,
+                  closed_trades, round(win_rate_pct, 2), round(profit_factor, 2),
+                  round(max_drawdown_pct, 2), round(total_return_pct, 2),
+                  consecutive_run_days, predictions_completed, predictions_needed,
+                  1 if bootstrap_unlocked else 0,
+                  json.dumps(detail_json or {}, default=str)))
+
+    def get_scorecard_history(self, market_id: str = "bist", limit: int = 30) -> List[Dict[str, Any]]:
+        conn = self._get_conn()
+        rows = conn.execute(
+            "SELECT * FROM scorecard_history WHERE market_id = ? ORDER BY date DESC LIMIT ?",
+            (market_id, limit),
+        ).fetchall()
+        return [dict(r) for r in rows]
+
     def close(self) -> None:
         """Close thread-local connection."""
         if hasattr(self._local, "conn") and self._local.conn:

huggingface-space/trading/market_registry.py

@@ -25,6 +25,11 @@ class MarketConfig:
     run_end_minute: int = 0
     scan_start_hour: int = 18   # hour in market's local timezone to run daily scan
     scan_start_minute: int = 0
+    # Market hours in UTC — used by RiskGate to block off-hours orders
+    market_open_hour_utc: int = 7
+    market_close_hour_utc: int = 15
+    # Whether this market is approved for live/paper trading
+    trading_enabled: bool = True
 
 
 _MARKETS = {
@@ -42,6 +47,9 @@ _MARKETS = {
         run_end_minute=0,
         scan_start_hour=19,   # 19:00 TR (1hr after 18:00 close)
         scan_start_minute=0,
+        market_open_hour_utc=7,   # BIST 10:00 Istanbul = 07:00 UTC
+        market_close_hour_utc=15, # BIST 18:00 Istanbul = 15:00 UTC
+        trading_enabled=True,
     ),
     "us": MarketConfig(
         market_id="us",
@@ -57,6 +65,9 @@ _MARKETS = {
         run_end_minute=0,
         scan_start_hour=17,   # 17:00 ET (1hr after 16:00 close)
         scan_start_minute=0,
+        market_open_hour_utc=13,  # NYSE 09:00 ET ≈ 13:00 UTC (DST: 14:00)
+        market_close_hour_utc=21, # NYSE 16:00 ET ≈ 21:00 UTC (DST: 20:00)
+        trading_enabled=True,     # ENABLED for paper trading
     ),
 }
 
@@ -114,6 +125,13 @@ def get_trading_db_path(market_id: str = DEFAULT_MARKET_ID) -> Path:
     return get_market_storage_dir(market_key) / "trading.db"
 
 
+def get_eligibility_path(market_id: str = DEFAULT_MARKET_ID) -> Path:
+    market_key = get_market_config(market_id).market_id
+    if market_key == DEFAULT_MARKET_ID:
+        return _PAPER_TRADING_DIR / "stock_eligibility.json"
+    return get_market_storage_dir(market_key) / "eligibility.json"
+
+
 def get_signal_output_dir(market_id: str = DEFAULT_MARKET_ID) -> Path:
     market_key = get_market_config(market_id).market_id
     if market_key == DEFAULT_MARKET_ID:

huggingface-space/trading/midas_broker.py

@@ -766,7 +766,7 @@ class MidasBroker(BrokerBase):
                 "pnl_pct": round((equity / max(1, initial) - 1) * 100, 2),
                 "positions": positions,
                 "trade_count": len(self._tracker.get_all_orders()),
-                "total_commission": 0.0,  # from order tracker
+                "total_commission": round(sum(o.get("commission", 0) for o in self._tracker.get_all_orders()), 2),
             }
         except Exception as e:
             logger.error("Failed to get Midas account info: %s", e)

huggingface-space/trading/model_risk.py

@@ -27,9 +27,16 @@ import numpy as np
 
 logger = logging.getLogger("trading.model_risk")
 
-_STATE_DIR = Path("paper_trading/model_risk")
-_STATE_FILE = _STATE_DIR / "risk_state.json"
-_PREDICTION_LOG = _STATE_DIR / "prediction_log.jsonl"
+# Legacy global defaults — kept only for backward-compatible helpers.
+# All new code should use the instance-level paths on ModelRiskManager.
+_DEFAULT_STATE_DIR = Path("paper_trading/model_risk")
+
+
+def _state_dir_for_market(market_id: str) -> Path:
+    """Return market-isolated model-risk state directory."""
+    from trading.market_registry import DEFAULT_MARKET_ID, get_market_storage_dir
+    key = (market_id or DEFAULT_MARKET_ID).strip().lower()
+    return get_market_storage_dir(key) / "model_risk"
 
 
 # ---------------------------------------------------------------------------
@@ -54,6 +61,10 @@ class ModelRiskConfig:
     # Auto-disable after N days without any valid evaluation
     max_days_without_eval: int = 14
 
+    # Bootstrap grace period — allow limited trading while predictions accumulate
+    bootstrap_grace_days: int = 14     # days after first prediction to allow trading
+    bootstrap_max_positions: int = 2   # max concurrent positions during bootstrap
+
     # Regime change detection
     vol_regime_change_threshold: float = 2.0  # if vol doubles → warning
 
@@ -89,17 +100,26 @@ class ModelRiskManager:
     4. is_model_safe() — called before executing any trade
     """
 
-    def __init__(self, config: Optional[ModelRiskConfig] = None) -> None:
+    def __init__(
+        self,
+        config: Optional[ModelRiskConfig] = None,
+        market_id: str = "bist",
+    ) -> None:
         self.config = config or ModelRiskConfig()
+        self.market_id = market_id
+        # Market-isolated paths
+        self._state_dir = _state_dir_for_market(market_id)
+        self._state_file = self._state_dir / "risk_state.json"
+        self._prediction_log = self._state_dir / "prediction_log.jsonl"
         self._state = self._load_state()
 
     # -- State persistence --
 
     def _load_state(self) -> Dict[str, Any]:
-        _STATE_DIR.mkdir(parents=True, exist_ok=True)
-        if _STATE_FILE.exists():
+        self._state_dir.mkdir(parents=True, exist_ok=True)
+        if self._state_file.exists():
             try:
-                return json.loads(_STATE_FILE.read_text())
+                return json.loads(self._state_file.read_text())
             except Exception:
                 pass
         return {
@@ -114,9 +134,9 @@ class ModelRiskManager:
         }
 
     def _save_state(self) -> None:
-        _STATE_DIR.mkdir(parents=True, exist_ok=True)
+        self._state_dir.mkdir(parents=True, exist_ok=True)
         self._state["updated_at"] = datetime.now(timezone.utc).isoformat()
-        _STATE_FILE.write_text(json.dumps(self._state, indent=2, default=str))
+        self._state_file.write_text(json.dumps(self._state, indent=2, default=str))
 
     # -- Prediction logging --
 
@@ -127,7 +147,7 @@ class ModelRiskManager:
         confidence: float,
         days_ahead: int = 7,
     ) -> None:
-        _STATE_DIR.mkdir(parents=True, exist_ok=True)
+        self._state_dir.mkdir(parents=True, exist_ok=True)
         record = {
             "symbol": symbol,
             "prediction_date": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
@@ -137,7 +157,7 @@ class ModelRiskManager:
             "actual_return_pct": None,
             "outcome_date": None,
         }
-        with open(_PREDICTION_LOG, "a") as f:
+        with open(self._prediction_log, "a") as f:
             f.write(json.dumps(record) + "\n")
 
     def log_outcome(
@@ -147,10 +167,10 @@ class ModelRiskManager:
         actual_return_pct: float,
     ) -> None:
         """Update a prediction with its actual outcome."""
-        if not _PREDICTION_LOG.exists():
+        if not self._prediction_log.exists():
             return
 
-        lines = _PREDICTION_LOG.read_text().strip().split("\n")
+        lines = self._prediction_log.read_text().strip().split("\n")
         updated = False
         new_lines = []
 
@@ -175,7 +195,7 @@ class ModelRiskManager:
                 new_lines.append(line)
 
         if updated:
-            _PREDICTION_LOG.write_text("\n".join(new_lines) + "\n")
+            self._prediction_log.write_text("\n".join(new_lines) + "\n")
 
     # -- Evaluation --
 
@@ -197,8 +217,9 @@ class ModelRiskManager:
                 "needed": self.config.min_samples_for_eval,
                 "model_enabled": self._state["model_enabled"],
             }
-            self._state["last_evaluation"] = datetime.now(timezone.utc).isoformat()
-            self._save_state()
+            # NOT writing last_evaluation here — insufficient data is not
+            # a valid evaluation.  This prevents the stale-eval bypass in
+            # is_model_safe() from hiding the bootstrap gap.
             return result
 
         # Compute metrics
@@ -298,11 +319,34 @@ class ModelRiskManager:
     def is_model_safe(self) -> bool:
         """Check if the model is currently safe to use for trading signals.
 
-        Also checks for stale evaluation (no eval in too long → unsafe).
+        Checks:
+        1. model_enabled flag (set by evaluate() on degradation)
+        2. Bootstrap guard: must have completed at least one real evaluation
+           (total_evaluations > 0) — BUT allows limited trading during
+           bootstrap_grace_days via is_bootstrap_mode()
+        3. Stale evaluation: no valid eval in max_days_without_eval → unsafe
         """
         if not self._state["model_enabled"]:
             return False
 
+        # Bootstrap guard — no real evaluation ever completed
+        if self._state.get("total_evaluations", 0) == 0:
+            # Check if within bootstrap grace period
+            if self._in_bootstrap_grace():
+                logger.info(
+                    "Model risk: bootstrap grace period — allowing limited trading "
+                    "(max %d positions). Need >= %d completed predictions for full evaluation.",
+                    self.config.bootstrap_max_positions,
+                    self.config.min_samples_for_eval,
+                )
+                return True  # allow limited trading (caller checks is_bootstrap_mode)
+            logger.warning(
+                "Model risk: bootstrap period expired — 0 completed evaluations. "
+                "Need >= %d completed predictions before trading is allowed.",
+                self.config.min_samples_for_eval,
+            )
+            return False
+
         # Check stale evaluation
         last_eval = self._state.get("last_evaluation")
         if last_eval:
@@ -322,11 +366,45 @@ class ModelRiskManager:
 
         return True
 
+    def _in_bootstrap_grace(self) -> bool:
+        """Check if we are within the bootstrap grace period.
+
+        Grace period starts from the date of the first logged prediction.
+        """
+        if not self._prediction_log.exists():
+            return False
+        try:
+            first_line = self._prediction_log.open().readline().strip()
+            if not first_line:
+                return False
+            rec = json.loads(first_line)
+            first_date = datetime.strptime(rec["prediction_date"], "%Y-%m-%d").replace(
+                tzinfo=timezone.utc
+            )
+            age_days = (datetime.now(timezone.utc) - first_date).days
+            return age_days <= self.config.bootstrap_grace_days
+        except Exception:
+            return False
+
+    def is_bootstrap_mode(self) -> bool:
+        """Return True if system is in bootstrap grace period with limited trading.
+
+        When True, the caller should limit concurrent positions to
+        config.bootstrap_max_positions.
+        """
+        return (
+            self._state.get("total_evaluations", 0) == 0
+            and self._state["model_enabled"]
+            and self._in_bootstrap_grace()
+        )
+
     def get_status(self) -> Dict[str, Any]:
         """Return current model risk status (safe for logging/display)."""
         return {
             "model_enabled": self._state["model_enabled"],
             "model_safe": self.is_model_safe(),
+            "bootstrap_mode": self.is_bootstrap_mode(),
+            "bootstrap_max_positions": self.config.bootstrap_max_positions if self.is_bootstrap_mode() else None,
             "disabled_reason": self._state.get("disabled_reason"),
             "disabled_at": self._state.get("disabled_at"),
             "last_evaluation": self._state.get("last_evaluation"),
@@ -355,10 +433,10 @@ class ModelRiskManager:
     # -- Internal --
 
     def _load_completed_predictions(self) -> List[Dict[str, Any]]:
-        if not _PREDICTION_LOG.exists():
+        if not self._prediction_log.exists():
             return []
         records = []
-        for line in _PREDICTION_LOG.read_text().strip().split("\n"):
+        for line in self._prediction_log.read_text().strip().split("\n"):
             try:
                 rec = json.loads(line)
                 if rec.get("actual_return_pct") is not None:

huggingface-space/trading/performance_scorecard.py

@@ -0,0 +1,428 @@
+"""Performance Scorecard — go/no-go readiness evaluation.
+
+Evaluates 7 hard criteria that ALL must pass before real money:
+1. DB integrity (no ghost records)
+2. Worker consistency (consecutive run days ≥ 60)
+3. Bootstrap guard unlocked (≥10 completed predictions, model evaluation passed)
+4. Statistical sample size (≥50 closed trades)
+5. Win rate ≥55% AND profit factor ≥1.5 (over 50+ trades)
+6. Max drawdown ≤10% at all times
+7. Walk-forward all periods positive
+
+Results are persisted to scorecard_history table for trend tracking.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("trading.scorecard")
+
+# ---------------------------------------------------------------------------
+# Thresholds (hard-coded — everything must pass)
+# ---------------------------------------------------------------------------
+
+MIN_CLOSED_TRADES = 50
+MIN_WIN_RATE_PCT = 55.0
+MIN_PROFIT_FACTOR = 1.5
+MAX_DRAWDOWN_PCT = 10.0
+MIN_CONSECUTIVE_RUN_DAYS = 60
+MIN_PREDICTIONS_COMPLETED = 10
+
+
+@dataclass
+class CheckResult:
+    name: str
+    passed: bool
+    current: Any
+    required: Any
+    detail: str = ""
+
+
+@dataclass
+class Scorecard:
+    date: str
+    market_id: str
+    verdict: str  # "GO" or "NO_GO"
+    checks: List[CheckResult] = field(default_factory=list)
+    # Summary metrics
+    closed_trades: int = 0
+    win_rate_pct: float = 0.0
+    profit_factor: float = 0.0
+    max_drawdown_pct: float = 0.0
+    total_return_pct: float = 0.0
+    consecutive_run_days: int = 0
+    predictions_completed: int = 0
+    bootstrap_unlocked: bool = False
+
+    @property
+    def checks_passed(self) -> int:
+        return sum(1 for c in self.checks if c.passed)
+
+    @property
+    def checks_total(self) -> int:
+        return len(self.checks)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "date": self.date,
+            "market_id": self.market_id,
+            "verdict": self.verdict,
+            "checks_passed": self.checks_passed,
+            "checks_total": self.checks_total,
+            "closed_trades": self.closed_trades,
+            "win_rate_pct": round(self.win_rate_pct, 2),
+            "profit_factor": round(self.profit_factor, 2),
+            "max_drawdown_pct": round(self.max_drawdown_pct, 2),
+            "total_return_pct": round(self.total_return_pct, 2),
+            "consecutive_run_days": self.consecutive_run_days,
+            "predictions_completed": self.predictions_completed,
+            "bootstrap_unlocked": self.bootstrap_unlocked,
+            "checks": [
+                {
+                    "name": c.name,
+                    "passed": c.passed,
+                    "current": c.current,
+                    "required": c.required,
+                    "detail": c.detail,
+                }
+                for c in self.checks
+            ],
+        }
+
+    def to_report(self) -> str:
+        lines = []
+        lines.append("=" * 60)
+        lines.append(f"  PERFORMANCE SCORECARD — {self.market_id.upper()}")
+        lines.append(f"  Date: {self.date}")
+        lines.append("=" * 60)
+        lines.append("")
+        lines.append(f"  VERDICT: {'✅ GO' if self.verdict == 'GO' else '❌ NO GO'}  ({self.checks_passed}/{self.checks_total} passed)")
+        lines.append("")
+        lines.append("-" * 60)
+        for c in self.checks:
+            icon = "✅" if c.passed else "❌"
+            lines.append(f"  {icon} {c.name}")
+            lines.append(f"     Current: {c.current}  |  Required: {c.required}")
+            if c.detail:
+                lines.append(f"     {c.detail}")
+        lines.append("-" * 60)
+        lines.append("")
+        lines.append("  METRICS:")
+        lines.append(f"    Closed trades:      {self.closed_trades}")
+        lines.append(f"    Win rate:            {self.win_rate_pct:.1f}%")
+        lines.append(f"    Profit factor:       {self.profit_factor:.2f}")
+        lines.append(f"    Max drawdown:        {self.max_drawdown_pct:.2f}%")
+        lines.append(f"    Total return:        {self.total_return_pct:.2f}%")
+        lines.append(f"    Consecutive days:    {self.consecutive_run_days}")
+        lines.append(f"    Predictions done:    {self.predictions_completed}/{MIN_PREDICTIONS_COMPLETED}")
+        lines.append(f"    Bootstrap unlocked:  {'Yes' if self.bootstrap_unlocked else 'No'}")
+        lines.append("=" * 60)
+        return "\n".join(lines)
+
+
+def _resolve_runtime_path(relative: str) -> str:
+    """If a runtime copy exists (macOS launchd on /Volumes), prefer its data paths."""
+    runtime_base = Path.home() / "borsa_uygulamasi_runtime" / "huggingface-space"
+    runtime_path = runtime_base / relative
+    if runtime_path.exists():
+        return str(runtime_path)
+    return relative
+
+
+def evaluate_readiness(
+    market_id: str = "bist",
+    db_path: Optional[str] = None,
+    model_risk_dir: Optional[str] = None,
+) -> Scorecard:
+    """Run all 7 readiness checks and return a Scorecard."""
+    from trading.db_store import TradingStore
+    from trading.market_registry import get_market_storage_dir
+
+    if db_path is None:
+        from trading.market_registry import get_trading_db_path
+        db_path = str(get_trading_db_path(market_id))
+        # Prefer runtime copy DB if it exists (daemon accumulates data there)
+        db_path = _resolve_runtime_path(db_path)
+
+    store = TradingStore(db_path=db_path)
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+    checks: List[CheckResult] = []
+
+    # --- Gather data ---
+    closed_trades = store.get_closed_trades(limit=10_000)
+    open_trades = store.get_open_trades()
+    equity_curve = store.get_equity_curve()
+    consecutive_days = store.get_consecutive_run_days(market_id)
+
+    # Prediction log
+    if model_risk_dir is None:
+        storage = get_market_storage_dir(market_id)
+        model_risk_dir = str(storage / "model_risk")
+        # BIST default path
+        if market_id == "bist":
+            model_risk_dir = "paper_trading/model_risk"
+        # Prefer runtime copy if it exists
+        model_risk_dir = _resolve_runtime_path(model_risk_dir)
+
+    pred_log_path = Path(model_risk_dir) / "prediction_log.jsonl"
+    risk_state_path = Path(model_risk_dir) / "risk_state.json"
+
+    predictions_completed = 0
+    if pred_log_path.exists():
+        for line in pred_log_path.read_text().strip().split("\n"):
+            if not line.strip():
+                continue
+            try:
+                entry = json.loads(line)
+                if entry.get("actual_return_pct") is not None:
+                    predictions_completed += 1
+            except Exception:
+                pass
+
+    bootstrap_unlocked = False
+    total_evaluations = 0
+    if risk_state_path.exists():
+        try:
+            rs = json.loads(risk_state_path.read_text())
+            total_evaluations = rs.get("total_evaluations", 0)
+            bootstrap_unlocked = total_evaluations > 0
+        except Exception:
+            pass
+
+    # --- CHECK 1: DB integrity ---
+    ghost_count = 0
+    for t in open_trades:
+        # A ghost is an open trade whose symbol is not in current broker positions
+        # We check by looking for duplicate symbols - same symbol open more than once
+        pass
+    # Simpler: check for is_closed=0 trades with zero confidence (pre-hardening artifacts)
+    import sqlite3
+    conn = sqlite3.connect(db_path)
+    cur = conn.cursor()
+    cur.execute("""
+        SELECT COUNT(*) FROM trades
+        WHERE is_closed = 0
+        AND (exit_reason = 'ghost_cleanup' OR signal_confidence < 10)
+    """)
+    ghost_count = cur.fetchone()[0]
+    # Also check for duplicate open symbols
+    cur.execute("""
+        SELECT symbol, COUNT(*) as cnt FROM trades
+        WHERE is_closed = 0
+        GROUP BY symbol HAVING cnt > 1
+    """)
+    dup_symbols = cur.fetchall()
+    conn.close()
+
+    db_clean = ghost_count == 0 and len(dup_symbols) == 0
+    db_detail = ""
+    if ghost_count > 0:
+        db_detail += f"{ghost_count} ghost record(s). "
+    if dup_symbols:
+        db_detail += f"Duplicate open: {[s[0] for s in dup_symbols]}"
+    checks.append(CheckResult(
+        name="DB Integrity (no ghosts/duplicates)",
+        passed=db_clean,
+        current="Clean" if db_clean else f"{ghost_count} ghosts, {len(dup_symbols)} dups",
+        required="No ghosts, no duplicate open positions",
+        detail=db_detail,
+    ))
+
+    # --- CHECK 2: Worker consistency ---
+    checks.append(CheckResult(
+        name=f"Worker Consistency (≥{MIN_CONSECUTIVE_RUN_DAYS} consecutive days)",
+        passed=consecutive_days >= MIN_CONSECUTIVE_RUN_DAYS,
+        current=f"{consecutive_days} consecutive trading days",
+        required=f"≥{MIN_CONSECUTIVE_RUN_DAYS} consecutive trading days",
+        detail=f"System ran {consecutive_days}/{MIN_CONSECUTIVE_RUN_DAYS} required days without gaps.",
+    ))
+
+    # --- CHECK 3: Bootstrap guard ---
+    checks.append(CheckResult(
+        name=f"Bootstrap Guard (≥{MIN_PREDICTIONS_COMPLETED} predictions, model evaluated)",
+        passed=bootstrap_unlocked,
+        current=f"{predictions_completed} predictions, {total_evaluations} evaluations",
+        required=f"≥{MIN_PREDICTIONS_COMPLETED} completed predictions + ≥1 successful evaluation",
+        detail="Model must prove prediction quality before trading is allowed." if not bootstrap_unlocked else "Bootstrap passed.",
+    ))
+
+    # --- CHECK 4: Sample size ---
+    n_closed = len(closed_trades)
+    checks.append(CheckResult(
+        name=f"Sample Size (≥{MIN_CLOSED_TRADES} closed trades)",
+        passed=n_closed >= MIN_CLOSED_TRADES,
+        current=f"{n_closed} closed trades",
+        required=f"≥{MIN_CLOSED_TRADES} closed trades",
+        detail=f"Need {max(0, MIN_CLOSED_TRADES - n_closed)} more closed trades for statistical significance.",
+    ))
+
+    # --- CHECK 5: Win rate + Profit factor ---
+    win_rate = 0.0
+    profit_factor = 0.0
+    total_pnl = 0.0
+    if n_closed > 0:
+        wins = [t for t in closed_trades if (t.get("net_pnl") or 0) > 0]
+        losses = [t for t in closed_trades if (t.get("net_pnl") or 0) <= 0]
+        win_rate = len(wins) / n_closed * 100
+        gross_wins = sum(t.get("net_pnl", 0) for t in wins)
+        gross_losses = abs(sum(t.get("net_pnl", 0) for t in losses))
+        profit_factor = gross_wins / max(1, gross_losses)
+        total_pnl = sum(t.get("net_pnl", 0) for t in closed_trades)
+
+    wr_ok = win_rate >= MIN_WIN_RATE_PCT and n_closed >= MIN_CLOSED_TRADES
+    pf_ok = profit_factor >= MIN_PROFIT_FACTOR and n_closed >= MIN_CLOSED_TRADES
+    perf_ok = wr_ok and pf_ok
+    checks.append(CheckResult(
+        name=f"Performance (WR≥{MIN_WIN_RATE_PCT}% & PF≥{MIN_PROFIT_FACTOR})",
+        passed=perf_ok,
+        current=f"WR={win_rate:.1f}% PF={profit_factor:.2f} (n={n_closed})",
+        required=f"WR≥{MIN_WIN_RATE_PCT}% AND PF≥{MIN_PROFIT_FACTOR} over ≥{MIN_CLOSED_TRADES} trades",
+        detail="Not enough trades to evaluate." if n_closed < MIN_CLOSED_TRADES else "",
+    ))
+
+    # --- CHECK 6: Max drawdown ---
+    max_dd = 0.0
+    total_return = 0.0
+    if len(equity_curve) >= 2:
+        equities = [s["equity"] for s in equity_curve]
+        initial = equities[0]
+        total_return = (equities[-1] - initial) / initial * 100 if initial > 0 else 0
+        peak = equities[0]
+        for eq in equities:
+            if eq > peak:
+                peak = eq
+            dd = (peak - eq) / peak * 100 if peak > 0 else 0
+            if dd > max_dd:
+                max_dd = dd
+
+    dd_ok = max_dd <= MAX_DRAWDOWN_PCT and len(equity_curve) >= MIN_CONSECUTIVE_RUN_DAYS
+    checks.append(CheckResult(
+        name=f"Max Drawdown (≤{MAX_DRAWDOWN_PCT}%)",
+        passed=dd_ok,
+        current=f"{max_dd:.2f}% (from {len(equity_curve)} snapshots)",
+        required=f"≤{MAX_DRAWDOWN_PCT}% over ≥{MIN_CONSECUTIVE_RUN_DAYS} days",
+        detail="Not enough daily snapshots to compute reliable drawdown." if len(equity_curve) < MIN_CONSECUTIVE_RUN_DAYS else "",
+    ))
+
+    # --- CHECK 7: Walk-forward all periods positive ---
+    wf_dir = Path("walk_forward_out")
+    wf_results: List[Dict[str, Any]] = []
+    all_positive = True
+
+    # Load market universe to filter walk-forward results by market
+    market_symbols: set = set()
+    try:
+        from trading.market_registry import get_scan_results_path
+        _scan_path = get_scan_results_path(market_id)
+        if _scan_path.exists():
+            import json as _json
+            _scan = _json.loads(_scan_path.read_text())
+            # stage1 keys are the scanned symbols for this market
+            if "stage1" in _scan and isinstance(_scan["stage1"], dict):
+                market_symbols = set(_scan["stage1"].keys())
+            elif "stage2" in _scan and isinstance(_scan["stage2"], dict):
+                market_symbols = set(_scan["stage2"].keys())
+    except Exception:
+        pass
+
+    if wf_dir.exists():
+        import csv
+        for trades_file in sorted(wf_dir.glob("*_trades.csv")):
+            try:
+                with open(trades_file) as f:
+                    rows = list(csv.DictReader(f))
+                if len(rows) < 2:
+                    continue
+                # Last sell row has final capital
+                sells = [r for r in rows if r.get("type") == "SELL"]
+                if sells:
+                    final_cap = float(sells[-1]["capital"])
+                    ret = (final_cap - 100_000) / 100_000 * 100
+                    sym = trades_file.stem.split("_7d_")[0]
+                    # Filter: only include symbols belonging to the requested market
+                    if market_symbols and sym not in market_symbols:
+                        continue
+                    wf_results.append({"symbol": sym, "return_pct": round(ret, 2), "trades": len(sells)})
+                    if ret <= 0:
+                        all_positive = False
+            except Exception:
+                pass
+
+    wf_ok = all_positive and len(wf_results) >= 3  # need at least 3 symbols tested
+    neg = [r for r in wf_results if r["return_pct"] <= 0]
+    checks.append(CheckResult(
+        name="Walk-Forward All Periods Positive",
+        passed=wf_ok,
+        current=f"{len(wf_results)} symbols tested, {len(neg)} negative",
+        required="All walk-forward test periods positive (≥3 symbols)",
+        detail=f"Negative: {[r['symbol'] for r in neg]}" if neg else "All positive." if wf_results else "No walk-forward data found.",
+    ))
+
+    # --- Build scorecard ---
+    verdict = "GO" if all(c.passed for c in checks) else "NO_GO"
+    sc = Scorecard(
+        date=today,
+        market_id=market_id,
+        verdict=verdict,
+        checks=checks,
+        closed_trades=n_closed,
+        win_rate_pct=win_rate,
+        profit_factor=profit_factor,
+        max_drawdown_pct=max_dd,
+        total_return_pct=total_return,
+        consecutive_run_days=consecutive_days,
+        predictions_completed=predictions_completed,
+        bootstrap_unlocked=bootstrap_unlocked,
+    )
+
+    # Persist to DB
+    store.record_scorecard(
+        date=today,
+        market_id=market_id,
+        verdict=verdict,
+        checks_passed=sc.checks_passed,
+        checks_total=sc.checks_total,
+        closed_trades=n_closed,
+        win_rate_pct=win_rate,
+        profit_factor=profit_factor,
+        max_drawdown_pct=max_dd,
+        total_return_pct=total_return,
+        consecutive_run_days=consecutive_days,
+        predictions_completed=predictions_completed,
+        predictions_needed=MIN_PREDICTIONS_COMPLETED,
+        bootstrap_unlocked=bootstrap_unlocked,
+        detail_json=sc.to_dict(),
+    )
+
+    return sc
+
+
+def print_readiness_report(market_id: str = "bist") -> Scorecard:
+    """Evaluate and print a human-readable readiness report."""
+    sc = evaluate_readiness(market_id=market_id)
+    print(sc.to_report())
+
+    # Print trend if history exists
+    from trading.db_store import TradingStore
+    from trading.market_registry import get_trading_db_path
+    store = TradingStore(db_path=str(get_trading_db_path(market_id)))
+    history = store.get_scorecard_history(market_id=market_id, limit=10)
+    if len(history) > 1:
+        print("\n  TREND (last 10 scorecards):")
+        print(f"  {'Date':<12} {'Pass':>5} {'Trades':>7} {'WR%':>6} {'PF':>6} {'DD%':>6} {'Days':>5}")
+        for h in reversed(history):
+            print(
+                f"  {h['date']:<12} {h['checks_passed']}/{h['checks_total']}   "
+                f"{h['closed_trades']:>5}  {h['win_rate_pct']:>5.1f} {h['profit_factor']:>5.2f} "
+                f"{h['max_drawdown_pct']:>5.2f} {h['consecutive_run_days']:>5}"
+            )
+        print()
+
+    return sc

huggingface-space/trading/risk_gate.py

@@ -78,10 +78,9 @@ def make_risk_limits_for_market(market_id: str) -> RiskLimits:
         return RiskLimits()  # defaults are BIST-calibrated
     # US equities — same capital ratios, USD-compatible amounts, NYSE hours
     return RiskLimits(
-        market_open_hour_utc=13,   # 9:30 AM EDT = 13:30 UTC (13 covers both DST/non-DST)
-        market_close_hour_utc=21,  # 4:00 PM EST = 21:00 UTC (21 covers both DST/non-DST)
-        min_price_tl=1.0,          # $1 minimum share price for US
-        # Capital limits same (25K USD/TL both reasonable for respective accounts)
+        market_open_hour_utc=13,
+        market_close_hour_utc=21,
+        min_price_tl=1.0,
     )
 
 
@@ -101,17 +100,21 @@ class RiskGate:
     and tracks daily order count / P&L internally.
     """
 
+    _STATE_KEY = "risk_gate_state"
+
     def __init__(
         self,
         limits: Optional[RiskLimits] = None,
         monitor: Optional[TradingMonitor] = None,
         kill_switch: Optional[KillSwitch] = None,
         alert_manager: Optional[AlertManager] = None,
+        store: Optional[Any] = None,
     ) -> None:
         self.limits = limits or RiskLimits()
         self.monitor = monitor
         self.kill_switch = kill_switch or KillSwitch()
         self.alerts = alert_manager
+        self._store = store  # TradingStore for persistence
 
         # Daily tracking
         self._daily_date: Optional[str] = None
@@ -120,12 +123,56 @@ class RiskGate:
         self._consecutive_losses: int = 0
         self._peak_equity: float = 0.0
 
+        # Restore persisted state on startup
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """Load persisted risk counters from SQLite (survives restarts)."""
+        if not self._store:
+            return
+        try:
+            saved = self._store.get_state(self._STATE_KEY)
+            if not saved or not isinstance(saved, dict):
+                return
+            today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+            saved_date = saved.get("daily_date")
+            # Daily counters: only restore if same day
+            if saved_date == today:
+                self._daily_date = today
+                self._daily_order_count = int(saved.get("daily_order_count", 0))
+                self._daily_realized_pnl = float(saved.get("daily_realized_pnl", 0.0))
+            # Cross-day counters: always restore
+            self._consecutive_losses = int(saved.get("consecutive_losses", 0))
+            self._peak_equity = float(saved.get("peak_equity", 0.0))
+            logger.info(
+                "RiskGate state restored: consec_losses=%d, peak_equity=%.0f, daily_orders=%d",
+                self._consecutive_losses, self._peak_equity, self._daily_order_count,
+            )
+        except Exception as e:
+            logger.warning("Failed to load risk gate state: %s", e)
+
+    def _save_state(self) -> None:
+        """Persist current risk counters to SQLite."""
+        if not self._store:
+            return
+        try:
+            self._store.set_state(self._STATE_KEY, {
+                "daily_date": self._daily_date,
+                "daily_order_count": self._daily_order_count,
+                "daily_realized_pnl": self._daily_realized_pnl,
+                "consecutive_losses": self._consecutive_losses,
+                "peak_equity": self._peak_equity,
+            })
+        except Exception as e:
+            logger.warning("Failed to save risk gate state: %s", e)
+
     def _reset_daily_if_needed(self) -> None:
         today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
         if self._daily_date != today:
             self._daily_date = today
             self._daily_order_count = 0
             self._daily_realized_pnl = 0.0
+            self._save_state()
 
     def record_trade_result(self, pnl: float) -> None:
         """Call after each trade closes to track consecutive losses."""
@@ -134,11 +181,13 @@ class RiskGate:
         else:
             self._consecutive_losses = 0
         self._daily_realized_pnl += pnl
+        self._save_state()
 
     def record_equity(self, equity: float) -> None:
         """Track peak equity for drawdown calculation."""
         if equity > self._peak_equity:
             self._peak_equity = equity
+            self._save_state()
 
     def check(
         self,
@@ -323,6 +372,7 @@ class RiskGate:
 
         # All checks passed
         self._daily_order_count += 1
+        self._save_state()
         return RiskCheckResult(
             passed=True,
             checks_performed=checks,

huggingface-space/trading/scanner_engine.py

@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import gc
+import json
+import logging
+import time
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from trading.market_registry import get_scan_results_path, to_provider_symbol
+from trading.universe_provider import get_market_universe
+
+
+def _default_backtest_end() -> str:
+    """Return the most recent completed trading weekday as YYYY-MM-DD."""
+    d = date.today() - timedelta(days=1)
+    while d.weekday() >= 5:  # Saturday=5, Sunday=6
+        d -= timedelta(days=1)
+    return d.isoformat()
+
+
+@dataclass(frozen=True)
+class ScanConfig:
+    market_id: str
+    universe_name: str
+    title: str
+    symbols: Optional[List[str]] = None
+    max_symbols: Optional[int] = None
+    min_data_days: int = 252
+    min_avg_volume: int = 500_000
+    min_price: float = 1.0
+    backtest_start: str = "2023-01-01"
+    backtest_end: str = field(default_factory=_default_backtest_end)
+    train_window: int = 252
+    days_ahead: int = 7
+    min_dir_acc: float = 0.53
+    min_sharpe: float = 0.0
+    min_hit_rate: float = 40.0
+    min_trades: int = 3
+
+    @property
+    def final_results_file(self) -> Path:
+        return get_scan_results_path(self.market_id, completed=True)
+
+    @property
+    def work_results_file(self) -> Path:
+        return get_scan_results_path(self.market_id, completed=False)
+
+    @property
+    def universe_key(self) -> str:
+        parts = [self.market_id, self.universe_name]
+        if self.symbols:
+            parts.append("symbols=" + ",".join(self.symbols))
+        if self.max_symbols:
+            parts.append(f"max={self.max_symbols}")
+        return "|".join(parts)
+
+
+def _load_results(config: ScanConfig) -> Dict[str, Any]:
+    src = None
+    if config.work_results_file.exists():
+        src = config.work_results_file
+    elif config.final_results_file.exists():
+        src = config.final_results_file
+
+    if src is not None and src.exists():
+        try:
+            return json.loads(src.read_text())
+        except Exception:
+            pass
+    return {
+        "market_id": config.market_id,
+        "scan_started": None,
+        "universe": None,
+        "universe_key": None,
+        "stage1": {},
+        "stage2": {},
+        "completed": False,
+    }
+
+
+def _save_results(config: ScanConfig, data: Dict[str, Any]) -> None:
+    config.work_results_file.parent.mkdir(parents=True, exist_ok=True)
+    data["market_id"] = config.market_id
+    data["updated_at"] = datetime.now(timezone.utc).isoformat()
+    tmp = config.work_results_file.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, default=str))
+    tmp.rename(config.work_results_file)
+
+
+def _publish_final_if_complete(config: ScanConfig, data: Dict[str, Any]) -> None:
+    if not data.get("completed", False):
+        return
+    config.final_results_file.parent.mkdir(parents=True, exist_ok=True)
+    tmp = config.final_results_file.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, default=str))
+    tmp.rename(config.final_results_file)
+
+
+def stage1_prefilter(symbol: str, config: ScanConfig) -> Dict[str, Any]:
+    import yfinance as yf
+
+    ticker = to_provider_symbol(symbol, market_id=config.market_id)
+    result: Dict[str, Any] = {
+        "market_id": config.market_id,
+        "symbol": symbol,
+        "provider_symbol": ticker,
+        "passed": False,
+        "reason": "",
+        "avg_volume": 0.0,
+        "data_days": 0,
+        "last_price": 0.0,
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    try:
+        df = yf.download(ticker, period="2y", progress=False, auto_adjust=True)
+        if df is None or df.empty:
+            result["reason"] = "no_data"
+            return result
+
+        data_days = len(df)
+        result["data_days"] = data_days
+        if data_days < config.min_data_days:
+            result["reason"] = f"insufficient_data ({data_days} < {config.min_data_days} days)"
+            return result
+
+        avg_vol = 0.0
+        if "Volume" in df.columns:
+            avg_vol_raw = df["Volume"].mean()
+            avg_vol = float(avg_vol_raw.iloc[0]) if hasattr(avg_vol_raw, "iloc") else float(avg_vol_raw)
+        result["avg_volume"] = round(avg_vol, 0)
+        if avg_vol < config.min_avg_volume:
+            result["reason"] = f"low_volume ({avg_vol:,.0f} < {config.min_avg_volume:,.0f})"
+            return result
+
+        last_price = float(df["Close"].iloc[-1].iloc[0]) if hasattr(df["Close"].iloc[-1], "iloc") else float(df["Close"].iloc[-1])
+        result["last_price"] = round(last_price, 2)
+        if last_price < config.min_price:
+            result["reason"] = f"below_min_price (price={last_price:.2f} < {config.min_price:.2f})"
+            return result
+
+        result["passed"] = True
+        result["reason"] = "OK"
+        return result
+    except Exception as exc:
+        result["reason"] = f"error: {exc}"
+        return result
+
+
+def stage2_backtest(symbol: str, config: ScanConfig, logger: logging.Logger) -> Dict[str, Any]:
+    from analysis.walk_forward_backtest import walk_forward_backtest
+
+    result: Dict[str, Any] = {
+        "market_id": config.market_id,
+        "symbol": symbol,
+        "eligible": False,
+        "reason": "",
+        "evaluated_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    try:
+        _, metrics = walk_forward_backtest(
+            symbol=symbol,
+            start_date=config.backtest_start,
+            end_date=config.backtest_end,
+            market_id=config.market_id,
+            days_ahead=config.days_ahead,
+            train_window=config.train_window,
+            model_type="rf",
+            use_technical_gate=True,
+            initial_capital=100_000.0,
+            commission_bps=10.0,
+            slippage_bps=10.0,
+            exit_rule="signal_or_fixed",
+            max_hold_days=config.days_ahead,
+            stop_loss_pct=0.05,
+            take_profit_pct=0.10,
+            trailing_stop_pct=0.07,
+            max_position_pct=0.50,
+            max_risk_per_trade_pct=0.02,
+        )
+
+        dir_acc = metrics["direction_accuracy"]
+        sharpe = metrics["sharpe"]
+        hit_rate = metrics.get("hit_rate_pct", 0.0)
+        total_ret = metrics["total_return_pct"]
+        trades = metrics["trades_count"]
+        max_dd = metrics.get("max_drawdown_pct", 0.0)
+
+        result.update({
+            "dir_acc": round(dir_acc, 4),
+            "sharpe": round(sharpe, 3),
+            "hit_rate": round(hit_rate, 1),
+            "total_return_pct": round(total_ret, 1),
+            "trades": trades,
+            "max_drawdown_pct": round(max_dd, 1),
+        })
+
+        reasons: List[str] = []
+        if dir_acc < config.min_dir_acc:
+            reasons.append(f"dir_acc={dir_acc:.1%}<{config.min_dir_acc:.0%}")
+        if sharpe < config.min_sharpe:
+            reasons.append(f"sharpe={sharpe:.3f}<{config.min_sharpe}")
+        if hit_rate < config.min_hit_rate:
+            reasons.append(f"hit_rate={hit_rate:.1f}%<{config.min_hit_rate}%")
+        if trades < config.min_trades:
+            reasons.append(f"trades={trades}<{config.min_trades}")
+
+        result["eligible"] = len(reasons) == 0
+        result["reason"] = "; ".join(reasons) if reasons else "OK"
+        return result
+    except Exception as exc:
+        result["reason"] = f"backtest_error: {exc}"
+        logger.warning("Stage 2 failed for %s: %s", symbol, exc)
+        return result
+
+
+def get_universe(config: ScanConfig, logger: logging.Logger) -> List[str]:
+    if config.symbols:
+        symbols = list(dict.fromkeys(config.symbols))
+        if config.max_symbols:
+            symbols = symbols[: config.max_symbols]
+        logger.info("Using explicit symbol subset for %s/%s: %s", config.market_id, config.universe_name, ", ".join(symbols))
+        return symbols
+    try:
+        result = get_market_universe(config.market_id, config.universe_name)
+        symbols = result.symbols
+        if config.max_symbols:
+            symbols = symbols[: config.max_symbols]
+            logger.info(
+                "Fetched %d stocks from %s/%s, limited to first %d symbols",
+                len(result.symbols), result.market_id, result.name, len(symbols),
+            )
+        else:
+            logger.info("Fetched %d stocks from %s/%s", len(result.symbols), result.market_id, result.name)
+        return symbols
+    except Exception as exc:
+        logger.error("Failed to fetch universe %s/%s: %s", config.market_id, config.universe_name, exc)
+        if config.market_id == "bist":
+            return [
+                "THYAO", "AKBNK", "GARAN", "EREGL", "SISE",
+                "TUPRS", "KCHOL", "ASELS", "BIMAS", "SAHOL",
+                "YKBNK", "HALKB", "VAKBN", "TCELL", "ARCLK",
+                "PETKM", "TOASO", "KOZAA", "KOZAL", "SASA",
+                "TAVHL", "TTKOM", "ENKAI", "FROTO", "EKGYO",
+                "PGSUS", "SOKM", "DOHOL", "GUBRF", "ISCTR",
+            ]
+        if config.market_id == "us":
+            return [
+                "AAPL", "MSFT", "AMZN", "GOOGL", "META",
+                "NVDA", "TSLA", "BRK-B", "JPM", "JNJ",
+                "V", "UNH", "PG", "HD", "MA",
+                "DIS", "BAC", "XOM", "PFE", "CSCO",
+                "ABBV", "AVGO", "KO", "PEP", "TMO",
+                "COST", "MRK", "WMT", "ABT", "CRM",
+            ]
+        return []
+
+
+def run_scan(config: ScanConfig, logger: logging.Logger, *, force: bool = False, stage1_only: bool = False) -> Dict[str, Any]:
+    symbols = get_universe(config, logger)
+    if not symbols:
+        logger.error("No symbols found for universe: %s", config.universe_name)
+        return {}
+
+    data = _load_results(config)
+    existing_key = data.get("universe_key") or data.get("universe")
+    is_same_universe = existing_key == config.universe_key
+    if not is_same_universe or force:
+        logger.info("Starting fresh scan for %s/%s (%d stocks)", config.market_id, config.universe_name, len(symbols))
+        data = {
+            "market_id": config.market_id,
+            "scan_started": datetime.now(timezone.utc).isoformat(),
+            "universe": config.universe_name,
+            "universe_key": config.universe_key,
+            "total_stocks": len(symbols),
+            "stage1": {},
+            "stage2": {},
+            "completed": False,
+        }
+        _save_results(config, data)
+    else:
+        s1_done = len(data.get("stage1", {}))
+        s2_done = len(data.get("stage2", {}))
+        logger.info("Resuming scan: %d/%d Stage1, %d Stage2 done", s1_done, len(symbols), s2_done)
+
+    logger.info("=" * 60)
+    logger.info("STAGE 1: Liquidity & Data Quality Pre-Filter")
+    logger.info("=" * 60)
+
+    s1_todo = [s for s in symbols if s not in data.get("stage1", {})]
+    total_s1 = len(symbols)
+    done_s1 = total_s1 - len(s1_todo)
+
+    for i, sym in enumerate(s1_todo, start=done_s1 + 1):
+        t0 = time.time()
+        result = stage1_prefilter(sym, config)
+        elapsed = time.time() - t0
+        status = "PASS" if result["passed"] else f"FAIL ({result['reason']})"
+        logger.info("[Stage1 %d/%d] %s: %s (%.1fs)", i, total_s1, sym, status, elapsed)
+        data.setdefault("stage1", {})[sym] = result
+        _save_results(config, data)
+        gc.collect()
+
+    s1_passed = [s for s, v in data["stage1"].items() if v.get("passed")]
+    s1_failed = [s for s, v in data["stage1"].items() if not v.get("passed")]
+    logger.info("")
+    logger.info("Stage 1 Results: %d PASS / %d FAIL out of %d", len(s1_passed), len(s1_failed), total_s1)
+    logger.info("Passed: %s", ", ".join(sorted(s1_passed)))
+    logger.info("")
+
+    if stage1_only:
+        data["completed"] = True
+        _save_results(config, data)
+        _publish_final_if_complete(config, data)
+        return data
+
+    logger.info("=" * 60)
+    logger.info("STAGE 2: ML Walk-Forward Backtest")
+    logger.info("=" * 60)
+
+    s2_todo = [s for s in s1_passed if s not in data.get("stage2", {})]
+    total_s2 = len(s1_passed)
+    done_s2 = total_s2 - len(s2_todo)
+    times_s2: List[float] = []
+
+    for i, sym in enumerate(s2_todo, start=done_s2 + 1):
+        t0 = time.time()
+        result = stage2_backtest(sym, config, logger)
+        elapsed = time.time() - t0
+        times_s2.append(elapsed)
+
+        if result["eligible"]:
+            status = (
+                f"ELIGIBLE (ret={result.get('total_return_pct', 0):.1f}%, "
+                f"sharpe={result.get('sharpe', 0):.3f}, "
+                f"hit={result.get('hit_rate', 0):.0f}%)"
+            )
+        else:
+            status = f"EXCLUDED ({result['reason']})"
+
+        avg_time = sum(times_s2) / len(times_s2)
+        remaining = total_s2 - i
+        eta_min = (remaining * avg_time) / 60
+        logger.info("[Stage2 %d/%d] %s: %s (%.1fs, ETA: %.0f min)", i, total_s2, sym, status, elapsed, eta_min)
+        data.setdefault("stage2", {})[sym] = result
+        _save_results(config, data)
+        gc.collect()
+
+    data["completed"] = True
+    data["scan_finished"] = datetime.now(timezone.utc).isoformat()
+    _save_results(config, data)
+    _publish_final_if_complete(config, data)
+    print_report(config, logger, data)
+    return data
+
+
+def print_report(config: ScanConfig, logger: logging.Logger, data: Optional[Dict[str, Any]] = None) -> None:
+    if data is None:
+        data = _load_results(config)
+
+    s2 = data.get("stage2", {})
+    if not s2:
+        logger.info("No Stage 2 results found. Run scan first.")
+        return
+
+    eligible = {s: v for s, v in s2.items() if v.get("eligible")}
+    excluded = {s: v for s, v in s2.items() if not v.get("eligible")}
+
+    print("\n" + "=" * 70)
+    print(f"  {config.title} SCAN RESULTS — {data.get('universe', '?').upper()}")
+    print("=" * 70)
+    s1 = data.get("stage1", {})
+    s1_pass = sum(1 for v in s1.values() if v.get("passed"))
+    s1_fail = sum(1 for v in s1.values() if not v.get("passed"))
+    print(f"\nStage 1 (Liquidity Filter):  {s1_pass} pass / {s1_fail} fail / {len(s1)} total")
+    print(f"Stage 2 (ML Backtest):       {len(eligible)} eligible / {len(excluded)} excluded / {len(s2)} tested")
+
+    if eligible:
+        print(f"\n{'─' * 70}")
+        print(f"  ELIGIBLE STOCKS ({len(eligible)})")
+        print(f"{'─' * 70}")
+        print(f"  {'Symbol':<10} {'Return%':>9} {'Sharpe':>8} {'HitRate%':>9} {'MaxDD%':>8} {'Trades':>7}")
+        print(f"  {'─'*10} {'─'*9} {'─'*8} {'─'*9} {'─'*8} {'─'*7}")
+        sorted_eligible = sorted(eligible.items(), key=lambda kv: kv[1].get("sharpe", -999), reverse=True)
+        for sym, metrics in sorted_eligible:
+            print(
+                f"  {sym:<10} {metrics.get('total_return_pct', 0):>+8.1f}% "
+                f"{metrics.get('sharpe', 0):>8.3f} "
+                f"{metrics.get('hit_rate', 0):>8.1f}% "
+                f"{metrics.get('max_drawdown_pct', 0):>7.1f}% "
+                f"{metrics.get('trades', 0):>7d}"
+            )
+
+    if excluded:
+        print(f"\n{'─' * 70}")
+        print(f"  EXCLUDED STOCKS ({len(excluded)})")
+        print(f"{'─' * 70}")
+        for sym, metrics in sorted(excluded.items()):
+            print(f"  {sym:<10} {metrics.get('reason', 'unknown')}")