split-stack 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

split_stack/__init__.py

@@ -46,11 +46,12 @@ from split_stack.session import (
     route,
     session_warnings,
 )
+from split_stack.stack_health import check_stack_health, format_stack_health
 from split_stack.startup_tips import emit_import_tips, model_recommendation_report
 from split_stack.tiering import assign_tiers, describe_tiers
 from split_stack.validation import validate_tier_map
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "ComplexityTier",
@@ -98,6 +99,8 @@ __all__ = [
     "score_prompt",
     "session_warnings",
     "stack_recommendation",
+    "check_stack_health",
+    "format_stack_health",
     "usage_requirements",
     "validate_tier_map",
     "__version__",

split_stack/cli.py

@@ -20,6 +20,7 @@ from split_stack.ollama_generate import ask_prompt_json, route_prompt_json
 from split_stack.requirements import UsageProfile, list_usage_profiles, usage_requirements
 from split_stack.presets import assign_recommended_tiers, list_recommended_stacks, recommended_models
 from split_stack.setup_wizard import format_setup_summary, plan_setup, run_setup
+from split_stack.stack_health import check_stack_health, format_stack_health
 from split_stack.tiering import assign_tiers, describe_tiers
 
 
@@ -159,7 +160,47 @@ def _cmd_profiles(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_doctor_check_stack(args: argparse.Namespace) -> int:
+    models = None
+    if args.models:
+        models = [part.strip() for part in args.models.split(",") if part.strip()]
+    report = check_stack_health(
+        profile=args.profile,
+        vram_gb=args.vram_gb,
+        quant=args.quant,
+        base_url=args.base_url,
+        models=models,
+    )
+    if args.json:
+        payload = {
+            "ready": report.ready,
+            "profile": report.profile,
+            "vram_gb": report.vram_gb,
+            "quant": report.quant,
+            "recommended": list(report.recommended),
+            "resolved": list(report.resolved),
+            "missing": list(report.missing),
+            "pool_size": report.pool_size,
+            "inventory_note": report.inventory_note,
+            "findings": [
+                {
+                    "level": item.level,
+                    "code": item.code,
+                    "message": item.message,
+                    "models": list(item.models),
+                }
+                for item in report.findings
+            ],
+        }
+        return _emit_json(payload)
+    print(format_stack_health(report))
+    return 0 if report.ready else 1
+
+
 def _cmd_doctor(args: argparse.Namespace) -> int:
+    if args.check_stack:
+        return _cmd_doctor_check_stack(args)
+
     advice = stack_recommendation(cursor_override_enabled=False)
     print(f"Cursor model: {advice.cursor_model}")
     print(f"Prose path: {advice.prose_path}")
@@ -505,6 +546,27 @@ def main(argv: list[str] | None = None) -> int:
         help="Path to split-stack.models.json (or set SPLIT_STACK_MODELS_CONFIG)",
     )
     _add_quant_arg(doctor_parser)
+    doctor_parser.add_argument(
+        "--check-stack",
+        action="store_true",
+        help="Offline stack health: missing models, duplicates, routing spread (exit 1 if not ready)",
+    )
+    doctor_parser.add_argument(
+        "--vram-gb",
+        type=int,
+        choices=[8, 12, 16, 24, 32],
+        help="GPU VRAM for recommended stack (alternative to --profile)",
+    )
+    doctor_parser.add_argument(
+        "--base-url",
+        default="http://127.0.0.1:11434",
+        help="Ollama base URL for inventory scan",
+    )
+    doctor_parser.add_argument(
+        "--models",
+        help="Comma-separated stack override when using --check-stack",
+    )
+    doctor_parser.add_argument("--json", action="store_true", help="JSON output (with --check-stack)")
     doctor_parser.set_defaults(handler=_cmd_doctor)
 
     requirements_parser = subparsers.add_parser(

split_stack/discovery.py

@@ -240,7 +240,7 @@ def audit_model_folders(
         primary = home if home.is_dir() else None
     return {
         "primary_root": str(primary) if primary else None,
-        "scan_roots": list(manifest_search_paths()),
+        "scan_roots": [str(path) for path in manifest_search_paths()],
         "tag_count": len(locations),
         "locations": {tag: list(paths) for tag, paths in locations.items()},
         "duplicates": duplicates,

split_stack/poc_models.py

@@ -1,85 +1,112 @@
-"""Default model stacks for POC demos and compare benchmarks."""
+"""Workstation stack helpers for demos and compare POC."""
 
 from __future__ import annotations
 
 from dataclasses import dataclass
 
-from split_stack.community_picks import focus_stack, vram_tier_for_profile
 from split_stack.discovery import list_model_inventory
-from split_stack.presets import recommended_models
+from split_stack.presets import RECOMMENDED_STACKS, recommended_models
+from split_stack.quantization import QAT_STACK_ADDITIONS, normalize_quant_mode
+from split_stack.session import profile_for_vram_gb
 
 DEFAULT_POC_STACK = ["gemma4:e4b", "qwen3:8b", "qwen3:14b"]
-QWEN_ONLY_STACK = ["qwen3:4b", "qwen3:8b", "qwen3:14b"]
+
+VRAM_OPTIONS: tuple[tuple[int, str], ...] = (
+    (8, "8 GB"),
+    (12, "12 GB"),
+    (16, "16 GB"),
+    (24, "24 GB"),
+    (32, "32 GB"),
+)
+
+QUANT_OPTIONS: tuple[tuple[str, str], ...] = (
+    ("default", "Default (PTQ)"),
+    ("qat", "Gemma QAT (int4)"),
+    ("qat_mobile", "Gemma mobile QAT"),
+    ("bf16", "BF16 (full size)"),
+)
+
+_PRESET_VRAM_ALIASES: dict[str, int] = {
+    "mixed_12gb": 12,
+    "mixed_16gb": 16,
+    "qwen_only": 12,
+    "recommended_12gb": 12,
+    "from_inventory": 0,
+}
 
 
 @dataclass(frozen=True)
-class StackPreset:
-    id: str
-    label: str
+class WorkstationStack:
+    vram_gb: int
+    profile: str
+    quant: str
     models: tuple[str, ...]
     description: str
+    notes: tuple[str, ...]
 
 
-STACK_PRESETS: tuple[StackPreset, ...] = (
-    StackPreset(
-        id="mixed_12gb",
-        label="Mixed 12 GB (Gemma + Qwen)",
-        models=tuple(DEFAULT_POC_STACK),
-        description="Gemma lookup, Qwen 8B medium, Qwen 14B complex",
-    ),
-    StackPreset(
-        id="qwen_only",
-        label="Qwen only (4B / 8B / 14B)",
-        models=tuple(QWEN_ONLY_STACK),
-        description="Single-family ladder",
-    ),
-    StackPreset(
-        id="recommended_12gb",
-        label="Full 12 GB specialist",
-        models=tuple(recommended_models("workstation_12gb")),
-        description="Gemma + Qwen + DeepSeek R1 for reasoning",
-    ),
-    StackPreset(
-        id="community_agentic",
-        label="Reddit agentic (M tier)",
-        models=tuple(),
-        description="r/LocalLLaMA Apr 2026 — Gemma lookup + Qwen spine for agent loops",
-    ),
-    StackPreset(
-        id="from_inventory",
-        label="From your Ollama (auto ladder)",
-        models=tuple(),
-        description="Picks small/mid/large tags from API + disk manifests",
-    ),
-)
+def list_vram_options() -> tuple[tuple[int, str], ...]:
+    return VRAM_OPTIONS
 
 
-def list_stack_presets() -> tuple[StackPreset, ...]:
-    return STACK_PRESETS
+def list_quant_options() -> tuple[tuple[str, str], ...]:
+    return QUANT_OPTIONS
+
+
+def recommended_stack_for_vram(
+    vram_gb: int,
+    *,
+    quant: str | None = None,
+) -> WorkstationStack:
+    profile = profile_for_vram_gb(vram_gb)
+    stack = RECOMMENDED_STACKS[profile]
+    quant_mode = normalize_quant_mode(quant)
+    models = recommended_models(profile, quant=quant_mode)
+    notes: list[str] = []
+    if quant_mode == "qat":
+        extras = QAT_STACK_ADDITIONS.get(profile, ())
+        if extras:
+            notes.append(
+                f"QAT adds {', '.join(extras)} on {vram_gb} GB — Gemma-only int4 runtime sizes."
+            )
+    elif quant_mode == "bf16":
+        notes.append("BF16 uses full Gemma pull sizes — prefer 24 GB+ or datacenter.")
+    return WorkstationStack(
+        vram_gb=vram_gb,
+        profile=profile,
+        quant=quant_mode,
+        models=tuple(models),
+        description=stack.description,
+        notes=tuple(notes),
+    )
 
 
 def models_for_preset(
     preset_id: str,
     *,
     base_url: str = "http://127.0.0.1:11434",
-    profile: str = "workstation_12gb",
+    profile: str | None = None,
+    quant: str | None = None,
 ) -> list[str]:
     if preset_id == "from_inventory":
         inventory = list_model_inventory(base_url=base_url)
         if inventory.suggested_stack:
             return list(inventory.suggested_stack)
         return list(DEFAULT_POC_STACK)
+    if preset_id == "qwen_only":
+        return ["qwen3:4b", "qwen3:8b", "qwen3:14b"]
     if preset_id == "community_agentic":
-        tier = vram_tier_for_profile(profile)
-        stack = focus_stack("agentic", vram_tier=tier)
-        if stack and stack.models:
-            return list(stack.models)
+        from split_stack.community_picks import focus_stack, vram_tier_for_profile
+
+        tier = vram_tier_for_profile(profile or "workstation_12gb")
+        focus = focus_stack("agentic", vram_tier=tier)
+        if focus and focus.models:
+            return list(focus.models)
         return list(DEFAULT_POC_STACK)
-    for item in STACK_PRESETS:
-        if item.id == preset_id:
-            return list(item.models)
-    valid = ", ".join(item.id for item in STACK_PRESETS)
-    raise ValueError(f"Unknown stack preset '{preset_id}'. Valid: {valid}")
+    vram = _PRESET_VRAM_ALIASES.get(preset_id)
+    if vram:
+        return list(recommended_stack_for_vram(vram, quant=quant).models)
+    raise ValueError(f"Unknown stack preset '{preset_id}'.")
 
 
 def available_model_pool(
@@ -87,7 +114,6 @@ def available_model_pool(
     base_url: str = "http://127.0.0.1:11434",
     source: str = "both",
 ) -> tuple[list[str], str | None]:
-    """Return model names from Ollama API, disk manifests, or both."""
     inventory = list_model_inventory(base_url=base_url)
     if source == "api":
         pool = list(inventory.api_models)
@@ -98,18 +124,15 @@ def available_model_pool(
     return pool, inventory.note
 
 
-def resolve_installed_stack(
+def resolve_stack_against_pool(
+    desired: list[str],
     installed: list[str],
-    *,
-    preset_id: str = "mixed_12gb",
-    base_url: str = "http://127.0.0.1:11434",
-) -> tuple[list[str], str | None]:
-    """Pick preset models that exist in the installed pool; warn when falling back."""
-    desired = models_for_preset(preset_id, base_url=base_url)
+) -> tuple[list[str], list[str], str | None]:
     installed_set = set(installed)
     matched = [name for name in desired if name in installed_set]
+    missing = [name for name in desired if name not in installed_set]
     if len(matched) >= 2:
-        return matched, None
+        return matched, missing, None
 
     if installed:
         from split_stack.model_registry import load_registry, model_weight
@@ -118,14 +141,61 @@ def resolve_installed_stack(
         ranked = sorted(installed, key=lambda name: model_weight(name, registry))
         if len(ranked) >= 2:
             warning = (
-                f"Preset '{preset_id}' not fully available ({', '.join(desired)}). "
+                f"Recommended stack not fully installed ({', '.join(desired)}). "
                 f"Using: {', '.join(ranked)}"
             )
-            return ranked, warning
+            return ranked, missing, warning
         warning = (
-            f"Preset '{preset_id}' not fully available. "
-            f"Using only {ranked[0]} — need 2+ models for compare spread."
+            f"Recommended stack not fully installed. "
+            f"Using only {ranked[0]} — need 2+ models for routing spread."
         )
-        return ranked, warning
+        return ranked, missing, warning
+
+    return desired, missing, f"Using recommended list (not verified against disk): {', '.join(desired)}"
 
-    return desired, f"Using preset list (not verified): {', '.join(desired)}"
+
+def resolve_installed_stack(
+    installed: list[str],
+    *,
+    preset_id: str = "mixed_12gb",
+    base_url: str = "http://127.0.0.1:11434",
+    vram_gb: int | None = None,
+    quant: str | None = None,
+    models: list[str] | None = None,
+) -> tuple[list[str], str | None]:
+    if models:
+        desired = models
+    elif vram_gb is not None:
+        desired = list(recommended_stack_for_vram(vram_gb, quant=quant).models)
+    else:
+        desired = models_for_preset(preset_id, base_url=base_url, quant=quant)
+    resolved, _missing, warning = resolve_stack_against_pool(desired, installed)
+    return resolved, warning
+
+
+def stack_payload(
+    *,
+    vram_gb: int = 16,
+    quant: str | None = "qat",
+    base_url: str = "http://127.0.0.1:11434",
+    source: str = "both",
+    models_override: list[str] | None = None,
+) -> dict[str, object]:
+    stack = recommended_stack_for_vram(vram_gb, quant=quant)
+    desired = list(models_override) if models_override else list(stack.models)
+    pool, inventory_note = available_model_pool(base_url=base_url, source=source)
+    resolved, missing, warning = resolve_stack_against_pool(desired, pool)
+    return {
+        "ready": True,
+        "vram_gb": vram_gb,
+        "profile": stack.profile,
+        "quant": stack.quant,
+        "description": stack.description,
+        "notes": list(stack.notes),
+        "models": desired,
+        "resolved_models": resolved,
+        "missing_models": missing,
+        "warning": warning,
+        "inventory_note": inventory_note,
+        "pool_size": len(pool),
+    }

split_stack/stack_health.py

@@ -0,0 +1,360 @@
+"""Offline stack health checks — missing models, duplicates, routing spread, quant honesty."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from split_stack.discovery import audit_model_folders, list_model_inventory
+from split_stack.poc_models import resolve_stack_against_pool, stack_payload
+from split_stack.presets import recommended_models
+from split_stack.quantization import adjust_vram_for_quant, normalize_quant_mode, pull_guidance_lines
+from split_stack.session import default_profile_from_env, profile_for_vram_gb
+
+
+@dataclass(frozen=True)
+class ModelTagInfo:
+    name: str
+    size_bytes: int
+    quantization_level: str | None
+
+
+@dataclass(frozen=True)
+class StackHealthFinding:
+    level: str  # ok, warn, error
+    code: str
+    message: str
+    models: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class StackHealthReport:
+    ready: bool
+    profile: str
+    vram_gb: int | None
+    quant: str
+    recommended: tuple[str, ...]
+    resolved: tuple[str, ...]
+    missing: tuple[str, ...]
+    pool_size: int
+    findings: tuple[StackHealthFinding, ...]
+    inventory_note: str | None = None
+
+
+def check_stack_health(
+    *,
+    profile: str | None = None,
+    vram_gb: int | None = None,
+    quant: str | None = None,
+    base_url: str = "http://127.0.0.1:11434",
+    models: list[str] | None = None,
+    source: str = "both",
+) -> StackHealthReport:
+    """Check recommended stack against local inventory (offline; no upstream registry)."""
+    quant_mode = normalize_quant_mode(quant)
+    if vram_gb is not None:
+        resolved_profile = profile_for_vram_gb(vram_gb)
+    else:
+        resolved_profile = profile or default_profile_from_env()
+        vram_gb = _vram_for_profile(resolved_profile)
+
+    if models:
+        recommended = tuple(models)
+        payload = stack_payload(
+            vram_gb=vram_gb or 12,
+            quant=quant_mode,
+            base_url=base_url,
+            source=source,
+            models_override=list(models),
+        )
+        resolved = tuple(payload.get("resolved_models") or ())
+        missing = tuple(payload.get("missing_models") or ())
+        inventory_note = payload.get("inventory_note")
+        if isinstance(inventory_note, str):
+            pass
+        else:
+            inventory_note = None
+        pool_size = int(payload.get("pool_size") or 0)
+    else:
+        recommended = tuple(recommended_models(resolved_profile, quant=quant_mode))
+        inventory = list_model_inventory(base_url=base_url)
+        if source == "api":
+            pool = list(inventory.api_models)
+        elif source == "disk":
+            pool = list(inventory.disk_models)
+        else:
+            pool = sorted(set(inventory.api_models) | set(inventory.disk_models))
+        resolved_list, missing_list, _warning = resolve_stack_against_pool(
+            list(recommended),
+            pool,
+        )
+        resolved = tuple(resolved_list)
+        missing = tuple(missing_list)
+        inventory_note = inventory.note
+        pool_size = len(pool)
+
+    findings: list[StackHealthFinding] = []
+
+    for name in recommended:
+        if name in missing:
+            findings.append(
+                StackHealthFinding(
+                    level="error",
+                    code="missing",
+                    message=f"{name} is recommended but not found in local inventory.",
+                    models=(name,),
+                )
+            )
+        elif name in resolved:
+            findings.append(
+                StackHealthFinding(
+                    level="ok",
+                    code="present",
+                    message=f"{name} is installed.",
+                    models=(name,),
+                )
+            )
+
+    if len(resolved) < 2:
+        findings.append(
+            StackHealthFinding(
+                level="error",
+                code="routing_spread",
+                message=(
+                    f"Only {len(resolved)} model(s) available for routing "
+                    f"({', '.join(resolved) or 'none'}). Need at least 2 for tier spread."
+                ),
+                models=resolved,
+            )
+        )
+    elif missing:
+        findings.append(
+            StackHealthFinding(
+                level="warn",
+                code="partial_stack",
+                message=(
+                    f"Using {len(resolved)} installed model(s); "
+                    f"{len(missing)} recommended tag(s) missing."
+                ),
+                models=resolved,
+            )
+        )
+    else:
+        findings.append(
+            StackHealthFinding(
+                level="ok",
+                code="stack_complete",
+                message=f"All {len(recommended)} recommended model(s) are installed.",
+                models=resolved,
+            )
+        )
+
+    audit = audit_model_folders()
+    duplicate_tags = audit.get("duplicate_tags") or []
+    if duplicate_tags:
+        dup_list = tuple(str(tag) for tag in duplicate_tags)
+        findings.append(
+            StackHealthFinding(
+                level="warn",
+                code="duplicate_tags",
+                message=(
+                    f"Duplicate tags across Ollama folders: {', '.join(dup_list)}. "
+                    "Keep one models directory or run audit cleanup."
+                ),
+                models=dup_list,
+            )
+        )
+
+    findings.extend(
+        _quant_mismatch_findings(
+            quant_mode=quant_mode,
+            model_names=tuple(name for name in resolved if name not in missing),
+            base_url=base_url,
+        )
+    )
+
+    ready = len(resolved) >= 2
+    return StackHealthReport(
+        ready=ready,
+        profile=resolved_profile,
+        vram_gb=vram_gb,
+        quant=quant_mode,
+        recommended=recommended,
+        resolved=resolved,
+        missing=missing,
+        pool_size=pool_size,
+        findings=tuple(findings),
+        inventory_note=inventory_note,
+    )
+
+
+def format_stack_health(report: StackHealthReport) -> str:
+    lines: list[str] = []
+    vram_label = f"{report.vram_gb} GB" if report.vram_gb is not None else report.profile
+    lines.append(f"Stack health ({vram_label}, quant={report.quant})")
+    lines.append(f"  Recommended: {', '.join(report.recommended) or '-'}")
+    lines.append(f"  Resolved:    {', '.join(report.resolved) or '-'}")
+    if report.missing:
+        lines.append(f"  Missing:     {', '.join(report.missing)}")
+    lines.append(f"  Inventory:   {report.pool_size} tag(s) seen (API + disk)")
+    if report.inventory_note:
+        lines.append(f"  Note:        {report.inventory_note}")
+    lines.append("")
+    for item in report.findings:
+        prefix = {"ok": "OK", "warn": "WARN", "error": "ERROR"}.get(item.level, item.level.upper())
+        lines.append(f"  [{prefix}] {item.message}")
+    lines.append("")
+    if report.ready:
+        lines.append("Routing: ready (2+ models)")
+    else:
+        lines.append("Routing: not ready — install more models or adjust profile/VRAM.")
+    return "\n".join(lines)
+
+
+def _vram_for_profile(profile: str) -> int | None:
+    from split_stack.model_registry import DEPLOYMENT_PROFILES
+
+    spec = DEPLOYMENT_PROFILES.get(profile)
+    if spec is None:
+        return None
+    return spec.assumed_vram_gb
+
+
+def _fetch_ollama_tag_info(
+    *,
+    base_url: str = "http://127.0.0.1:11434",
+) -> dict[str, ModelTagInfo]:
+    try:
+        import requests
+    except ImportError:
+        return {}
+
+    url = f"{base_url.rstrip('/')}/api/tags"
+    try:
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()
+    except Exception:
+        return {}
+
+    out: dict[str, ModelTagInfo] = {}
+    payload = response.json() or {}
+    for item in payload.get("models") or []:
+        name = (item.get("name") or "").strip()
+        if not name:
+            continue
+        details = item.get("details") or {}
+        quant = details.get("quantization_level")
+        out[name] = ModelTagInfo(
+            name=name,
+            size_bytes=int(item.get("size") or 0),
+            quantization_level=str(quant) if quant else None,
+        )
+    return out
+
+
+def _is_gemma_tag(name: str) -> bool:
+    family = name.split(":")[0].lower()
+    return family.startswith("gemma")
+
+
+def _tag_suggests_qat(name: str) -> bool:
+    lowered = name.lower()
+    markers = ("qat", "ud-q4", "ud_q4", "unsloth", "gemma-4-qat")
+    return any(marker in lowered for marker in markers)
+
+
+def _tag_suggests_bf16(name: str) -> bool:
+    lowered = name.lower()
+    return "bf16" in lowered or "-it-bf16" in lowered
+
+
+def _quant_mismatch_findings(
+    *,
+    quant_mode: str,
+    model_names: tuple[str, ...],
+    base_url: str,
+) -> list[StackHealthFinding]:
+    if quant_mode == "default":
+        return []
+
+    tag_info = _fetch_ollama_tag_info(base_url=base_url)
+    if not tag_info:
+        return [
+            StackHealthFinding(
+                level="warn",
+                code="quant_check_skipped",
+                message=(
+                    "Quant check skipped — Ollama /api/tags unreachable or "
+                    "install split-stack[ollama] for requests."
+                ),
+            )
+        ]
+
+    findings: list[StackHealthFinding] = []
+    gemma_tags = [name for name in model_names if _is_gemma_tag(name)]
+    if not gemma_tags:
+        return findings
+
+    for name in gemma_tags:
+        info = tag_info.get(name)
+        if info is None:
+            continue
+
+        expected_gb = adjust_vram_for_quant(name, base_vram_gb=999, quant_mode=quant_mode)
+        size_gb = info.size_bytes / (1024**3) if info.size_bytes else 0.0
+        quant_label = info.quantization_level or "unknown"
+
+        if quant_mode == "bf16":
+            if not _tag_suggests_bf16(name) and quant_label not in {"F16", "BF16", "FP16"}:
+                findings.append(
+                    StackHealthFinding(
+                        level="warn",
+                        code="quant_mismatch",
+                        message=(
+                            f"{name}: quant=bf16 but installed as {quant_label} "
+                            f"({size_gb:.1f} GB on disk). VRAM sizing may be wrong."
+                        ),
+                        models=(name,),
+                    )
+                )
+            continue
+
+        # qat / qat_mobile — expect smaller runtime than library Q4_K_M pulls
+        if _tag_suggests_qat(name):
+            findings.append(
+                StackHealthFinding(
+                    level="ok",
+                    code="quant_ok",
+                    message=f"{name}: tag looks QAT-aligned ({quant_label}, {size_gb:.1f} GB).",
+                    models=(name,),
+                )
+            )
+            continue
+
+        oversized = expected_gb is not None and size_gb > expected_gb * 1.35
+        library_ptq = quant_label in {"Q4_K_M", "Q4_0", "Q5_K_M", "Q5_0"}
+        if oversized or library_ptq:
+            expected_text = f"~{expected_gb} GB runtime" if expected_gb else "smaller QAT runtime"
+            findings.append(
+                StackHealthFinding(
+                    level="warn",
+                    code="quant_mismatch",
+                    message=(
+                        f"{name}: quant={quant_mode} expects {expected_text} but installed "
+                        f"{quant_label} at {size_gb:.1f} GB — likely library PTQ, not QAT."
+                    ),
+                    models=(name,),
+                )
+            )
+
+    if any(item.code == "quant_mismatch" for item in findings):
+        hint = pull_guidance_lines(quant_mode)
+        if hint:
+            findings.append(
+                StackHealthFinding(
+                    level="warn",
+                    code="quant_hint",
+                    message=hint[0],
+                )
+            )
+
+    return findings

{split_stack-0.2.0.dist-info → split_stack-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: split-stack
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python routing library for local LLM agent loops: score prompts, map tiers to model names, embed in your runner.
 Author: Eddie Baumel
 License: MIT

{split_stack-0.2.0.dist-info → split_stack-0.3.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-split_stack/__init__.py,sha256=AtvBma-QYci2OlS4bm0WqNQr1uRAaUMya2XklE5dwVA,2869
+split_stack/__init__.py,sha256=4xE6uDgiYDt7yLVFaSGrS8a7g85EfNndTbHxnMNEUmw,2999
 split_stack/__main__.py,sha256=X79S2PFqrYOGd2hLQtB0-uqsdquj9Iuez7SYR64r0Ps,90
 split_stack/advice.py,sha256=KBw-Ly35O-4KaJgXwabtJqIFeaoP65wOj7VscodUiWc,427
 split_stack/benchmark.py,sha256=lx2sJvlPlzHsCkGxQ5YS_Z4duzt25yhmqQpNSdAsOPM,3170
-split_stack/cli.py,sha256=ohcTIV4V2fo7uoB52K_4Ynu1euDTq_jLPqalpwlnMMs,25005
+split_stack/cli.py,sha256=nZgwDioIua7GoITTh3p5z_X1JA1m0mcuebf_Gqt36Ew,27129
 split_stack/community_picks.py,sha256=Jaq0Wxs3_U4ix8kYLu2ge_VDMgym5xqKGtPsfxdEQhs,8148
 split_stack/compare.py,sha256=4u4OQ38I6DhMft-TYrAKljLJ8vIam-SlfiT9hcjun-Q,6665
 split_stack/complexity.py,sha256=R3N2t5QkGIkprx4fKnEqmsTPbTdsRo1Ap8-Er0lDEXk,1884
-split_stack/discovery.py,sha256=W4B7DLpCQBkVtipIy2wlcs6bcNGikGHzoB94TJG4AI8,9693
+split_stack/discovery.py,sha256=l__HjKmy3ESjX9lVnrj7A77kavZhxmdIdI5vtB_iX1E,9711
 split_stack/hints.py,sha256=jsfbWzuPDgZwrfmuuwhh1QHSFA7650Yy4VOuouJFSww,3125
 split_stack/local_models.py,sha256=IEHrE9w0tmJ0Nb9toP50EJcOQMbO8VXX4id0TWS-MkY,2270
 split_stack/model_guide.py,sha256=_xKFfyI30kN2VM8GgY4a05SIqPXTyDluOUZUcDpvuVw,9782
@@ -14,19 +14,20 @@ split_stack/model_registry.py,sha256=vXPj0-sRPv0tPNkodVpz5WyucOfrmawrWiTq8yaEYls
 split_stack/models.py,sha256=nDqFdeSGmcPPUCOVEEsArvUJApehNWvMFB97TaBI7zY,1820
 split_stack/ollama_errors.py,sha256=nu3qLCGIcS3asX03AEKKALuiCnvLmr5BhP0RcRHhtlQ,962
 split_stack/ollama_generate.py,sha256=qHJN1izaS855nL2TdiPnYV05TZPVpz03tqlXljcxvNo,3789
-split_stack/poc_models.py,sha256=4wSXsRy2gz3aFPsTuwf4Mf2qbWAX9Cef_RS3zB5ZiPs,4422
+split_stack/poc_models.py,sha256=EfUMJaMkLGIsUCeeK6DYxcRXON7EyWGzU3b3_PiUsQg,6562
 split_stack/presets.py,sha256=1E7UsT0bahQMZZxBHr0iG0fxEIvq7f0VPKxPTRj_CI0,2580
 split_stack/quantization.py,sha256=zZMs7aiqksUyVXzKK5JxQDEDYiYXYza2gXkMlWQqywE,4311
 split_stack/requirements.py,sha256=QK7lxn7jVU39z2IZByEKOiv1xz3G2SIs96uRsspskdY,9475
 split_stack/routing.py,sha256=99fZilyXddkZIhTaPQEsE6P2EDDuaXo4n1Xqs28Zq5Y,3219
 split_stack/session.py,sha256=_YkoNhsOp_4u14NgzWSkIDDNiCrhUt0-eU3e5y6lTfI,7959
 split_stack/setup_wizard.py,sha256=EyCr_QtiUZMBW20mEjYbjvHBg6tIqAUafLHZd_9dqBY,8195
+split_stack/stack_health.py,sha256=Mr4TvwOAkRsriucLDRxqQU3En4IO4uZTjgaoP-1QJeU,12163
 split_stack/startup_tips.py,sha256=CY6k_lBSgmulbe0PLH3sIy6qL3B1wtQeLGGpHisskNs,5524
 split_stack/tiering.py,sha256=M4outcZwO-m-th7OYbKYRILB5trnxJU6oQI0pEo_MsY,2163
 split_stack/validation.py,sha256=-JMuDnia1Rd3fMYtHVHtJ-GW_4Rrbijl9MKlTnfpCyw,3056
-split_stack-0.2.0.dist-info/licenses/LICENSE,sha256=scGzQpUJlz3hAQQfj_Ukpj_rGSSDKp2TgqP5wzchytQ,1069
-split_stack-0.2.0.dist-info/METADATA,sha256=dvnZStht1fgl5ZDKsItIjILSxcVyJaYeujrJFceQP3g,13655
-split_stack-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-split_stack-0.2.0.dist-info/entry_points.txt,sha256=ZByxKJLPs5y8blfIgplNejfVkjQuH2F9A99JoH1m5gw,47
-split_stack-0.2.0.dist-info/top_level.txt,sha256=gfw1Q0n9UcJE069uO9G-TPSU9P1fwvOj0nhUYKix2pM,12
-split_stack-0.2.0.dist-info/RECORD,,
+split_stack-0.3.0.dist-info/licenses/LICENSE,sha256=scGzQpUJlz3hAQQfj_Ukpj_rGSSDKp2TgqP5wzchytQ,1069
+split_stack-0.3.0.dist-info/METADATA,sha256=qbPkSiM_X_0J51Qc7qNB2UDuqgm35IuOy01ah2eU-NQ,13655
+split_stack-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+split_stack-0.3.0.dist-info/entry_points.txt,sha256=ZByxKJLPs5y8blfIgplNejfVkjQuH2F9A99JoH1m5gw,47
+split_stack-0.3.0.dist-info/top_level.txt,sha256=gfw1Q0n9UcJE069uO9G-TPSU9P1fwvOj0nhUYKix2pM,12
+split_stack-0.3.0.dist-info/RECORD,,