ui: a signal's details sit directly under its name; its unit is user-changeable and saved with the session

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

src/model.cpp

@@ -232,6 +232,13 @@ void ScopeModel::set_signals(std::vector<SignalInfo> signals) {
   signals.erase(std::remove_if(signals.begin(), signals.end(),
                                [](const SignalInfo& s) { return s.math; }),
                 signals.end());
+  // The renames come off the stream's own units first, so that an identical CONFIG still compares
+  // equal against `signals_` (which holds the renamed ones) and a reconnect keeps its history.
+  declared_unit_.clear();
+  for (SignalInfo& s : signals) {
+    declared_unit_[s.name] = s.unit;
+    if (const auto it = unit_override_.find(s.name); it != unit_override_.end()) s.unit = it->second;
+  }
   if (!signals_.empty() && same_stream_signals(signals, signals_)) {
     // A reconnect's identical CONFIG: the honest recovery is *nothing* -- the ring keeps
     // its history, the trigger keeps its state and its held event, and the outage shows
@@ -770,6 +777,38 @@ void ScopeModel::set_calibration(std::size_t signal, double gain, double offset)
   }
 }
 
+void ScopeModel::set_signal_unit(std::size_t signal, const std::string& unit) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (signal >= signals_.size() || signals_[signal].math) return;
+  const std::string name = signals_[signal].name;
+  std::string shown = unit;
+  if (unit.empty()) {
+    unit_override_.erase(name);
+    const auto it = declared_unit_.find(name);
+    shown = it != declared_unit_.end() ? it->second : std::string();
+  } else {
+    unit_override_[name] = unit;
+  }
+  if (signals_[signal].unit == shown) return;
+  signals_[signal].unit = shown;
+  for (ChannelInfo& c : channels_) {
+    if (c.signal == signal) c.unit = shown;
+  }
+  generation_.fetch_add(1, std::memory_order_release);
+}
+
+std::string ScopeModel::declared_unit(std::size_t signal) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (signal >= signals_.size()) return std::string();
+  const auto it = declared_unit_.find(signals_[signal].name);
+  return it != declared_unit_.end() ? it->second : signals_[signal].unit;
+}
+
+std::vector<std::pair<std::string, std::string>> ScopeModel::unit_overrides() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return {unit_override_.begin(), unit_override_.end()};
+}
+
 double ScopeModel::channel_dt(std::size_t channel) const {
   return channel < channels_.size() ? channels_[channel].dt : 0.0;
 }