Full model-URL breakdowns, gauge clarity, CPU honesty, multi-platform buying guide, chart tooltips, runner icon

app.py

@@ -62,11 +62,12 @@ def api_advise(payload: AdviseIn):
 class MinSpecsIn(BaseModel):
     usecase: str = "chat"
     usecases: list[str] | None = None   # multi-goal: union of requirements
+    mode: str = "run"                    # "run" = inference, "finetune" = training
 
 
 @app.post("/api/minspecs")
 def api_minspecs(payload: MinSpecsIn):
-    return min_specs(payload.usecases or [payload.usecase])
+    return min_specs(payload.usecases or [payload.usecase], payload.mode)
 
 
 class LookupIn(AdviseIn):

engine/finetune.py

@@ -274,9 +274,17 @@ def _llm_finetune(uc, candidates, spec, focus) -> dict:
                 f"path — see the options below."
             )
         scale = max(fast or total, need, 1) * 1.05
+        has_fast = spec.has_fast_path
+        if spec.is_apple_silicon:
+            fast_label, total_label = "GPU can use", "Unified memory"
+        elif has_fast:
+            fast_label, total_label = "On the GPU (VRAM)", "GPU + system RAM"
+        else:
+            fast_label, total_label = "", "System RAM (no GPU)"
         gauge = {
             "need_gb": f"{need:g} GB needed to train",
             "fast_gb": f"{fast:g} GB", "total_gb": f"{total:g} GB",
+            "fast_label": fast_label, "total_label": total_label, "has_fast": has_fast,
             "fill_pct": round(min(need / scale, 1.0) * 100, 1),
             "mark_pct": round(min((fast or total) / scale, 1.0) * 100, 1),
             "breakdown": [

engine/hub_lookup.py

@@ -17,11 +17,54 @@ from functools import lru_cache
 
 from .hardware import HardwareSpec
 from .real_advisor import (
-    USE_CASES, _SAFETY_FILL, _evaluate, _option_json, catalogue,
+    USE_CASES, _SAFETY_FILL, _evaluate, _option_json, catalogue, advise_real,
 )
 
 _RELATION = re.compile(r"^base_model:(finetune|adapter|quantized|merge):(.+)$")
 
+# Hugging Face pipeline_tag -> our use-case key, so a looked-up model is
+# compared against the right slice of the catalogue.
+_PIPE_UC = {
+    "text-generation": "chat", "text2text-generation": "chat",
+    "image-text-to-text": "vlm", "visual-question-answering": "vlm", "image-to-text": "vlm",
+    "automatic-speech-recognition": "stt", "text-to-speech": "tts", "text-to-audio": "music",
+    "text-to-image": "imagegen", "image-to-image": "inpaint",
+    "object-detection": "detect", "image-segmentation": "segment",
+    "image-classification": "classify", "depth-estimation": "depth",
+    "feature-extraction": "embed", "sentence-similarity": "embed",
+}
+
+# Effective bits-per-weight for a synthesised quant ladder (k-quant layouts).
+_SYNTH_QUANTS = [
+    ("Q8_0", "Near-full (8-bit)", 8.5), ("Q6_K", "High (6-bit)", 6.6),
+    ("Q5_K_M", "Balanced+ (5-bit)", 5.7), ("Q4_K_M", "Balanced (4-bit)", 4.85),
+    ("Q3_K_M", "Compact (3-bit)", 3.9),
+]
+
+
+def _synthetic_entry(repo_id: str, info) -> dict | None:
+    """Build a catalogue-shaped entry for a model NOT in our catalogue, so it
+    runs through the same engine (memory gauge, speed chart, comparison). Sizes
+    are estimated from the parameter count and labelled as estimates."""
+    st = getattr(info, "safetensors", None)
+    total = getattr(st, "total", None) if st else None
+    if not total:
+        return None
+    params_b = round(total / 1e9, 2)
+    quants = [{"key": k, "plain": p, "file_gb": round(params_b * b / 8, 2)}
+              for k, p, b in _SYNTH_QUANTS]
+    card = getattr(info, "card_data", None)
+    lic = ""
+    if card:
+        lic = (card.get("license") if hasattr(card, "get") else getattr(card, "license", "")) or ""
+    return {
+        "key": "_lookup", "family": "llm", "name": repo_id.split("/")[-1],
+        "repo_id": repo_id, "params_b": params_b, "quants": quants,
+        "provenance": "estimated", "good_for": f"{params_b:g}B parameters, looked up live on Hugging Face.",
+        "license": lic, "gated": bool(getattr(info, "gated", False)),
+        "links": {"hf": f"https://huggingface.co/{repo_id}"}, "use_cases": [],
+    }
+
 
 @lru_cache(maxsize=1)
 def _index() -> dict:
@@ -126,35 +169,23 @@ def lookup(repo_input: str, payload: dict, spec: HardwareSpec) -> dict:
                 "explain": explain, "option": opt, "live": via is not None or info is not None,
                 "focus_name": entry["name"], "uc_key": uc_key}
 
-    # 3) Raw math from parameter count — clearly labelled estimate.
-    st = getattr(info, "safetensors", None)
-    total = getattr(st, "total", None) if st else None
-    if not total:
+    # 3) Not in the catalogue: build a synthetic entry from its real parameter
+    # count and run it through the FULL engine — same memory gauge, speed chart
+    # and comparison as any catalogue model, with sizes labelled as estimates.
+    synth = _synthetic_entry(repo_id, info)
+    if synth is None:
         return {"error": f"'{repo_id}' exists, but doesn't share its size or a known "
                          f"base model, so an honest estimate isn't possible."}
-    params_b = total / 1e9
-    weights_4bit = round(params_b * 4.85 / 8, 2)   # effective 4-bit bits/weight
-    need = round(weights_4bit * 1.25 + 0.58, 2)
-    fast, total_b = spec.fast_budget_gb, spec.total_budget_gb
-    if spec.has_fast_path and need <= fast * _SAFETY_FILL:
-        verdict = "great"
-    elif need <= total_b * _SAFETY_FILL:
-        verdict = "tight"
-    else:
-        verdict = "no"
-    return {
-        "found": True, "match": "estimate", "chain": chain, "live": True,
-        "explain": (f"<b>{repo_id.split('/')[-1]}</b> isn't in our catalogue and lists no "
-                    f"known base, so this is raw math from its {params_b:.1f}B parameters "
-                    f"at a 4-bit setting — an estimate, not a measured figure."),
-        "option": {
-            "verdict": verdict, "model": repo_id.split("/")[-1],
-            "desc": f"{params_b:.1f}B parameters (from its files on Hugging Face)",
-            "setting": "Balanced (4-bit)",
-            "memory": "Too big" if verdict == "no" else f"{need:g} GB",
-            "feel": "", "url": f"https://huggingface.co/{repo_id}",
-            "license": "", "license_note": "", "gated": bool(getattr(info, "gated", False)),
-            "run": {}, "provenance": "estimated", "stale": False,
-            "params_b": round(params_b, 2), "active_params_b": None,
-        },
-    }
+    pipe = getattr(info, "pipeline_tag", None) or ""
+    uc_key = _PIPE_UC.get(pipe, payload.get("usecase") or "chat")
+    look_payload = dict(payload)
+    look_payload["usecase"] = uc_key
+    look_payload["focus"] = synth["name"]
+    advice = advise_real(look_payload, spec, extra_entries=[synth])
+    name = repo_id.split("/")[-1]
+    explain = (f"<b>{name}</b> isn't in our catalogue, so its sizes are estimated from its "
+               f"{synth['params_b']:g}B parameters (not exact file sizes). Everything below — "
+               f"the memory breakdown, the speed chart, the comparison — is computed the same "
+               f"way as for catalogue models.")
+    return {"found": True, "match": "estimate", "chain": chain, "live": True,
+            "explain": explain, "advice": advice}

engine/real_advisor.py

@@ -407,9 +407,14 @@ def _provenance_line(headline: dict | None) -> str:
     return "The memory figure is estimated from the model's size — conservative, not measured."
 
 
-def advise_real(payload: dict, spec: HardwareSpec) -> dict:
+def advise_real(payload: dict, spec: HardwareSpec, extra_entries: list | None = None) -> dict:
     uc = USE_CASES.get(payload.get("usecase", "chat"), USE_CASES["chat"])
-    candidates = _by_use_case().get(uc.key, [])
+    candidates = list(_by_use_case().get(uc.key, []))
+    # A live-looked-up model not in the catalogue is injected here as a synthetic
+    # candidate, so it flows through the same gauge / speed-chart / comparison
+    # pipeline as catalogue models (its sizes are estimates, labelled as such).
+    if extra_entries:
+        candidates = list(extra_entries) + candidates
 
     # Honest gap, not a fake answer: if the catalogue doesn't cover a goal yet,
     # say so and point at the live lookup instead of inventing options.
@@ -470,29 +475,51 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
         e, est, q = headline["entry"], headline["est"], headline["quant"]
         hv = headline["verdict"]
         need = est["total"]
+        no_gpu = not spec.has_fast_path
         where = ("on your Mac" if spec.is_apple_silicon and hv == "great" else
                  "on your graphics card" if hv == "great" and spec.has_fast_path else
+                 "on the processor" if hv == "tight" and no_gpu else
                  "using your computer's memory" if hv == "tight" else "")
         if hv == "great":
             head_text = f"Yes, you can run {e['name']} {where}, today."
+        elif hv == "tight" and no_gpu:
+            # CPU inference of a small quantised model is genuinely usable, just
+            # not instant — say that plainly rather than "with trade-offs".
+            head_text = f"Yes, with no graphics card {e['name']} runs {where} (slower, but it works)."
         elif hv == "tight":
             head_text = f"Sort of. {e['name']} will run {where}, with trade-offs."
         else:
             head_text = f"{e['name']} won't fit on this machine."
+        # "What you have" reads differently with vs without a dedicated GPU.
+        if spec.is_apple_silicon:
+            have_clause = (f"and your Mac shares <b>{total:g} GB</b> of unified memory between "
+                           f"the processor and graphics.")
+        elif no_gpu:
+            have_clause = (f"and with no separate graphics card it runs on the processor using "
+                           f"your <b>{total:g} GB</b> of system memory — slower than a GPU, but "
+                           f"it works, especially at a 4-bit setting.")
+        else:
+            have_clause = (f"and you have about <b>{fast:g} GB</b> on the graphics card, or "
+                           f"<b>{total:g} GB</b> counting system memory it can spill into.")
         if e.get("quants"):
+            # Be honest about whether the weights figure is an exact file size
+            # (catalogue / GGUF) or a parameter-count estimate (live lookup).
+            if e.get("provenance") == "filesize":
+                weights_phrase = f"the model file is {est['weights']:g} GB — exact size on Hugging Face"
+            else:
+                weights_phrase = (f"the weights are about {est['weights']:g} GB at this setting "
+                                  f"(estimated from its {e.get('params_b', 0):g}B parameters)")
             detail = (
                 f"For this goal, the honest pick is <b>{e['name']}</b> at the "
                 f"<b>{q.get('plain', q['key'])}</b> setting. {e.get('good_for','')} "
                 f"It needs about <b>{need:g} GB</b> "
-                f"(the model file is {est['weights']:g} GB — exact size on Hugging Face — "
-                f"plus {est['kv']:g} GB chat memory and {est['overhead']:g} GB working space), "
-                f"and you have roughly <b>{fast:g} GB</b> fast / <b>{total:g} GB</b> total."
+                f"({weights_phrase} plus {est['kv']:g} GB chat memory and "
+                f"{est['overhead']:g} GB working space), {have_clause}"
             )
         else:
             detail = (
                 f"For this goal, the honest pick is <b>{e['name']}</b>. "
-                f"{e.get('good_for','')} It needs about <b>{need:g} GB</b>, and you have "
-                f"roughly <b>{fast:g} GB</b> fast / <b>{total:g} GB</b> total."
+                f"{e.get('good_for','')} It needs about <b>{need:g} GB</b>, {have_clause}"
             )
         model_part, work_part = est["weights"], round(need - est["weights"], 2)
     else:
@@ -523,9 +550,18 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
         note_bits.append("This model is gated: accept its terms on Hugging Face once before downloading.")
 
     scale = max(total, need, 1) * 1.05
+    has_fast = spec.has_fast_path
+    if spec.is_apple_silicon:
+        fast_label, total_label = "GPU can use", "Unified memory"
+    elif has_fast:
+        fast_label, total_label = "On the GPU (VRAM)", "GPU + system RAM"
+    else:
+        fast_label, total_label = "", "System RAM (no GPU)"
     gauge = {
         "need_gb": f"{need:g} GB needed",
         "fast_gb": f"{fast:g} GB", "total_gb": f"{total:g} GB",
+        "fast_label": fast_label, "total_label": total_label,
+        "has_fast": has_fast,
         "fill_pct": round(min(need / scale, 1.0) * 100, 1),
         "mark_pct": round(min(fast / scale, 1.0) * 100, 1),
         "breakdown": [
@@ -582,44 +618,96 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
 
 
 # --------------------------------------------------------------------------
-# Reverse mode: "what machine do I need for X?"
+# Reverse mode: "what machine do I need for X?"  Multi-platform, 2026 hardware.
 # --------------------------------------------------------------------------
 
-# Ladders are cheap -> expensive. Budget hints are rough 2026 street prices for
-# a whole sensible build, shown as guidance, not gospel.
-_PC_LADDER = [
-    ("Any old laptop (8 GB RAM, no GPU)", dict(ram_gb=8, vram_gb=0, vendor="none"), "what you may already own"),
-    ("16 GB RAM laptop, no GPU", dict(ram_gb=16, vram_gb=0, vendor="none"), "~$500"),
-    ("16 GB RAM + RTX 4060 (8 GB)", dict(ram_gb=16, vram_gb=8, vendor="nvidia"), "~$800"),
-    ("16 GB RAM + RTX 3060 (12 GB)", dict(ram_gb=16, vram_gb=12, vendor="nvidia"), "~$900"),
-    ("32 GB RAM + RTX 5070 (12 GB)", dict(ram_gb=32, vram_gb=12, vendor="nvidia"), "~$1,300"),
-    ("32 GB RAM + RTX 5070 Ti (16 GB)", dict(ram_gb=32, vram_gb=16, vendor="nvidia"), "~$1,600"),
-    ("32 GB RAM + RTX 4090 (24 GB)", dict(ram_gb=32, vram_gb=24, vendor="nvidia"), "~$2,500"),
-    ("64 GB RAM + RTX 5090 (32 GB)", dict(ram_gb=64, vram_gb=32, vendor="nvidia"), "~$3,500+"),
-]
-_MAC_LADDER = [
-    ("Mac with 16 GB unified memory", dict(ram_gb=16), "~$1,000"),
-    ("Mac with 24 GB unified memory", dict(ram_gb=24), "~$1,400"),
-    ("Mac with 32 GB unified memory", dict(ram_gb=32), "~$1,800"),
-    ("Mac with 64 GB unified memory", dict(ram_gb=64), "~$2,800"),
-    ("Mac with 128 GB unified memory", dict(ram_gb=128), "~$4,500+"),
+# Each platform is a cheap -> expensive ladder of representative builds. The
+# memory numbers feed the SAME engine (so recommendations are grounded, not
+# hand-waved); `spec` and `detail` power the human-readable + click-to-expand
+# card. Prices are rough mid-2026 street figures (the DRAM shortage moved them),
+# shown as guidance, not gospel. Sources: TechPowerUp/Tom's (bandwidth), vendor
+# pages; software-support notes from ROCm/MLX/CUDA reporting.
+_PLATFORMS = [
+    {
+        "key": "nvidia", "name": "NVIDIA PC", "icon": "brand-nvidia",
+        "blurb": "The path of least resistance: CUDA, so every tool just works. Best if you might fine-tune.",
+        "tiers": [
+            ("RTX 5060 Ti 16GB build", "~$1,000", dict(ram_gb=32, vram_gb=16, vendor="nvidia"),
+             "8-core CPU, 32 GB DDR5, RTX 5060 Ti 16GB, 1 TB NVMe",
+             "16 GB of VRAM is the real sweet spot: it runs 13-14B models comfortably and starts to fine-tune 7B with QLoRA. The 5060 Ti's narrow memory bus makes it slower than a 5070 Ti, but it is the cheapest 16 GB CUDA card. Desktop over laptop here: you get more VRAM per dollar and can swap the GPU later."),
+            ("RTX 5070 Ti build", "~$1,500", dict(ram_gb=32, vram_gb=16, vendor="nvidia"),
+             "8-core CPU, 32-64 GB DDR5, RTX 5070 Ti 16GB, 2 TB NVMe",
+             "Same 16 GB ceiling but much faster generation (896 GB/s). The mainstream pick for someone who wants snappy local AI without overspending. A desktop card runs cooler and faster under sustained load than the same chip in a laptop, which throttles."),
+            ("RTX 4090 / 24 GB build", "~$2,400", dict(ram_gb=64, vram_gb=24, vendor="nvidia"),
+             "12-core CPU, 64 GB DDR5, 24 GB GPU (RTX 4090, used), 2 TB NVMe",
+             "24 GB runs ~30B models comfortably and QLoRA-fine-tunes up to ~30B. The 4090 is end-of-life and scarcity-priced, so buy used carefully or wait for a 24 GB 50-series. 64 GB of system RAM lets big models spill over when needed."),
+            ("RTX 5090 build", "~$3,800", dict(ram_gb=64, vram_gb=32, vendor="nvidia"),
+             "12-16 core CPU, 64-128 GB DDR5, RTX 5090 32GB, 2 TB NVMe",
+             "The fastest consumer card and the only one with 32 GB, so it runs ~30B at full speed and big diffusion models. Workstation territory in price. If you mainly fine-tune, two 24 GB cards can beat one 5090 for multi-GPU training."),
+        ],
+    },
+    {
+        "key": "amd", "name": "AMD PC", "icon": "brand-amd",
+        "blurb": "Cheaper VRAM for inference. On Windows use the Vulkan path (LM Studio); rougher for training.",
+        "tiers": [
+            ("RX 9070 XT build", "~$1,200", dict(ram_gb=32, vram_gb=16, vendor="amd"),
+             "8-core CPU, 32 GB DDR5, Radeon RX 9070 XT 16GB, 2 TB NVMe",
+             "16 GB at a good price; runs up to ~14B models well. For 'open a model and chat' the AMD-vs-NVIDIA gap is now mostly price. Caveat: on Windows use llama.cpp / LM Studio via Vulkan (near plug-and-play); ROCm is Linux-first and fine-tuning support lags CUDA."),
+            ("RX 7900 XTX build", "~$1,500", dict(ram_gb=64, vram_gb=24, vendor="amd"),
+             "12-core CPU, 64 GB DDR5, Radeon RX 7900 XTX 24GB, 2 TB NVMe",
+             "The AMD standout for local AI: 24 GB and 960 GB/s for under $1k on the card, runs 70B at 4-bit. Best VRAM-per-dollar at this tier. Still AMD-software caveats for training, but excellent for inference."),
+        ],
+    },
+    {
+        "key": "apple", "name": "Mac (Apple Silicon)", "icon": "brand-apple",
+        "blurb": "Unified memory runs models no consumer GPU can hold, quietly and efficiently. Inference-focused.",
+        "tiers": [
+            ("Mac mini / Air M4, 16 GB", "~$1,000", dict(ram_gb=16, apple=True),
+             "Apple M4, 16 GB unified memory",
+             "The shared memory pool means the GPU can use almost all 16 GB. Runs small and mid models quietly. Buy the RAM you need up front: Apple memory is soldered and cannot be upgraded later, ever."),
+            ("Mac M4 Pro, 36 GB", "~$1,700", dict(ram_gb=36, apple=True),
+             "Apple M4 Pro, 36 GB unified memory, 273 GB/s",
+             "A strong quiet inference machine: 36 GB holds ~30B-class models, and the Pro's higher bandwidth keeps them usable. Great everyday computer too. Weaker than NVIDIA for fine-tuning (MLX does small LoRA; real training wants CUDA)."),
+            ("Mac M4 Max, 64 GB", "~$2,800", dict(ram_gb=64, apple=True),
+             "Apple M4 Max, 64 GB unified memory, 410-546 GB/s",
+             "64 GB of unified memory runs models a 24 GB GPU simply cannot load, at higher bandwidth than the mini-PC boxes. The sweet spot for running big models quietly. Studio (desktop) or MacBook Pro (laptop) both work; the Studio sustains load better."),
+            ("Mac Studio M4 Max / Ultra, 128 GB+", "~$4,000+", dict(ram_gb=128, apple=True),
+             "Apple M4 Max / M3 Ultra, 128-512 GB unified memory",
+             "Capacity king: 128 GB holds 70-120B-class models, and an M3 Ultra at 512 GB holds 600B+ MoE models no other single box can. The win is capacity and quiet, not raw speed (a 5090 is faster on whatever fits its 32 GB)."),
+        ],
+    },
+    {
+        "key": "mini", "name": "Mini-PC (unified memory)", "icon": "monitor",
+        "blurb": "Big models in a small, silent, low-power box. They fit huge models; they run them at a steady jog, not a sprint.",
+        "tiers": [
+            ("Ryzen AI Max+ 395, 64 GB", "~$1,500", dict(ram_gb=64, unified=True, vendor="amd"),
+             "AMD Ryzen AI Max+ 395 'Strix Halo', 64 GB unified memory, ~256 GB/s",
+             "16 Zen 5 cores plus a strong integrated GPU sharing 64 GB, in a tiny quiet box, no discrete card. Runs ~30B comfortably. Bandwidth is far below a discrete GPU, so big models fit and are usable but not fast. Vulkan works well; ROCm is fiddlier."),
+            ("Ryzen AI Max+ 395, 128 GB", "~$2,400", dict(ram_gb=128, unified=True, vendor="amd"),
+             "AMD Ryzen AI Max+ 395 'Strix Halo', 128 GB unified memory, ~256 GB/s",
+             "128 GB of unified memory runs 70B-class models (AMD demos 128B in LM Studio) for far less than a Mac with the same capacity, and sips power. Best capacity-per-dollar for big-model experimentation; accept moderate speed. The DGX Spark is a CUDA-compatible alternative but costs ~2x and is slower per token."),
+        ],
+    },
 ]
 
 
-def _spec_for_tier(kind: str, hw: dict) -> HardwareSpec:
-    if kind == "mac":
-        return HardwareSpec(os="macos", ram_gb=hw["ram_gb"], gpu_vendor="apple",
+def _spec_for_tier(hw: dict) -> HardwareSpec:
+    # Apple and unified-memory mini-PCs share one memory pool (model like Apple);
+    # a normal PC has separate VRAM + system RAM.
+    if hw.get("apple") or hw.get("unified"):
+        return HardwareSpec(os="macos" if hw.get("apple") else "linux",
+                            ram_gb=hw["ram_gb"], gpu_vendor=hw.get("vendor", "apple"),
                             is_apple_silicon=True, form_factor="mac")
     return HardwareSpec(os="windows", ram_gb=hw["ram_gb"],
                         gpu_vendor=hw.get("vendor", "none"),
                         vram_gb=hw.get("vram_gb", 0.0), form_factor="desktop")
 
 
-def min_specs(usecases) -> dict:
-    """For one OR several goals: the cheapest tier where EVERY goal genuinely
-    works (the union of requirements, not a sum), the tier where every goal
-    runs great, and what each goal would actually run on those tiers.
-    Pure engine inversion — fully offline."""
+def min_specs(usecases, mode: str = "run") -> dict:
+    """For one OR several goals, across every platform: the cheapest build where
+    EVERY goal genuinely works (the union of requirements), and the build where
+    every goal runs great. `mode="finetune"` sizes for training instead of
+    inference. Pure engine inversion — fully offline."""
     if isinstance(usecases, str):
         usecases = [usecases]
     seen = set()
@@ -630,19 +718,29 @@ def min_specs(usecases) -> dict:
             seen.add(uc.key)
             ucs.append(uc)
 
-    def walk(kind, ladder):
+    finetune = mode == "finetune"
+    if finetune:
+        from .finetune import advise_finetune
+
+    def assess(uc, spec):
+        if finetune:
+            return advise_finetune({"usecase": uc.key}, spec)
+        return advise_real({"usecase": uc.key}, spec)
+
+    def walk(tiers):
         minimum = comfortable = None
-        for label, hw, price in ladder:
-            spec = _spec_for_tier(kind, hw)
+        for label, price, hw, spec_line, detail in tiers:
+            spec = _spec_for_tier(hw)
             per_goal, all_meet, all_great = [], True, True
             for uc in ucs:
-                res = advise_real({"usecase": uc.key}, spec)
+                res = assess(uc, spec)
                 all_meet &= res["meets_goal"] and res["verdict"] in ("great", "tight")
                 all_great &= res["meets_goal"] and res["verdict"] == "great"
                 per_goal.append({"goal": uc.plain_name,
                                  "model": res["headline_model"] or "nothing realistic",
                                  "verdict": res["verdict"]})
-            tier = {"label": label, "price": price, "goals": per_goal,
+            tier = {"label": label, "price": price, "spec": spec_line, "detail": detail,
+                    "goals": per_goal,
                     "runs": "; ".join(f"{g['goal']}: {g['model']}" for g in per_goal)
                             if len(per_goal) > 1 else per_goal[0]["model"]}
             if minimum is None and all_meet:
@@ -653,19 +751,25 @@ def min_specs(usecases) -> dict:
                 break
         return minimum, comfortable
 
-    pc_min, pc_comfy = walk("pc", _PC_LADDER)
-    mac_min, mac_comfy = walk("mac", _MAC_LADDER)
+    platforms = []
+    for p in _PLATFORMS:
+        mn, comfy = walk(p["tiers"])
+        platforms.append({"key": p["key"], "name": p["name"], "icon": p["icon"],
+                          "blurb": p["blurb"], "minimum": mn, "comfortable": comfy})
+
     notes = [uc.note for uc in ucs if uc.note]
+    verb = "fine-tune" if finetune else "run"
     return {
         "use_case": " + ".join(uc.plain_name for uc in ucs),
         "goals": [uc.plain_name for uc in ucs],
+        "mode": mode,
         "catalogue_version": catalogue_date(),
         "note": "  ".join(notes),
-        "pc": {"minimum": pc_min, "comfortable": pc_comfy},
-        "mac": {"minimum": mac_min, "comfortable": mac_comfy},
-        "disclaimer": ("Price hints are rough 2026 street prices for a sensible whole "
-                       "build — they vary a lot by region and second-hand luck. The "
-                       "memory math is the same conservative engine as the main check."
-                       + (" Tiers are the union of every goal you picked: each one has "
-                          "to genuinely work." if len(ucs) > 1 else "")),
+        "platforms": platforms,
+        "disclaimer": (f"Two honest builds per platform: the cheapest that genuinely lets you "
+                       f"{verb} these goals, and the one that does it comfortably. Click any card "
+                       f"for what to look for. Prices are rough mid-2026 street figures and drift; "
+                       f"the memory math is the same conservative engine as the main check."
+                       + (" Builds cover the union of every goal you picked: each must work."
+                          if len(ucs) > 1 else "")),
     }

static/app.js

@@ -81,12 +81,8 @@ function applyMode() {
     const el = $(s); if (el) el.style.display = buy ? "none" : "";
   });
   const repo = $("#repo-field"); if (repo) repo.style.display = buy ? "none" : "";
-  const tog = $("#task-toggle"); if (tog) tog.style.display = buy ? "none" : "";
-  if (buy && state.task !== "run") {        // buy advice is inference-only
-    state.task = "run";
-    tog.classList.remove("train");
-    tog.querySelectorAll(".tt-opt").forEach(x => x.classList.toggle("active", x.dataset.task === "run"));
-  }
+  // The Run/Train toggle applies in buy mode too: "what should I buy to run X"
+  // vs "to fine-tune X" are very different machines.
   $("#check-btn").innerHTML = (buy ? "What should I get? " : "Check my setup ")
     + '<span class="ic" data-ic="arrow"></span>';
   hydrate($("#check-btn"));
@@ -117,11 +113,21 @@ function buildPicker() {
       state.usecases.push(uc);
       p.classList.add("active");
     }
-    $("#custom-uc-field").style.display = state.usecases.includes("custom") ? "block" : "none";
+    syncCustomRepo();
     maybeLiveUpdate();
   }));
 }
 
+// When "Custom: describe it" is the goal, the model box is the way in, so drop
+// its "(optional)" tag and flag it as the expected input.
+function syncCustomRepo() {
+  const isCustom = state.usecases.includes("custom");
+  const opt = $("#repo-optional");
+  if (opt) opt.style.display = isCustom ? "none" : "";
+  const field = $("#repo-field");
+  if (field) field.classList.toggle("required", isCustom);
+}
+
 // ---- Segmented controls ---------------------------------------------------
 function wireSegmented(id, key, after) {
   $(id).querySelectorAll(".seg-btn").forEach(b => b.addEventListener("click", () => {
@@ -213,7 +219,6 @@ function gather() {
     paste: $("#paste").value.trim(),
     usecase: state.usecases[0],
     usecases: state.usecases.slice(),
-    custom: $("#custom-uc").value.trim(),
     priority: state.priority,
     mode: state.task,            // "run" (inference) or "finetune" (training)
     repo: $("#repo-check") ? $("#repo-check").value.trim() : "",
@@ -234,7 +239,7 @@ async function check() {
     if (state.mode === "buy") {
       const res = await fetch("/api/minspecs", {
         method: "POST", headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ usecases: state.usecases }),
+        body: JSON.stringify({ usecases: state.usecases, mode: state.task }),
       });
       renderBuy(await res.json());
       return;
@@ -304,24 +309,21 @@ async function lookupRepo(payload) {
     }
     return;
   }
-  // We don't know this model: honest raw-parameter estimate, clearly labelled.
-  const o = d.option || {};
-  const v = VMAP[o.verdict] || VMAP.tight;
-  $("#results").innerHTML = `
-    <div class="reveal">
-      <div class="verdict" style="--status:${v.cls};--status-soft:${v.soft}">
-        <span class="badge"><span class="dot"></span>${v.word}</span>
-        <span class="live-tag">Live Hugging Face lookup</span>
-        <h2>${o.model || payload.repo}</h2>
-        <p>${d.explain || ""}</p>
-      </div>
-      <div class="lookup-card" style="--status:${v.cls};--status-soft:${v.soft}">
-        <div class="lookup-meta">
-          ${o.memory && o.memory !== "Too big" ? `<span><b>${o.memory}</b> needed (${o.setting})</span>` : `<span><b>Too big</b> for this machine</span>`}
-          ${o.url ? `<a href="${o.url}" target="_blank" rel="noopener">View on Hugging Face</a>` : ""}
-        </div>
-      </div>
-    </div>`;
+  // Not in the catalogue: the engine still built a FULL breakdown from the
+  // looked-up parameter count. Render it like any result, with an estimate banner.
+  if (d.match === "estimate" && d.advice) {
+    render(d.advice);
+    const wrap = $("#results").firstElementChild;
+    if (wrap) {
+      const banner = document.createElement("div");
+      banner.className = "lookup-banner estimate";
+      banner.innerHTML = `<span class="live-tag">Live Hugging Face lookup · estimate</span><p>${d.explain || ""}</p>`;
+      wrap.prepend(banner);
+    }
+    return;
+  }
+  // Last resort: a bare error/explain with no advice payload.
+  $("#results").innerHTML = `<div class="ans-card"><h3>${payload.repo}</h3><p>${d.explain || "No estimate available."}</p></div>`;
   hydrate($("#results"));
 }
 
@@ -357,38 +359,50 @@ function renderMulti(results) {
   $("#cat-version").textContent = (results[0] || {}).catalogue_version || "—";
 }
 
-// ---- Buy-advice render ------------------------------------------------------
+// ---- Buy-advice render: multi-platform, click any card for what to look for -
 function renderBuy(d) {
-  const goalLines = (t) => (t.goals && t.goals.length > 1)
-    ? `<ul class="goal-lines">${t.goals.map(g =>
-        `<li><span>${g.goal}</span><b>${g.model}</b>${g.verdict === "tight" ? " <i>(trade-offs)</i>" : ""}</li>`).join("")}</ul>`
-    : `<div class="twhat">Runs: ${t.runs}${t.goals && t.goals[0] && t.goals[0].verdict === "tight" ? " (with trade-offs)" : ""}</div>`;
-  const lane = (title, icon, lanes) => {
-    const tier = (t, kind) => t ? `
-      <div class="tool" style="border-left:3px solid ${kind === "min" ? "var(--warn)" : "var(--ok)"}">
-        <div class="tool-head"><span class="tname">${kind === "min" ? "Minimum" : "Comfortable"}</span>
-          <span class="tag ${kind === "min" ? "mid" : "best"}">${t.price}</span></div>
-        <div class="twhat"><b>${t.label}</b></div>
-        ${goalLines(t)}
-      </div>` : `
-      <div class="tool"><div class="twhat">No tier on this ladder handles ${d.goals && d.goals.length > 1 ? "all of these together" : "it"} comfortably — this combination wants workstation hardware.</div></div>`;
-    return `
-      <div class="section-title"><span class="ic" data-ic="${icon}"></span>${title}</div>
-      <div class="tool-grid">${tier(lanes.minimum, "min")}${tier(lanes.comfortable, "comfy")}</div>`;
+  const ft = d.mode === "finetune";
+  const verb = ft ? "fine-tune" : "run";
+  const multi = (d.goals || []).length > 1;
+  const tierCard = (t, kind) => {
+    if (!t) return `<div class="buy-card empty">
+      <div class="bc-head"><span class="bc-kind ${kind}">${kind === "min" ? "Minimum" : "Comfortable"}</span></div>
+      <p class="bc-none">No build on this platform ${ft ? "trains" : "runs"} ${multi ? "all of these" : "this"}${ft ? "" : " well"} — it wants more than this ladder offers.</p>
+    </div>`;
+    const goalsHtml = multi
+      ? `<ul class="bc-goals">${t.goals.map(g => `<li><span>${g.goal}</span><b>${g.model}</b>${g.verdict === "tight" ? " <i>(tight)</i>" : ""}</li>`).join("")}</ul>`
+      : `<div class="bc-runs">${ft ? "Can train up to" : "Runs"} <b>${t.runs}</b>${t.goals[0] && t.goals[0].verdict === "tight" ? " <i>(tight)</i>" : ""}</div>`;
+    return `<div class="buy-card">
+      <div class="bc-head"><span class="bc-kind ${kind}">${kind === "min" ? "Minimum" : "Comfortable"}</span><span class="tag ${kind === "min" ? "mid" : "best"}">${t.price}</span></div>
+      <div class="bc-label">${t.label}</div>
+      ${goalsHtml}
+      <button class="bc-more">What to look for <span class="chev ic" data-ic="chevron"></span></button>
+      <div class="bc-detail" hidden><div class="bc-spec">${t.spec}</div><p>${t.detail}</p></div>
+    </div>`;
   };
+  const platforms = (d.platforms || []).map(p => `
+    <div class="buy-platform">
+      <div class="bp-head"><span class="ic" data-ic="${p.icon}"></span><span class="bp-name">${p.name}</span></div>
+      <div class="bp-blurb">${p.blurb}</div>
+      <div class="buy-grid">${tierCard(p.minimum, "min")}${tierCard(p.comfortable, "comfy")}</div>
+    </div>`).join("");
   $("#results").innerHTML = `
     <div class="reveal">
       <div class="verdict" style="--status:var(--accent);--status-soft:var(--accent-soft)">
-        <span class="badge"><span class="dot"></span>Buying advice</span>
-        <h2>What you need for ${(d.use_case || "this").toLowerCase()}</h2>
-        <p>Two honest tiers per platform: the cheapest setup that genuinely works, and the one that feels good daily.</p>
+        <span class="badge"><span class="dot"></span>Buying advice · to ${verb}</span>
+        <h2>What to buy to ${verb} ${(d.use_case || "this").toLowerCase()}</h2>
+        <p>${d.disclaimer || ""}</p>
         ${d.note ? `<div class="note">${d.note}</div>` : ""}
       </div>
-      ${lane("Windows / Linux PC", "brand-windows", d.pc || {})}
-      ${lane("Mac (Apple Silicon)", "brand-apple", d.mac || {})}
-      <p class="cmd-intro" style="margin-top:var(--s-4)">${d.disclaimer || ""}</p>
+      ${platforms}
     </div>`;
   hydrate($("#results"));
+  $("#results").querySelectorAll(".buy-card .bc-more").forEach(b => b.addEventListener("click", () => {
+    const det = b.nextElementSibling;
+    const opening = det.hasAttribute("hidden");
+    if (opening) det.removeAttribute("hidden"); else det.setAttribute("hidden", "");
+    b.classList.toggle("open", opening);
+  }));
   $("#cat-version").textContent = d.catalogue_version || "—";
 }
 
@@ -468,12 +482,12 @@ function render(d) {
         <div class="gauge-top"><span class="label" style="margin:0">Memory needed vs. what you have</span>
           <span class="need">${g.need_gb}</span></div>
         <div class="gauge" style="--pct:${g.fill_pct};--gcolor:${v.cls};--needpct:${g.mark_pct}">
-          <div class="gauge-fill"></div><div class="gauge-need"></div>
+          <div class="gauge-fill"></div>${g.has_fast ? `<div class="gauge-need" data-tip="Your GPU memory limit. A model that fits left of this line runs at full GPU speed; past it, the overflow runs from slower system RAM."></div>` : ""}
         </div>
         <div class="gauge-legend">
           ${(g.breakdown||[]).map(b=>`<span class="item"><span class="sw" style="background:${b.color}"></span>${b.label}</span>`).join("")}
-          <span class="item marker">Fast: ${g.fast_gb}</span>
-          <span class="item marker">Total: ${g.total_gb}</span>
+          ${g.has_fast && g.fast_label ? `<span class="item marker" data-tip="Your graphics card's own memory. Models that fit here run at full speed.">${g.fast_label}: ${g.fast_gb}</span>` : ""}
+          <span class="item marker" data-tip="${g.has_fast ? "GPU memory plus a slice of system RAM the model can spill into (the spilled part runs slower)." : "With no separate graphics card, the model runs on the processor using your system memory."}">${g.total_label || "Total"}: ${g.total_gb}</span>
         </div>
         ${d.provenance ? `<div class="prov">${d.provenance}</div>` : ""}
       </div>` : ""}
@@ -601,9 +615,10 @@ async function drawRoofline(speed) {
 
   // real measurement dots, shaded by model size
   const shade = p => p.params_b <= 2 ? "rl-p1" : (p.params_b <= 9 ? "rl-p8" : "rl-p14");
+  const esc = t => String(t == null ? "" : t).replace(/"/g, "&quot;");
   for (const p of pts) {
     if (p.bw < xmin || p.tps < ymin) continue;
-    s += `<circle cx="${lx(Math.min(p.bw, xmax)).toFixed(1)}" cy="${ly(Math.min(p.tps, ymax)).toFixed(1)}" r="2.6" class="rl-dot ${shade(p)}"><title>${p.accel} — ${p.model}: ${p.tps} tok/s</title></circle>`;
+    s += `<circle cx="${lx(Math.min(p.bw, xmax)).toFixed(1)}" cy="${ly(Math.min(p.tps, ymax)).toFixed(1)}" r="2.6" class="rl-dot ${shade(p)}" data-m="${esc(p.model)}" data-a="${esc(p.accel)}" data-t="${esc(p.tps)}" data-b="${esc(Math.round(p.bw))}" data-p="${esc(p.params_b)}"></circle>`;
   }
 
   if (speed) {
@@ -618,7 +633,7 @@ async function drawRoofline(speed) {
     s += `<line x1="${ux}" y1="${ly(Math.min(Math.max(speed.lo, ymin), ymax))}" x2="${ux}" y2="${ly(Math.min(Math.max(speed.hi, ymin), ymax))}" class="rl-band"/>`;
     // flip the label to the left when the dot sits near the right edge
     const flip = ux > W * 0.72;
-    s += `<circle cx="${ux}" cy="${uy}" r="6" class="rl-you"/>` +
+    s += `<circle cx="${ux}" cy="${uy}" r="6" class="rl-you" data-you="1" data-m="${esc(speed.model)}" data-t="${esc(speed.tps)}" data-b="${esc(Math.round(speed.eff_bw || speed.bw))}"/>` +
          `<text x="${flip ? ux - 10 : ux + 10}" y="${uy + 4}" class="rl-you-label" text-anchor="${flip ? "end" : "start"}">you ≈${speed.tps} tok/s</text>`;
   }
   s += `</svg>
@@ -630,6 +645,31 @@ async function drawRoofline(speed) {
       <span class="item"><span class="sw rl-you-sw"></span>your machine</span>
     </div>`;
   host.innerHTML = s;
+
+  // Hover any dot for a plain-words info bubble: what model, what hardware,
+  // how fast, at what bandwidth. The whole point of the chart is legibility.
+  host.style.position = "relative";
+  const tip = document.createElement("div");
+  tip.className = "rl-tip"; tip.hidden = true;
+  host.appendChild(tip);
+  const svg = host.querySelector("svg");
+  if (svg) {
+    svg.addEventListener("mousemove", (e) => {
+      const t = e.target;
+      const cls = t.getAttribute && t.getAttribute("class");
+      if (!cls || (!cls.includes("rl-dot") && !cls.includes("rl-you"))) { tip.hidden = true; return; }
+      const d = t.dataset;
+      tip.innerHTML = d.you
+        ? `<b>Your machine</b><br>${d.m || "your pick"} ≈ <b>${d.t} tok/s</b><br><span class="rl-tip-sub">at ~${d.b} GB/s memory bandwidth</span>`
+        : `<b>${d.m || "model"}</b>${d.p ? ` · ${d.p}B` : ""}<br>${d.a || ""}<br><b>${d.t} tok/s</b> <span class="rl-tip-sub">at ~${d.b} GB/s</span>`;
+      tip.hidden = false;
+      const r = host.getBoundingClientRect();
+      const x = e.clientX - r.left, y = e.clientY - r.top;
+      tip.style.left = Math.min(x + 14, host.clientWidth - 150) + "px";
+      tip.style.top = Math.max(y - 10, 0) + "px";
+    });
+    svg.addEventListener("mouseleave", () => { tip.hidden = true; });
+  }
 }
 
 // ---- Live progress ticker (gradio-style elapsed seconds) -------------------
@@ -802,7 +842,7 @@ function init() {
   wireSegmented("#provider-seg", "provider", fillGpu);
   wireSegmented("#priority-seg", "priority");
   wireTaskToggle();
-  ["#ram","#gpu","#vram","#custom-uc","#repo-check"].forEach(s => { const el = $(s); if (el) el.addEventListener("change", maybeLiveUpdate); });
+  ["#ram","#gpu","#vram","#repo-check"].forEach(s => { const el = $(s); if (el) el.addEventListener("change", maybeLiveUpdate); });
   $("#paste").addEventListener("input", maybeLiveUpdate);
   $("#check-btn").addEventListener("click", check);
   const pb = $("#parse-btn"); if (pb) pb.addEventListener("click", parsePaste);

static/icons.js

@@ -1,6 +1,7 @@
 /* Auto-generated by build_icons.py. Inline icons = offline-safe. */
 window.ICONS = {
 "chat": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" > <path d=\"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719\" /> </svg>",
+"run": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" > <circle cx=\"14\" cy=\"4\" r=\"1.8\" /> <path d=\"m5 19 3.5-4.5-2-3.5 4.5-2.5\" /> <path d=\"m9.5 10.5 4.5 2 .8 6.5\" /> <path d=\"M11.5 8 15.5 6.5l1.7 3.2 3.3.8\" /> </svg>",
 "writing": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" > <path d=\"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7\" /> <path d=\"M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z\" /> </svg>",
 "coding": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" > <path d=\"m18 16 4-4-4-4\" /> <path d=\"m6 8-4 4 4 4\" /> <path d=\"m14.5 4-5 16\" /> </svg>",
 "agents": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" > <path d=\"M12 8V4H8\" /> <rect x=\"4\" y=\"8\" rx=\"2\" /> <path d=\"M2 14h2\" /> <path d=\"M20 14h2\" /> <path d=\"M15 13v2\" /> <path d=\"M9 13v2\" /> </svg>",

static/index.html

@@ -102,19 +102,15 @@
           <div class="step-head"><span class="step-num">2</span><h2>What do you want to do? <span class="optional">(pick one or several)</span></h2></div>
           <div class="task-toggle" id="task-toggle" role="tablist"
                data-tip="Running a model and fine-tuning it need very different memory. Switch this and the recommendations below recompute for training.">
-            <button class="tt-opt active" data-task="run" role="tab"><span class="ic" data-ic="chat"></span>Run a model</button>
+            <button class="tt-opt active" data-task="run" role="tab"><span class="ic" data-ic="run"></span>Run a model</button>
             <button class="tt-opt" data-task="finetune" role="tab"><span class="ic" data-ic="finetune"></span>Train / fine-tune</button>
             <span class="tt-slider" aria-hidden="true"></span>
           </div>
           <div id="usecase-picker"><!-- rendered by app.js --></div>
-          <div class="field" id="custom-uc-field" style="display:none; margin-top:var(--s-3)">
-            <span class="label">Describe what you want to build</span>
-            <input type="text" id="custom-uc" placeholder="e.g. real-time hand tracking from my webcam" />
-          </div>
           <div class="field" id="repo-field" style="margin-top:var(--s-4); margin-bottom:0">
-            <span class="label">Have a specific model in mind? <span class="optional">(optional)</span></span>
+            <span class="label">Check a specific model <span class="optional" id="repo-optional">(optional)</span></span>
             <input type="text" id="repo-check" placeholder="Paste a Hugging Face model id or link, e.g. lerobot/smolvla_base" />
-            <div class="hint">Checks that exact model with a live Hugging Face lookup (the rest of FitCheck runs fully offline).</div>
+            <div class="hint">Paste any model and FitCheck gives the full breakdown for it — memory, speed, and how it compares — <b>even models not in our catalogue</b>, via a live Hugging Face lookup. (The rest of FitCheck runs fully offline.)</div>
           </div>
         </div>
 

static/style.css

@@ -448,6 +448,46 @@ details.disc > summary:hover { color: var(--text-primary); }
 .tool .tinstall { font-size: 12.5px; color: var(--text-muted); display: flex; align-items: center; gap: 6px; }
 .tool .tinstall .ic { font-size: 14px; }
 
+/* Buy advice: per-platform, click-to-expand cards */
+.buy-platform { margin-top: var(--s-5); }
+.bp-head { display: flex; align-items: center; gap: 9px; }
+.bp-head .ic { font-size: 19px; color: var(--text-secondary); }
+.bp-head .ic.brand { color: var(--text-primary); }
+.bp-name { font-family: var(--font-head); font-weight: 800; font-size: 16px; }
+.bp-blurb { font-size: 13px; color: var(--text-muted); margin: 4px 0 var(--s-3); line-height: 1.5; }
+.buy-grid { display: grid; grid-template-columns: 1fr 1fr; gap: var(--s-3); }
+@media (max-width: 620px) { .buy-grid { grid-template-columns: 1fr; } }
+.buy-card {
+  background: var(--bg-raised); border: 1px solid var(--border);
+  border-radius: var(--r-md); padding: var(--s-3) var(--s-4);
+}
+.buy-card.empty { opacity: .7; }
+.bc-head { display: flex; align-items: center; justify-content: space-between; }
+.bc-kind { font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: .04em; color: var(--text-muted); }
+.bc-kind.min { color: var(--warn); } .bc-kind.comfy { color: var(--ok); }
+.bc-label { font-family: var(--font-head); font-weight: 700; font-size: 15px; margin: 6px 0; }
+.bc-runs { font-size: 13.5px; color: var(--text-secondary); }
+.bc-runs b { color: var(--text-primary); }
+.bc-none { font-size: 13px; color: var(--text-muted); margin: 6px 0 0; line-height: 1.5; }
+.bc-goals { margin: 6px 0 0; padding: 0; list-style: none; font-size: 13px; }
+.bc-goals li { display: flex; justify-content: space-between; gap: 10px; padding: 3px 0; border-top: 1px solid var(--border); }
+.bc-goals li:first-child { border-top: 0; }
+.bc-goals b { color: var(--text-primary); font-weight: 600; text-align: right; }
+.bc-more {
+  margin-top: var(--s-3); background: none; border: 0; cursor: pointer; padding: 0;
+  color: var(--accent); font-size: 12.5px; font-weight: 600;
+  display: inline-flex; align-items: center; gap: 5px;
+}
+.bc-more .chev { font-size: 14px; transition: transform .2s; }
+.bc-more.open .chev { transform: rotate(180deg); }
+.bc-detail { margin-top: var(--s-3); border-top: 1px solid var(--border); padding-top: var(--s-3); }
+.bc-spec {
+  font-family: ui-monospace, 'SF Mono', Menlo, Consolas, monospace; font-size: 12px;
+  color: var(--text-secondary); background: var(--bg-base);
+  border: 1px solid var(--border); border-radius: var(--r-sm); padding: 7px 10px; margin-bottom: var(--s-2);
+}
+.bc-detail p { font-size: 13px; color: var(--text-secondary); line-height: 1.6; margin: 0; }
+
 /* Command block */
 .cmd-intro { font-size: 14px; color: var(--text-secondary); margin: var(--s-2) 0 var(--s-3); }
 .cmd { display: grid; grid-template-columns: 1fr 1fr; gap: var(--s-3); }
@@ -470,7 +510,17 @@ details.disc > summary:hover { color: var(--text-primary); }
 .rl-grid { stroke: var(--border); stroke-width: 1; opacity: .5; }
 .rl-tick { fill: var(--text-muted); font: 500 10.5px var(--font-body); }
 .rl-axis { fill: var(--text-secondary); font: 600 11.5px var(--font-body); }
-.rl-dot { opacity: .6; }
+.rl-dot { opacity: .6; transition: r .1s, opacity .1s; cursor: pointer; }
+.rl-dot:hover { opacity: 1; r: 4.5; }
+.rl-you { cursor: pointer; }
+/* Hover info bubble for chart points */
+.rl-tip {
+  position: absolute; z-index: 20; pointer-events: none;
+  background: var(--bg-raised); border: 1px solid var(--border-hi);
+  border-radius: var(--r-sm); padding: 7px 10px; font-size: 12px; line-height: 1.5;
+  color: var(--text-primary); box-shadow: var(--shadow-lg); max-width: 200px;
+}
+.rl-tip-sub { color: var(--text-muted); }
 .rl-p1 { fill: #2DD4BF; }   /* ~1B runs: teal */
 .rl-p8 { fill: #F472B6; }   /* ~8B runs: pink */
 .rl-p14 { fill: #93C5FD; }  /* ~14B runs: light blue */
@@ -543,6 +593,9 @@ details.disc > summary:hover { color: var(--text-primary); }
   border-radius: var(--r-md); padding: var(--s-3) var(--s-4); margin-bottom: var(--s-4);
 }
 .lookup-banner p { color: var(--text-secondary); font-size: 13.5px; margin: 0; }
+.lookup-banner.estimate { background: var(--warn-soft); border-color: var(--warn); }
+/* When the goal is "Custom", the model box is the expected input, not optional. */
+#repo-field.required input { border-color: var(--accent); box-shadow: 0 0 0 3px var(--accent-soft); }
 
 /* Ask a follow-up (the model brick) */
 .ask-row { display: flex; gap: var(--s-2); }