Multi-goal checks (union buying advice), fix vision/audio quality bars, honest niche fallback

app.py

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

engine/real_advisor.py

@@ -49,8 +49,12 @@ _COMPROMISE_QUANTS = ["Q4_K_M", "IQ4_XS", "Q3_K_M", "Q2_K"]
 # --------------------------------------------------------------------------
 
 class UC:
-    def __init__(self, key, plain, family, ctx=4096, min_b=0.5, good_b=3.0,
+    def __init__(self, key, plain, family, ctx=4096, min_b=0.0, good_b=0.0,
                  factor=1.0, note=""):
+        # min_b/good_b are LLM-quality bars in billions of params. They default
+        # to 0 because they're meaningless for vision/audio/etc. — a 0.003B
+        # YOLO is a complete, excellent model, not a too-small LLM. Only the
+        # text use cases set them explicitly.
         self.key, self.plain_name, self.family = key, plain, family
         self.context_tokens, self.min_b, self.good_b = ctx, min_b, good_b
         self.overhead_factor, self.note = factor, note
@@ -69,7 +73,7 @@ USE_CASES = {u.key: u for u in [
     UC("finetune", "Fine-tune an LLM (LoRA)", "llm", 2048, 3.0, 7.0, 2.2,
        note="Training needs roughly 2-3x the memory of just chatting. That's baked into these numbers."),
     UC("custom", "Your custom goal", "llm", 4096, 0.5, 7.0),
-    UC("vlm", "Chat about images & video", "vlm", 4096, 2.0, 4.0),
+    UC("vlm", "Chat about images & video", "vlm", 4096, 1.5, 4.0),
     UC("detect", "Object detection", "vision"),
     UC("segment", "Image segmentation", "vision"),
     UC("pose", "Pose estimation (2D & 6-DoF)", "vision"),
@@ -326,9 +330,12 @@ def _pick_headline(results: list[dict], uc: UC) -> tuple[dict | None, bool]:
         # Fast-and-capable is the best answer: biggest model that runs great.
         return max(great_ok, key=params), True
     if tight_ok:
-        # Compromise: close to the ideal size, not needlessly oversized-and-slow.
-        below = [r for r in tight_ok if params(r) <= uc.good_b * 1.5]
-        return (max(below, key=params) if below else min(tight_ok, key=params)), True
+        if uc.good_b > 0:
+            # LLMs: close to the ideal size, not needlessly oversized-and-slow.
+            below = [r for r in tight_ok if params(r) <= uc.good_b * 1.5]
+            return (max(below, key=params) if below else min(tight_ok, key=params)), True
+        # Non-LLM families: the biggest model that fits is simply the best one.
+        return max(tight_ok, key=params), True
     if great:
         return max(great, key=params), False
     if tight:
@@ -358,6 +365,25 @@ def _provenance_line(headline: dict | None) -> str:
 def advise_real(payload: dict, spec: HardwareSpec) -> dict:
     uc = USE_CASES.get(payload.get("usecase", "chat"), USE_CASES["chat"])
     candidates = _by_use_case().get(uc.key, [])
+
+    # 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.
+    if not candidates:
+        return {
+            "catalogue_version": catalogue_date(),
+            "verdict": "tight", "verdict_word": "Not covered yet",
+            "headline": "Our catalogue doesn't cover this goal yet.",
+            "detail": ("FitCheck only answers from verified model data, and nothing in the "
+                       "current catalogue serves this goal — so rather than guess, we'd "
+                       "rather say so. If you know a specific model for it, paste its "
+                       "Hugging Face id in the <b>'Have a specific model in mind?'</b> box "
+                       "and we'll check that exact model against your machine."),
+            "note": "The catalogue grows every night; niche goals are next in line.",
+            "gauge": {}, "options": [], "tools": _TOOLS.get(uc.family, []),
+            "commands": {"intro": "", "items": []}, "provenance": "",
+            "meets_goal": False, "use_case": uc.plain_name,
+        }
+
     results = [_evaluate(e, spec, uc) for e in candidates]
 
     fast, total = spec.fast_budget_gb, spec.total_budget_gb
@@ -462,6 +488,7 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
         "provenance": _provenance_line(headline),
         "meets_goal": meets_goal,
         "use_case": uc.plain_name,
+        "headline_model": headline["entry"]["name"] if headline else "",
     }
 
 
@@ -499,26 +526,39 @@ def _spec_for_tier(kind: str, hw: dict) -> HardwareSpec:
                         vram_gb=hw.get("vram_gb", 0.0), form_factor="desktop")
 
 
-def min_specs(usecase: str) -> dict:
-    """For a goal: cheapest tier that works at all, the comfortable tier, and
-    what each would actually run. Pure engine inversion — fully offline."""
-    uc = USE_CASES.get(usecase, USE_CASES["chat"])
+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."""
+    if isinstance(usecases, str):
+        usecases = [usecases]
+    seen = set()
+    ucs = []
+    for u in usecases or ["chat"]:
+        uc = USE_CASES.get(u, USE_CASES["chat"])
+        if uc.key not in seen:
+            seen.add(uc.key)
+            ucs.append(uc)
 
     def walk(kind, ladder):
         minimum = comfortable = None
         for label, hw, price in ladder:
             spec = _spec_for_tier(kind, hw)
-            res = advise_real({"usecase": uc.key}, spec)
-            great = [o for o in res["options"] if o["verdict"] == "great"]
-            fits = [o for o in res["options"] if o["memory"] != "Too big"]
-            best = (max(great, key=lambda o: o.get("params_b") or 0) if great
-                    else (max(fits, key=lambda o: o.get("params_b") or 0) if fits else None))
-            tier = {"label": label, "price": price,
-                    "runs": best["model"] if best else "",
-                    "verdict": res["verdict"]}
-            if minimum is None and res["verdict"] in ("great", "tight") and res["meets_goal"]:
+            per_goal, all_meet, all_great = [], True, True
+            for uc in ucs:
+                res = advise_real({"usecase": uc.key}, 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,
+                    "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:
                 minimum = tier
-            if comfortable is None and res["verdict"] == "great" and res["meets_goal"]:
+            if comfortable is None and all_great:
                 comfortable = tier
             if minimum and comfortable:
                 break
@@ -526,13 +566,17 @@ def min_specs(usecase: str) -> dict:
 
     pc_min, pc_comfy = walk("pc", _PC_LADDER)
     mac_min, mac_comfy = walk("mac", _MAC_LADDER)
+    notes = [uc.note for uc in ucs if uc.note]
     return {
-        "use_case": uc.plain_name,
+        "use_case": " + ".join(uc.plain_name for uc in ucs),
+        "goals": [uc.plain_name for uc in ucs],
         "catalogue_version": catalogue_date(),
-        "note": uc.note,
+        "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."),
+                       "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 "")),
     }

model_brick.py

@@ -229,7 +229,7 @@ if _should_load():
             _state["tok"] = tok
             _state["model"] = model.to("cuda").eval()
 
-        @spaces.GPU(duration=120)
+        @spaces.GPU(duration=90)   # cold load ~50s + generate; shorter = better queue priority
         def _generate(question: str, facts_text: str) -> str:
             if _state["model"] is None:
                 _load()
@@ -248,7 +248,7 @@ if _should_load():
             prompt_len = inputs["input_ids"].shape[1]
             with torch.no_grad():
                 out = model.generate(
-                    **inputs, max_new_tokens=192, do_sample=False,
+                    **inputs, max_new_tokens=160, do_sample=False,
                     pad_token_id=tok.eos_token_id,
                 )
             return tok.decode(out[0][prompt_len:], skip_special_tokens=True).strip()

static/app.js

@@ -74,8 +74,9 @@ const GPUS = {
 };
 
 const $ = (s) => document.querySelector(s);
-const state = { mode: "have", computer: "Windows laptop", provider: "none", priority: "balanced", usecase: "chat", checked: false };
+const state = { mode: "have", computer: "Windows laptop", provider: "none", priority: "balanced", usecases: ["chat"], checked: false };
 let lastAdvice = null;   // the most recent /api/advise result — facts the model explains
+let multiCache = null;   // {ucs, results} when several goals are checked at once
 
 // ---- Buy-vs-check mode -----------------------------------------------------
 function applyMode() {
@@ -130,11 +131,17 @@ function buildPicker() {
     </div>`).join("");
   hydrate(wrap);
 
+  // Pills toggle: pick one goal or several (several = checked together).
   wrap.querySelectorAll(".uc-pill").forEach(p => p.addEventListener("click", () => {
-    wrap.querySelectorAll(".uc-pill").forEach(x => x.classList.remove("active"));
-    p.classList.add("active");
-    state.usecase = p.dataset.uc;
-    $("#custom-uc-field").style.display = state.usecase === "custom" ? "block" : "none";
+    const uc = p.dataset.uc;
+    const i = state.usecases.indexOf(uc);
+    if (i >= 0) {
+      if (state.usecases.length > 1) { state.usecases.splice(i, 1); p.classList.remove("active"); }
+    } else {
+      state.usecases.push(uc);
+      p.classList.add("active");
+    }
+    $("#custom-uc-field").style.display = state.usecases.includes("custom") ? "block" : "none";
     maybeLiveUpdate();
   }));
 }
@@ -200,7 +207,8 @@ function gather() {
     gpu: sel.style.display === "none" ? "" : sel.value,
     vram_gb: $("#vram").value ? parseFloat($("#vram").value) : null,
     paste: $("#paste").value.trim(),
-    usecase: state.usecase,
+    usecase: state.usecases[0],
+    usecases: state.usecases.slice(),
     custom: $("#custom-uc").value.trim(),
     priority: state.priority,
     repo: $("#repo-check") ? $("#repo-check").value.trim() : "",
@@ -221,11 +229,23 @@ async function check() {
     if (state.mode === "buy") {
       const res = await fetch("/api/minspecs", {
         method: "POST", headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ usecase: state.usecase }),
+        body: JSON.stringify({ usecases: state.usecases }),
       });
       renderBuy(await res.json());
       return;
     }
+    if (state.usecases.length > 1) {
+      const results = await Promise.all(state.usecases.map(u =>
+        fetch("/api/advise", {
+          method: "POST", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ...payload, usecase: u }),
+        }).then(r => r.json())));
+      multiCache = { ucs: state.usecases.slice(), results };
+      renderMulti(results);
+      if (payload.repo) lookupRepo(payload);
+      return;
+    }
+    multiCache = null;
     const res = await fetch("/api/advise", {
       method: "POST", headers: { "Content-Type": "application/json" },
       body: JSON.stringify(payload),
@@ -279,17 +299,53 @@ async function lookupRepo(payload) {
   }
 }
 
+// ---- Multi-goal overview (several goals checked at once) -------------------
+function renderMulti(results) {
+  const ok = results.filter(d => d.verdict === "great").length;
+  const cards = results.map((d, i) => {
+    const v = VMAP[d.verdict] || VMAP.tight;
+    const need = (d.gauge || {}).need_gb || "";
+    return `
+      <div class="goal-card" data-i="${i}" style="--status:${v.cls};--status-soft:${v.soft}">
+        <div class="goal-top"><span class="badge"><span class="dot"></span>${d.verdict_word || v.word}</span></div>
+        <div class="goal-name">${d.use_case || ""}</div>
+        <div class="goal-pick">${d.headline_model ? `→ ${d.headline_model}` : "Nothing realistic on this machine"}</div>
+        <div class="goal-need">${need}</div>
+        <div class="goal-more">See full breakdown</div>
+      </div>`;
+  }).join("");
+  $("#results").innerHTML = `
+    <div class="reveal">
+      <div id="lookup-result"></div>
+      <div class="verdict" style="--status:var(--accent);--status-soft:var(--accent-soft)">
+        <span class="badge"><span class="dot"></span>${results.length} goals checked</span>
+        <h2>${ok} of ${results.length} run great on this machine.</h2>
+        <p>Each goal is checked independently with the same conservative engine. Click any card for the full honest breakdown, links and commands.</p>
+      </div>
+      <div class="goal-grid">${cards}</div>
+    </div>`;
+  hydrate($("#results"));
+  $("#results").querySelectorAll(".goal-card").forEach(c => c.addEventListener("click", () => {
+    render(multiCache.results[parseInt(c.dataset.i, 10)]);
+  }));
+  $("#cat-version").textContent = (results[0] || {}).catalogue_version || "—";
+}
+
 // ---- Buy-advice render ------------------------------------------------------
 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>
-        <div class="twhat">Runs: ${t.runs}${kind === "min" && t.verdict === "tight" ? " (with trade-offs)" : ""}</div>
+        ${goalLines(t)}
       </div>` : `
-      <div class="tool"><div class="twhat">No tier on this ladder handles it comfortably — this goal wants workstation hardware.</div></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>`;
@@ -408,6 +464,13 @@ function render(d) {
       </div>
     </div>`;
 
+  if (multiCache) {
+    const back = document.createElement("button");
+    back.className = "back-link";
+    back.textContent = "← All goals";
+    back.addEventListener("click", () => renderMulti(multiCache.results));
+    $("#results").firstElementChild.prepend(back);
+  }
   hydrate($("#results"));
   $("#results").querySelectorAll(".copy-btn").forEach(b => b.addEventListener("click", () => {
     navigator.clipboard.writeText(decodeURIComponent(b.dataset.code));
@@ -433,7 +496,8 @@ async function askQuestion(question) {
   const box = $("#ask-answer");
   if (!question || !box) return;
   box.hidden = false;
-  box.innerHTML = `<div class="ans-loading"><span class="spinner"></span>Thinking it through…</div>`;
+  box.innerHTML = `<div class="ans-loading"><span class="spinner"></span>Thinking it through…
+    <span class="ans-cold">first question after a quiet spell wakes the model (up to a minute); after that it's a few seconds</span></div>`;
   try {
     const a = await callAsk(question, JSON.stringify(lastAdvice || {}));
     renderAnswer(box, a);

static/index.html

@@ -97,7 +97,7 @@
 
         <!-- Step 2: goal -->
         <div class="step">
-          <div class="step-head"><span class="step-num">2</span><h2>What do you want to do?</h2></div>
+          <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 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>

static/style.css

@@ -377,6 +377,42 @@ details.disc > summary:hover { color: var(--text-primary); }
 .copy-btn:hover { color: var(--text-primary); border-color: var(--border-hi); }
 .copy-btn.done { color: var(--ok); border-color: var(--ok); }
 
+/* Multi-goal overview */
+.goal-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(230px, 1fr)); gap: var(--s-3); }
+.goal-card {
+  background: var(--bg-raised); border: 1px solid var(--border);
+  border-left: 4px solid var(--status, var(--border)); border-radius: var(--r-md);
+  padding: var(--s-4); cursor: pointer;
+  transition: transform .2s, box-shadow .2s;
+}
+.goal-card:hover { transform: translateY(-2px); box-shadow: var(--shadow-lg); }
+.goal-card .badge {
+  display: inline-flex; align-items: center; gap: 6px;
+  padding: 4px 10px; border-radius: var(--r-pill);
+  background: var(--status-soft); color: var(--status);
+  font: 700 11.5px/1 var(--font-head); text-transform: uppercase; letter-spacing: .04em;
+}
+.goal-card .badge .dot { width: 7px; height: 7px; border-radius: 50%; background: currentColor; }
+.goal-name { font: 700 15px/1.3 var(--font-head); margin-top: var(--s-3); }
+.goal-pick { font-size: 13.5px; color: var(--text-secondary); margin-top: 4px; }
+.goal-need { font-size: 12.5px; color: var(--text-muted); margin-top: 2px; }
+.goal-more { font-size: 12.5px; font-weight: 600; color: var(--accent); margin-top: var(--s-3); }
+.back-link {
+  background: var(--bg-inset); border: 1px solid var(--border); color: var(--text-secondary);
+  border-radius: var(--r-pill); padding: 6px 14px; font-size: 13px; font-weight: 600;
+  margin-bottom: var(--s-4); display: inline-block;
+}
+.back-link:hover { color: var(--text-primary); border-color: var(--border-hi); }
+.goal-lines { list-style: none; padding: 0; margin: var(--s-2) 0 0; }
+.goal-lines li {
+  display: flex; justify-content: space-between; gap: var(--s-3);
+  font-size: 13px; color: var(--text-secondary); padding: 3px 0;
+  border-bottom: 1px dashed var(--border);
+}
+.goal-lines li:last-child { border-bottom: none; }
+.goal-lines li b { color: var(--text-primary); font-weight: 600; text-align: right; }
+.goal-lines li i { color: var(--text-muted); font-style: normal; font-size: 12px; }
+
 /* Live single-model lookup card */
 .lookup-card {
   border: 1px solid var(--border); border-left: 4px solid var(--status, var(--accent));
@@ -431,7 +467,8 @@ details.disc > summary:hover { color: var(--text-primary); }
 .ans-card.ans-error { border-left-color: var(--no); }
 .ans-card.ans-error h3 { color: var(--no); }
 .ans-card.ans-error p { color: var(--text-secondary); font-size: 13.5px; word-break: break-word; }
-.ans-loading { display: flex; align-items: center; gap: var(--s-2); color: var(--text-muted); font-size: 14px; padding: var(--s-2) 0; }
+.ans-loading { display: flex; align-items: center; gap: var(--s-2); color: var(--text-muted); font-size: 14px; padding: var(--s-2) 0; flex-wrap: wrap; }
+.ans-cold { font-size: 12px; color: var(--text-muted); opacity: .75; }
 .spinner {
   width: 15px; height: 15px; flex: none; border-radius: 50%;
   border: 2px solid var(--border-hi); border-top-color: var(--accent);