quantization/hsaq/candidate_record.py

"""
Sovereign Hive — Model Hunter Candidate Record

Pure-data module. No I/O, no Vault access, no network. All persistence happens
through the Vault module, which routes through PermissionGate.

Convention: this file MUST NOT import sqlite3, requests, httpx, os, pathlib,
subprocess, or socket. If it ever needs to, that's a signal the logic belongs
in the Vault module or the hunter agent, not here.
"""

from __future__ import annotations

from dataclasses import asdict, dataclass, field
from datetime import UTC, datetime
from enum import StrEnum
from typing import Literal

# ---------------------------------------------------------------------------
# Enums
# ---------------------------------------------------------------------------


class ArchType(StrEnum):
    MHA = "MHA"
    GQA = "GQA"
    MQA = "MQA"


class EligibilityTier(StrEnum):
    GREEN = "green"  # fits comfortably, ready to profile/quantize
    YELLOW = "yellow"  # fits but tight, or constrained on pruning/tokenizer
    RED = "red"  # should not have survived filter; diagnostic only


# ---------------------------------------------------------------------------
# VRAM prediction constants & helpers
# ---------------------------------------------------------------------------
# These should ideally be sourced from project config. Kept here as the
# reference implementation that matches the HSAQ spec.

HSAQ_TIER_SPLIT = (0.30, 0.40, 0.30)  # critical, normal, tolerant
HSAQ_TIER_BITS = (4, 3, 3)  # 2-bit floor opt-in only — keep at 3
HQQ_OVERHEAD_FACTOR = 0.07  # group-quant scales + zeros, ~5-8%
LORA_RANK_16_GB = 0.05  # rank-16 adapter on a 20B-class model
ACTIVATIONS_GB_4K = 0.8  # batch=1, ctx=4k, generous
VRAM_BUDGET_GB = 12.0  # RTX 5070
VRAM_DRIVER_HEADROOM_GB = 0.5  # OS/driver reserve
MAX_REALISTIC_PARAM_COUNT = 22_000_000_000


def predicted_avg_bits() -> float:
    return sum(s * b for s, b in zip(HSAQ_TIER_SPLIT, HSAQ_TIER_BITS, strict=False))


def predict_weights_gb(param_count: int) -> float:
    """Mixed 3/4-bit weights at HSAQ default tier split, with HQQ overhead."""
    raw = (param_count * predicted_avg_bits() / 8) / 1e9
    return raw * (1 + HQQ_OVERHEAD_FACTOR)


def predict_kv_gb(
    num_kv_heads: int,
    head_dim: int,
    num_layers: int,
    context_length: int = 4096,
    bytes_per_element: int = 1,  # int8 KV by default
) -> float:
    """KV cache size in GB at a given context length and precision."""
    bytes_per_token = 2 * num_kv_heads * head_dim * num_layers * bytes_per_element
    return (bytes_per_token * context_length) / 1e9


# ---------------------------------------------------------------------------
# CandidateRecord
# ---------------------------------------------------------------------------


@dataclass
class CandidateRecord:
    # --- Identity ---
    model_id: str
    model_hash: str
    source: Literal["hf_hub", "local_mirror", "manual"]
    discovered_at: datetime

    # --- Architecture ---
    arch_type: ArchType
    param_count: int
    hidden_size: int
    num_layers: int
    num_attention_heads: int
    num_kv_heads: int
    head_dim: int
    max_position_embeddings: int

    # --- License & compat ---
    license: str
    license_commercial_ok: bool
    tokenizer_family: str
    tokenizer_compat_score: float

    # --- Provenance (audit chain) ---
    discovered_by_agent_id: str
    discovered_by_agent_tier: int

    # --- Sensitivity priors (skip the 30-min pass if these exist) ---
    has_published_sensitivity_profile: bool = False
    published_profile_source: str | None = None

    # --- Computed fields (filled by __post_init__ / refresh_predictions) ---
    kv_bytes_per_token_fp16: int = 0
    kv_bytes_per_token_int8: int = 0
    predicted_vram_weights_mixed_34: float = 0.0
    predicted_vram_kv_4k_int8: float = 0.0
    predicted_vram_total_4k: float = 0.0
    predicted_headroom_gb: float = 0.0

    pruning_eligible: bool = False
    pruning_eligible_reason: str = ""

    hsaq_eligibility: EligibilityTier = EligibilityTier.RED
    eligibility_reasons: list[str] = field(default_factory=list)

    def __post_init__(self) -> None:
        self.refresh_predictions()

    # -- Predictions ---------------------------------------------------------

    def refresh_predictions(self) -> None:
        """Recompute all derived fields. Idempotent."""
        self.kv_bytes_per_token_fp16 = 2 * self.num_kv_heads * self.head_dim * self.num_layers * 2
        self.kv_bytes_per_token_int8 = self.kv_bytes_per_token_fp16 // 2

        self.predicted_vram_weights_mixed_34 = predict_weights_gb(self.param_count)
        self.predicted_vram_kv_4k_int8 = predict_kv_gb(
            num_kv_heads=self.num_kv_heads,
            head_dim=self.head_dim,
            num_layers=self.num_layers,
            context_length=4096,
            bytes_per_element=1,
        )
        self.predicted_vram_total_4k = (
            self.predicted_vram_weights_mixed_34 + self.predicted_vram_kv_4k_int8 + LORA_RANK_16_GB + ACTIVATIONS_GB_4K
        )
        self.predicted_headroom_gb = VRAM_BUDGET_GB - VRAM_DRIVER_HEADROOM_GB - self.predicted_vram_total_4k

        self._compute_pruning_eligibility()
        self._compute_eligibility()

    def _compute_pruning_eligibility(self) -> None:
        # Default: pruning OFF for GQA/MQA. The published literature on safe
        # head pruning is MHA-centric; GQA/MQA share KV heads across query
        # heads and structured pruning needs separate validation per arch.
        if self.arch_type is ArchType.MHA:
            self.pruning_eligible = True
            self.pruning_eligible_reason = "MHA arch — head pruning literature applies"
        else:
            self.pruning_eligible = False
            self.pruning_eligible_reason = (
                f"{self.arch_type.value} arch — head pruning off by default; shared KV heads need separate validation"
            )

    def _compute_eligibility(self) -> None:
        reasons: list[str] = []
        tier = EligibilityTier.GREEN

        # ----- Hard fails (RED) -----
        if self.predicted_headroom_gb < 0:
            reasons.append(
                f"OOM predicted: total {self.predicted_vram_total_4k:.2f} GB "
                f"exceeds usable {VRAM_BUDGET_GB - VRAM_DRIVER_HEADROOM_GB:.2f} GB"
            )
            tier = EligibilityTier.RED
        if not self.license_commercial_ok:
            reasons.append(f"License '{self.license}' not commercial-compatible")
            tier = EligibilityTier.RED
        if self.tokenizer_compat_score < 0.6:
            reasons.append(f"Tokenizer compat {self.tokenizer_compat_score:.2f} < 0.6")
            tier = EligibilityTier.RED
        if self.param_count > MAX_REALISTIC_PARAM_COUNT:
            reasons.append(f"Param count {self.param_count:,} above realistic ceiling ({MAX_REALISTIC_PARAM_COUNT:,})")
            tier = EligibilityTier.RED

        if tier is EligibilityTier.RED:
            self.hsaq_eligibility = tier
            self.eligibility_reasons = reasons
            return

        # ----- Soft constraints (downgrade GREEN -> YELLOW) -----
        if self.predicted_headroom_gb < 1.0:
            reasons.append(
                f"Tight headroom: {self.predicted_headroom_gb:.2f} GB free after "
                "predicted load; long-context use likely to OOM"
            )
            tier = EligibilityTier.YELLOW
        if self.arch_type is ArchType.MHA:
            reasons.append("MHA arch — larger KV cache than GQA equivalents")
            if tier is EligibilityTier.GREEN:
                tier = EligibilityTier.YELLOW
        if 0.6 <= self.tokenizer_compat_score < 0.85:
            reasons.append(f"Tokenizer compat {self.tokenizer_compat_score:.2f} below 0.85")
            if tier is EligibilityTier.GREEN:
                tier = EligibilityTier.YELLOW

        if tier is EligibilityTier.GREEN and not reasons:
            reasons.append("All checks passed at green threshold")

        self.hsaq_eligibility = tier
        self.eligibility_reasons = reasons

    # -- Serialization -------------------------------------------------------
    # The Vault module owns the INSERT/SELECT. These helpers just produce
    # and consume row-shaped dicts. Vault writes go through PermissionGate
    # and include originating agent_id + tier on every row.

    def to_vault_payload(self) -> dict:
        d = asdict(self)
        d["arch_type"] = self.arch_type.value
        d["hsaq_eligibility"] = self.hsaq_eligibility.value
        d["discovered_at"] = self.discovered_at.astimezone(UTC).isoformat()
        # eligibility_reasons stays as list — Vault module is responsible for
        # JSON-encoding on insert and decoding on select.
        return d

    @classmethod
    def from_vault_row(cls, row: dict) -> CandidateRecord:
        row = dict(row)  # shallow copy — don't mutate caller's row
        row["arch_type"] = ArchType(row["arch_type"])
        row["hsaq_eligibility"] = EligibilityTier(row["hsaq_eligibility"])
        if isinstance(row["discovered_at"], str):
            row["discovered_at"] = datetime.fromisoformat(row["discovered_at"])
        return cls(**row)