Call-1 vibe weights: reasoning pass + anti-zero prompt + degenerate guard

Live traces showed MiniCPM5-1B returning an all-zero weighting for
"quiet green wander" that passed validation (used_fallback=False), so the
router got no taste signal and defaulted to nearby well-tagged POIs
(public art) — a green vibe came out "arty".

Root causes + fixes:
- Prompt showed `"cafe": 0.0-1.0`; the 1B parroted `0.0` as the value.
Rewrite states 0..1 in words, forbids all-zero/all-equal, gives one
worked example on an unrelated vibe (shape, not value).
- run_inference now supports enable_thinking (MiniCPM5-1B is hybrid-
reasoning, verified on the model card); vibe->weights runs a reasoning
pass and the <think> block is stripped before JSON parse.
- _is_degenerate() rejects all-zero/all-equal output so the dispatcher
falls through to the bge-small embed tier instead of routing tasteless.

Test: test_llm_rejects_degenerate_weights (from the real all-zero trace).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/discoverroute/interpret/llm_vibe.py

@@ -15,15 +15,28 @@ import time
 
 from discoverroute.interpret import mapping
 
+# NOTE on prompt design: the previous schema literally showed each key as
+# `"cafe": 0.0-1.0`, and the 1B model parroted the `0.0` back as the value —
+# returning an all-zero weighting that the router can't act on (a "quiet green
+# wander" came out tasteless). We now state the 0..1 meaning in words, forbid the
+# all-zero / all-equal degenerate answers explicitly, and give ONE worked example
+# (a vibe unrelated to any preset) so the model copies the *shape*, not a value.
 SYSTEM_PROMPT = (
-    "You are a routing preference extractor.\n"
-    "Output ONLY valid JSON. No prose, no explanation, no markdown.\n"
-    'Schema: {"cafe": 0.0-1.0, "park": 0.0-1.0, "bookshop": 0.0-1.0, '
-    '"museum": 0.0-1.0, "bakery": 0.0-1.0, "restaurant": 0.0-1.0, '
-    '"bar": 0.0-1.0, "viewpoint": 0.0-1.0, "market": 0.0-1.0, '
-    '"quiet": 0.0-1.0, "green": 0.0-1.0, "historic": 0.0-1.0, '
-    '"busy": 0.0-1.0, "detour_budget_multiplier": 0.5-2.0}\n'
-    "All keys required. Values reflect how strongly the vibe matches each."
+    "You convert a walk/ride 'vibe' into place-type preference weights for a "
+    "routing engine.\n"
+    "For each place type, score how strongly the vibe calls for it: 0 means "
+    "irrelevant, 1 means central to the vibe. Most vibes strongly want only two "
+    "to four types — give those 0.7-1.0 and keep the rest low. Never set every "
+    "value to 0, and never give every type the same value.\n"
+    "detour_budget_multiplier is how far off the direct line the vibe justifies: "
+    "0.5 = stay direct, 2.0 = big detours welcome.\n"
+    "Reply with ONLY a JSON object (no prose, no markdown) using EXACTLY these "
+    "keys: cafe, park, bookshop, museum, bakery, restaurant, bar, viewpoint, "
+    "market, quiet, green, historic, busy, detour_budget_multiplier.\n"
+    "Example — for the vibe \"sunny riverside picnic\":\n"
+    '{"cafe":0.4,"park":0.9,"bookshop":0.1,"museum":0.1,"bakery":0.6,'
+    '"restaurant":0.2,"bar":0.1,"viewpoint":0.7,"market":0.5,"quiet":0.6,'
+    '"green":0.9,"historic":0.2,"busy":0.1,"detour_budget_multiplier":1.2}'
 )
 
 REQUIRED_KEYS = (
@@ -71,6 +84,22 @@ def _validate(obj: dict | None) -> dict | None:
     return out
 
 
+def _is_degenerate(weights: dict[str, float]) -> bool:
+    """A weighting carries no usable taste signal if every place-type score is
+    zero, or they're all equal (the model emitted a flat default). Such output
+    passed ``_validate`` but tells the router nothing — so we reject it and let
+    the dispatcher fall through to the embedding tier, which *does* read the vibe.
+    (``detour_budget_multiplier`` is excluded — it isn't a place-type score.)"""
+    cats = [v for k, v in weights.items() if k != "detour_budget_multiplier"]
+    if not cats:
+        return True
+    if max(cats) <= 0.0:                     # all-zero
+        return True
+    if max(cats) - min(cats) < 1e-9:         # all-equal → no differentiation
+        return True
+    return False
+
+
 @functools.lru_cache(maxsize=256)
 def extract(vibe: str) -> dict | None:
     """Return ``{"affinity", "budget_multiplier", "raw"}`` or ``None``.
@@ -90,12 +119,18 @@ def extract(vibe: str) -> dict | None:
 
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": f"Extract routing weights for this vibe: {vibe}"},
+        {"role": "user", "content": f"Vibe: {vibe}\nReturn the JSON weights now."},
     ]
     t0 = time.time()
     try:
         from discoverroute.narrate.llm import run_inference
-        raw_text = run_inference(messages, max_new_tokens=160, temperature=0.2)
+        # Reasoning pass: MiniCPM5-1B is hybrid-reasoning, and scoring a fuzzy vibe
+        # across 14 types is exactly the kind of short deliberation a 1B does better
+        # with than off-the-cuff. enable_thinking=True lets it reason, then emit the
+        # JSON; run_inference strips the <think> block and returns only the JSON. The
+        # budget covers the reasoning + the ~120-token object (truncated reasoning →
+        # empty answer → clean fallback).
+        raw_text = run_inference(messages, max_new_tokens=512, enable_thinking=True)
     except Exception as exc:  # noqa: BLE001 - never break interpretation
         latency = int((time.time() - t0) * 1000)
         trace.log_trace("vibe_extraction", {"vibe": vibe},
@@ -105,9 +140,12 @@ def extract(vibe: str) -> dict | None:
 
     latency = int((time.time() - t0) * 1000)
     parsed = _validate(_extract_json(raw_text))
-    if parsed is None:
+    # Reject unparseable OR degenerate (all-zero / all-equal) output: both leave the
+    # router with no taste signal, so fall through to the embedding tier instead.
+    if parsed is None or _is_degenerate(parsed):
         trace.log_trace("vibe_extraction", {"vibe": vibe},
-                        {"raw": raw_text}, latency, used_fallback=True)
+                        {"raw": raw_text, "degenerate": parsed is not None},
+                        latency, used_fallback=True)
         return None
 
     affinity = mapping.brief_scores_to_affinity(parsed)

src/discoverroute/narrate/llm.py

@@ -46,21 +46,40 @@ def _load():
 
 @_gpu
 def run_inference(messages: list[dict], max_new_tokens: int = 320,
-                  temperature: float = 0.7) -> str:
-    """Run a chat completion. ``messages`` = [{"role","content"}, ...]."""
+                  temperature: float | None = None,
+                  enable_thinking: bool = False) -> str:
+    """Run a chat completion. ``messages`` = [{"role","content"}, ...].
+
+    MiniCPM5-1B is a hybrid-reasoning model (verified on the model card: built-in
+    ``<think>`` template, switched by ``enable_thinking``). With thinking ON it
+    first emits a ``<think>…</think>`` reasoning block and *then* the answer; we
+    strip the block and return only the answer, so callers parse clean output.
+    With thinking OFF the template injects an empty block and there's nothing to
+    strip — the fast direct path.
+
+    ``temperature`` defaults to the model card's recommended sampling for the
+    chosen mode (Think 0.9 / No-Think 0.7), both with top_p 0.95.
+    """
     tok, model = _load()
-    # MiniCPM5 is a hybrid-reasoning model: with thinking on it emits a
-    # <think>...</think> block first, which would devour the JSON/narration token
-    # budget and leave nothing usable. We want the fast direct answer, so disable
-    # it explicitly (the kwarg is ignored harmlessly by templates that lack it).
+    if temperature is None:
+        temperature = 0.9 if enable_thinking else 0.7
     text = tok.apply_chat_template(
-        messages, tokenize=False, add_generation_prompt=True, enable_thinking=False
+        messages, tokenize=False, add_generation_prompt=True,
+        enable_thinking=enable_thinking,
     )
     inputs = tok([text], return_tensors="pt").to(model.device)
-    # MiniCPM5 "no-think" recommended sampling: temperature 0.7, top_p 0.95.
     out = model.generate(
         **inputs, max_new_tokens=max_new_tokens,
         temperature=temperature, top_p=0.95, top_k=20, do_sample=True,
     )
     gen = out[0][inputs.input_ids.shape[1]:]
-    return tok.decode(gen, skip_special_tokens=True).strip()
+    decoded = tok.decode(gen, skip_special_tokens=True).strip()
+    if enable_thinking:
+        # Keep only what follows the reasoning block. If the model never closed
+        # </think> (reasoning ran to the token budget), there's no usable answer —
+        # return "" so the caller falls back rather than parsing half a thought.
+        if "</think>" in decoded:
+            decoded = decoded.split("</think>")[-1].strip()
+        else:
+            decoded = ""
+    return decoded

tests/test_interpret_fallback.py

@@ -47,6 +47,23 @@ def test_llm_json_extract_and_validate():
     assert llm_vibe._extract_json("sorry, I cannot do that") is None
 
 
+def test_llm_rejects_degenerate_weights():
+    """All-zero / all-equal extractions pass _validate but carry no taste signal,
+    so _is_degenerate must flag them (the live trace showed a real all-zero row for
+    'quiet green wander' that the router then ignored)."""
+    keys = llm_vibe.REQUIRED_KEYS
+    all_zero = {k: 0.0 for k in keys}
+    all_zero["detour_budget_multiplier"] = 0.5
+    assert llm_vibe._is_degenerate(all_zero) is True
+    all_equal = {k: 0.5 for k in keys}
+    all_equal["detour_budget_multiplier"] = 1.0
+    assert llm_vibe._is_degenerate(all_equal) is True
+    # a real, differentiated weighting is kept
+    good = {k: 0.1 for k in keys}
+    good.update(park=0.9, green=0.9, quiet=0.7, detour_budget_multiplier=1.2)
+    assert llm_vibe._is_degenerate(good) is False
+
+
 def test_resolve_affinity_neutral_on_empty():
     aff, src = affinity.resolve_affinity("")
     assert src == "neutral"