Dashboard Engines preview always shows "Lemonade — not installed" (lemond_version is never populated)

Current behavior

The dashboard's Serving → Engines side preview always renders

Engines
· Lemonade — not installed
· vLLM — open to check

even when Lemonade is installed and working. On the same machine, at the same moment, rocm engines list reports the truth:

* lemonade   default embedded Lemonade server with ROCm llama.cpp backend
    adapter: built-in
    runtime: ready
    runtime kind: lemonade embeddable
    runtime executable: available
    note: Lemonade is ready on your AMD GPU.

So one binary contradicts the other, and the panel nudges the user into rocm engines install lemonade — which succeeds, changes nothing, and reads as a broken install. (I observed four redundant engine_install engine=lemonade entries in ~/.rocm/audit/events.jsonl from chasing this.)

Note also that the Engines manager modal (Enter on that row) has no install-status column at all — the status claim only exists in the preview line.

Expected behavior

Either report the real status (Lemonade 11.5.1), or, if the daemon has no engine detection yet, say so the same way the adjacent vLLM line already does. It should never assert "not installed" for an engine that is installed.

Steps to reproduce

1. rocm engines install lemonade (on a managed TheRock runtime; rocm engines list must print note: Lemonade is ready on your AMD GPU.)
2. rocm → d (Open full dashboard) → Tab 3 Serving → select Engines
3. Read the right-hand preview panel: · Lemonade — not installed

Root cause

crates/rocm-dash-tui/src/ui/tabs/pane.rs:364

KeyAction::OpenEngineManager => {
    let mut lines = vec![head("Engines".into())];
    let lemon = info().and_then(|i| i.lemond_version.clone());
    lines.push(Line::from(vec![
        mark(lemon.is_some()),
        Span::styled(
            lemon.map_or_else(
                || "Lemonade — not installed".into(),
                |v| format!("Lemonade {v}"),
            ),

info() is just state.latest.gpu_system_info (pane.rs:319), and lemond_version is never written anywhere in the codebase. Grepping HEAD 03c46b5 excluding tests yields only a declaration, a demo stub, and this one reader:

$ grep -rn "lemond_version" --include=*.rs . | grep -v tests/
crates/rocm-dash-core/src/metrics.rs:59:  pub lemond_version: Option<String>,   # declaration
crates/rocm-dash-daemon/src/demo.rs:557:  lemond_version: None,                # demo fixture
crates/rocm-dash-tui/src/ui/tabs/pane.rs:364: ...clone()                       # only reader

The real producer is crates/rocm-dash-collectors/src/amd_smi.rs:108 → parse_system_info(), which starts from GpuSystemInfo::default() and fills only rocm_version, driver_version, gpu_model, card counts, partition modes and VRAM. lemond_version keeps its default None.

Consequence: lemon.is_some() is statically false, so mark(...) is always the "off" glyph, the map_or_else fallback always wins, and the format!("Lemonade {v}") branch at pane.rs:369 is unreachable code.

The three sibling fields llama_server_build, ccr_version and llamacpp_backend (metrics.rs:60-62) have the identical shape — declared, never written, currently unread. If anything starts reading them they will lie the same way.

The detection itself already exists, just not on this path: engines/lemonade/src/lib.rs:395,410 ("Lemonade embeddable {} is installed at {}", installed: runtime.is_some()) is what rocm engines list uses.

Possible solution

Two options, both small:

1. Minimum, and already the established pattern in the same function — the comment 4 lines below is exactly right about vLLM, and the same treatment applied to Lemonade removes the false claim:

   // The daemon doesn't surface Lemonade detection yet — open the manager to
   // check rather than claiming a status we don't have.
   

   i.e. render · Lemonade — open to check muted instead of not installed.
2. Better: populate info.lemond_version in parse_system_info() (or in the daemon runner) from the Lemonade engine install manifest / lemond --version, reusing the same resolution rocm engines list already performs, so the panel shows Lemonade 11.5.1.

Option 1 alone stops the misleading "go install it" nudge. Option 2 without option 1 leaves the label wrong whenever the probe is merely unavailable.

Your environment

• rocm-cli channel: release
• rocm-cli version (rocm --version): rocm 0.1.0 (upstream HEAD 03c46b5, 2026-09-08 — bug present at HEAD)
• Platform: Linux
• OS / Distro: Linux Mint 22.3, kernel 7.0.0-31-generic
• GPU/APU: AMD Radeon 8060S Graphics (gfx1151 / Strix Halo), managed TheRock ROCm 7.13.0 runtime, Lemonade embeddable 11.5.1 (~/.rocm/runtimes/wheel/release-wheel-gfx1151-7-13-0/engines/lemonade/runtime/lemond, lemond version 11.5.1)

Relevant log output

rocm engines list (truth) vs the dashboard preview (false), same machine, same minute:

$ ~/.local/bin/rocm engines list | grep -A5 lemonade
* lemonade   default embedded Lemonade server with ROCm llama.cpp backend
    adapter: built-in
    runtime: ready
    runtime kind: lemonade embeddable
    runtime executable: available
    note: Lemonade is ready on your AMD GPU.

$ ls -l ~/.rocm/runtimes/wheel/release-wheel-gfx1151-7-13-0/engines/lemonade/runtime/lemond
-rwxr-xr-x 1 lide lide 11565728  9月  7 15:48 .../lemond
$ .../lemond --version
lemond version 11.5.1

rocm daemon --status is unrelated — the dashboard is connected, and the string not installed does not appear in rocmd at all; it is composed client-side in rocm-dash-tui. No engine probe is logged anywhere during the dashboard path (~/.rocm/audit/events.jsonl only ever shows actor:"cli" engine events), which is consistent with the label being derived from a snapshot field that is never populated.

Additional context

The misleading label costs real user time: it implies a broken install, so the natural remedy (rocm engines install lemonade) is run repeatedly with no effect, and serving itself was never actually broken.

Start at crates/rocm-dash-tui/src/ui/tabs/pane.rs:364, then compare the Lemonade preview branch with the adjacent vLLM status handling. Verify the daemon snapshot does not populate lemond_version and check the existing dashboard tests or run the relevant TUI test suite. Done means an undetected Lemonade engine is not shown as “not installed,” while an installed version can still be displayed when available.