Sync from GitHub (tests passed)

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11-slim
+FROM python:3.11-slim@sha256:9a7765b36773a37061455b332f18e265e7f58f6fea9c419a550d2a8b0e9db834
 
 WORKDIR /code
 

app/main.py

@@ -8,6 +8,7 @@ Endpoints:
 """
 
 import logging
+from collections import defaultdict
 from dataclasses import dataclass
 
 # Suppress httpx request logging to prevent API keys in URLs from appearing in logs
@@ -18,7 +19,7 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Optional
 
-from fastapi import FastAPI, HTTPException, Query, WebSocket, WebSocketDisconnect, Depends, Header, BackgroundTasks
+from fastapi import FastAPI, HTTPException, Query, WebSocket, WebSocketDisconnect, Depends, Header, BackgroundTasks, Request
 from fastapi.middleware.cors import CORSMiddleware
 from sqlalchemy import func
 
@@ -100,10 +101,18 @@ app = FastAPI(
     lifespan=lifespan,
 )
 
+def _resolve_cors_origins() -> list[str]:
+    settings = get_settings()
+    origins = settings.cors_allowed_origins_list
+    if "*" in origins and settings.environment.lower() in {"prod", "production"}:
+        raise RuntimeError("CORS wildcard is forbidden in production")
+    return origins
+
+
 # CORS configuration
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, restrict this
+    allow_origins=_resolve_cors_origins(),
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -1150,7 +1159,32 @@ async def api_root():
 # =============================================================================
 
 
-def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
+_PIPELINE_AUTH_FAILURES: dict[str, list[datetime]] = defaultdict(list)
+
+
+def _pipeline_auth_key(request: Request) -> str:
+    if request.client and request.client.host:
+        return request.client.host
+    return "unknown"
+
+
+def _record_pipeline_auth_failure(key: str) -> None:
+    now = datetime.now(timezone.utc)
+    cutoff = now - timedelta(minutes=10)
+    recent = [ts for ts in _PIPELINE_AUTH_FAILURES[key] if ts >= cutoff]
+    recent.append(now)
+    _PIPELINE_AUTH_FAILURES[key] = recent
+    if len(recent) > 5:
+        raise HTTPException(
+            status_code=429,
+            detail="Too many invalid pipeline trigger attempts",
+        )
+
+
+def verify_pipeline_secret(
+    request: Request,
+    authorization: Optional[str] = Header(None),
+) -> None:
     """
     Verify the pipeline trigger secret from Authorization header.
     
@@ -1158,9 +1192,12 @@ def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
     """
     settings = get_settings()
     
+    auth_key = _pipeline_auth_key(request)
+
     # If no secret is configured, reject all requests (fail secure)
     if not settings.pipeline_trigger_secret:
         logger.warning("Pipeline trigger attempted but PIPELINE_TRIGGER_SECRET not configured")
+        _record_pipeline_auth_failure(auth_key)
         raise HTTPException(
             status_code=401,
             detail="Pipeline trigger authentication not configured. Set PIPELINE_TRIGGER_SECRET."
@@ -1168,6 +1205,7 @@ def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
     
     # Check Authorization header
     if not authorization:
+        _record_pipeline_auth_failure(auth_key)
         raise HTTPException(
             status_code=401,
             detail="Missing Authorization header. Expected: Bearer <token>"
@@ -1176,6 +1214,7 @@ def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
     # Parse Bearer token
     parts = authorization.split(" ", 1)
     if len(parts) != 2 or parts[0].lower() != "bearer":
+        _record_pipeline_auth_failure(auth_key)
         raise HTTPException(
             status_code=401,
             detail="Invalid Authorization format. Expected: Bearer <token>"
@@ -1187,11 +1226,13 @@ def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
     import secrets
     if not secrets.compare_digest(token, settings.pipeline_trigger_secret):
         logger.warning("Pipeline trigger attempted with invalid token")
+        _record_pipeline_auth_failure(auth_key)
         raise HTTPException(
             status_code=401,
             detail="Invalid pipeline trigger token"
         )
-    
+
+    _PIPELINE_AUTH_FAILURES.pop(auth_key, None)
     logger.info("Pipeline trigger authorized successfully")
 
 
@@ -1208,7 +1249,12 @@ def verify_pipeline_secret(authorization: Optional[str] = Header(None)) -> None:
 )
 async def trigger_pipeline(
     train_model: bool = Query(default=False, description="Train/retrain XGBoost model"),
-    trigger_source: str = Query(default="api", description="Source of trigger (api, cron, manual)"),
+    trigger_source: str = Query(
+        default="api",
+        max_length=32,
+        pattern="^(api|cron|manual|github-actions)$",
+        description="Source of trigger (api, cron, manual, github-actions)",
+    ),
     _auth: None = Depends(verify_pipeline_secret),
 ):
     """
@@ -1386,7 +1432,11 @@ async def get_tft_summary(
         weekly_mr = metrics.get("weekly_magnitude_ratio")
         weekly_tail = metrics.get("weekly_tail_capture_rate")
         weekly_pi80 = metrics.get("weekly_pi80_coverage")
+        weekly_pi80_width_ratio = metrics.get("weekly_pi80_width_ratio")
+        weekly_pi96 = metrics.get("weekly_pi96_coverage")
+        weekly_pi96_width_ratio = metrics.get("weekly_pi96_width_ratio")
         weekly_qcross = metrics.get("weekly_quantile_crossing_rate")
+        weekly_sorted_qcross = metrics.get("weekly_sorted_quantile_crossing_rate")
         weekly_gap = metrics.get("weekly_median_sort_gap_max")
         weekly_samples = metrics.get("weekly_sample_count")
         
@@ -1401,7 +1451,11 @@ async def get_tft_summary(
             weekly_magnitude_ratio=weekly_mr,
             weekly_tail_capture_rate=weekly_tail,
             weekly_pi80_coverage=weekly_pi80,
+            weekly_pi80_width_ratio=weekly_pi80_width_ratio,
+            weekly_pi96_coverage=weekly_pi96,
+            weekly_pi96_width_ratio=weekly_pi96_width_ratio,
             weekly_quantile_crossing_rate=weekly_qcross,
+            weekly_sorted_quantile_crossing_rate=weekly_sorted_qcross,
             weekly_median_sort_gap_max=weekly_gap,
             weekly_sample_count=weekly_samples,
         )
@@ -1422,7 +1476,11 @@ async def get_tft_summary(
             "weekly_magnitude_ratio": weekly_mr,
             "weekly_tail_capture_rate": weekly_tail,
             "weekly_pi80_coverage": weekly_pi80,
+            "weekly_pi80_width_ratio": weekly_pi80_width_ratio,
+            "weekly_pi96_coverage": weekly_pi96,
+            "weekly_pi96_width_ratio": weekly_pi96_width_ratio,
             "weekly_quantile_crossing_rate": weekly_qcross,
+            "weekly_sorted_quantile_crossing_rate": weekly_sorted_qcross,
             "weekly_median_sort_gap_max": weekly_gap,
             "weekly_sample_count": weekly_samples,
         }.items():

app/quality_gate.py

@@ -25,7 +25,11 @@ def evaluate_quality_gate(
     weekly_magnitude_ratio: Optional[float] = None,
     weekly_tail_capture_rate: Optional[float] = None,
     weekly_pi80_coverage: Optional[float] = None,
+    weekly_pi80_width_ratio: Optional[float] = None,
+    weekly_pi96_coverage: Optional[float] = None,
+    weekly_pi96_width_ratio: Optional[float] = None,
     weekly_quantile_crossing_rate: Optional[float] = None,
+    weekly_sorted_quantile_crossing_rate: Optional[float] = None,
     weekly_median_sort_gap_max: Optional[float] = None,
     weekly_sample_count: Optional[int] = None,
 ) -> Tuple[bool, List[str]]:
@@ -64,10 +68,32 @@ def evaluate_quality_gate(
     elif weekly_pi80_coverage < 0.74 or weekly_pi80_coverage > 0.86:
         reasons.append(f"WeeklyPI80={weekly_pi80_coverage:.4f} outside [0.74, 0.86]")
 
+    if weekly_pi80_width_ratio is None:
+        reasons.append("Missing weekly_pi80_width_ratio")
+    elif weekly_pi80_width_ratio > 2.0 and weekly_pi80_coverage is not None and weekly_pi80_coverage > 0.86:
+        reasons.append(
+            f"WeeklyPI80Overwide={weekly_pi80_width_ratio:.4f} with coverage={weekly_pi80_coverage:.4f}"
+        )
+
+    if weekly_pi96_coverage is None:
+        reasons.append("Missing weekly_pi96_coverage")
+
+    if weekly_pi96_width_ratio is None:
+        reasons.append("Missing weekly_pi96_width_ratio")
+    elif weekly_pi96_width_ratio > 3.0:
+        reasons.append(f"WeeklyPI96WidthRatio={weekly_pi96_width_ratio:.4f} > 3.0")
+
     if weekly_quantile_crossing_rate is None:
         reasons.append("Missing weekly_quantile_crossing_rate")
-    elif weekly_quantile_crossing_rate > 0.10:
-        reasons.append(f"WeeklyQuantileCrossing={weekly_quantile_crossing_rate:.4f} > 0.10")
+    elif weekly_quantile_crossing_rate > 0.05:
+        reasons.append(f"WeeklyQuantileCrossing={weekly_quantile_crossing_rate:.4f} > 0.05")
+
+    if weekly_sorted_quantile_crossing_rate is None:
+        reasons.append("Missing weekly_sorted_quantile_crossing_rate")
+    elif weekly_sorted_quantile_crossing_rate > 0.0:
+        reasons.append(
+            f"WeeklySortedQuantileCrossing={weekly_sorted_quantile_crossing_rate:.4f} > 0.0"
+        )
 
     if weekly_median_sort_gap_max is not None and weekly_median_sort_gap_max > 0.005:
         reasons.append(f"WeeklyMedianSortGapMax={weekly_median_sort_gap_max:.4f} > 0.005")

app/settings.py

@@ -63,6 +63,13 @@ class Settings(BaseSettings):
     # API settings
     analysis_ttl_minutes: int = 30
     log_level: str = "INFO"
+    environment: str = "development"
+    cors_allowed_origins: str = (
+        "http://localhost:3000,"
+        "http://localhost:5173,"
+        "http://127.0.0.1:3000,"
+        "http://127.0.0.1:5173"
+    )
     
     # NOTE: `futures_spot_adjustment` was removed 2026-04.
     # It was an unused 1:1 scaling constant between HG=F and XCU/USD which
@@ -204,6 +211,16 @@ class Settings(BaseSettings):
         Always uses env variable (14 symbols).
         """
         return [s.strip() for s in self.yfinance_symbols.split(",") if s.strip()]
+
+    @property
+    def cors_allowed_origins_list(self) -> list[str]:
+        """Parse CORS origins from comma-separated environment configuration."""
+        origins = [
+            origin.strip()
+            for origin in self.cors_allowed_origins.split(",")
+            if origin.strip()
+        ]
+        return origins or ["http://localhost:3000", "http://localhost:5173"]
     
     @property
     def target_symbol(self) -> str:

deep_learning/config.py

@@ -136,15 +136,15 @@ class ASROConfig:
 
 @dataclass(frozen=True)
 class WeeklyLossConfig:
-    lambda_weekly_quantile: float = 0.55
+    lambda_weekly_quantile: float = 0.60
     lambda_t1_quantile: float = 0.10
-    lambda_directional: float = 0.15
-    lambda_magnitude: float = 0.35
-    lambda_vol: float = 0.15
-    lambda_crossing: float = 5.0
-    lambda_sanity: float = 0.10
-    lambda_width: float = 0.25
-    lambda_tail_width: float = 0.05
+    lambda_directional: float = 0.10
+    lambda_magnitude: float = 0.55
+    lambda_vol: float = 0.35
+    lambda_crossing: float = 7.0
+    lambda_sanity: float = 0.20
+    lambda_width: float = 0.50
+    lambda_tail_width: float = 0.30
 
 
 @dataclass(frozen=True)
@@ -167,7 +167,7 @@ class TrainingConfig:
     num_workers: int = 0
     # 25→15: CI budget fix. 15 trials × 3 folds × 25 epochs ≈ 108 min;
     # final trainer adds ~40-50 min → total ~155 min < 180 min limit.
-    optuna_n_trials: int = 15
+    optuna_n_trials: int = 30
     # Walk-Forward temporal CV folds for hyperopt (REG-2026-001 P2).
     # Set to 1 to disable CV and fall back to single-split behaviour.
     cv_n_folds: int = 3

deep_learning/data/feature_store.py

@@ -223,14 +223,21 @@ def _build_daily_embedding_features(
     from app.models import NewsEmbedding, NewsProcessed, NewsRaw
     from deep_learning.data.embeddings import bytes_to_embedding, aggregate_daily_embeddings
     from pipelines.market_calendar import assign_market_date
+    from sqlalchemy import func
+
+    start_date = index.min().to_pydatetime()
+    end_date = index.max().to_pydatetime()
+    available_expr = func.coalesce(NewsRaw.fetched_at, NewsRaw.published_at)
 
     rows = (
         session.query(
             NewsRaw.published_at,
+            NewsRaw.fetched_at,
             NewsEmbedding.embedding_pca,
         )
         .join(NewsProcessed, NewsEmbedding.news_processed_id == NewsProcessed.id)
         .join(NewsRaw, NewsProcessed.raw_id == NewsRaw.id)
+        .filter(NewsRaw.published_at <= end_date, available_expr <= end_date)
         .order_by(NewsRaw.published_at.asc())
         .all()
     )
@@ -241,7 +248,13 @@ def _build_daily_embedding_features(
 
     date_groups: dict[str, list[np.ndarray]] = {}
     for r in rows:
-        d = assign_market_date(r.published_at).isoformat()
+        published_market_date = assign_market_date(r.published_at)
+        available_at = getattr(r, "fetched_at", None) or r.published_at
+        available_market_date = assign_market_date(available_at)
+        market_date = max(published_market_date, available_market_date)
+        if not (pd.Timestamp(start_date).date() <= market_date <= pd.Timestamp(end_date).date()):
+            continue
+        d = market_date.isoformat()
         vec = bytes_to_embedding(r.embedding_pca, dim=pca_dim)
         # bytes_to_embedding now always returns dim-length arrays, but
         # guard against any future shape surprises to keep stack safe.
@@ -260,6 +273,10 @@ def _build_daily_embedding_features(
             record[f"emb_pca_{i}"] = float(v)
         records.append(record)
 
+    if not records:
+        cols = [f"emb_pca_{i}" for i in range(pca_dim)]
+        return pd.DataFrame(0.0, index=index, columns=cols)
+
     emb_df = pd.DataFrame(records).set_index("date").sort_index()
     emb_df.index = pd.to_datetime(emb_df.index)
 

deep_learning/data/sentiment_market_date.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import pandas as pd
+from sqlalchemy import func
 
 from app.models import NewsProcessed, NewsRaw, NewsSentimentV2
 from pipelines.market_calendar import assign_market_date, is_after_close_news
@@ -12,6 +13,30 @@ MATERIAL_RELEVANCE_MIN = 0.60
 MATERIAL_CONFIDENCE_MIN = 0.55
 
 
+def _effective_available_at(row) -> object:
+    return (
+        getattr(row, "available_at", None)
+        or getattr(row, "fetched_at", None)
+        or getattr(row, "published_at", None)
+    )
+
+
+def _effective_market_date(row):
+    """Map news to the later of publication market date and availability date."""
+    published_market_date = assign_market_date(row.published_at)
+    available_at = _effective_available_at(row)
+    if available_at is None:
+        return published_market_date
+    available_market_date = assign_market_date(available_at)
+    return max(published_market_date, available_market_date)
+
+
+def _within_window(market_date, start_date, end_date) -> bool:
+    start = pd.Timestamp(start_date).date()
+    end = pd.Timestamp(end_date).date()
+    return start <= market_date <= end
+
+
 def build_market_date_sentiment_frame(session, start_date, end_date) -> pd.DataFrame:
     """Return daily sentiment indexed by market date, not publication date."""
     columns = [
@@ -29,6 +54,7 @@ def build_market_date_sentiment_frame(session, start_date, end_date) -> pd.DataF
         session.query(
             NewsRaw.published_at,
             NewsRaw.fetched_at,
+            NewsSentimentV2.available_at,
             NewsSentimentV2.final_score,
             NewsSentimentV2.confidence_calibrated,
             NewsSentimentV2.relevance_score,
@@ -36,7 +62,15 @@ def build_market_date_sentiment_frame(session, start_date, end_date) -> pd.DataF
         )
         .join(NewsProcessed, NewsProcessed.raw_id == NewsRaw.id)
         .join(NewsSentimentV2, NewsSentimentV2.news_processed_id == NewsProcessed.id)
-        .filter(NewsRaw.published_at >= start_date, NewsRaw.published_at <= end_date)
+        .filter(
+            NewsRaw.published_at <= end_date,
+            func.coalesce(
+                NewsSentimentV2.available_at,
+                NewsRaw.fetched_at,
+                NewsRaw.published_at,
+            )
+            <= end_date,
+        )
         .all()
     )
 
@@ -45,7 +79,9 @@ def build_market_date_sentiment_frame(session, start_date, end_date) -> pd.DataF
 
     records = []
     for r in rows:
-        market_date = assign_market_date(r.published_at)
+        market_date = _effective_market_date(r)
+        if not _within_window(market_date, start_date, end_date):
+            continue
         relevance = float(r.relevance_score or 0.0)
         confidence = float(r.confidence_calibrated or 0.0)
         material = relevance >= MATERIAL_RELEVANCE_MIN and confidence >= MATERIAL_CONFIDENCE_MIN
@@ -61,6 +97,8 @@ def build_market_date_sentiment_frame(session, start_date, end_date) -> pd.DataF
         )
 
     raw = pd.DataFrame(records)
+    if raw.empty:
+        return pd.DataFrame(columns=columns)
 
     def _weighted_sentiment(g: pd.DataFrame) -> float:
         denom = g["weight"].sum()
@@ -105,11 +143,21 @@ def build_market_date_event_counts_from_db(session, start_date, end_date) -> pd.
     rows = (
         session.query(
             NewsRaw.published_at,
+            NewsRaw.fetched_at,
+            NewsSentimentV2.available_at,
             NewsSentimentV2.event_type,
         )
         .join(NewsProcessed, NewsSentimentV2.news_processed_id == NewsProcessed.id)
         .join(NewsRaw, NewsProcessed.raw_id == NewsRaw.id)
-        .filter(NewsRaw.published_at >= start_date, NewsRaw.published_at <= end_date)
+        .filter(
+            NewsRaw.published_at <= end_date,
+            func.coalesce(
+                NewsSentimentV2.available_at,
+                NewsRaw.fetched_at,
+                NewsRaw.published_at,
+            )
+            <= end_date,
+        )
         .all()
     )
     if not rows:
@@ -117,12 +165,15 @@ def build_market_date_event_counts_from_db(session, start_date, end_date) -> pd.
 
     records = [
         {
-            "market_date": assign_market_date(r.published_at),
+            "market_date": _effective_market_date(r),
             "event_type": r.event_type,
             "count": 1,
         }
         for r in rows
+        if _within_window(_effective_market_date(r), start_date, end_date)
     ]
+    if not records:
+        return pd.DataFrame()
     df = pd.DataFrame(records)
     pivot = df.pivot_table(index="market_date", columns="event_type", values="count", aggfunc="sum", fill_value=0)
     pivot.index = pd.to_datetime(pivot.index)

deep_learning/inference/predictor.py

@@ -134,6 +134,20 @@ class TFTPredictor:
             return
 
         metadata_path = Path(self._checkpoint_path).parent / "tft_metadata.json"
+        try:
+            from deep_learning.models.hub import validate_artifact_manifest
+
+            if not validate_artifact_manifest(metadata_path.parent):
+                raise IncompatibleTFTCheckpointError(
+                    "Incompatible TFT checkpoint: missing or invalid artifact manifest. Retraining required."
+                )
+        except IncompatibleTFTCheckpointError:
+            raise
+        except Exception as exc:
+            raise IncompatibleTFTCheckpointError(
+                f"Incompatible TFT checkpoint: artifact manifest validation failed ({exc}). Retraining required."
+            ) from exc
+
         if not metadata_path.exists():
             raise IncompatibleTFTCheckpointError(
                 "Incompatible TFT checkpoint: missing weekly_log_v1 metadata. Retraining required."

deep_learning/models/hub.py

@@ -11,6 +11,8 @@ from __future__ import annotations
 import json
 import logging
 import os
+import hashlib
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
@@ -24,11 +26,13 @@ _ARTIFACTS = [
     "conformal_calibration.json",
     "pca_finbert.joblib",
     "optuna_results.json",
+    "artifact_manifest.json",
 ]
 
 _REQUIRED_ARTIFACTS = [
     "best_tft_asro.ckpt",
     "tft_metadata.json",
+    "artifact_manifest.json",
 ]
 
 
@@ -36,6 +40,82 @@ def _get_token() -> Optional[str]:
     return os.environ.get(_HF_TOKEN_ENV)
 
 
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def build_artifact_manifest(local_dir: str | Path) -> dict:
+    """Build a SHA256 manifest for every present TFT artifact except itself."""
+    local_dir = Path(local_dir)
+    artifacts = {}
+    for name in _ARTIFACTS:
+        if name == "artifact_manifest.json":
+            continue
+        path = local_dir / name
+        if not path.exists():
+            continue
+        artifacts[name] = {
+            "sha256": _sha256_file(path),
+            "size_bytes": path.stat().st_size,
+            "required": name in {"best_tft_asro.ckpt", "tft_metadata.json"},
+        }
+
+    return {
+        "manifest_version": 1,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "artifacts": artifacts,
+    }
+
+
+def write_artifact_manifest(local_dir: str | Path) -> Path:
+    """Write the artifact integrity manifest next to TFT artifacts."""
+    local_dir = Path(local_dir)
+    manifest_path = local_dir / "artifact_manifest.json"
+    manifest = build_artifact_manifest(local_dir)
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    return manifest_path
+
+
+def validate_artifact_manifest(local_dir: str | Path) -> bool:
+    """Verify artifact_manifest.json hashes before loading checkpoint/joblib files."""
+    local_dir = Path(local_dir)
+    manifest_path = local_dir / "artifact_manifest.json"
+    if not manifest_path.exists():
+        logger.warning("TFT artifact manifest missing in %s", local_dir)
+        return False
+
+    try:
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        artifacts = data.get("artifacts") or {}
+        for required in ("best_tft_asro.ckpt", "tft_metadata.json"):
+            if required not in artifacts:
+                logger.warning("TFT artifact manifest missing required entry: %s", required)
+                return False
+
+        for name, meta in artifacts.items():
+            path = local_dir / name
+            if not path.exists():
+                logger.warning("TFT artifact listed in manifest is missing: %s", name)
+                return False
+            expected = str(meta.get("sha256", "")).lower()
+            actual = _sha256_file(path).lower()
+            if not expected or actual != expected:
+                logger.warning("TFT artifact hash mismatch for %s", name)
+                return False
+            expected_size = meta.get("size_bytes")
+            if expected_size is not None and int(expected_size) != path.stat().st_size:
+                logger.warning("TFT artifact size mismatch for %s", name)
+                return False
+        return True
+    except Exception as exc:
+        logger.warning("TFT artifact manifest validation failed: %s", exc)
+        return False
+
+
 def _metadata_contract_valid(metadata_path: Path) -> bool:
     """Return True when metadata proves the current weekly TFT contract."""
     if not metadata_path.exists():
@@ -94,6 +174,9 @@ def validate_tft_artifact_set(local_dir: str | Path) -> bool:
         logger.warning("TFT artifact set has incompatible metadata in %s", local_dir)
         return False
 
+    if not validate_artifact_manifest(local_dir):
+        return False
+
     return True
 
 
@@ -114,13 +197,18 @@ def upload_tft_artifacts(
         return False
 
     local_dir = Path(local_dir)
-    if not validate_tft_artifact_set(local_dir):
+    if not _metadata_contract_valid(local_dir / "tft_metadata.json"):
         logger.warning(
             "TFT artifact set in %s is not contract-complete; upload skipped",
             local_dir,
         )
         return False
 
+    write_artifact_manifest(local_dir)
+    if not validate_tft_artifact_set(local_dir):
+        logger.warning("TFT artifact manifest validation failed before upload")
+        return False
+
     files_to_upload = [
         local_dir / name for name in _ARTIFACTS if (local_dir / name).exists()
     ]
@@ -175,6 +263,9 @@ def download_tft_artifacts(
     metadata_path = local_dir / "tft_metadata.json"
     if metadata_path.exists() and not _metadata_contract_valid(metadata_path):
         force_download.add("tft_metadata.json")
+    manifest_path = local_dir / "artifact_manifest.json"
+    if manifest_path.exists() and not validate_artifact_manifest(local_dir):
+        force_download.update(_ARTIFACTS)
 
     try:
         from huggingface_hub import hf_hub_download

deep_learning/models/tft_copper.py

@@ -131,15 +131,15 @@ try:
         def __init__(
             self,
             quantiles: list,
-            lambda_weekly_quantile: float = 0.55,
+            lambda_weekly_quantile: float = 0.60,
             lambda_t1_quantile: float = 0.10,
-            lambda_directional: float = 0.15,
-            lambda_magnitude: float = 0.35,
-            lambda_vol: float = 0.15,
-            lambda_crossing: float = 5.0,
-            lambda_sanity: float = 0.10,
-            lambda_width: float = 0.25,
-            lambda_tail_width: float = 0.05,
+            lambda_directional: float = 0.10,
+            lambda_magnitude: float = 0.55,
+            lambda_vol: float = 0.35,
+            lambda_crossing: float = 7.0,
+            lambda_sanity: float = 0.20,
+            lambda_width: float = 0.50,
+            lambda_tail_width: float = 0.30,
             sharpe_eps: float = 1e-6,
             daily_log_return_bound: float = 0.08,
             weekly_log_return_bound: float = 0.20,
@@ -193,14 +193,21 @@ try:
 
             abs_actual = actual_weekly.abs()
             material_mask = abs_actual > (abs_actual.median() + self.sharpe_eps)
+            global_magnitude_loss = torch.abs(
+                torch.log(
+                    (pred_weekly_median.abs() + self.sharpe_eps)
+                    / (actual_weekly.abs() + self.sharpe_eps)
+                )
+            ).mean()
             if material_mask.any():
                 pred_abs = pred_weekly_median[material_mask].abs()
                 true_abs = actual_weekly[material_mask].abs()
-                magnitude_loss = torch.abs(
+                material_magnitude_loss = torch.abs(
                     torch.log((pred_abs + self.sharpe_eps) / (true_abs + self.sharpe_eps))
                 ).mean()
             else:
-                magnitude_loss = y_pred.new_tensor(0.0)
+                material_magnitude_loss = y_pred.new_tensor(0.0)
+            magnitude_loss = 0.5 * global_magnitude_loss + 0.5 * material_magnitude_loss
 
             weekly_spread = (
                 pred_weekly_quantiles[:, self._q90_idx]
@@ -211,16 +218,19 @@ try:
             mean_weekly_spread = weekly_spread.mean()
             vol_loss = torch.abs(mean_weekly_spread - target_spread)
             width_ratio = mean_weekly_spread / (target_spread + self.sharpe_eps)
-            width_loss = torch.relu(width_ratio - 2.0).pow(2)
+            safe_width_ratio = torch.clamp(width_ratio + self.sharpe_eps, min=1e-6)
+            width_loss = torch.abs(torch.log(safe_width_ratio))
+            width_loss = width_loss + torch.relu(width_ratio - 2.0).pow(2)
 
             weekly_tail_spread = (
                 pred_weekly_quantiles[:, self._q98_idx]
                 - pred_weekly_quantiles[:, self._q02_idx]
             )
             target_tail_spread = 4.10 * actual_weekly_std
-            tail_width_loss = torch.relu(
-                weekly_tail_spread.mean() - 2.0 * target_tail_spread
-            )
+            tail_width_ratio = weekly_tail_spread.mean() / (target_tail_spread + self.sharpe_eps)
+            safe_tail_width_ratio = torch.clamp(tail_width_ratio + self.sharpe_eps, min=1e-6)
+            tail_width_loss = torch.abs(torch.log(safe_tail_width_ratio))
+            tail_width_loss = tail_width_loss + torch.relu(tail_width_ratio - 3.0).pow(2)
             daily_crossing_loss = quantile_crossing_penalty(y_pred)
             weekly_crossing_loss = quantile_crossing_penalty(pred_weekly_quantiles.unsqueeze(1))
             crossing_loss = daily_crossing_loss + weekly_crossing_loss

deep_learning/training/hyperopt.py

@@ -38,7 +38,7 @@ from deep_learning.config import (
 
 logger = logging.getLogger(__name__)
 
-MIN_COMPLETED_TRIALS = 3
+MIN_COMPLETED_TRIALS = 10
 SHARPE_PRUNE_THRESHOLD = -0.3
 FOLD_SHARPE_PRUNE_THRESHOLD = -1.0
 
@@ -55,10 +55,14 @@ KNOWN_GOOD_TRIAL_PARAMS = {
     "lambda_quantile": 0.25,
     "lambda_madl": 0.40,
     "lambda_weekly_quantile": 0.60,
-    "lambda_t1_quantile": 0.15,
+    "lambda_t1_quantile": 0.10,
     "lambda_directional": 0.10,
-    "lambda_magnitude": 0.40,
+    "lambda_magnitude": 0.55,
     "weekly_lambda_vol": 0.35,
+    "lambda_width": 0.50,
+    "lambda_tail_width": 0.30,
+    "lambda_sanity": 0.20,
+    "lambda_crossing": 7.0,
     "batch_size": 32,
 }
 
@@ -129,6 +133,8 @@ def _build_prune_diagnostics(study) -> tuple[dict[str, int], list[dict]]:
         "weekly_magnitude_collapse": 0,
         "weekly_magnitude_explosion": 0,
         "weekly_interval_width_explosion": 0,
+        "weekly_tail_width_explosion": 0,
+        "weekly_raw_crossing_prune": 0,
         "weekly_overcoverage_width_explosion": 0,
         "error": 0,
     }
@@ -142,7 +148,11 @@ def _build_prune_diagnostics(study) -> tuple[dict[str, int], list[dict]]:
         "avg_weekly_magnitude_ratio",
         "avg_weekly_pi80_coverage",
         "avg_weekly_pi80_width_ratio",
+        "avg_weekly_pi96_width_ratio",
+        "avg_weekly_raw_crossing_rate",
+        "avg_weekly_sorted_crossing_rate",
         "avg_weekly_interval_score_80",
+        "avg_weekly_interval_score_96",
         "fold_score_std",
     )
 
@@ -217,32 +227,32 @@ def _enqueue_known_good_trial(study, base_cfg: TFTASROConfig) -> bool:
 def create_trial_config(trial, base_cfg: TFTASROConfig) -> TFTASROConfig:
     """Map an Optuna trial to a TFT-ASRO configuration."""
     model_cfg = TFTModelConfig(
-        max_encoder_length=trial.suggest_int("max_encoder_length", 30, 90, step=10),
+        max_encoder_length=trial.suggest_categorical("max_encoder_length", [40, 50, 60, 75, 90]),
         max_prediction_length=base_cfg.model.max_prediction_length,
         # Post-MRMR pruning (~60-80 features), smaller models generalise better.
         # 24 is viable now that feature count dropped from 200+ to ~60-80.
-        hidden_size=trial.suggest_int("hidden_size", 24, 48, step=8),
-        attention_head_size=trial.suggest_int("attention_head_size", 1, 2),
+        hidden_size=trial.suggest_categorical("hidden_size", [24, 32, 48]),
+        attention_head_size=trial.suggest_categorical("attention_head_size", [1, 2]),
         # Floor at 0.20: 313 samples with dropout<0.20 causes co-adaptation
         # and memorization (REG-2026-001).  Cap at 0.35: dropout>0.35 with
         # small hidden_size collapses the output range.
-        dropout=trial.suggest_float("dropout", 0.20, 0.35, step=0.05),
+        dropout=trial.suggest_categorical("dropout", [0.20, 0.25, 0.30, 0.35]),
         # Paired reduction: with hidden=24-48 and ~60-80 features,
         # 8-16 is the sweet spot for continuous variable processing.
-        hidden_continuous_size=trial.suggest_int("hidden_continuous_size", 8, 16, step=8),
+        hidden_continuous_size=trial.suggest_categorical("hidden_continuous_size", [8, 16]),
         quantiles=base_cfg.model.quantiles,
         # Range [1e-4, 1e-3]: LR < 1e-4 produces near-zero pred_std (VR=0.14);
         # LR > 1e-3 causes 1-epoch divergence. This band is the stable zone.
-        learning_rate=trial.suggest_float("learning_rate", 1e-4, 1e-3, log=True),
+        learning_rate=trial.suggest_float("learning_rate", 1e-4, 6e-4, log=True),
         reduce_on_plateau_patience=4,
-        gradient_clip_val=trial.suggest_float("gradient_clip_val", 0.5, 2.0, step=0.5),
-        weight_decay=trial.suggest_float("weight_decay", 1e-5, 1e-3, log=True),
+        gradient_clip_val=trial.suggest_categorical("gradient_clip_val", [0.5, 1.0, 1.5]),
+        weight_decay=trial.suggest_float("weight_decay", 1e-5, 5e-4, log=True),
     )
 
     asro_cfg = ASROConfig(
         # Floor at 0.25: three Optuna runs consistently selected 0.30-0.35.
         # Lower values let the model collapse to near-zero pred_std.
-        lambda_vol=trial.suggest_float("lambda_vol", 0.30, 0.45, step=0.05),
+        lambda_vol=trial.suggest_float("lambda_vol", 0.25, 0.40, step=0.05),
         # lambda_quantile is the explicit w_quantile weight (w_sharpe = 1 - w_q)
         # Capped at 0.40 to ensure Sharpe (directional) component always has
         # ≥60% weight.  Higher values caused the "perfect calibration, coin-flip
@@ -250,20 +260,20 @@ def create_trial_config(trial, base_cfg: TFTASROConfig) -> TFTASROConfig:
         # expense of directional signal.
         lambda_quantile=trial.suggest_float("lambda_quantile", 0.25, 0.4, step=0.05),
         # MADL weight: how much the directional loss contributes relative to Sharpe.
-        lambda_madl=trial.suggest_float("lambda_madl", 0.3, 0.5, step=0.1),
+        lambda_madl=trial.suggest_float("lambda_madl", 0.35, 0.60, step=0.05),
         risk_free_rate=0.0,
     )
 
     weekly_loss_cfg = WeeklyLossConfig(
-        lambda_weekly_quantile=trial.suggest_float("lambda_weekly_quantile", 0.55, 0.70, step=0.05),
-        lambda_t1_quantile=trial.suggest_float("lambda_t1_quantile", 0.10, 0.20, step=0.05),
-        lambda_directional=trial.suggest_float("lambda_directional", 0.05, 0.15, step=0.05),
-        lambda_magnitude=trial.suggest_float("lambda_magnitude", 0.35, 0.55, step=0.05),
+        lambda_weekly_quantile=trial.suggest_float("lambda_weekly_quantile", 0.60, 0.75, step=0.05),
+        lambda_t1_quantile=trial.suggest_float("lambda_t1_quantile", 0.05, 0.15, step=0.05),
+        lambda_directional=trial.suggest_float("lambda_directional", 0.05, 0.12, step=0.01),
+        lambda_magnitude=trial.suggest_float("lambda_magnitude", 0.50, 0.80, step=0.05),
         lambda_vol=trial.suggest_float("weekly_lambda_vol", 0.25, 0.45, step=0.05),
-        lambda_crossing=base_cfg.weekly_loss.lambda_crossing,
-        lambda_sanity=base_cfg.weekly_loss.lambda_sanity,
-        lambda_width=base_cfg.weekly_loss.lambda_width,
-        lambda_tail_width=base_cfg.weekly_loss.lambda_tail_width,
+        lambda_crossing=trial.suggest_float("lambda_crossing", 5.0, 10.0, step=1.0),
+        lambda_sanity=trial.suggest_float("lambda_sanity", 0.10, 0.30, step=0.05),
+        lambda_width=trial.suggest_float("lambda_width", 0.40, 0.90, step=0.05),
+        lambda_tail_width=trial.suggest_float("lambda_tail_width", 0.25, 0.75, step=0.05),
     )
 
     training_cfg = TrainingConfig(
@@ -360,7 +370,11 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
     fold_weekly_mr_list: list[float] = []
     fold_weekly_pi80_coverage_list: list[float] = []
     fold_weekly_pi80_width_ratio_list: list[float] = []
+    fold_weekly_pi96_width_ratio_list: list[float] = []
+    fold_weekly_raw_crossing_list: list[float] = []
+    fold_weekly_sorted_crossing_list: list[float] = []
     fold_weekly_interval_score_80_list: list[float] = []
+    fold_weekly_interval_score_96_list: list[float] = []
 
     for fold_idx, (fold_train_ds, fold_val_ds) in enumerate(cv_folds):
         # ---- setup ----
@@ -430,7 +444,11 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
         fold_weekly_mr = 1.0
         fold_weekly_pi80_coverage = 0.0
         fold_weekly_pi80_width_ratio = 1.0
+        fold_weekly_pi96_width_ratio = 1.0
+        fold_weekly_raw_crossing = 0.0
+        fold_weekly_sorted_crossing = 0.0
         fold_weekly_interval_score_80 = 0.0
+        fold_weekly_interval_score_96 = 0.0
 
         try:
             pred_tensor = model.predict(fold_val_dl, mode="quantiles")
@@ -494,19 +512,31 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
             fold_weekly_mr = float(weekly.get("weekly_magnitude_ratio", 1.0))
             fold_weekly_pi80_coverage = float(weekly.get("weekly_pi80_coverage", 0.0))
             fold_weekly_pi80_width_ratio = float(weekly.get("weekly_pi80_width_ratio", 1.0))
+            fold_weekly_pi96_width_ratio = float(weekly.get("weekly_pi96_width_ratio", 1.0))
+            fold_weekly_raw_crossing = float(weekly.get("weekly_quantile_crossing_rate", 0.0))
+            fold_weekly_sorted_crossing = float(
+                weekly.get("weekly_sorted_quantile_crossing_rate", 0.0)
+            )
             fold_weekly_interval_score_80 = float(weekly.get("weekly_interval_score_80", 0.0))
+            fold_weekly_interval_score_96 = float(weekly.get("weekly_interval_score_96", 0.0))
             weekly_actual_std = float(weekly.get("weekly_actual_std", 0.0))
             interval_score_penalty = fold_weekly_interval_score_80 / (weekly_actual_std + 1e-8)
+            interval_score_96_penalty = fold_weekly_interval_score_96 / (weekly_actual_std + 1e-8)
             coverage_penalty = abs(fold_weekly_pi80_coverage - 0.80)
-            width_penalty = max(0.0, fold_weekly_pi80_width_ratio - 2.0)
+            width_penalty = max(0.0, fold_weekly_pi80_width_ratio - 1.5)
+            tail_width_penalty = max(0.0, fold_weekly_pi96_width_ratio - 3.0)
+            raw_crossing_penalty = max(0.0, fold_weekly_raw_crossing - 0.05)
             fold_weekly_objective = (
                 0.35 * weekly_pinball
                 + 0.15 * (1.0 - float(weekly.get("weekly_directional_accuracy", 0.5)))
-                + 0.30 * abs(np.log(fold_weekly_mr + 1e-8))
+                + 0.50 * abs(np.log(fold_weekly_mr + 1e-8))
                 + 0.20 * coverage_penalty
                 + 0.25 * width_penalty
+                + 0.35 * tail_width_penalty
                 + 0.10 * interval_score_penalty
-                + 0.20 * float(weekly.get("weekly_quantile_crossing_rate", 0.0))
+                + 0.05 * interval_score_96_penalty
+                + 0.50 * raw_crossing_penalty
+                + 0.25 * fold_weekly_sorted_crossing
             )
         except Exception as exc:
             logger.warning(
@@ -523,7 +553,11 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
         fold_weekly_mr_list.append(fold_weekly_mr)
         fold_weekly_pi80_coverage_list.append(fold_weekly_pi80_coverage)
         fold_weekly_pi80_width_ratio_list.append(fold_weekly_pi80_width_ratio)
+        fold_weekly_pi96_width_ratio_list.append(fold_weekly_pi96_width_ratio)
+        fold_weekly_raw_crossing_list.append(fold_weekly_raw_crossing)
+        fold_weekly_sorted_crossing_list.append(fold_weekly_sorted_crossing)
         fold_weekly_interval_score_80_list.append(fold_weekly_interval_score_80)
+        fold_weekly_interval_score_96_list.append(fold_weekly_interval_score_96)
 
         # Incorporate DA directly into fold_score as a reward (not just penalty).
         # DA > 50% (coin-flip) is rewarded, < 50% penalised.
@@ -584,6 +618,22 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
             trial.set_user_attr("prune_reason", "weekly_interval_width_explosion")
             raise optuna.exceptions.TrialPruned()
 
+        if fold_weekly_pi96_width_ratio > 3.0 and fold_idx >= 1 and not protect_trial:
+            logger.warning(
+                "Trial %d PRUNED at fold %d: weekly_pi96_width_ratio=%.4f > 3.0",
+                trial.number, fold_idx + 1, fold_weekly_pi96_width_ratio,
+            )
+            trial.set_user_attr("prune_reason", "weekly_tail_width_explosion")
+            raise optuna.exceptions.TrialPruned()
+
+        if fold_weekly_raw_crossing > 0.05 and fold_idx >= 1 and not protect_trial:
+            logger.warning(
+                "Trial %d PRUNED at fold %d: weekly raw crossing=%.4f > 0.05",
+                trial.number, fold_idx + 1, fold_weekly_raw_crossing,
+            )
+            trial.set_user_attr("prune_reason", "weekly_raw_crossing_prune")
+            raise optuna.exceptions.TrialPruned()
+
         if (
             fold_weekly_pi80_coverage >= 0.98
             and fold_weekly_pi80_width_ratio > 3.0
@@ -628,11 +678,31 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
         if fold_weekly_pi80_width_ratio_list
         else 1.0
     )
+    avg_weekly_pi96_width_ratio = (
+        float(np.mean(fold_weekly_pi96_width_ratio_list))
+        if fold_weekly_pi96_width_ratio_list
+        else 1.0
+    )
+    avg_weekly_raw_crossing = (
+        float(np.mean(fold_weekly_raw_crossing_list))
+        if fold_weekly_raw_crossing_list
+        else 0.0
+    )
+    avg_weekly_sorted_crossing = (
+        float(np.mean(fold_weekly_sorted_crossing_list))
+        if fold_weekly_sorted_crossing_list
+        else 0.0
+    )
     avg_weekly_interval_score_80 = (
         float(np.mean(fold_weekly_interval_score_80_list))
         if fold_weekly_interval_score_80_list
         else 0.0
     )
+    avg_weekly_interval_score_96 = (
+        float(np.mean(fold_weekly_interval_score_96_list))
+        if fold_weekly_interval_score_96_list
+        else 0.0
+    )
 
     # High fold-score variance = trial is unreliable (works in one regime, fails in another)
     consistency_penalty = (
@@ -647,7 +717,11 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
     trial.set_user_attr("avg_weekly_magnitude_ratio", round(avg_weekly_mr, 4))
     trial.set_user_attr("avg_weekly_pi80_coverage", round(avg_weekly_pi80_coverage, 4))
     trial.set_user_attr("avg_weekly_pi80_width_ratio", round(avg_weekly_pi80_width_ratio, 4))
+    trial.set_user_attr("avg_weekly_pi96_width_ratio", round(avg_weekly_pi96_width_ratio, 4))
+    trial.set_user_attr("avg_weekly_raw_crossing_rate", round(avg_weekly_raw_crossing, 4))
+    trial.set_user_attr("avg_weekly_sorted_crossing_rate", round(avg_weekly_sorted_crossing, 4))
     trial.set_user_attr("avg_weekly_interval_score_80", round(avg_weekly_interval_score_80, 4))
+    trial.set_user_attr("avg_weekly_interval_score_96", round(avg_weekly_interval_score_96, 4))
     trial.set_user_attr(
         "fold_score_std",
         round(float(np.std(fold_scores)) if len(fold_scores) > 1 else 0.0, 4),
@@ -670,6 +744,14 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
         trial.set_user_attr("prune_reason", "crossing_prune")
         raise optuna.exceptions.TrialPruned()
 
+    if (avg_weekly_raw_crossing > 0.05 or avg_weekly_sorted_crossing > 0.0) and not protect_trial:
+        logger.warning(
+            "Trial %d PRUNED: weekly quantile incoherence raw=%.3f sorted=%.3f",
+            trial.number, avg_weekly_raw_crossing, avg_weekly_sorted_crossing,
+        )
+        trial.set_user_attr("prune_reason", "weekly_raw_crossing_prune")
+        raise optuna.exceptions.TrialPruned()
+
     # Soft penalty: avg DA below coin-flip
     da_penalty = 2.0 * max(0.0, 0.50 - avg_da) if avg_da < 0.50 else 0.0
 

deep_learning/training/metrics.py

@@ -139,6 +139,32 @@ def directional_accuracy(
     return float(matches.mean())
 
 
+def directional_accuracy_count(
+    y_actual: np.ndarray,
+    y_pred: np.ndarray,
+) -> tuple[int, int]:
+    """Return ``(matches, n)`` for directional accuracy confidence intervals."""
+    actual_sign = np.sign(y_actual)
+    pred_sign = np.sign(y_pred)
+    matches = (actual_sign == pred_sign) | ((actual_sign == 0) & (pred_sign == 0))
+    return int(matches.sum()), int(matches.size)
+
+
+def wilson_interval(
+    successes: int,
+    n: int,
+    z: float = 1.959963984540054,
+) -> tuple[float, float]:
+    """Two-sided Wilson confidence interval for a binomial proportion."""
+    if n <= 0:
+        return 0.0, 0.0
+    phat = successes / n
+    denom = 1.0 + z * z / n
+    centre = phat + z * z / (2.0 * n)
+    margin = z * np.sqrt((phat * (1.0 - phat) + z * z / (4.0 * n)) / n)
+    return float((centre - margin) / denom), float((centre + margin) / denom)
+
+
 def tail_capture_rate(
     y_actual: np.ndarray,
     y_pred: np.ndarray,
@@ -217,14 +243,27 @@ def compute_all_metrics(
     # This is the correct series to compute Sharpe/Sortino on — not the raw predictions.
     # Using y_pred_median directly produces an inflated ratio because pred_std << actual_std.
     strategy_returns = np.sign(y_pred_median) * y_actual
+    direction_hits, direction_n = directional_accuracy_count(y_actual, y_pred_median)
+    da_ci_low, da_ci_high = wilson_interval(direction_hits, direction_n)
+    zero_mae = float(np.abs(y_actual).mean())
+    zero_rmse = float(np.sqrt((y_actual ** 2).mean()))
 
     metrics: dict[str, float] = {
         "mae": float(np.abs(y_actual - y_pred_median).mean()),
         "rmse": float(np.sqrt(((y_actual - y_pred_median) ** 2).mean())),
         "directional_accuracy": directional_accuracy(y_actual, y_pred_median),
+        "directional_accuracy_ci_low": da_ci_low,
+        "directional_accuracy_ci_high": da_ci_high,
+        "directional_accuracy_n": float(direction_n),
         "tail_capture_rate": tail_capture_rate(y_actual, y_pred_median, tail_threshold),
         "sharpe_ratio": sharpe_ratio(strategy_returns),
         "sortino_ratio": sortino_ratio(strategy_returns),
+        "naive_zero_mae": zero_mae,
+        "naive_zero_rmse": zero_rmse,
+        "mae_vs_naive_zero": float(np.abs(y_actual - y_pred_median).mean() / (zero_mae + 1e-12)),
+        "rmse_vs_naive_zero": float(
+            np.sqrt(((y_actual - y_pred_median) ** 2).mean()) / (zero_rmse + 1e-12)
+        ),
     }
 
     pred_std = float(y_pred_median.std())
@@ -238,19 +277,29 @@ def compute_all_metrics(
         q90 = np.asarray(y_pred_q90, dtype=np.float64)
         metrics["pi80_coverage"] = prediction_interval_coverage(y_actual, q10, q90)
         metrics["pi80_width"] = prediction_interval_width(q10, q90)
+        metrics["pi80_interval_score"] = interval_score(y_actual, q10, q90, alpha=0.20)
 
     if y_pred_q02 is not None and y_pred_q98 is not None:
         q02 = np.asarray(y_pred_q02, dtype=np.float64)
         q98 = np.asarray(y_pred_q98, dtype=np.float64)
         metrics["pi96_coverage"] = prediction_interval_coverage(y_actual, q02, q98)
         metrics["pi96_width"] = prediction_interval_width(q02, q98)
+        metrics["pi96_interval_score"] = interval_score(y_actual, q02, q98, alpha=0.04)
 
     if y_pred_quantiles is not None:
         q_arr = np.asarray(y_pred_quantiles, dtype=np.float64)
-        metrics["quantile_crossing_rate"] = quantile_crossing_rate(q_arr)
+        sorted_q = np.sort(q_arr, axis=-1)
+        raw_crossing = quantile_crossing_rate(q_arr)
+        sorted_crossing = quantile_crossing_rate(sorted_q)
+        metrics["quantile_crossing_rate"] = raw_crossing
+        metrics["raw_quantile_crossing_rate"] = raw_crossing
+        metrics["sorted_quantile_crossing_rate"] = sorted_crossing
         gap_mean, gap_max = quantile_median_sort_gap(q_arr)
         metrics["median_sort_gap_mean"] = gap_mean
         metrics["median_sort_gap_max"] = gap_max
+        sorted_gap_mean, sorted_gap_max = quantile_median_sort_gap(sorted_q)
+        metrics["sorted_median_sort_gap_mean"] = sorted_gap_mean
+        metrics["sorted_median_sort_gap_max"] = sorted_gap_max
 
     return metrics
 
@@ -268,7 +317,8 @@ def compute_weekly_metrics(
     to simple returns happens only during inference formatting.
     """
     weekly_actual = cumulative_horizon(y_actual_path, horizon=horizon)
-    weekly_quantiles = cumulative_quantiles(y_pred_quantiles_path, horizon=horizon)
+    approx_weekly_quantiles = cumulative_quantiles(y_pred_quantiles_path, horizon=horizon)
+    weekly_quantiles = np.sort(approx_weekly_quantiles, axis=-1)
 
     median_idx = len(quantiles) // 2
     q10_idx = quantiles.index(0.10)
@@ -290,11 +340,18 @@ def compute_weekly_metrics(
         y_pred_q90=weekly_quantiles[:, q90_idx],
         y_pred_q02=weekly_quantiles[:, q02_idx],
         y_pred_q98=weekly_quantiles[:, q98_idx],
-        y_pred_quantiles=weekly_quantiles,
+        y_pred_quantiles=approx_weekly_quantiles,
         tail_threshold=tail_threshold,
     )
 
     weekly_metrics = {f"weekly_{k}": v for k, v in metrics.items()}
+    weekly_metrics["weekly_interval_quantile_source"] = 1.0
+    weekly_metrics["weekly_approx_quantile_crossing_rate"] = quantile_crossing_rate(
+        approx_weekly_quantiles
+    )
+    approx_gap_mean, approx_gap_max = quantile_median_sort_gap(approx_weekly_quantiles)
+    weekly_metrics["weekly_approx_median_sort_gap_mean"] = approx_gap_mean
+    weekly_metrics["weekly_approx_median_sort_gap_max"] = approx_gap_max
     weekly_metrics["weekly_magnitude_ratio"] = magnitude_ratio(weekly_actual, weekly_pred)
     weekly_metrics["weekly_mean_actual_abs"] = float(np.mean(np.abs(weekly_actual)))
     weekly_metrics["weekly_mean_pred_abs"] = float(np.mean(np.abs(weekly_pred)))
@@ -311,5 +368,11 @@ def compute_weekly_metrics(
         weekly_quantiles[:, q90_idx],
         alpha=0.20,
     )
+    weekly_metrics["weekly_interval_score_96"] = interval_score(
+        weekly_actual,
+        weekly_quantiles[:, q02_idx],
+        weekly_quantiles[:, q98_idx],
+        alpha=0.04,
+    )
     weekly_metrics["weekly_sample_count"] = int(len(weekly_actual))
     return weekly_metrics

deep_learning/training/trainer.py

@@ -46,6 +46,7 @@ warnings.filterwarnings(
 logger = logging.getLogger(__name__)
 
 KNOWN_GOOD_CONFIG = {
+    "max_encoder_length": 60,
     "hidden_size": 48,
     "attention_head_size": 2,
     "dropout": 0.30,
@@ -56,12 +57,14 @@ KNOWN_GOOD_CONFIG = {
     "lambda_quantile": 0.25,
     "lambda_madl": 0.40,
     "lambda_weekly_quantile": 0.60,
-    "lambda_t1_quantile": 0.15,
+    "lambda_t1_quantile": 0.10,
     "lambda_directional": 0.10,
-    "lambda_magnitude": 0.40,
+    "lambda_magnitude": 0.55,
     "weekly_lambda_vol": 0.35,
-    "lambda_width": 0.25,
-    "lambda_tail_width": 0.05,
+    "lambda_width": 0.50,
+    "lambda_tail_width": 0.30,
+    "lambda_sanity": 0.20,
+    "lambda_crossing": 7.0,
     "batch_size": 32,
 }
 
@@ -70,9 +73,14 @@ REQUIRED_PROMOTABLE_METRICS = (
     "weekly_magnitude_ratio",
     "weekly_tail_capture_rate",
     "weekly_pi80_coverage",
+    "weekly_pi80_width_ratio",
+    "weekly_pi96_coverage",
+    "weekly_pi96_width_ratio",
     "weekly_sample_count",
     "weekly_quantile_crossing_rate",
+    "weekly_sorted_quantile_crossing_rate",
     "quantile_crossing_rate",
+    "sorted_quantile_crossing_rate",
 )
 
 
@@ -451,8 +459,17 @@ def train_tft_model(
     # Write metadata JSON to disk for CI quality gate
     meta_json_path = Path(cfg.training.best_model_path).parent / "tft_metadata.json"
     try:
+        result["artifact_manifest_path"] = str(meta_json_path.parent / "artifact_manifest.json")
         meta_json_path.write_text(json.dumps(result, indent=2, default=str))
         logger.info("Training metadata written to %s", meta_json_path)
+        try:
+            from deep_learning.models.hub import write_artifact_manifest
+
+            manifest_path = write_artifact_manifest(meta_json_path.parent)
+            result["artifact_manifest_path"] = str(manifest_path)
+            logger.info("Artifact manifest written to %s", manifest_path)
+        except Exception as exc:
+            logger.warning("Could not write artifact manifest: %s", exc)
     except Exception as exc:
         logger.warning("Could not write metadata JSON: %s", exc)
 
@@ -515,7 +532,10 @@ def _write_conformal_calibration_artifact(
             return None
 
         weekly_actual = cumulative_horizon(y_actual_path[:n], horizon=cfg.forecast.primary_horizon_days)
-        weekly_quantiles = cumulative_quantiles(pred_np[:n], horizon=cfg.forecast.primary_horizon_days)
+        weekly_quantiles = np.sort(
+            cumulative_quantiles(pred_np[:n], horizon=cfg.forecast.primary_horizon_days),
+            axis=-1,
+        )
         q = tuple(cfg.model.quantiles)
         q10_idx = q.index(0.10)
         q90_idx = q.index(0.90)
@@ -606,6 +626,28 @@ def _apply_optuna_results(cfg: TFTASROConfig) -> TFTASROConfig:
             params["lambda_quantile"] = min(max(float(params["lambda_quantile"]), 0.25), 0.40)
         if "lambda_madl" in params:
             params["lambda_madl"] = max(float(params["lambda_madl"]), 0.30)
+        if "max_encoder_length" in params and int(params["max_encoder_length"]) < 40:
+            logger.warning(
+                "Optuna max_encoder_length=%s is below weekly-safe floor; clamping to 40",
+                params["max_encoder_length"],
+            )
+            params["max_encoder_length"] = 40
+        if "learning_rate" in params:
+            params["learning_rate"] = min(float(params["learning_rate"]), 6e-4)
+        if "weight_decay" in params:
+            params["weight_decay"] = min(float(params["weight_decay"]), 5e-4)
+        if "lambda_magnitude" in params:
+            params["lambda_magnitude"] = max(float(params["lambda_magnitude"]), 0.50)
+        if "lambda_directional" in params:
+            params["lambda_directional"] = min(float(params["lambda_directional"]), 0.12)
+        if "lambda_width" in params:
+            params["lambda_width"] = max(float(params["lambda_width"]), 0.40)
+        if "lambda_tail_width" in params:
+            params["lambda_tail_width"] = max(float(params["lambda_tail_width"]), 0.25)
+        if "lambda_sanity" in params:
+            params["lambda_sanity"] = max(float(params["lambda_sanity"]), 0.10)
+        if "lambda_crossing" in params:
+            params["lambda_crossing"] = max(float(params["lambda_crossing"]), 5.0)
 
         logger.info(
             "Loaded Optuna best params (trial #%d, weekly_objective=%.4f): %s",

pyproject.toml

@@ -58,6 +58,7 @@ dev = [
     "pytest>=7.4.3",
     "pytest-asyncio>=0.21.1",
     "httpx>=0.25.2",
+    "pip-audit>=2.7.0",
 ]
 
 [tool.setuptools.packages.find]

scripts/tft_quality_gate.py

@@ -41,7 +41,11 @@ def main() -> int:
     weekly_mr = metrics.get("weekly_magnitude_ratio")
     weekly_tail = metrics.get("weekly_tail_capture_rate")
     weekly_pi80 = metrics.get("weekly_pi80_coverage")
+    weekly_pi80_width_ratio = metrics.get("weekly_pi80_width_ratio")
+    weekly_pi96 = metrics.get("weekly_pi96_coverage")
+    weekly_pi96_width_ratio = metrics.get("weekly_pi96_width_ratio")
     weekly_qcross = metrics.get("weekly_quantile_crossing_rate")
+    weekly_sorted_qcross = metrics.get("weekly_sorted_quantile_crossing_rate")
     weekly_gap = metrics.get("weekly_median_sort_gap_max")
     weekly_samples = metrics.get("weekly_sample_count")
 
@@ -55,7 +59,9 @@ def main() -> int:
         "Weekly gate metrics: "
         f"WeeklyDA={weekly_da} WeeklyMR={weekly_mr} "
         f"WeeklyTail={weekly_tail} WeeklyPI80={weekly_pi80} "
-        f"WeeklyQCross={weekly_qcross} WeeklyN={weekly_samples}"
+        f"WeeklyPI96WidthRatio={weekly_pi96_width_ratio} "
+        f"WeeklyQCross={weekly_qcross} WeeklySortedQCross={weekly_sorted_qcross} "
+        f"WeeklyN={weekly_samples}"
     )
 
     passed, reasons = evaluate_quality_gate(
@@ -69,7 +75,11 @@ def main() -> int:
         weekly_magnitude_ratio=weekly_mr,
         weekly_tail_capture_rate=weekly_tail,
         weekly_pi80_coverage=weekly_pi80,
+        weekly_pi80_width_ratio=weekly_pi80_width_ratio,
+        weekly_pi96_coverage=weekly_pi96,
+        weekly_pi96_width_ratio=weekly_pi96_width_ratio,
         weekly_quantile_crossing_rate=weekly_qcross,
+        weekly_sorted_quantile_crossing_rate=weekly_sorted_qcross,
         weekly_median_sort_gap_max=weekly_gap,
         weekly_sample_count=weekly_samples,
     )