Give the window an outputs row, and something to send with

§5.9's last unbuilt row, and the one Phase 5's exit criterion turns on: "a new user
can go from launch to synced output without documentation, a text editor, or a
restart". Until now the window could watch a tempo perfectly and nothing left the
machine — Link, OSC and MIDI clock existed only in takt4-cli.

The window owns §4.2's output thread now, so **it stopped draining the beat ring**.
`rt::SpscRing` allows one consumer; with two, the window and the runner would take
half the beats each and the transports would send every other one. `tick()` drains
frames, which is a different ring with a different consumer — §5.9's trace.

The ordering §4.3 needs has moved into `LiveTracker` rather than staying a rule for
callers to remember. The host time stamp is taken on the audio thread, so the clock
has to be installed before the stream is opened; `setHostTimeSource` now hands the
tracker a clock and `start()` installs it at the right moment. It also resets the
regression there, which nothing did before and nothing needed to: the console opens
one stream and exits, but a window opens a new one every time Start is pressed, and
a regression fitted to the last run maps a sample counter that has restarted at zero
to a time long past. `HostTimeSource` grew `resetHostTimeFilter` as a default no-op
for that — a restarted sample clock is the interface's business, not Link's alone.

The row itself is the sketch: Link with its peer count, an OSC target field, a MIDI
port picker, and what has actually been sent. The tick and the reading are
deliberately different things — a box says what the operator asked for, the peer
count and the beat counter say what is happening, and "on, with nobody at the other
end" is exactly the failure somebody needs to see at a gig. The MIDI picker's first
entry is empty, so switching the clock off is a choice in the same list rather than
a second control.

Two small decisions in the OSC field. It applies on Enter rather than on every
keystroke, because `edited` fires per character and each one would tear the sockets
down and rebuild them halfway through an address. And a part that will not parse is
named on the status line while the rest are still applied: an operator typing a
second address must not lose the first one that was working. Commas separate, since
the window offers a single line.

Seven tests. Two hold `LiveTracker` to the §4.3 ordering with a fake `HostTimeSource`
— that the clock is not touched before a run, that it is forgotten *before* the
stream rather than after, and that a second run forgets the first. Five drive the
row: that the window comes up sending nothing, that the Link tick reaches the
transports without putting takt4 in front of peers before Start, that a bad OSC entry
keeps the good ones, that a MIDI port which will not open is said out loud, and —
with a real device — that nothing is dropped, which is what proves exactly one
consumer is draining that ring.

176 tests with the UI off, 197 with it on. The excerpt still ends "499 frames, 21
beats (5 downbeats), ending at 127.7 BPM in 4/4, locked".

Author: Fohdeesha

src/core/audio/host_time.hpp

@@ -27,6 +27,14 @@ class HostTimeSource {
     /// source promises to call it from exactly one thread.
     virtual std::int64_t hostMicrosForSample(double sampleTime) noexcept = 0;
 
+    /// Forgets whatever was learned from the sample clock so far.
+    ///
+    /// A restarted stream counts from zero again, and a regression fitted to the previous
+    /// run maps that to a time long past — so whoever opens a stream calls this first.
+    /// `engine::LiveTracker::start` does. The default does nothing, for a source with no
+    /// state to forget.
+    virtual void resetHostTimeFilter() noexcept {}
+
 protected:
     HostTimeSource() = default;
     HostTimeSource(const HostTimeSource&) = default;

src/core/engine/live_tracker.cpp

@@ -43,6 +43,13 @@ void LiveTracker::start(const audio::InputDevice& device,
     // driver that will not give up the interface (PortAudioError, HANDOFF R2).
     auto stream =
         std::make_unique<audio::InputStream>(session_, device, selection, fanout_, options_.stream);
+    // §4.3's stamp is taken on the audio thread, so the clock has to be in place before
+    // there is one. A restarted stream begins its sample counter again, and the filter's
+    // regression is fitted to the old one, so it is forgotten with the run it belonged to.
+    if (hostTime_ != nullptr) {
+        hostTime_->resetHostTimeFilter();
+    }
+    engine_->setHostTimeSource(hostTime_);
     // Before the stream, so the workers are draining by the time the first hop lands.
     engine_->start();
     try {

src/core/engine/live_tracker.hpp

@@ -62,6 +62,17 @@ class LiveTracker {
     LiveTracker(const LiveTracker&) = delete;
     LiveTracker& operator=(const LiveTracker&) = delete;
 
+    /// The clock that stamps each hop with the host time its audio arrived at (§4.3), or
+    /// null for none. Ableton Link is the one that exists; `output::OutputRunner` hands
+    /// its session over as `hostTimeClock()`.
+    ///
+    /// Set it once, on a tracker that is stopped, and leave it: `start()` installs it
+    /// before the stream is opened and `stop()` clears it afterwards, which is the
+    /// ordering §4.3 requires and the reason this is here rather than left to a caller
+    /// to remember. It must outlive every run it is set for.
+    void setHostTimeSource(audio::HostTimeSource* source) noexcept { hostTime_ = source; }
+    audio::HostTimeSource* hostTimeSource() const noexcept { return hostTime_; }
+
     /// Every input device PortAudio can see, freshly enumerated each call — a device list
     /// goes stale the moment somebody plugs something in. The indices in it are only
     /// meaningful while this object lives.
@@ -112,6 +123,8 @@ class LiveTracker {
     audio::HopMeter meter_;
     /// The tracker first: a late meter is a late meter, a late tracker is a dropout.
     audio::HopFanout fanout_;
+    /// Not owned, and null unless a caller supplied one. See `setHostTimeSource`.
+    audio::HostTimeSource* hostTime_ = nullptr;
     /// Declared after everything it points at, so it is destroyed before them.
     std::unique_ptr<audio::InputStream> stream_;
     std::optional<Running> current_;

src/core/output/link_session.hpp

@@ -50,7 +50,7 @@ class LinkSession final : public audio::HostTimeSource {
     /// **Audio thread.** HANDOFF §4.3's regression; see HostTimeSource.
     std::int64_t hostMicrosForSample(double sampleTime) noexcept override;
     /// Forgets the regression, for a stream that has been restarted.
-    void resetHostTimeFilter() noexcept;
+    void resetHostTimeFilter() noexcept override;
 
     /// Publishes the tracker's tempo, effective at `at`.
     void setTempo(double bpm, std::chrono::microseconds at);

src/ui/main_window.slint

@@ -18,7 +18,7 @@
 // Nothing in this file assumes a meter of four. `beats-per-bar` comes from the particle
 // filter's downbeat stage and the bar indicator is drawn from it, as §5.5 requires.
 
-import { CheckBox, ComboBox, Palette, Slider } from "std-widgets.slint";
+import { CheckBox, ComboBox, LineEdit, Palette, Slider } from "std-widgets.slint";
 
 /// One 50 Hz frame of the activation trace. The network's two probabilities, and
 /// whether the tracker actually called a beat on this frame — which is the difference
@@ -277,6 +277,19 @@ export component MainWindow inherits Window {
   in-out property <float> input-peak;
   in-out property <string> input-reading;
 
+  // --- §5.9's OUTPUTS row --------------------------------------------------------
+  // What is being sent, and what it is being sent to. `*-on` is what the operator
+  // asked for; `link-peers` and `beats-sent` are what actually happened, which is the
+  // difference between a tick box and a working rig.
+  in-out property <bool> link-on;
+  in-out property <int> link-peers;
+  in-out property <bool> osc-on;
+  in-out property <string> osc-targets;   // one host:port per line
+  in-out property <bool> midi-on;
+  in-out property <string> midi-port;
+  in-out property <[string]> midi-ports;
+  in-out property <int> beats-sent;
+
   in-out property <string> status;
   in-out property <bool> status-is-error;
 
@@ -295,6 +308,10 @@ export component MainWindow inherits Window {
   callback fold-max-changed(float);
   callback latency-changed(float);
 
+  callback link-toggled(bool);
+  callback osc-targets-edited(string);
+  callback midi-port-picked(string);
+
   VerticalLayout {
     padding: 0;
     spacing: 0;
@@ -763,6 +780,113 @@ export component MainWindow inherits Window {
       vertical-stretch: 0;
     }
 
+    // --- §5.9's OUTPUTS row ---------------------------------------------------------
+    // "Link ✓ · OSC 192.168.1.40:7000 ✓ · MIDI clock ✓", and settable rather than only
+    // shown: Phase 5's exit is a new user going from launch to synced output without a
+    // text editor or a restart, so this is where that happens.
+    //
+    // The tick and the reading are deliberately different things. A box says what the
+    // operator asked for; the peer count and the beat counter say what is actually
+    // happening, and an output that is on with nothing at the other end is exactly the
+    // failure somebody needs to see at a gig.
+    Rectangle {
+      background: Theme.panel;
+      vertical-stretch: 0;
+
+      HorizontalLayout {
+        padding-left: 24px;
+        padding-right: 24px;
+        padding-top: 12px;
+        padding-bottom: 12px;
+        spacing: 10px;
+
+        Text {
+          text: "outputs";
+          color: Theme.dim;
+          font-size: 12px;
+          width: 74px;
+          vertical-alignment: center;
+        }
+
+        CheckBox {
+          text: "Link";
+          checked <=> root.link-on;
+          width: 74px;
+          toggled => {
+            root.link-toggled(self.checked);
+          }
+        }
+
+        Text {
+          // Peers are the whole point of Link, and "on with nobody there" is the state
+          // worth being able to see.
+          text: !root.link-on ? ""
+            : root.link-peers == 0 ? "no peers"
+            : root.link-peers == 1 ? "1 peer"
+            : root.link-peers + " peers";
+          color: root.link-peers > 0 ? Theme.locked : Theme.dim;
+          font-size: 12px;
+          width: 72px;
+          vertical-alignment: center;
+        }
+
+        Text {
+          text: "OSC";
+          color: root.osc-on ? Theme.text : Theme.dim;
+          font-size: 12px;
+          width: 32px;
+          vertical-alignment: center;
+        }
+
+        osc-field := LineEdit {
+          text <=> root.osc-targets;
+          placeholder-text: "host:port — Enter to apply";
+          font-size: 12px;
+          horizontal-stretch: 1;
+          // `accepted`, not `edited`: `edited` fires on every keystroke, and each one
+          // would tear the sockets down and build them again halfway through an address.
+          accepted(text) => {
+            root.osc-targets-edited(text);
+          }
+        }
+
+        Text {
+          text: "MIDI clock";
+          color: root.midi-on ? Theme.text : Theme.dim;
+          font-size: 12px;
+          width: 72px;
+          vertical-alignment: center;
+        }
+
+        midi-picker := ComboBox {
+          model: root.midi-ports;
+          current-value <=> root.midi-port;
+          horizontal-stretch: 1;
+          selected => {
+            root.midi-port-picked(self.current-value);
+          }
+        }
+
+        Text {
+          // What has actually gone out. Nothing else on screen distinguishes a transport
+          // that is configured from one that is working.
+          text: root.beats-sent > 0 ? root.beats-sent + " beats sent" : "";
+          color: Theme.dim;
+          font-size: 12px;
+          font-family: "Consolas";
+          width: 104px;
+          horizontal-alignment: right;
+          vertical-alignment: center;
+        }
+      }
+    }
+
+    Rectangle {
+      height: 1px;
+      background: Theme.line;
+      vertical-stretch: 0;
+    }
+
     // --- the status line ------------------------------------------------------------
     Rectangle {
       background: Theme.panel;

src/ui/shot.cpp

@@ -22,6 +22,7 @@
 #include "core/engine/beat_engine.hpp"
 #include "core/io/wav_file.hpp"
 #include "core/model/weights.hpp"
+#include "core/output/midi_ports.hpp"
 #include "core/tracking/state_space.hpp"
 #include "core/tracking/tempo_tracker.hpp"
 #include "ui/app.hpp"
@@ -223,11 +224,29 @@ int renderShot(const std::filesystem::path& out, const ShotOptions& options) {
     publishControlLimits(*window);
     window->set_tap_needs(3);
     fillPickers(*window);
+
+    // The machine's real MIDI outputs, as the window offers them; the empty first entry
+    // is "none", exactly as WindowController builds it.
+    auto midiPorts = std::make_shared<slint::VectorModel<slint::SharedString>>();
+    midiPorts->push_back(slint::SharedString(""));
+    for (const std::string& port : output::listMidiOutputPorts()) {
+        midiPorts->push_back(slint::SharedString(port));
+    }
+    window->set_midi_ports(midiPorts);
     auto traceModel =
         std::make_shared<slint::VectorModel<TracePoint>>(std::vector<TracePoint>(kTraceLength));
     window->set_trace(traceModel);
     if (options.running) {
         fillFromSyntheticRun(*window, traceModel);
+        // §5.9's own example row, so the picture shows what a configured rig looks like
+        // rather than an empty one. There is no output thread behind a shot, so these are
+        // illustrative in the way the status line below already is; the beat count is the
+        // excerpt's real 21.
+        window->set_link_on(true);
+        window->set_link_peers(2);
+        window->set_osc_on(true);
+        window->set_osc_targets(slint::SharedString("192.168.1.40:7000"));
+        window->set_beats_sent(21);
         window->set_status(slint::SharedString(
             "In 7 of MOTU Pro Audio  ·  48000 Hz -> 22050 Hz  ·  native pick  ·  "
             "latency 12.0 ms input + 16.4 ms resampler + 40.0 ms centred framing"));