Version and feedback in the app, longer console history with Save, USBTMC stall recovery, Metrics under Instruments, kit styles in drawers

- Top bar shows the running version; Feedback drawer (version, copy, GitHub issues links opened in the system browser via the open_page command)
- Instrument console: 50 000 entries / 8 MiB per instrument, first fetch limited, Save writes the full log; GET /devices/{id}/wire takes limit
- USBTMC (Linux kernel driver and nusb): a stalled bulk-out is aborted and cleared once and the write retried; recovery steps logged in the console
- Metrics moved to an Instruments tab, judged against limits in the bench page style
- Drawer pages share .bench-page / .bench-group; e2e edge guard; Instruments form buttons and fields use the kit styles

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: MarkoVcode

CLAUDE.md

@@ -164,9 +164,10 @@ code; the definitions' `ui_component` is not used by the UI.
 | `bench/panels/` | class panels (`PsuPanel`, `DmmPanel`, `EllPanel` - modes without a setpoint, Short (two presses); `AwgChannel` - frequency or period, amplitude as Vpp / Vrms / dBm / high-low levels, phase, ramp symmetry, load, pulse duty/width/edges, mode CW / MOD (AM/FM/PM: modulating wave, frequency, depth or deviation) / SWEEP (start, stop, time, spacing, trigger) / BURST (N cycles or infinite, period, trigger), each control only when the definition binds it: conversions in `bench/awgMath.ts`, values the instrument does not report tagged CALC; `OscPanel` - one screen for all channels, `LcrPanel` - primary/secondary readouts, function keys L/C/R/Z/DCR → secondary → SER/PAR, frequency/level, range/speed, open/short correction with a prompt, bias; `SalPanel` - spectrum screen (`kit/SpectrumScreen`: dB graticule, max-hold ghost, marker diamond, click to place), marker readout, annotation bar, soft-key groups FREQ/BW/AMPT/SWEEP/TRACE/MKR/TG; `GenericPanel`) |
 | `bench/layout.ts`, `Rack.tsx` | panel order / width (S, M, L, W) / hidden / channel layout of multi-channel panels (side by side or stacked), persisted in `localStorage` (`benchmesh:bench-layout`); columns follow the window width (300 px units) |
 | `bench/BenchLayout.tsx` | shell: top bar, **Arrange** mode (drag, ◀ ▶, width, channels ⇆ / ⇅, hide), drawers (Instruments config, Request log) |
-| `drawers/` | instrument configuration + settings (incl. **Detect**: `DetectView.tsx`, `detect.ts`), request log |
+| `drawers/` | Instruments drawer tabs: configuration (incl. **Detect**: `DetectView.tsx`, `detect.ts`), Supported, Miscellaneous, **Metrics** (`MetricsView.tsx` + `metrics.ts`: per instrument link busy, exchanges/s, API latency from `/ws/metrics`, judged against limits), Remote access; request log |
 | `recording/` | recordings v2 (`ai_context/migration/RECORDINGS.md`): `RecordingsProvider` (REST + `/ws/recordings`, live sample buffers; main and panel windows), recordable readings (`signal.tsx`: `SignalScope` + `Recordable`, kit `ContextMenu` on right-click / context-menu key, red dot when recorded), recorder dock (bottom of the main window, `benchmesh:recorder-dock`), recordings drawer (history, zoomable chart, rename, CSV export, delete). Chart: `chartModel.ts` (one y-axis per series, colours `--kit-series-1..8`), ECharts core loaded lazily in `RecordingChart.tsx` |
 | `kit/brand.ts`, `kit/BrandMark.tsx` | the logo ("Readout": seven-segment b, ghost segments, amber decimal point): one geometry, colours on dark / on light; `BrandMark` follows the skin (`--kit-brand-*`) or takes fixed colours (website). `node scripts/logo/build.mjs` writes `docs/static/logo/*.svg`, `frontend/public/favicon.svg` and the app icons (`crates/benchmesh-app/icons`, via Inkscape + `cargo tauri icon`); a test fails when they are stale |
+| `about/` | top-bar version (`GET /version`, `version.ts`) and the **Feedback** drawer (`AboutView.tsx`: version, Copy version, GitHub issues links). External pages open by name (`links.tsx`): in the desktop app the system browser via the `open_page` command (fixed list, `crates/benchmesh-app/src/links.rs`, capability `links.json`), in a browser a new tab |
 | `automation/` | Automation drawer (top bar **Automation**, contract `ai_context/AUTOMATION.md`): saved flows (new, duplicate, delete, import/export JSON), flow editor (parameter form, Setup / Steps / Cleanup step cards with vocabulary pickers, live validation shown at each step's path, JSON view; pure document model `flowModel.ts`), run panel (arm dialog for energising flows, live log, variables, prompt Continue, Abort / Escape), assistant (user's own LLM key, result loaded as unsaved), settings tab (provider, key - only its hint is ever shown, model, base URL; MCP access + connection snippets). `RunProvider.tsx` polls `/automation/run` for the whole UI: top-bar `▶ flow - state` + red **Stop** while a run is active |
 
 Panel **window controls** (header, top right): fold to the header line (saved with the layout;
@@ -182,16 +183,27 @@ allow keep-on-top; `BENCHMESH_NATIVE_WAYLAND=1` opts out.
 
 **Instrument console** (panel header, console icon): an optional pane at the bottom of the panel
 showing what is sent to (→) and received from (←) the instrument, plus port events (•), from
-`GET /devices/{id}/wire?after=<seq>` (per-device ring of 2000 entries, `bm_driver::wirelog`;
-reply chunks joined in the UI). Auto / Text / Hex view, pause, clear, and **Copy**: paste-ready
-evidence with instrument, model, identify reply, link and app version (`bench/wire.ts`,
-`bench/WireConsole.tsx`). Open state per panel in `localStorage` `benchmesh:consoles`.
+`GET /devices/{id}/wire?after=<seq>&limit=<n>` (per-device ring of 50 000 entries / 8 MiB, about
+19 minutes of a polled oscilloscope and longer for meters, `bm_driver::wirelog`; reply chunks
+joined in the UI, which shows the last 5000 lines). Auto / Text / Hex view, pause, clear, **Copy**:
+paste-ready evidence with instrument, model, identify reply, link and app version, and **Save**:
+the same for everything the server kept, as a text file (`bench/wire.ts`, `bench/WireConsole.tsx`).
+Transports add their own events as info lines (`Transport::take_notes`), e.g. a USBTMC recovery:
+a write that times out or stalls gets abort bulk-out/in, clear halts and a device clear, then one
+more try, else an error telling the user to replug (`bm-transport` usbtmc.rs, usbtmc_proto.rs). Open state per panel in `localStorage` `benchmesh:consoles`.
 
 Every control that changes the instrument waits for **confirmation**: after the request is sent it
 pulses discreetly until the instrument's reported value (registry status, or a read-back for
 setpoints) equals the requested one, and shows a small red dot if that does not happen within 6 s
 (`kit/confirm.ts`). Pass the reported value, never a locally assumed one.
 
+Drawer pages of text and controls use the shared page standard in `bench/bench.css`: content in
+`.bench-page` (16 px inset, 14 px rhythm, `.bench-hint` text), boxes in `.bench-group`, rows in
+`.bench-group__row` (About and feedback, Metrics, Remote access); `e2e/about-feedback.spec.ts` fails when a
+drawer's content comes closer than 8 px to the drawer's sides. Buttons are kit buttons (`bench-btn`, `--primary` for
+the main action, `--danger` for removal, `--icon` for a glyph), fields the kit field (`kit-field`, `kit-label`,
+`kit-input`); the Instruments form styles its fields with the same tokens.
+
 Adding a class panel: write `bench/panels/<Cls>Panel.tsx` from kit components, a `<cls>Profile()`
 in `profiles.ts` (with tests against `bench/__tests__/bench-fixtures.json`, captured from the
 simulated bench), and dispatch it in `InstrumentPanel.tsx`.

ai_context/migration/device-notes/rigol_dho800.md

@@ -58,5 +58,19 @@ measurement" (e.g. FREQ on a flat line) → status null.
   device clear did not help, and the scope **dropped off USB and came back ≈ 50 s later**
   (re-enumerated; settings intact). Operation disabled in the definition. Next step: the userspace
   USBTMC transport (`nusb`, same item as the DGE screenshot) with proper multi-transfer reads.
+- **USB lockup during normal use** (2026-10-21, kernel usbtmc, app polling the panel): twice in
+  ten minutes a read request timed out (`usbtmc 1-2:1.0: send_request_dev_dep_msg_in returned
+  -110`), after which every write timed out (`Unable to send data, error -110`) until the cable
+  was replugged; the scope did not drop off USB by itself. The trigger is not known yet (the wire
+  log then kept only 46 s). Since then the transport runs one USB recovery when a write times out
+  or stalls (abort bulk-out/in, clear halts, device clear; `bm-transport` usbtmc.rs and
+  usbtmc_proto.rs), the wire log keeps about 19 minutes of this scope, and the console's Save
+  writes it to a file. Bench result the same night (a third lockup, caused by a development
+  rebuild killing the app mid-exchange): the recovery made the scope take commands again
+  (abort bulk-out answered "not in progress", clear halts and device clear ok) but it never
+  replied; it then dropped off USB and failed to enumerate (-71). After a cable replug it
+  answered with stale bTags and then not at all - the scope powers its own USB side, so a
+  replug does not reset its firmware. Only switching the scope off and on brought it back.
+  The recovery stays (cheap, may help lighter stalls); the cure is not to interrupt sessions.
 - Edge trigger only (other trigger types not modelled). Digital channels (D0-D15), math, decoders,
   memory depth and RAW/MAXimum waveform reads are not modelled.

crates/benchmesh-app/build.rs

@@ -1,6 +1,6 @@
 fn main() {
-    // The app's own commands (update.rs) get permissions, so a capability can grant them to the
+    // The app's own commands (update.rs, links.rs) get permissions, so a capability can grant them to the
     // UI, which is served by the embedded server (a remote origin to Tauri).
-    let manifest = tauri_build::AppManifest::new().commands(&["update_check", "update_install", "update_open_page"]);
+    let manifest = tauri_build::AppManifest::new().commands(&["update_check", "update_install", "update_open_page", "open_page"]);
     tauri_build::try_build(tauri_build::Attributes::new().app_manifest(manifest)).expect("failed to run tauri-build");
 }

crates/benchmesh-app/capabilities/links.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "links",
+  "description": "The UI (served by the embedded server on 127.0.0.1) opens the feedback and releases pages in the system browser by name (src/links.rs).",
+  "windows": ["main", "panel-*"],
+  "remote": { "urls": ["http://127.0.0.1:*", "http://localhost:*"] },
+  "permissions": ["allow-open-page"]
+}

crates/benchmesh-app/src/links.rs

@@ -0,0 +1,44 @@
+//! Web pages the UI opens in the system browser (the webview does not follow external links).
+//! A fixed list: the UI is served over HTTP, so it names a page and never passes a URL.
+
+pub const RELEASES: &str = "https://github.com/MarkoVcode/BenchMesh/releases/latest";
+const PAGES: [(&str, &str); 3] = [
+    ("issues", "https://github.com/MarkoVcode/BenchMesh/issues"),
+    ("new-issue", "https://github.com/MarkoVcode/BenchMesh/issues/new"),
+    ("releases", RELEASES),
+];
+
+pub fn url_of(page: &str) -> Option<&'static str> {
+    PAGES.iter().find(|(name, _)| *name == page).map(|(_, url)| *url)
+}
+
+/// Open `url` with the system's default browser.
+pub fn open(url: &str) -> std::io::Result<()> {
+    #[cfg(target_os = "linux")]
+    let child = std::process::Command::new("xdg-open").arg(url).spawn();
+    #[cfg(target_os = "macos")]
+    let child = std::process::Command::new("open").arg(url).spawn();
+    #[cfg(windows)]
+    let child = std::process::Command::new("cmd").args(["/C", "start", "", url]).spawn();
+    child.map(|_| ())
+}
+
+/// Open one of the known pages (`issues`, `new-issue`, `releases`).
+#[tauri::command]
+pub fn open_page(page: String) -> Result<(), String> {
+    let url = url_of(&page).ok_or_else(|| format!("unknown page {page:?}"))?;
+    open(url).map_err(|e| format!("could not start the browser: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::url_of;
+
+    #[test]
+    fn only_known_pages_open() {
+        assert_eq!(url_of("new-issue"), Some("https://github.com/MarkoVcode/BenchMesh/issues/new"));
+        assert!(url_of("issues").unwrap().ends_with("/issues"));
+        assert_eq!(url_of("https://example.com"), None);
+        assert_eq!(url_of(""), None);
+    }
+}

crates/benchmesh-app/src/main.rs

@@ -14,7 +14,8 @@
 //!   by the UI; capability `capabilities/panels.json`). Closing the main window closes them too.
 //! - Linux/Wayland: windows cannot ask to stay on top under Wayland, so the app runs through
 //!   XWayland (`GDK_BACKEND=x11`) unless `BENCHMESH_NATIVE_WAYLAND=1`.
-//! - Updates: one check per start, offered by the UI (`update.rs`).
+//! - Updates: one check per start, offered by the UI (`update.rs`). Feedback / releases pages
+//!   open in the system browser by name (`links.rs`, capability `capabilities/links.json`).
 //! - Windows: the UI's "Install driver" (USBTMC instruments) starts this executable again
 //!   elevated with `--install-winusb` (`bm_transport::winusb`); `main` hands that run over first.
 //! - `benchmesh --mcp`: no window - a stdio bridge to the running app's MCP endpoint for AI
@@ -29,6 +30,7 @@ use std::time::Duration;
 use bm_server::run::{start, RunningServer, ServerOptions};
 use tauri::{Manager, RunEvent, WebviewUrl, WebviewWindowBuilder, WindowEvent};
 
+mod links;
 mod update;
 
 struct Server(Mutex<Option<RunningServer>>);
@@ -104,7 +106,7 @@ fn main() {
     let app = tauri::Builder::default()
         .plugin(tauri_plugin_updater::Builder::new().build())
         .manage(update::PendingState::default())
-        .invoke_handler(tauri::generate_handler![update::update_check, update::update_install, update::update_open_page])
+        .invoke_handler(tauri::generate_handler![update::update_check, update::update_install, update::update_open_page, links::open_page])
         // the main window owns the app: closing it closes detached instrument windows too
         .on_window_event(|window, event| {
             if window.label() == "main" && matches!(event, WindowEvent::Destroyed) {

crates/benchmesh-app/src/update.rs

@@ -14,8 +14,6 @@ use serde::Serialize;
 use tauri::{AppHandle, Emitter, Manager, State};
 use tauri_plugin_updater::{Update, UpdaterExt};
 
-const RELEASES_PAGE: &str = "https://github.com/MarkoVcode/BenchMesh/releases/latest";
-
 /// Download progress for the UI (`downloaded` bytes of `total`, absent when unknown).
 const PROGRESS_EVENT: &str = "update://progress";
 
@@ -112,12 +110,7 @@ pub async fn update_install(app: AppHandle, pending: State<'_, PendingState>) ->
 /// Open the releases page in the system browser.
 #[tauri::command]
 pub fn update_open_page() {
-    #[cfg(target_os = "linux")]
-    let _ = std::process::Command::new("xdg-open").arg(RELEASES_PAGE).spawn();
-    #[cfg(target_os = "macos")]
-    let _ = std::process::Command::new("open").arg(RELEASES_PAGE).spawn();
-    #[cfg(windows)]
-    let _ = std::process::Command::new("cmd").args(["/C", "start", "", RELEASES_PAGE]).spawn();
+    let _ = crate::links::open(crate::links::RELEASES);
 }
 
 #[cfg(test)]

crates/bm-driver/src/engine.rs

@@ -26,6 +26,11 @@ pub trait Transport: Send {
     /// Bytes that arrived within `timeout`; empty = nothing arrived. Message-based
     /// transports (USBTMC) return exactly one device message per call.
     fn read(&mut self, timeout: Duration) -> std::io::Result<Vec<u8>>;
+    /// What the transport did on its own since the last call (a USB recovery, say), for the
+    /// instrument's wire log.
+    fn take_notes(&mut self) -> Vec<String> {
+        Vec::new()
+    }
 }
 
 /// Result of an operation.