code/methods/llm_finetune.py

"""LLM fine-tune (LoRA SFT) method (family ``llm_ft``).

A single concrete class :class:`LLMFineTuned` (``name="llm_finetuned"``)
that wraps QLoRA SFT over any of the three MacroLens panel LLMs:
``llama_scout``, ``gemma4``, ``qwen35``.

Per the unified-API plan §9, this method's ``tasks`` defaults to the
maximum coverage (T1..T7); the runner narrows to the post-hoc-selected
ZS-winner's coverage at config time.

Method contract (sklearn-style):

    LLMFineTuned(task="T1", config=LLMFineTunedConfig(...), dry_run=False)
        .fit(X_train, y_train, seed=42)   # LoRA SFT on (prompt, answer) pairs
        .predict(X_test)                   # generate with the merged adapter
        .save(path)                        # PEFT adapter + manifest.json
        LLMFineTuned.load(path)            # reload

Hard rules:
- Zero IO of benchmark data (the loader provides X / y).
- Zero eval imports.
- Zero ``meta`` consumption.
- Honors ``MACROLENS_DETERMINISTIC=1`` via :func:`_seed_from_env`.

Per-task input / output shapes match :mod:`methods.llm` and
:mod:`methods.llm_ts_reason`.

Inference engine
----------------
``predict`` calls go through a single shared protocol —
``engine.chat_complete(messages, max_tokens, ...) -> str`` — exposed by
:mod:`methods._openai_engine`. The runner serves the LoRA adapter via
``vllm serve --enable-lora --lora-modules <id>=<path>`` and injects an
``OpenAIChatEngine`` whose ``model_id`` resolves to the adapter id; in
``dry_run=True`` mode (no live endpoint) a
:class:`methods._openai_engine.DryRunEngine` is used so the
shape-contract smoke tests still pass.

Per-task fine-tune framing (training pair construction):

    T1 : (lookback close → forecast horizon close) — instruction is the
         numeric history serialised as text; output is the horizon close
         trajectory rounded to 2dp.
    T2/T5: fundamentals → market-cap dollar value.
    T3/T6: company snapshot → JSON of XBRL field → value pairs.
    T4 : event_type + event_description → return percentage.
    T7 : property attributes → JSON ``{rent, price}``.

Serialisation: ``LLMFineTuned.save(path)`` writes:
    - ``manifest.json``  — name, family, tasks, schema_version, task,
                            hyperparams (config.model_dump()), lib_versions.
    - ``adapter/``       — ``PeftModel.save_pretrained(adapter_path)``.
    - ``tokenizer/``     — ``AutoTokenizer.save_pretrained(...)`` so the
                            same tokenizer is used at load time.
    - ``adapter.sha256``  — sha256 of the adapter directory tree (recorded
                            in manifest as a provenance hash).

``LLMFineTuned.load(path)`` reverses the above and prepares the model
for ``predict(X)``.
"""

from __future__ import annotations

import hashlib
import json
import logging
import os
import pathlib
import re
from typing import Any, Literal

import numpy as np
import pandas as pd

from ._config import LLMFineTunedConfig
from ._openai_engine import DryRunEngine
from ._registry import register
from .base import Method, _HFSaveMixin

logger = logging.getLogger(__name__)


# ── Map a config base_model literal to a HuggingFace repo id ─────────────


_BASE_MODEL_ID: dict[str, str] = {
    "llama_scout": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
    "gemma4":      "google/gemma-4-31B-it",
    "qwen35":      "Qwen/Qwen3.5-27B-FP8",
}


# ── Default XBRL field panel for T3/T6 when y_train is unavailable ──────


_DEFAULT_T3_T6_FIELDS = (
    "Revenues",
    "NetIncomeLoss",
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "OperatingIncomeLoss",
    "CashAndCashEquivalents",
    "PropertyPlantAndEquipmentNet",
    "LongTermDebt",
    "ResearchAndDevelopmentExpense",
)


# ── Shared helpers (kept in sync with methods.llm_ts_reason) ─────────────


_NUM_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")


def _parse_first_number(text: str) -> float | None:
    if not text:
        return None
    m = _NUM_RE.search(text.replace(",", ""))
    if not m:
        return None
    try:
        return float(m.group(0))
    except (TypeError, ValueError):
        return None


def _parse_horizon_list(response: str, horizon: int) -> np.ndarray | None:
    """Extract a JSON list of floats representing a forecast trajectory.

    Looks for the first ``[...]`` substring in ``response`` and parses it
    as JSON. Returns a ``(horizon,)`` float32 ndarray, padding with the
    last value when shorter and truncating when longer. Falls back to
    extracting all numeric tokens from the bracketed slice when JSON
    parsing fails. Returns ``None`` on total parse failure.
    """
    if not response:
        return None
    start = response.find("[")
    end = response.rfind("]")
    if start < 0 or end <= start:
        return None
    candidate = response[start : end + 1]
    parsed: list[Any] | None = None
    try:
        loaded = json.loads(candidate)
        if isinstance(loaded, list):
            parsed = loaded
    except json.JSONDecodeError:
        parsed = None
    if parsed is None:
        tokens = _NUM_RE.findall(candidate)
        if not tokens:
            return None
        try:
            parsed = [float(t) for t in tokens]
        except ValueError:
            return None
    vals: list[float] = []
    for v in parsed:
        try:
            vals.append(float(v))
        except (TypeError, ValueError):
            continue
    if not vals:
        return None
    if len(vals) >= horizon:
        out = np.asarray(vals[:horizon], dtype=np.float32)
    else:
        pad = [vals[-1]] * (horizon - len(vals))
        out = np.asarray(vals + pad, dtype=np.float32)
    return out


def _extract_json_object(response: str) -> dict[str, Any] | None:
    """Extract a structured ``{field: value}`` map from an LLM response.

    Two paths:

    1. **JSON object**: legacy support for replies like
       ``{"Revenues": 1000000, "Assets": 5000000}``. Slices from the first
       ``{`` to the last ``}`` and tries ``json.loads``.
    2. **Plain-text key/value**: line-oriented format ``<Field>: <number>``
       which is what current prompts request. Each line is matched by
       regex; numbers may use ``$``, commas, scientific notation. This is
       the natural LLM output mode and avoids JSON parse failures.

    Returns ``None`` if neither path yields any field/value pair.
    """
    if not response:
        return None
    # Path 1: legacy JSON object.
    start = response.find("{")
    end = response.rfind("}")
    if start >= 0 and end > start:
        try:
            j = json.loads(response[start:end + 1])
            if isinstance(j, dict):
                return j
        except json.JSONDecodeError:
            pass
        depth = 0
        for i in range(start, len(response)):
            ch = response[i]
            if ch == "{":
                depth += 1
            elif ch == "}":
                depth -= 1
                if depth == 0:
                    try:
                        j = json.loads(response[start:i + 1])
                        if isinstance(j, dict):
                            return j
                    except json.JSONDecodeError:
                        break
    # Path 2: plain-text "<Field>: <number>" lines (one or many).
    out: dict[str, float] = {}
    line_re = re.compile(
        r"\*?\*?\s*([A-Za-z][A-Za-z0-9_]*)\s*:\s*\$?\s*"
        r"(-?\d[\d,]*(?:\.\d+)?(?:[eE][-+]?\d+)?)"
    )
    for m in line_re.finditer(response):
        field = m.group(1)
        num_str = m.group(2).replace(",", "")
        try:
            out[field] = float(num_str)
        except ValueError:
            continue
    return out or None


def _safe_float(v: Any, default: float = 0.0) -> float:
    if v is None:
        return default
    if isinstance(v, (int, float)) and not (
        isinstance(v, float) and np.isnan(v)
    ):
        return float(v)
    try:
        if pd.isna(v):  # type: ignore[arg-type]
            return default
    except (TypeError, ValueError):
        pass
    try:
        return float(v)
    except (TypeError, ValueError):
        return default


def _seed_from_env(seed: int) -> None:
    import random

    random.seed(seed)
    np.random.seed(seed)
    os.environ.setdefault("PYTHONHASHSEED", str(seed))
    try:
        import torch

        torch.manual_seed(seed)
        if os.environ.get("MACROLENS_DETERMINISTIC") == "1":
            try:
                torch.use_deterministic_algorithms(True)
            except Exception:
                pass
            try:
                torch.backends.cudnn.deterministic = True  # type: ignore[attr-defined]
            except Exception:
                pass
    except Exception:
        pass


def _find_close_idx_from_array(X: np.ndarray) -> int:
    if X.ndim != 3 or X.shape[2] == 0:
        return 0
    samples = X.reshape(-1, X.shape[2])
    pos_mask = (samples >= 0).all(axis=0)
    if not pos_mask.any():
        return 0
    medians = np.median(np.abs(samples), axis=0)
    candidates = np.where(
        pos_mask & (medians >= 1.0) & (medians <= 5000.0)
    )[0]
    if len(candidates) == 0:
        return 0
    cand_meds = medians[candidates]
    log_cand = np.log10(cand_meds + 1e-9)
    target = np.median(log_cand)
    return int(candidates[np.argmin(np.abs(log_cand - target))])


def _sha256_dir(path: pathlib.Path) -> str:
    """Stable SHA256 over a directory tree (sorted file order)."""
    h = hashlib.sha256()
    if not path.exists():
        return h.hexdigest()
    for fp in sorted(path.rglob("*")):
        if not fp.is_file():
            continue
        h.update(fp.relative_to(path).as_posix().encode("utf-8"))
        h.update(b"\x00")
        h.update(fp.read_bytes())
    return h.hexdigest()


# ── Per-task (X, y) → (instruction, response) pair builders ──────────────


def _t1_pairs(
    X: np.ndarray, y: np.ndarray, *, close_idx: int,
) -> list[tuple[str, str]]:
    """T1 SFT pairs: (numeric history → horizon close trajectory).

    The instruction matches :func:`_t1_predict_prompt` so the SFT-trained
    adapter sees the same prompt at fit and predict time. The response is
    a bare JSON array of ``horizon`` floats — directly parseable by
    :func:`_parse_horizon_list`.
    """
    if X.ndim != 3 or y.ndim != 2:
        raise ValueError(
            f"T1 expects X (N,L,F), y (N,H); got X={X.shape}, y={y.shape}"
        )
    n, _lookback, _ = X.shape
    horizon = y.shape[1]
    pairs: list[tuple[str, str]] = []
    for i in range(n):
        close_history = X[i, :, close_idx]
        instr = _t1_predict_prompt(close_history, X.shape[1], horizon)
        target_str = ", ".join(
            f"{round(float(v), 2)}" for v in y[i].tolist()
        )
        resp = f"[{target_str}]"
        pairs.append((instr, resp))
    return pairs


def _t2_t5_pairs(
    X: pd.DataFrame, y: np.ndarray, *, task: str,
) -> list[tuple[str, str]]:
    pairs: list[tuple[str, str]] = []
    if task == "T2":
        for (_, row), tgt in zip(X.iterrows(), y):
            sector = row.get("sector", "Unknown")
            revenue = _safe_float(row.get("stmt_revenue", 0))
            net_income = _safe_float(row.get("stmt_net_income", 0))
            total_assets = _safe_float(row.get("stmt_total_assets", 0))
            employees = row.get("fullTimeEmployees", "N/A")
            instr = (
                f"You are a financial analyst. Estimate the total equity "
                f"market capitalization of this company.\n\n"
                f"Sector: {sector}\n"
                f"Revenue: ${revenue:,.0f}\n"
                f"Net Income: ${net_income:,.0f}\n"
                f"Total Assets: ${total_assets:,.0f}\n"
                f"Employees: {employees}"
            )
            resp = f"Estimated market cap: ${float(tgt):,.0f}"
            pairs.append((instr, resp))
    else:  # T5
        stmt_cols = [c for c in X.columns if c.startswith("stmt_")]
        for (_, row), tgt in zip(X.iterrows(), y):
            sector = row.get("sector", "Unknown")
            industry = row.get("industry", "Unknown")
            items = []
            for c in stmt_cols:
                val = row.get(c)
                if pd.notna(val):
                    try:
                        items.append(f"{c}: ${float(val):,.0f}")
                    except (TypeError, ValueError):
                        continue
            block = "\n".join(items) if items else "No financial statement data available"
            instr = (
                f"You are a private equity analyst. Given ONLY financial "
                f"statement data (no market price), estimate the market "
                f"capitalization of this company.\n\n"
                f"Sector: {sector}\nIndustry: {industry}\n{block}"
            )
            resp = f"Estimated market cap: ${float(tgt):,.0f}"
            pairs.append((instr, resp))
    return pairs


def _t3_t6_pairs(
    X: pd.DataFrame, y: pd.DataFrame, *, task: str,
) -> list[tuple[str, str]]:
    """T3 / T6: build one pair per (ticker, fiscal_year) row of X.

    Response is a JSON object aggregating all ground-truth fields for
    that (ticker, fiscal_year). Rows missing in ``y`` are skipped (no
    silent zero-fill).
    """
    pairs: list[tuple[str, str]] = []
    # Group y by (ticker, fiscal_year)
    if y.empty:
        return pairs
    y_grouped = (
        y.groupby(["ticker", "fiscal_year"])
        .apply(lambda g: dict(zip(g["field"], g["value"])))
        .to_dict()
    )
    fields_seen: list[str] = []
    for _, row in X.iterrows():
        ticker = str(row.get("ticker", "?"))
        fy = row.get("fiscal_year", None)
        key = (ticker, fy)
        # Pandas Int64 keys may not round-trip; try a tolerant lookup.
        if key not in y_grouped:
            for cand_key in y_grouped:
                if str(cand_key[0]) == ticker and str(cand_key[1]) == str(fy):
                    key = cand_key
                    break
        gt_fields = y_grouped.get(key, {})
        if not gt_fields:
            continue
        fields_str = ", ".join(sorted(gt_fields.keys()))
        if not fields_seen:
            fields_seen = sorted(gt_fields.keys())
        if task == "T3":
            sector = row.get("sector", "Unknown")
            revenue = _safe_float(row.get("stmt_revenue", 0))
            net_income = _safe_float(row.get("stmt_net_income", 0))
            instr = (
                f"You are a financial analyst. Given {ticker}'s known "
                f"fundamentals (sector={sector}, revenue=${revenue:,.0f}, "
                f"net_income=${net_income:,.0f}), predict these XBRL "
                f"fields: [{fields_str}]"
            )
        else:  # T6
            description = row.get(
                "company_description", f"A company with ticker {ticker}",
            )
            sector = row.get("sector", "Unknown")
            industry = row.get("industry", "Unknown")
            instr = (
                f"Given this company description: '{description}', "
                f"sector: '{sector}', industry: '{industry}', generate "
                f"plausible financial statement values for these XBRL "
                f"fields: [{fields_str}]"
            )
        resp = json.dumps(
            {k: round(float(v), 2) for k, v in gt_fields.items()
             if pd.notna(v)},
        )
        pairs.append((instr, resp))
    return pairs


def _t4_pairs(X: Any, y: np.ndarray) -> list[tuple[str, str]]:
    if isinstance(X, pd.DataFrame):
        event_type = X.get("event_type", pd.Series([], dtype=object)).to_numpy()
        event_desc = X.get(
            "event_description", pd.Series([""] * len(event_type), dtype=object),
        ).to_numpy()
    elif isinstance(X, dict):
        event_type = np.asarray(X.get("event_type", []))
        event_desc = np.asarray(X.get("event_description", []))
    else:
        raise ValueError(
            f"T4 X must be DataFrame or dict, got {type(X).__name__}"
        )
    pairs: list[tuple[str, str]] = []
    for et, ed, tgt in zip(event_type, event_desc, y):
        et_s = str(et) if et is not None else "unknown"
        ed_s = str(ed)[:200] if ed is not None else ""
        instr = (
            f"You are a financial analyst. Given the scenario:\n"
            f"- Event type: {et_s}\n"
            + (f"- Description: {ed_s}\n" if ed_s else "")
            + "\nPredict the stock return (%) following this event."
        )
        resp = f"Predicted return: {float(tgt):.2f}%"
        pairs.append((instr, resp))
    return pairs


def _t7_pairs(X: pd.DataFrame, y: pd.DataFrame) -> list[tuple[str, str]]:
    pairs: list[tuple[str, str]] = []
    y_by_addr = (
        y.set_index("address").to_dict("index")
        if "address" in y.columns else {}
    )
    for _, row in X.iterrows():
        addr = row.get("address", None)
        gt = y_by_addr.get(addr, {})
        rent_val = float(gt.get("rent", 0) or 0) if gt else 0.0
        price_val = float(gt.get("price", 0) or 0) if gt else 0.0
        if rent_val <= 0 and price_val <= 0:
            continue
        city = row.get("city", "Unknown")
        state = row.get("state", "Unknown")
        property_type = row.get("property_type", "Unknown")
        sqft = row.get("sqft", "N/A")
        beds = row.get("bedrooms", row.get("beds", "N/A"))
        baths = row.get("bathrooms", row.get("baths", "N/A"))
        year_built = row.get("year_built", "N/A")
        instr = (
            f"Estimate AS OF 2026-04-11. Given this property: "
            f"location={city}, {state}, type={property_type}, sqft={sqft}, "
            f"beds={beds}, baths={baths}, year_built={year_built}. "
            f"Estimate the monthly rent and sale price."
        )
        resp = json.dumps(
            {"rent": round(rent_val, 2), "price": round(price_val, 2)},
        )
        pairs.append((instr, resp))
    return pairs


# ── Per-task predict prompts (no labels) ──────────────────────────────────


def _t1_predict_prompt(
    history: np.ndarray, lookback: int, horizon: int,
) -> str:
    last = float(history[-1]) if len(history) else 0.0
    mean = float(np.mean(history)) if len(history) else 0.0
    std = float(np.std(history)) if len(history) else 0.0
    denom = max(float(history[0]) if len(history) else 1e-2, 1e-2)
    trend = float((history[-1] - history[0]) / denom * 100) if len(history) else 0.0
    last20 = ", ".join(f"{v:.4f}" for v in history[-20:])
    return (
        f"You are a quantitative analyst. Predict the daily closing prices "
        f"of the stock for each of the next {horizon} trading days, given:\n"
        f"- Current close: ${last:.2f}\n"
        f"- Past {lookback} closes: mean=${mean:.2f}, std=${std:.2f}, "
        f"trend={trend:+.1f}%\n"
        f"- Recent close series (last 20 of {lookback}): [{last20}]\n\n"
        f"Reply with ONLY a JSON array of {horizon} floats, one per future "
        f"trading day, in chronological order:\n"
        f"[float, float, ..., float]"
    )


# ── Dry-run engine for CPU-only smoke tests ──────────────────────────────


class _DryRunFTEngine:
    """Deterministic stand-in for an SFT-trained LLM during smoke tests.

    Returns shape-correct placeholder responses so :meth:`predict` can be
    exercised without HF / peft / GPU. The runner never sees this in
    real runs (it injects a real OpenAIChatEngine pointed at a vLLM
    LoRA-aware endpoint via ``--enable-lora``).

    Exposes BOTH the legacy ``generate(prompt)`` hook AND the unified
    ``chat_complete(messages, ...)`` protocol so it slots into the same
    code path the real OpenAIChatEngine uses.
    """

    def __init__(self, marker: float = 1.0) -> None:
        self.marker = float(marker)
        self.model_id = "dry-run-ft"

    def generate(self, prompt: str) -> str:  # noqa: D401
        lower = prompt.lower()
        if "rent" in lower and "sale price" in lower:
            return '{"rent": 2000, "price": 500000}'
        if "xbrl" in lower:
            return '{"Revenues": 1000000, "NetIncomeLoss": 100000}'
        if "predict the stock return" in lower:
            return f"Predicted return: {self.marker:.2f}%"
        if "json array" in lower:
            # T1 horizon-list forecast: try to recover horizon from prompt.
            m = re.search(r"json array of (\d+) floats", lower)
            horizon = int(m.group(1)) if m else 21
            return "[" + ", ".join(
                [f"{self.marker:.4f}"] * horizon
            ) + "]"
        if "next" in lower and "closing prices" in lower:
            # Legacy fallback: emit a 21-element horizon list.
            return "[" + ", ".join([f"{self.marker:.4f}"] * 21) + "]"
        return f"{self.marker:.4f}"

    def chat_complete(
        self,
        messages: list[dict[str, str]],
        *,
        max_tokens: int = 256,
        temperature: float = 0.0,
        top_p: float = 1.0,
    ) -> str:
        """Adapt the unified chat-complete protocol to the legacy generate hook."""
        try:
            prompt = " ".join(
                str(m.get("content", "")) for m in (messages or [])
            )
        except Exception:
            prompt = ""
        return self.generate(prompt)

    def chat_complete_batch(
        self,
        batched_messages,
        *,
        max_tokens: int = 256,
        temperature: float = 0.0,
        top_p: float = 1.0,
    ) -> list[str]:
        return [
            self.chat_complete(msgs, max_tokens=max_tokens)
            for msgs in batched_messages
        ]


# ── Main class ────────────────────────────────────────────────────────────


@register(
    name="llm_finetuned",
    family="llm_ft",
    # Default: maximum coverage. The runner narrows to the post-hoc
    # ZS-winner's coverage at config time per plan §9.
    tasks={"T1", "T2", "T3", "T4", "T5", "T6", "T7"},
    config_class=LLMFineTunedConfig,
)
class LLMFineTuned(_HFSaveMixin, Method):
    """LoRA SFT wrapper around any of the four MacroLens panel LLMs.

    The base model is selected via ``LLMFineTunedConfig.model_id``; the
    corresponding panel short-name (``llama_scout`` / ``gemma4`` /
    ``qwen35``) is recovered from the HF id when needed.

    Parameters
    ----------
    task : {"T1", ..., "T7"}
        Task this instance is fitted for.
    config : LLMFineTunedConfig | None
        Hyperparameters (LoRA r/alpha, epochs, learning rate, ...).
        Defaults to :meth:`default_config`.
    base_model : {"llama_scout","gemma4","qwen35"} | None
        Convenience override; if provided, sets
        ``config.model_id`` accordingly.
    dry_run : bool
        When True, fit / predict short-circuit to a CPU-only deterministic
        stand-in for shape-only smoke testing. No HF / peft / torch GPU
        is required. Default: False.

    Notes
    -----
    The QLoRA SFT recipe is preserved verbatim from
    :mod:`baselines.llm_finetune`: bnb NF4 4-bit quant, paged AdamW 8-bit,
    LoRA on q/k/v/o projections, bf16 compute. The Gemma-4 special-case
    (load full MM checkpoint, keep only ``language_model``) is applied
    for ``base_model="gemma4"``.

    Runner-side dispatch
    --------------------
    Per plan §9, the SFT base model is picked from the post-hoc-selected
    ZS winner. :meth:`from_zs_winner` is the intended dispatch entrypoint:
    it takes a per-method dict of zero-shot scores (lower-is-better) and
    returns an instance with ``base_model`` set to the argmin.
    """

    def __init__(
        self,
        *,
        task: str,
        config: LLMFineTunedConfig | None = None,
        engine: Any = None,
        base_model: Literal[
            "llama_scout", "gemma4", "qwen35", None
        ] | None = None,
        dry_run: bool = False,
        **kwargs: Any,
    ) -> None:
        if task not in self.tasks:
            raise ValueError(
                f"LLMFineTuned: task={task!r} not in supported set "
                f"{sorted(self.tasks)}"
            )
        if config is None:
            config = LLMFineTunedConfig(**kwargs) if kwargs else LLMFineTunedConfig()
        elif kwargs:
            merged = {**config.model_dump(), **kwargs}
            config = LLMFineTunedConfig(**merged)
        if base_model is not None:
            mid = _BASE_MODEL_ID.get(base_model)
            if mid is None:
                raise ValueError(
                    f"base_model={base_model!r}; expected one of "
                    f"{sorted(_BASE_MODEL_ID)}"
                )
            config = LLMFineTunedConfig(
                **{**config.model_dump(), "model_id": mid},
            )
        self.task = task
        self.config = config
        # Honor either an explicit ``dry_run`` ctor kwarg OR ``config.dry_run``
        # (the smoke-test path sets the latter via ``cfg.model_copy(...)``).
        self.dry_run = bool(dry_run) or bool(getattr(config, "dry_run", False))
        # Adapter / tokenizer state (populated by fit / load).
        self._adapter_dir: pathlib.Path | None = None
        self._tokenizer_dir: pathlib.Path | None = None
        self._model: Any = None
        self._tokenizer: Any = None
        # OpenAIChatEngine injected by the runner for HTTP-served LoRA
        # inference. ``_dry_engine`` is the local fallback used when
        # ``dry_run=True`` AND no real engine was supplied.
        self.engine: Any = engine
        self._dry_engine: _DryRunFTEngine | None = (
            _DryRunFTEngine() if self.dry_run else None
        )
        # Per-task hints (mirrors :mod:`methods.llm_ts_reason`).
        self._t1_close_idx: int | None = None
        self._t1_horizon: int = 21
        # T3/T6 fitted-field tracking: predict-time prompts need to declare
        # the same field list the adapter was trained on. Populated by
        # ``fit`` and used by ``_predict_t3_t6``.
        self._fitted_fields_per_ticker: dict[str, list[str]] = {}
        self._fitted_fields_global: list[str] = []
        self.last_predict_meta: dict[str, Any] = {}

    # ── fit (LoRA SFT) ───────────────────────────────────────────────────

    @classmethod
    def default_config(cls) -> LLMFineTunedConfig:
        return LLMFineTunedConfig()

    @classmethod
    def from_zs_winner(
        cls,
        zs_results: dict[str, float],
        *,
        task: str,
        config: LLMFineTunedConfig | None = None,
        **kwargs: Any,
    ) -> "LLMFineTuned":
        """Construct an instance keyed to the zero-shot winner.

        Parameters
        ----------
        zs_results : dict[str, float]
            Per-method primary-metric scores, e.g.
            ``{"llama_scout": 0.5, "gemma4": 0.4, ...}``. Lower-is-better:
            the argmin is selected as the LoRA SFT base model.
        task : str
            Task this instance will be fitted for.
        config, **kwargs
            Forwarded to :class:`LLMFineTuned` along with the resolved
            ``base_model``.

        Returns
        -------
        LLMFineTuned
            An instance with ``base_model`` set to the argmin of
            ``zs_results`` (restricted to the four panel LLMs).

        Raises
        ------
        ValueError
            If ``zs_results`` is empty or contains no recognised panel
            short-names (``llama_scout``, ``gemma4``, ``qwen35``).
        """
        if not zs_results:
            raise ValueError(
                "from_zs_winner: zs_results is empty; cannot pick a winner."
            )
        valid = {
            k: float(v)
            for k, v in zs_results.items()
            if k in _BASE_MODEL_ID
        }
        if not valid:
            raise ValueError(
                f"from_zs_winner: zs_results keys {sorted(zs_results)} "
                f"contain no recognised panel short-name; expected any of "
                f"{sorted(_BASE_MODEL_ID)}."
            )
        winner = min(valid, key=lambda k: valid[k])
        return cls(
            task=task, config=config, base_model=winner, **kwargs,
        )

    def fit(self, X: Any, y: Any, *, seed: int = 42) -> "Method":
        """Run LoRA SFT on (X, y) framed as (instruction, response) pairs.

        In ``dry_run=True`` mode this is a no-op (no HF deps needed). In
        normal mode it loads the base model with bnb NF4, applies a LoRA
        adapter, runs SFT via TRL's ``SFTTrainer``, and stores the
        merged adapter dir on ``self._adapter_dir``.
        """
        _seed_from_env(seed)
        # Capture T1 horizon from y so ``predict`` emits matching length
        # trajectories. The default ``_t1_horizon = 21`` is wrong for the
        # canonical T1 task whose horizon is 252 trading days.
        if self.task == "T1" and isinstance(y, np.ndarray) and y.ndim == 2:
            self._t1_horizon = int(y.shape[1])
        # Capture the T3/T6 fitted-field set so predict-time prompts can
        # declare the same fields the adapter was trained on.
        if self.task in ("T3", "T6"):
            if isinstance(y, pd.DataFrame) and not y.empty and "field" in y.columns:
                self._fitted_fields_per_ticker = {
                    str(t): sorted(grp["field"].astype(str).unique().tolist())
                    for t, grp in y.groupby("ticker", sort=False)
                }
                self._fitted_fields_global = sorted(
                    y["field"].astype(str).unique().tolist()
                )
        if self.dry_run:
            return self

        # Build (instruction, response) pairs for the task.
        pairs = self._build_pairs(X, y)
        if not pairs:
            raise RuntimeError(
                f"LLMFineTuned.fit({self.task}): no training pairs constructed."
            )
        texts = [
            f"### Instruction:\n{instr}\n\n### Response:\n{resp}"
            for instr, resp in pairs
        ]

        try:
            import torch
            from transformers import (
                AutoModelForCausalLM, AutoTokenizer,
                BitsAndBytesConfig, TrainingArguments,
            )
            from peft import (
                LoraConfig, get_peft_model, prepare_model_for_kbit_training,
            )
            from trl import SFTTrainer
            from datasets import Dataset as HFDataset
        except ImportError as exc:
            raise RuntimeError(
                "LLMFineTuned.fit requires transformers + peft + trl + "
                f"bitsandbytes + datasets. Underlying error: {exc!r}"
            ) from exc

        quant_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_use_double_quant=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
        )

        model_id = self.config.model_id
        # Gemma-4 special-case: full MM checkpoint → text-only language model.
        if "gemma-4" in model_id.lower():
            from transformers import (
                Gemma4ForCausalLM,
                Gemma4ForConditionalGeneration,
            )
            full_model = Gemma4ForConditionalGeneration.from_pretrained(
                model_id,
                quantization_config=quant_config,
                device_map="auto",
                trust_remote_code=True,
                torch_dtype=torch.bfloat16,
                attn_implementation="eager",
            )
            text_config = full_model.config.text_config
            model = Gemma4ForCausalLM(text_config)
            model.model = full_model.model.language_model
            if hasattr(full_model, "lm_head"):
                model.lm_head = full_model.lm_head
            model.config._name_or_path = model_id
            del full_model
        else:
            model = AutoModelForCausalLM.from_pretrained(
                model_id,
                quantization_config=quant_config,
                device_map="auto",
                trust_remote_code=True,
                torch_dtype=torch.bfloat16,
                attn_implementation="eager",
            )
        tokenizer = AutoTokenizer.from_pretrained(
            model_id, trust_remote_code=True,
        )
        if tokenizer.pad_token is None:
            tokenizer.pad_token = tokenizer.eos_token

        model = prepare_model_for_kbit_training(model)
        lora_cfg = LoraConfig(
            r=self.config.lora_r,
            lora_alpha=self.config.lora_alpha,
            target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
            lora_dropout=0.05,
            bias="none",
            task_type="CAUSAL_LM",
        )
        model = get_peft_model(model, lora_cfg)

        # Output dir under a process-local checkpoint root so multiple
        # (task, seed) fits don't collide.
        ckpt_root = pathlib.Path(
            os.environ.get(
                "MACROLENS_CHECKPOINT_ROOT",
                str(pathlib.Path.home() / ".cache" / "macrolens" / "llm_ft"),
            )
        )
        model_short = model_id.split("/")[-1].lower().replace("-", "_")
        output_dir = ckpt_root / f"{model_short}_{self.task}_seed{seed}"
        output_dir.mkdir(parents=True, exist_ok=True)

        train_dataset = HFDataset.from_dict({"text": texts})
        training_args = TrainingArguments(
            output_dir=str(output_dir),
            num_train_epochs=self.config.epochs,
            per_device_train_batch_size=4,
            gradient_accumulation_steps=8,
            learning_rate=self.config.learning_rate,
            weight_decay=0.01,
            warmup_ratio=0.1,
            logging_steps=50,
            save_strategy="epoch",
            save_total_limit=1,
            report_to="none",
            fp16=False,
            bf16=True,
            gradient_checkpointing=True,
            optim="paged_adamw_8bit",
            max_grad_norm=0.3,
            seed=seed,
        )
        trainer = SFTTrainer(
            model=model,
            args=training_args,
            train_dataset=train_dataset,
        )
        trainer.train()

        # Persist the adapter inline so ``predict`` can re-load it with
        # the same artifact ``save`` will expose downstream.
        adapter_dir = output_dir / "adapter"
        tokenizer_dir = output_dir / "tokenizer"
        model.save_pretrained(str(adapter_dir))
        tokenizer.save_pretrained(str(tokenizer_dir))

        self._model = model
        self._tokenizer = tokenizer
        self._adapter_dir = adapter_dir
        self._tokenizer_dir = tokenizer_dir
        return self

    def _build_pairs(self, X: Any, y: Any) -> list[tuple[str, str]]:
        """Dispatch to the per-task pair builder."""
        if self.task == "T1":
            X_arr = np.asarray(X, dtype=np.float32)
            close_idx = (
                self._t1_close_idx
                if self._t1_close_idx is not None
                else _find_close_idx_from_array(X_arr)
            )
            return _t1_pairs(X_arr, np.asarray(y, dtype=np.float32),
                             close_idx=close_idx)
        if self.task in ("T2", "T5"):
            return _t2_t5_pairs(X, np.asarray(y, dtype=np.float64),
                                task=self.task)
        if self.task in ("T3", "T6"):
            return _t3_t6_pairs(X, y, task=self.task)
        if self.task == "T4":
            return _t4_pairs(X, np.asarray(y, dtype=np.float32))
        if self.task == "T7":
            return _t7_pairs(X, y)
        raise ValueError(f"Unknown task: {self.task!r}")

    # ── predict (adapter inference) ──────────────────────────────────────

    def predict(self, X: Any) -> np.ndarray | pd.DataFrame:
        if self.task == "T1":
            return self._predict_t1(X)
        if self.task == "T2":
            return self._predict_t2_t5(X, task="T2")
        if self.task == "T3":
            return self._predict_t3_t6(X, task="T3")
        if self.task == "T4":
            return self._predict_t4(X)
        if self.task == "T5":
            return self._predict_t2_t5(X, task="T5")
        if self.task == "T6":
            return self._predict_t3_t6(X, task="T6")
        if self.task == "T7":
            return self._predict_t7(X)
        raise ValueError(f"Unknown task: {self.task!r}")

    def _generate(self, prompt: str, *, max_new_tokens: int = 256) -> str:
        """Run a single-prompt generate.

        Resolution order:
        1. Injected ``self.engine`` (an
           :class:`methods._openai_engine.OpenAIChatEngine` against a
           vLLM ``--enable-lora`` endpoint serving the adapter as
           ``model_id``). Preferred path; HTTP, no GPUs in this process.
        2. In-process ``self._model`` / ``self._tokenizer`` (set by
           ``fit`` / ``load`` with peft + bnb). Legacy path kept for
           backwards compatibility when no HTTP endpoint is available.
        3. ``self._dry_engine`` (when ``dry_run=True``).
        """
        # Wrap instruction-tuned prompt envelope so the SFT-trained
        # adapter sees the same text shape at fit and predict time.
        full_prompt = f"### Instruction:\n{prompt}\n\n### Response:\n"

        # 1. Real OpenAI-compatible engine (preferred).
        if self.engine is not None and hasattr(self.engine, "chat_complete"):
            messages = [{"role": "user", "content": full_prompt}]
            return str(self.engine.chat_complete(
                messages, max_tokens=max_new_tokens, temperature=0.0,
            ))

        # 3. Dry-run fallback (smoke tests).
        if self.dry_run:
            assert self._dry_engine is not None
            return self._dry_engine.generate(prompt)

        # 2. In-process peft model fallback.
        if self._model is None or self._tokenizer is None:
            raise RuntimeError(
                "LLMFineTuned.predict: no engine injected, model/tokenizer "
                "not loaded, and dry_run=False. Either inject an "
                "OpenAIChatEngine via the engine= ctor kwarg, call "
                ".fit(...) / .load(...) first, or set dry_run=True."
            )
        import torch

        inputs = self._tokenizer(
            full_prompt, return_tensors="pt", truncation=True, max_length=2048,
        )
        dev = next(self._model.parameters()).device
        inputs = {k: v.to(dev) for k, v in inputs.items()}
        with torch.no_grad():
            outputs = self._model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                do_sample=False,
                pad_token_id=self._tokenizer.eos_token_id,
            )
        return self._tokenizer.decode(
            outputs[0][inputs["input_ids"].shape[1]:],
            skip_special_tokens=True,
        )

    # ── Per-task predictors (mirror :mod:`methods.llm_ts_reason`) ──

    def _predict_t1(self, X: np.ndarray) -> np.ndarray:
        if not isinstance(X, np.ndarray) or X.ndim != 3:
            raise ValueError(
                f"T1 X must be (N, lookback, F) np.ndarray, got "
                f"shape={getattr(X, 'shape', None)} type={type(X).__name__}"
            )
        n, lookback, _ = X.shape
        horizon = int(self._t1_horizon)
        if n == 0:
            self.last_predict_meta = {"task": "T1", "n_attempted": 0,
                                       "n_parse_errors": 0}
            return np.zeros((0, horizon), dtype=np.float32)
        close_idx = (
            self._t1_close_idx
            if self._t1_close_idx is not None
            else _find_close_idx_from_array(X)
        )
        preds = np.full((n, horizon), np.nan, dtype=np.float32)
        n_errors = 0
        # Trajectory output requires more tokens than a single scalar:
        # budget ~12 tokens per horizon step plus brackets/separators.
        max_new_tokens = max(64, 12 * horizon + 16)
        for i in range(n):
            history = X[i, :, close_idx]
            prompt = _t1_predict_prompt(history, lookback, horizon)
            response = self._generate(prompt, max_new_tokens=max_new_tokens)
            traj = _parse_horizon_list(response, horizon)
            if traj is None:
                n_errors += 1
                continue
            preds[i, :] = traj
        self.last_predict_meta = {
            "task": "T1", "n_attempted": int(n),
            "n_parse_errors": int(n_errors),
            "horizon": horizon, "close_idx": int(close_idx),
        }
        return preds

    def _predict_t2_t5(
        self, X: pd.DataFrame, *, task: str,
    ) -> np.ndarray:
        if not isinstance(X, pd.DataFrame):
            raise ValueError(
                f"{task} X must be a DataFrame, got {type(X).__name__}"
            )
        n = len(X)
        if n == 0:
            self.last_predict_meta = {"task": task, "n_attempted": 0,
                                       "n_parse_errors": 0}
            return np.zeros(0, dtype=np.float32)
        if task == "T2":
            instructions = []
            for _, row in X.iterrows():
                sector = row.get("sector", "Unknown")
                revenue = _safe_float(row.get("stmt_revenue", 0))
                net_income = _safe_float(row.get("stmt_net_income", 0))
                total_assets = _safe_float(row.get("stmt_total_assets", 0))
                employees = row.get("fullTimeEmployees", "N/A")
                instructions.append(
                    f"You are a financial analyst. Estimate the total "
                    f"equity market capitalization of this company.\n\n"
                    f"Sector: {sector}\nRevenue: ${revenue:,.0f}\n"
                    f"Net Income: ${net_income:,.0f}\n"
                    f"Total Assets: ${total_assets:,.0f}\n"
                    f"Employees: {employees}"
                )
        else:
            # Match `_t2_t5_pairs` (T5 branch) exactly.
            stmt_cols = [c for c in X.columns if c.startswith("stmt_")]
            instructions = []
            for _, row in X.iterrows():
                sector = row.get("sector", "Unknown")
                industry = row.get("industry", "Unknown")
                items = []
                for c in stmt_cols:
                    val = row.get(c)
                    if pd.notna(val):
                        try:
                            items.append(f"{c}: ${float(val):,.0f}")
                        except (TypeError, ValueError):
                            continue
                block = (
                    "\n".join(items) if items
                    else "No financial statement data available"
                )
                instructions.append(
                    f"You are a private equity analyst. Given ONLY financial "
                    f"statement data (no market price), estimate the market "
                    f"capitalization of this company.\n\n"
                    f"Sector: {sector}\nIndustry: {industry}\n{block}"
                )
        preds = np.full(n, np.nan, dtype=np.float64)
        n_errors = 0
        for i, prompt in enumerate(instructions):
            response = self._generate(prompt, max_new_tokens=64)
            v = _parse_first_number(response)
            if v is None or v <= 0:
                n_errors += 1
                continue
            preds[i] = float(v)
        self.last_predict_meta = {
            "task": task, "n_attempted": int(n),
            "n_parse_errors": int(n_errors),
        }
        return preds

    def _predict_t3_t6(
        self, X: pd.DataFrame, *, task: str,
    ) -> pd.DataFrame:
        if not isinstance(X, pd.DataFrame):
            raise ValueError(
                f"{task} X must be a DataFrame, got {type(X).__name__}"
            )
        n = len(X)
        if n == 0:
            self.last_predict_meta = {"task": task, "n_attempted": 0,
                                       "n_parse_errors": 0}
            return pd.DataFrame(
                columns=["ticker", "fiscal_year", "field", "pred"]
            )
        # Field set: per-ticker if fitted, else global, else default panel.
        global_fields = (
            self._fitted_fields_global
            or list(_DEFAULT_T3_T6_FIELDS)
        )

        rows: list[dict[str, Any]] = []
        n_errors = 0
        for _, row in X.iterrows():
            ticker = str(row.get("ticker", "?"))
            fy = row.get("fiscal_year", None)
            fields_for_row = (
                self._fitted_fields_per_ticker.get(ticker)
                or global_fields
            )
            fields_str = ", ".join(fields_for_row)
            if task == "T3":
                sector = row.get("sector", "Unknown")
                revenue = _safe_float(row.get("stmt_revenue", 0))
                net_income = _safe_float(row.get("stmt_net_income", 0))
                # Match `_t3_pairs` exactly so the adapter sees the same
                # instruction text at predict time as it did during SFT.
                instr = (
                    f"You are a financial analyst. Given {ticker}'s known "
                    f"fundamentals (sector={sector}, revenue=${revenue:,.0f}, "
                    f"net_income=${net_income:,.0f}), predict these XBRL "
                    f"fields: [{fields_str}]"
                )
            else:
                description = row.get(
                    "company_description", f"A company with ticker {ticker}",
                )
                sector = row.get("sector", "Unknown")
                industry = row.get("industry", "Unknown")
                # Match `_t6_pairs` exactly.
                instr = (
                    f"Given this company description: '{description}', "
                    f"sector: '{sector}', industry: '{industry}', generate "
                    f"plausible financial statement values for these XBRL "
                    f"fields: [{fields_str}]"
                )
            response = self._generate(instr, max_new_tokens=512)
            parsed = _extract_json_object(response)
            if parsed is None:
                n_errors += 1
                continue
            for field, val in parsed.items():
                try:
                    rows.append({
                        "ticker": ticker, "fiscal_year": fy,
                        "field": str(field), "pred": float(val),
                    })
                except (TypeError, ValueError):
                    continue
        self.last_predict_meta = {
            "task": task, "n_attempted": int(n),
            "n_parse_errors": int(n_errors),
        }
        return pd.DataFrame(
            rows, columns=["ticker", "fiscal_year", "field", "pred"]
        )

    def _predict_t4(self, X: Any) -> np.ndarray:
        if isinstance(X, dict):
            event_type = np.asarray(X.get("event_type", []))
            event_desc = np.asarray(X.get("event_description", []))
        elif isinstance(X, pd.DataFrame):
            event_type = (
                X["event_type"].to_numpy()
                if "event_type" in X.columns else np.array([])
            )
            event_desc = (
                X["event_description"].to_numpy()
                if "event_description" in X.columns
                else np.array([""] * len(event_type))
            )
        else:
            raise ValueError(
                f"T4 X must be DataFrame or dict, got {type(X).__name__}"
            )
        n = int(len(event_type))
        if n == 0:
            self.last_predict_meta = {"task": "T4", "n_attempted": 0,
                                       "n_parse_errors": 0}
            return np.zeros(0, dtype=np.float32)
        preds = np.full(n, np.nan, dtype=np.float32)
        n_errors = 0
        for i in range(n):
            et_s = str(event_type[i]) if event_type[i] is not None else "unknown"
            ed_s = str(event_desc[i])[:200] if event_desc[i] is not None else ""
            instr = (
                f"You are a financial analyst. Given the scenario:\n"
                f"- Event type: {et_s}\n"
                + (f"- Description: {ed_s}\n" if ed_s else "")
                + "\nPredict the stock return (%) following this event."
            )
            response = self._generate(instr, max_new_tokens=64)
            v = _parse_first_number(response)
            if v is None:
                n_errors += 1
                continue
            preds[i] = float(v)
        self.last_predict_meta = {
            "task": "T4", "n_attempted": int(n),
            "n_parse_errors": int(n_errors),
        }
        return preds

    def _predict_t7(self, X: pd.DataFrame) -> pd.DataFrame:
        if not isinstance(X, pd.DataFrame):
            raise ValueError(
                f"T7 X must be a DataFrame, got {type(X).__name__}"
            )
        n = len(X)
        if n == 0:
            self.last_predict_meta = {"task": "T7", "n_attempted": 0,
                                       "n_parse_errors": 0}
            return pd.DataFrame(
                columns=["address", "pred_rent", "pred_price"]
            )
        rows: list[dict[str, Any]] = []
        n_errors = 0
        for _, row in X.iterrows():
            addr = row.get("address", None)
            city = row.get("city", "Unknown")
            state = row.get("state", "Unknown")
            property_type = row.get("property_type", "Unknown")
            sqft = row.get("sqft", "N/A")
            beds = row.get("bedrooms", row.get("beds", "N/A"))
            baths = row.get("bathrooms", row.get("baths", "N/A"))
            year_built = row.get("year_built", "N/A")
            instr = (
                f"Estimate AS OF 2026-04-11. Given this property: "
                f"location={city}, {state}, type={property_type}, "
                f"sqft={sqft}, beds={beds}, baths={baths}, "
                f"year_built={year_built}. Estimate the monthly rent and "
                f"sale price."
            )
            response = self._generate(instr, max_new_tokens=128)
            parsed = _extract_json_object(response)
            if parsed is None:
                n_errors += 1
                rows.append({"address": addr, "pred_rent": np.nan,
                             "pred_price": np.nan})
                continue
            ci = {str(k).lower(): v for k, v in parsed.items()}
            try:
                rent_val = float(ci.get("rent", 0) or 0)
            except (TypeError, ValueError):
                rent_val = np.nan
            try:
                price_val = float(ci.get("price", 0) or 0)
            except (TypeError, ValueError):
                price_val = np.nan
            rows.append({"address": addr, "pred_rent": rent_val,
                         "pred_price": price_val})
        self.last_predict_meta = {
            "task": "T7", "n_attempted": int(n),
            "n_parse_errors": int(n_errors),
        }
        return pd.DataFrame(
            rows, columns=["address", "pred_rent", "pred_price"]
        )

    # ── HF save / load hooks ─────────────────────────────────────────────

    def _manifest(self) -> dict[str, Any]:
        m = super()._manifest()
        adapter_sha = ""
        if self._adapter_dir is not None and self._adapter_dir.exists():
            adapter_sha = _sha256_dir(self._adapter_dir)
        m["sha256s"] = {"adapter": adapter_sha}
        return m

    def _hf_save(self, path: pathlib.Path) -> None:
        """Persist the LoRA adapter + tokenizer to ``path``.

        Layout::

            path/manifest.json     # Method ABC
            path/adapter/          # peft.PeftModel.save_pretrained
            path/tokenizer/        # tokenizer.save_pretrained
            path/adapter.sha256    # plain-text hash recorded in manifest
        """
        if self.dry_run or self._adapter_dir is None:
            # Dry-run mode: write a placeholder so load() can detect mode.
            (path / "DRY_RUN").write_text("1\n")
            return

        import shutil

        target_adapter = path / "adapter"
        if target_adapter.exists():
            shutil.rmtree(target_adapter)
        shutil.copytree(self._adapter_dir, target_adapter)

        if self._tokenizer_dir is not None and self._tokenizer_dir.exists():
            target_tok = path / "tokenizer"
            if target_tok.exists():
                shutil.rmtree(target_tok)
            shutil.copytree(self._tokenizer_dir, target_tok)

        sha = _sha256_dir(target_adapter)
        (path / "adapter.sha256").write_text(sha + "\n")

    def _hf_load(self, path: pathlib.Path) -> None:
        """Reload adapter + tokenizer; rebuild a merged model in memory.

        In dry_run mode this short-circuits (the placeholder marker file
        is detected and ``self._dry_engine`` is re-established).
        """
        if (path / "DRY_RUN").exists():
            self.dry_run = True
            self._dry_engine = _DryRunFTEngine()
            return

        try:
            import torch
            from transformers import (
                AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig,
            )
            from peft import PeftModel
        except ImportError as exc:
            raise RuntimeError(
                "LLMFineTuned.load requires transformers + peft + "
                f"bitsandbytes. Underlying error: {exc!r}"
            ) from exc

        adapter_dir = path / "adapter"
        tokenizer_dir = path / "tokenizer"
        if not adapter_dir.exists():
            raise FileNotFoundError(
                f"adapter directory missing at {adapter_dir}"
            )

        quant_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_use_double_quant=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
        )
        model_id = self.config.model_id
        if "gemma-4" in model_id.lower():
            from transformers import Gemma4ForCausalLM
            base = Gemma4ForCausalLM.from_pretrained(
                model_id, quantization_config=quant_config,
                device_map="auto", trust_remote_code=True,
                torch_dtype=torch.bfloat16, attn_implementation="eager",
            )
        else:
            base = AutoModelForCausalLM.from_pretrained(
                model_id, quantization_config=quant_config,
                device_map="auto", trust_remote_code=True,
                torch_dtype=torch.bfloat16, attn_implementation="eager",
            )
        peft_model = PeftModel.from_pretrained(base, str(adapter_dir))
        tok_src = tokenizer_dir if tokenizer_dir.exists() else model_id
        tokenizer = AutoTokenizer.from_pretrained(
            str(tok_src), trust_remote_code=True,
        )
        if tokenizer.pad_token is None:
            tokenizer.pad_token = tokenizer.eos_token

        self._model = peft_model
        self._tokenizer = tokenizer
        self._adapter_dir = adapter_dir
        self._tokenizer_dir = tokenizer_dir if tokenizer_dir.exists() else None


__all__ = ["LLMFineTuned"]