fix(ui): namespace mouthfeel terms so the sensation isn't drowned by the like-named note

Verifying the chips on the live box exposed a real semantic bug: picking `pungent`
under Mouthfeel returned Acetic Acid, Acetone, Ammonia and CO2 — sharp-SMELLING
molecules — with only 1 TRPV1 agent in 40 results. Both the aroma head and the
sensation head wrote the same bare `pungent` tag, and the far larger aroma set
drowned the sensation one. `cooling` only looked correct by luck (menthol genuinely
smells and feels cool).

Mouthfeel tags are now namespaced (`mouthfeel:pungent`), matching how the profile
index already keys `aroma:cooling` vs `mouthfeel:cooling`. Chips send the namespaced
term; the UI renders the plain label. Verified after restart:
  mouthfeel:pungent -> allyl isothiocyanate, diallyl disulfide, capsaicin
  note:pungent      -> acetic acid, acetaldehyde, acetone, ammonia

Also splits _MOUTHFEEL_CARRIERS out of _NOTE_CARRIERS: both CSVs key on bare names,
so merging them would have relabelled aroma_supplement's `pungent` Piper amides as
sensation agents. All five chips now return real agents (tingling finds 11, of which
2 are food-listed — the sanshools aren't on the FDA/EU registers, which is correct).

Signed-off-by: Austin L. <86896075+rvnminers-A-and-N@users.noreply.github.com>

Author: rvnminers-A-and-N

training/app.py

@@ -1101,14 +1101,15 @@ def _resolve_one(it):
 
 def _load_note_carriers():
     """descriptor/note -> [(smiles, name)] of KNOWN character-impact molecules, from the curated
-    flavors.csv + aroma_supplement.csv + mouthfeel_supplement.csv (same schema). The recipe designer
-    prefers these (e.g. gamma-nonalactone for coconut, maltol for caramel) over a generic palette
-    match, which can surface poor carriers. The mouthfeel agents matter especially here: the design
-    pool is built from the HSDB *odor* corpus, which barely contains them (0 of 11 tingling agents,
-    1 of 11 astringent), so without folding them in those chips would match nothing."""
+    flavors.csv + aroma_supplement.csv. The recipe designer prefers these (e.g. gamma-nonalactone
+    for coconut, maltol for caramel) over a generic palette match, which can surface poor carriers.
+
+    Mouthfeel agents load separately (_load_mouthfeel_carriers) and are NOT merged here: both files
+    key on bare names, so aroma_supplement's `pungent` Piper amides and mouthfeel_supplement's
+    TRPV1 agents would collide under one key and lose their modality."""
     import csv
     m = {}
-    for path in ("flavors.csv", "aroma_supplement.csv", "mouthfeel_supplement.csv"):
+    for path in ("flavors.csv", "aroma_supplement.csv"):
         with contextlib.suppress(Exception), open(path, encoding="utf-8") as fh:  # missing file / bad rows; just skip
             for r in csv.DictReader(fh):
                 note = (r.get("flavor") or "").strip().lower()
@@ -1119,7 +1120,25 @@ def _load_note_carriers():
     return m
 
 
+def _load_mouthfeel_carriers():
+    """sensation -> [(smiles, name)] of curated trigeminal agents (mouthfeel_supplement.csv, same
+    schema as flavors.csv). Kept separate from _NOTE_CARRIERS so the modality survives: the design
+    pool is built from the HSDB *odor* corpus, which barely contains these (0 of 11 tingling agents,
+    1 of 11 astringent), so without folding them in those chips match nothing."""
+    import csv
+    m = {}
+    with contextlib.suppress(Exception), open("mouthfeel_supplement.csv", encoding="utf-8") as fh:
+        for r in csv.DictReader(fh):
+            note = (r.get("flavor") or "").strip().lower()
+            smi = (r.get("smiles") or "").strip()
+            nm = (r.get("molecule") or "").strip()
+            if note and smi:
+                m.setdefault(note, []).append((smi, nm or note))
+    return m
+
+
 _NOTE_CARRIERS = _load_note_carriers()
+_MOUTHFEEL_CARRIERS = _load_mouthfeel_carriers()
 
 
 class DesignRecipeQuery(BaseModel):
@@ -1473,9 +1492,13 @@ def _precompute_design():
             if clf is not None:
                 for i in np.where(clf.predict_proba(X)[:, 1] >= 0.5)[0]:
                     tagsets[i].add(t)
+        # Mouthfeel tags are NAMESPACED ("mouthfeel:pungent"), matching how the profile index keys
+        # its dims. Without this, picking `pungent` under Mouthfeel returned sharp-SMELLING
+        # molecules (acetic acid, ammonia, CO2) from the far larger aroma:pungent set instead of
+        # the TRPV1 burn agents — the two modalities share a name but not a meaning.
         for name, clf in P._MOUTHFEEL_MODELS.items():             # mouthfeel / chemesthesis
             for i in np.where(clf.predict_proba(X)[:, 1] >= 0.5)[0]:
-                tagsets[i].add(name)
+                tagsets[i].add(f"mouthfeel:{name}")
         cnt, pool = Counter(), []
         for (smi, nm, skel, _, _), tags in zip(rows, tagsets):
             if not tags:
@@ -1485,26 +1508,27 @@ def _precompute_design():
         # fold the curated character-impact molecules (supplement + flavors) into the index so
         # their descriptors (coconut, nutty, vanilla, cinnamon...) are searchable + offerable even
         # where the industrial-skewed odor corpus is thin on them
-        for note, carriers in _NOTE_CARRIERS.items():
+        # aroma/flavor carriers keep their bare note; mouthfeel carriers carry the namespaced tag
+        folds = [(n, c, n) for n, c in _NOTE_CARRIERS.items()]
+        folds += [(n, c, f"mouthfeel:{n}") for n, c in _MOUTHFEEL_CARRIERS.items()]
+        for _note, carriers, tag in folds:
             for csmi, cnm in carriers:
                 cm = Chem.MolFromSmiles(csmi)
                 if cm is None:
                     continue
-                pool.append({"smiles": csmi, "name": cnm or "", "tags": {note},
+                pool.append({"smiles": csmi, "name": cnm or "", "tags": {tag},
                              "gras": Chem.MolToInchiKey(cm).split("-")[0] in P._GRAS})
-                cnt.update([note])
+                cnt.update([tag])
         _DESIGN[:] = pool
         # Offer EVERY trained aroma head as a selectable note (even aroma-only ones with few
-        # food-safe carriers), plus any design note that has >=5 carriers — but keep the
-        # mouthfeel-ONLY sensations out of the notes list (they get their own group below).
-        # cooling/pungent are exempt from that subtraction: they're genuine aroma heads too.
-        mouth_only = set(P._MOUTHFEEL_MODELS) - set(P._AROMA_MODELS)
+        # food-safe carriers), plus any design note with >=5 carriers. Namespaced mouthfeel tags
+        # are excluded — they're a separate modality with their own pick-list below.
         _DESIGN_DESCS[:] = sorted(
-            ({d for d, n in cnt.items() if n >= 5} | set(P._AROMA_MODELS)) - mouth_only)
-        # Mouthfeel is offered as its own pick-list — a different modality, not an odour note.
-        # cooling/pungent intentionally appear in BOTH lists (they're a trained aroma head *and* a
-        # trained sensation head), so a molecule that smells cool and one that feels cool both match.
-        _DESIGN_MOUTHFEEL[:] = sorted(P._MOUTHFEEL_MODELS)
+            {d for d, n in cnt.items() if n >= 5 and not d.startswith("mouthfeel:")}
+            | set(P._AROMA_MODELS))
+        # Mouthfeel terms stay namespaced ("mouthfeel:cooling") so picking `cooling` here matches
+        # the SENSATION, not the like-named odour note. The UI shows the bare label.
+        _DESIGN_MOUTHFEEL[:] = [f"mouthfeel:{m}" for m in sorted(P._MOUTHFEEL_MODELS)]
 
 
 def _fpvec(mol):

training/workbench.html

@@ -2317,7 +2317,8 @@ <h4>Software &amp; type</h4>
     if(mouth.length){
       html += `<div class="studio-section"><div class="ss-head"><svg class="ic"><use href="#ic-notes"/></svg> Mouthfeel <span class="ss-sub">how it <b>feels</b> in the mouth — chemesthesis, not smell</span></div><div class="ss-body">`+
         `<div class="studio-group studio-group-notes">`+
-        mouth.map(m=>`<button type="button" class="schip schip-mouth" data-term="${esc(m)}" title="${esc(MOUTHFEEL_HELP[m]||m)}">${m}</button>`).join('')+
+        mouth.map(m=>{const lbl=m.replace(/^mouthfeel:/,'');  // term stays namespaced, label reads plain
+          return `<button type="button" class="schip schip-mouth" data-term="${esc(m)}" title="${esc(MOUTHFEEL_HELP[lbl]||lbl)}">${lbl}</button>`;}).join('')+
         `</div></div></div>`;
     }
     $('studioChips').innerHTML = html;
@@ -2589,8 +2590,9 @@ <h4>Software &amp; type</h4>
   // mouthfeel targets — the trigeminal sensations, aimed at like notes but a distinct modality
   const mbox=$('formTargetMouth');
   (d.mouthfeel||[]).forEach(m=>{
-    const b=document.createElement('span'); b.className='chip chip-mouth'; b.textContent=m; b.dataset.term=m;
-    b.title=MOUTHFEEL_HELP[m]||m;
+    const lbl=m.replace(/^mouthfeel:/,'');   // term stays namespaced so it matches the sensation tag
+    const b=document.createElement('span'); b.className='chip chip-mouth'; b.textContent=lbl; b.dataset.term=m;
+    b.title=MOUTHFEEL_HELP[lbl]||lbl;
     b.onclick=()=>{ if(_formTarget.has(m)){ _formTarget.delete(m); b.classList.remove('on'); } else { _formTarget.add(m); b.classList.add('on'); } };
     mbox.appendChild(b);
   });