create-leafmesh 2.6.2__tar.gz → 2.6.3__tar.gz

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.6.2
+Version: 2.6.3
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/create_leafmesh/__init__.py

@@ -1,3 +1,3 @@
 """create-leafmesh — Project scaffolding + cloud-deploy tool for LeafMesh."""
 
-__version__ = "2.6.2"
+__version__ = "2.6.3"

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/create_leafmesh/cli.py

@@ -196,150 +196,6 @@ def _grouped_templates() -> list[tuple[str, list[dict]]]:
     return display
 
 
-def _interactive_search(questionary, style) -> str | None:
-    """State 1 → state 2 bridge inside the TUI picker.
-
-    Prompt for keywords, run the fuzzy search, and — if anything matches —
-    auto-switch to a template-level selection (state 2). Returns a chosen
-    slug, or None to return to the category view (state 1).
-    """
-    ready = list_templates(include_planned=False)
-    query = questionary.text(
-        "Search templates (keywords — spelling needn't be exact):",
-        style=style,
-    ).ask()
-    if not query or not query.strip():
-        return None
-    query = query.strip()
-
-    matches = search_templates(ready, query)
-    if not matches:
-        print(f"\n  No templates matched '{query}'. "
-              f"Try a broader term (e.g. 'sales', 'finance', 'support').\n")
-        return None
-
-    # Auto-switch to state 2 — show the matching templates directly.
-    name_w = max((len(t.get("short_name", t["slug"])) for t, _ in matches),
-                 default=12) + 2
-    tpl_choices = []
-    for t, _score in matches:
-        short = t.get("short_name", t["slug"])
-        one = t.get("one_line", "")
-        tpl_choices.append(questionary.Choice(
-            title=f"{short.ljust(name_w)} — {one}", value=t["slug"]))
-    tpl_choices.append(questionary.Separator())
-    tpl_choices.append(questionary.Choice(title="← Back / new search",
-                                          value="__back__"))
-
-    chosen = questionary.select(
-        f"Matches for '{query}':",
-        choices=tpl_choices,
-        style=style,
-        instruction="(↑/↓ to move, Enter to select)",
-        use_indicator=True,
-    ).ask()
-
-    if chosen is None or chosen == "__back__":
-        return None
-    return chosen
-
-
-def _prompt_template_choice_interactive() -> str:
-    """Arrow-key TUI picker — cascading category → template selection.
-
-    Uses `questionary` for arrow-key navigation. Two stages:
-      1. Pick a business category
-      2. Pick a template within that category (with 'Back' option)
-
-    Loops until a template is chosen or user cancels.
-    """
-    import questionary
-    from questionary import Style
-
-    style = Style([
-        ("qmark",       "fg:#00d7ff bold"),
-        ("question",    "bold"),
-        ("answer",      "fg:#5fff5f bold"),
-        ("pointer",     "fg:#00d7ff bold"),
-        ("highlighted", "fg:#00d7ff bold"),
-        ("selected",    "fg:#5fff5f"),
-        ("separator",   "fg:#6c6c6c"),
-        ("instruction", "fg:#6c6c6c"),
-    ])
-
-    display = _grouped_templates()
-    if not display:
-        print("  No templates available. Reinstall create-leafmesh.")
-        sys.exit(2)
-
-    cat_to_items = dict(display)
-
-    while True:
-        # ── Step 1: pick a category ──────────────────────────────────
-        cat_choices = []
-        for cat, items in display:
-            n = len(items)
-            label = f"{cat}  ({n} template{'s' if n != 1 else ''})"
-            cat_choices.append(questionary.Choice(title=label, value=cat))
-        cat_choices.append(questionary.Separator())
-        cat_choices.append(questionary.Choice(title="Search by keyword…",
-                                              value="__search__"))
-        # NOTE: `value=None` causes questionary to fall back to the title
-        # string (treats None as "unset"), which then crashes our
-        # cat_to_items lookup with KeyError: 'Quit'. Use an explicit
-        # sentinel string instead.
-        cat_choices.append(questionary.Choice(title="Quit", value="__quit__"))
-
-        chosen_cat = questionary.select(
-            "Choose a business area:",
-            choices=cat_choices,
-            style=style,
-            instruction="(↑/↓ to move, Enter to select)",
-            use_indicator=True,
-        ).ask()
-
-        if chosen_cat is None or chosen_cat == "__quit__":
-            print("\n  Cancelled.\n")
-            sys.exit(0)
-
-        if chosen_cat == "__search__":
-            slug = _interactive_search(questionary, style)
-            if slug:
-                return slug
-            continue  # no match / backed out → back to the category view
-
-        # ── Step 2: pick a template in that category ─────────────────
-        items = cat_to_items[chosen_cat]
-        # Pad short_names so the one-liner column aligns nicely.
-        name_w = max((len(t.get("short_name", t["slug"])) for t in items), default=12) + 2
-
-        tpl_choices = []
-        for t in items:
-            short = t.get("short_name", t["slug"])
-            one = t.get("one_line", "")
-            label = f"{short.ljust(name_w)} — {one}"
-            tpl_choices.append(questionary.Choice(title=label, value=t["slug"]))
-        tpl_choices.append(questionary.Separator())
-        tpl_choices.append(questionary.Choice(title="← Back to categories",
-                                              value="__back__"))
-        tpl_choices.append(questionary.Choice(title="Quit", value="__quit__"))
-
-        chosen = questionary.select(
-            f"Template in {chosen_cat}:",
-            choices=tpl_choices,
-            style=style,
-            instruction="(↑/↓ to move, Enter to select)",
-            use_indicator=True,
-        ).ask()
-
-        if chosen is None or chosen == "__quit__":
-            print("\n  Cancelled.\n")
-            sys.exit(0)
-        if chosen == "__back__":
-            continue
-        return chosen
-
-
 def _prompt_template_choice_fallback() -> str:
     """Numbered-list fallback for non-TTY terminals (CI, piped input)."""
     display = _grouped_templates()
@@ -423,18 +279,25 @@ def _prompt_template_choice_fallback() -> str:
 def prompt_template_choice() -> str:
     """Pick the right picker for the environment.
 
-    On a real terminal: arrow-key cascading TUI (category → template).
-    On CI / piped input / dumb terminals: numbered-list fallback.
+    On a real terminal: the full-screen Discover browser (live type-to-search,
+    ↑/↓ to move, Enter for a detail/confirm screen).
+    On CI / piped input / dumb terminals (or if prompt_toolkit is missing):
+    the numbered-list fallback (which has its own `/keywords` search).
     """
     is_tty = sys.stdin.isatty() and sys.stdout.isatty()
     if is_tty:
         try:
-            return _prompt_template_choice_interactive()
+            from create_leafmesh.discover import discover_templates
+            slug = discover_templates(list_templates(include_planned=False))
+            if slug is None:
+                print("\n  Cancelled.\n")
+                sys.exit(0)
+            return slug
         except KeyboardInterrupt:
             print("\n\n  Cancelled.\n")
             sys.exit(0)
         except ImportError:
-            # questionary missing → fall through to text picker
+            # prompt_toolkit unavailable → fall through to text picker
             pass
     return _prompt_template_choice_fallback()
 

create_leafmesh-2.6.3/create_leafmesh/discover.py

@@ -0,0 +1,269 @@
+"""Full-screen, live type-to-search template browser (the "Discover" UI).
+
+Modelled on Claude Code's `/plugin` Discover screen: a search box at the top
+that filters as you type, a scrollable list of templates below (name ·
+category, with a one-line summary), and a footer of key hints. Pressing Enter
+on a row opens a detail screen with a confirm-to-scaffold step.
+
+Built on prompt_toolkit, which ships as a dependency of `questionary` — so
+this adds no new requirement. Falls back (in cli.py) to the numbered-list
+picker when there's no TTY or prompt_toolkit is unavailable.
+
+Public entry point: `discover_templates(templates) -> str | None`
+    returns the chosen template slug, or None if the user cancelled.
+"""
+
+from __future__ import annotations
+
+import textwrap
+from typing import Any
+
+from create_leafmesh.search import browser_filter
+
+
+def discover_templates(
+    templates: list[dict[str, Any]],
+    *,
+    _input=None,
+    _output=None,
+) -> str | None:
+    """Run the full-screen Discover browser. Returns a slug or None.
+
+    Raises ImportError if prompt_toolkit isn't importable, so the caller can
+    fall back to the numbered picker.
+
+    `_input` / `_output` are test seams: pass a prompt_toolkit pipe input and
+    a DummyOutput to drive the browser headlessly.
+    """
+    from prompt_toolkit.application import Application
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.filters import Condition
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import Layout
+    from prompt_toolkit.layout.containers import HSplit, VSplit, Window
+    from prompt_toolkit.layout.controls import (
+        BufferControl,
+        FormattedTextControl,
+    )
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.styles import Style
+
+    total = len(templates)
+
+    # ── Mutable UI state ─────────────────────────────────────────────
+    state = {
+        "filtered": list(templates),  # current visible templates
+        "sel": 0,                     # selected index into filtered
+        "offset": 0,                  # scroll offset (top visible item)
+        "mode": "list",               # "list" | "detail"
+        "result": None,               # chosen slug on exit
+    }
+
+    search = Buffer(multiline=False)
+
+    def _refilter(_buf=None) -> None:
+        state["filtered"] = browser_filter(templates, search.text)
+        state["sel"] = 0
+        state["offset"] = 0
+
+    search.on_text_changed += _refilter
+
+    is_list = Condition(lambda: state["mode"] == "list")
+    is_detail = Condition(lambda: state["mode"] == "detail")
+
+    def _current() -> dict[str, Any] | None:
+        f = state["filtered"]
+        if not f:
+            return None
+        return f[min(state["sel"], len(f) - 1)]
+
+    def _visible_rows() -> int:
+        """How many templates fit, given the terminal height (2 lines each)."""
+        from prompt_toolkit.application import get_app
+        try:
+            h = get_app().output.get_size().rows
+        except Exception:
+            h = 24
+        # header + spacer + search + spacer + footer ≈ 6 chrome lines
+        return max(3, (h - 6) // 2)
+
+    # ── Header ───────────────────────────────────────────────────────
+    def header_text():
+        n = len(state["filtered"])
+        count = f"{n}/{total}" if n != total else f"{total}"
+        return [("class:title", f"  Discover templates "),
+                ("class:dim", f"({count})")]
+
+    # ── List / detail body ───────────────────────────────────────────
+    def body_text():
+        if state["mode"] == "detail":
+            return _detail_text()
+        return _list_text()
+
+    def _list_text():
+        f = state["filtered"]
+        if not f:
+            return [("class:dim", "\n  No templates match — try fewer letters.\n")]
+
+        vis = _visible_rows()
+        sel = min(state["sel"], len(f) - 1)
+        off = state["offset"]
+        if sel < off:
+            off = sel
+        elif sel >= off + vis:
+            off = sel - vis + 1
+        state["offset"] = off
+
+        out: list[tuple[str, str]] = []
+        window = f[off:off + vis]
+        slug_w = max((len(t["slug"]) for t in window), default=16) + 2
+        for i, t in enumerate(window, start=off):
+            selected = (i == sel)
+            ptr = "❯ " if selected else "  "
+            row_style = "class:sel" if selected else "class:row"
+            slug = t["slug"].ljust(slug_w)
+            cat = t.get("category", "")
+            out.append((row_style, f"  {ptr}{slug}"))
+            out.append(("class:sel-cat" if selected else "class:cat", f"{cat}\n"))
+            one = t.get("one_line", "")
+            if len(one) > 70:
+                one = one[:67] + "…"
+            out.append(("class:dim", f"      {one}\n"))
+        if off + vis < len(f):
+            out.append(("class:dim", "  ↓ more below\n"))
+        return out
+
+    def _detail_text():
+        t = _current()
+        if t is None:
+            return [("", "")]
+        out: list[tuple[str, str]] = []
+        out.append(("class:title", f"\n  {t.get('full_name', t['slug'])}\n"))
+        out.append(("class:dim", f"  {t['slug']}\n\n"))
+        meta = []
+        if t.get("agent_count"):
+            meta.append(f"{t['agent_count']} agents")
+        if t.get("cron_count") not in (None, "", "0", 0):
+            meta.append(f"{t['cron_count']} cron")
+        if t.get("complexity"):
+            meta.append(f"complexity: {t['complexity']}")
+        if meta:
+            out.append(("class:meta", "  " + "  ·  ".join(meta) + "\n\n"))
+        desc = " ".join((t.get("description", "") or "").split())
+        for line in textwrap.wrap(desc, width=72) or [""]:
+            out.append(("class:row", f"  {line}\n"))
+        if t.get("trust_lead"):
+            out.append(("class:dim", "\n  Gates: "))
+            trust = " ".join(t["trust_lead"].split())
+            wrapped = textwrap.wrap(trust, width=64) or [""]
+            out.append(("class:dim", wrapped[0]))
+            for line in wrapped[1:]:
+                out.append(("class:dim", f"\n         {line}"))
+            out.append(("", "\n"))
+        return out
+
+    # ── Footer ───────────────────────────────────────────────────────
+    def footer_text():
+        if state["mode"] == "detail":
+            return [("class:foot", "  Enter "), ("class:dim", "scaffold   "),
+                    ("class:foot", "Esc "), ("class:dim", "back")]
+        return [("class:dim", "  Type to search · "),
+                ("class:foot", "↑/↓ "), ("class:dim", "move · "),
+                ("class:foot", "Enter "), ("class:dim", "view · "),
+                ("class:foot", "Esc "), ("class:dim", "cancel")]
+
+    # ── Search box (label + live buffer), shown only in list mode ─────
+    search_line = VSplit([
+        Window(FormattedTextControl(lambda: [("class:prompt", "  ⌕ ")]),
+               width=5, height=1),
+        Window(BufferControl(buffer=search), height=1),
+    ])
+
+    body = Window(content=FormattedTextControl(body_text), wrap_lines=True,
+                  height=Dimension(min=3))
+
+    root = HSplit([
+        Window(FormattedTextControl(header_text), height=1),
+        Window(height=1, char=" "),   # spacer
+        search_line,
+        Window(height=1, char=" "),   # spacer
+        body,
+        Window(FormattedTextControl(footer_text), height=1),
+    ])
+
+    # ── Key bindings ─────────────────────────────────────────────────
+    kb = KeyBindings()
+
+    @kb.add("up", filter=is_list, eager=True)
+    @kb.add("c-p", filter=is_list, eager=True)
+    def _up(event):
+        if state["filtered"]:
+            state["sel"] = (state["sel"] - 1) % len(state["filtered"])
+
+    @kb.add("down", filter=is_list, eager=True)
+    @kb.add("c-n", filter=is_list, eager=True)
+    def _down(event):
+        if state["filtered"]:
+            state["sel"] = (state["sel"] + 1) % len(state["filtered"])
+
+    @kb.add("enter", filter=is_list, eager=True)
+    def _enter_list(event):
+        if _current() is not None:
+            state["mode"] = "detail"
+
+    @kb.add("enter", filter=is_detail, eager=True)
+    def _enter_detail(event):
+        t = _current()
+        if t is not None:
+            state["result"] = t["slug"]
+            event.app.exit()
+
+    @kb.add("escape", filter=is_detail, eager=True)
+    def _esc_detail(event):
+        state["mode"] = "list"
+
+    @kb.add("escape", filter=is_list, eager=True)
+    def _esc_list(event):
+        state["result"] = None
+        event.app.exit()
+
+    # In detail mode, swallow any other key so typing doesn't edit the query.
+    @kb.add("<any>", filter=is_detail, eager=True)
+    def _swallow(event):
+        pass
+
+    @kb.add("c-c")
+    @kb.add("c-q")
+    def _cancel(event):
+        state["result"] = None
+        event.app.exit()
+
+    style = Style([
+        ("title",   "bold"),
+        ("dim",     "fg:#6c6c6c"),
+        ("prompt",  "fg:#00d7ff bold"),
+        ("row",     ""),
+        ("cat",     "fg:#6c6c6c"),
+        ("sel",     "fg:#00d7ff bold"),
+        ("sel-cat", "fg:#00d7ff"),
+        ("meta",    "fg:#5fafff"),
+        ("foot",    "fg:#5fff5f bold"),
+    ])
+
+    app_kwargs = {}
+    if _input is not None:
+        app_kwargs["input"] = _input
+    if _output is not None:
+        app_kwargs["output"] = _output
+
+    app = Application(
+        layout=Layout(root, focused_element=search_line),
+        key_bindings=kb,
+        style=style,
+        full_screen=True,
+        mouse_support=False,
+        **app_kwargs,
+    )
+    _refilter()
+    app.run()
+    return state["result"]

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/create_leafmesh/search.py

@@ -139,6 +139,55 @@ def score_template(t: dict[str, Any], query: str) -> float:
     return score
 
 
+def browser_filter(
+    templates: list[dict[str, Any]],
+    query: str,
+) -> list[dict[str, Any]]:
+    """Lenient, responsive filter for the live Discover browser.
+
+    Unlike `search_templates` (which thresholds for "best answer" intent),
+    this is for incremental typing: an empty query returns everything in the
+    given display order, and a partial query surfaces anything whose text
+    contains the typed tokens as substrings — so "proc" immediately reveals
+    procurement-ops — ranked by relevance (fuzzy still helps with typos).
+    """
+    q = (query or "").strip().lower()
+    if not q:
+        return list(templates)
+
+    q_tokens = _tokens(q)
+    q_compact = q.replace(" ", "")
+    ranked: list[tuple[dict[str, Any], int, float, str]] = []
+    for t in templates:
+        primary_text, secondary_text, _ = _corpus(t)
+        hay = primary_text + " " + secondary_text
+        # Substring inclusion: every typed token appears somewhere.
+        substr = all(tok in hay for tok in q_tokens) if q_tokens else False
+        s = score_template(t, q)
+        if not (substr or s > 0):
+            continue
+        # Tier the result so live typing feels right. A name prefix (the query
+        # starts the slug or a name word) is the strongest signal, then a
+        # keyword/synonym prefix, then a mid-word substring, then a fuzzy-only
+        # (typo) hit. Within a tier, higher relevance score first.
+        slug = t.get("slug", "")
+        name_text = f"{slug} {t.get('short_name', '')} {t.get('full_name', '')}"
+        name_prefix = (slug.startswith(q_compact)
+                       or any(tok.startswith(q) for tok in _tokens(name_text)))
+        kw_prefix = any(tok.startswith(q) for tok in _tokens(primary_text))
+        if name_prefix:
+            tier = 0
+        elif kw_prefix:
+            tier = 1
+        elif substr:
+            tier = 2
+        else:
+            tier = 3
+        ranked.append((t, tier, s, slug))
+    ranked.sort(key=lambda r: (r[1], -r[2], r[3]))
+    return [t for t, _tier, _s, _slug in ranked]
+
+
 def search_templates(
     templates: list[dict[str, Any]],
     query: str,

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/create_leafmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.6.2
+Version: 2.6.3
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/create_leafmesh.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ create_leafmesh/__init__.py
 create_leafmesh/cli.py
 create_leafmesh/create.py
 create_leafmesh/deploy.py
+create_leafmesh/discover.py
 create_leafmesh/search.py
 create_leafmesh.egg-info/PKG-INFO
 create_leafmesh.egg-info/SOURCES.txt
@@ -707,4 +708,5 @@ create_leafmesh/templates/warehouse-supply-chain/tests/__init__.py
 create_leafmesh/templates/warehouse-supply-chain/tests/conftest.py
 create_leafmesh/templates/warehouse-supply-chain/tests/test_agent_logic.py
 create_leafmesh/templates/warehouse-supply-chain/tests/test_config_shape.py
+tests/test_discover.py
 tests/test_search.py

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "create-leafmesh"
-version = "2.6.2"
+version = "2.6.3"
 description = "Project scaffolding + cloud-deploy tool for LeafMesh"
 readme = "README.md"
 requires-python = ">=3.10"

create_leafmesh-2.6.3/tests/test_discover.py

@@ -0,0 +1,66 @@
+"""Headless drive of the full-screen Discover browser (create_leafmesh.discover).
+
+prompt_toolkit ships a pipe-input + DummyOutput test seam; discover_templates
+accepts them via `_input`/`_output`, so we can script keystrokes and assert the
+returned slug without a real terminal.
+
+Key bytes: "\\r" = Enter, "\\x1b[B" = Down, "\\x1b[A" = Up, "\\x1b" = Esc,
+"\\x03" = Ctrl-C.
+"""
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("prompt_toolkit")
+
+from prompt_toolkit.output import DummyOutput  # noqa: E402
+
+try:
+    from prompt_toolkit.input import create_pipe_input
+except ImportError:  # older prompt_toolkit
+    from prompt_toolkit.input.defaults import create_pipe_input
+
+from create_leafmesh.create import list_templates  # noqa: E402
+from create_leafmesh.discover import discover_templates  # noqa: E402
+
+
+def _run(keys: str):
+    templates = list_templates(include_planned=False)
+    cm = create_pipe_input()
+    if hasattr(cm, "__enter__"):
+        with cm as inp:
+            inp.send_text(keys)
+            return discover_templates(templates, _input=inp, _output=DummyOutput())
+    cm.send_text(keys)
+    return discover_templates(templates, _input=cm, _output=DummyOutput())
+
+
+def test_search_then_select():
+    # type 'proc' -> top is procurement-ops; Enter (detail), Enter (scaffold)
+    assert _run("proc\r\r") == "procurement-ops"
+
+
+def test_navigate_down_then_select():
+    # 'cust' lists customer-success then customer-support; Down picks the 2nd
+    assert _run("cust\x1b[B\r\r") == "customer-support"
+
+
+def test_exactish_query_select():
+    assert _run("warehouse\r\r") == "warehouse-supply-chain"
+
+
+def test_detail_back_then_reselect():
+    # 'fin' -> detail -> Esc back to list -> Enter detail -> Enter scaffold
+    assert _run("fin\r\x1b\r\r") == "finance-ops"
+
+
+def test_escape_cancels():
+    assert _run("\x1b") is None
+
+
+def test_ctrl_c_cancels():
+    assert _run("proc\x03") is None
+
+
+def test_no_match_then_cancel():
+    assert _run("zzzznope\x03") is None

{create_leafmesh-2.6.2 → create_leafmesh-2.6.3}/tests/test_search.py

@@ -10,7 +10,11 @@ from __future__ import annotations
 import pytest
 
 from create_leafmesh.create import list_templates
-from create_leafmesh.search import score_template, search_templates
+from create_leafmesh.search import (
+    browser_filter,
+    score_template,
+    search_templates,
+)
 
 
 @pytest.fixture(scope="module")
@@ -128,6 +132,32 @@ def test_score_is_monotonic_for_relevance(templates):
         score_template(fin, "cold email outreach")
 
 
+# ── Browser filter (live Discover typing) ──
+
+def test_browser_filter_empty_returns_all(templates):
+    assert len(browser_filter(templates, "")) == len(templates)
+
+
+@pytest.mark.parametrize("query,expected_top", [
+    ("proc", "procurement-ops"),
+    ("fin", "finance-ops"),
+    ("ware", "warehouse-supply-chain"),
+    ("mark", "marketing-ops"),
+    ("recru", "recruiting-ops"),
+    ("bench", "bench-management"),
+    ("qual", "quality-yield"),
+])
+def test_browser_filter_name_prefix_ranks_first(templates, query, expected_top):
+    # A name/slug prefix must beat a keyword-prefix or fuzzy hit while typing.
+    res = browser_filter(templates, query)
+    assert res, f"{query!r} returned nothing"
+    assert res[0]["slug"] == expected_top, [t["slug"] for t in res[:3]]
+
+
+def test_browser_filter_unknown_returns_empty(templates):
+    assert browser_filter(templates, "zzzznope") == []
+
+
 # ── CLI surface ──
 
 def test_cli_search_exit_codes(capsys):