diff --git a/info-kit.html b/info-kit.html
index 51c6e7b..c8e2566 100644
--- a/info-kit.html
+++ b/info-kit.html
@@ -4,7 +4,7 @@
 <meta charset="UTF-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <title>VARASYS PM_K‑1 Kit — wiring, parts &amp; firmware (Raspberry Pi Pico build)</title>
-<meta name="description" content="PM_K‑1 Kit — build a touchscreen polymeter metronome from a Raspberry Pi Pico on the 52Pi EP‑0172 breadboard kit (3.5in ST7796 cap‑touch, joystick, RGB, buzzer). Pinout, parts list, and the precompiled CircuitPython firmware bundle." />
+<meta name="description" content="PM_K‑1 Kit — build a touchscreen polymeter metronome from a Raspberry Pi Pico on the 52Pi EP‑0172 breadboard kit (3.5in ST7796 cap‑touch, joystick, RGB, speaker). Pinout, parts list, and the precompiled CircuitPython firmware bundle." />
 <link rel="icon" type="image/svg+xml" href="data:image/svg+xml;base64,@BUILD:favicon@">
 <script>
   (function(){ try{ var p = localStorage.getItem("metronome.theme");
@@ -51,12 +51,12 @@
   <p>This is the first member of the family you can actually build today from off‑the‑shelf parts: a
     <b>Raspberry Pi Pico</b> seated on the <b>52Pi EP‑0172 "Pico Breadboard Kit Plus"</b>, which carries a
     3.5″ <b>ST7796</b> 320×480 capacitive‑touch screen (<b>GT911</b>), a PSP <b>joystick</b>, a <b>WS2812 RGB</b>
-    LED, a <b>buzzer</b> and two buttons — all pre‑wired, so you don't solder anything; you just seat the Pico
+    LED, a <b>speaker</b> and two buttons — all pre‑wired, so you don't solder anything; you just seat the Pico
     and drop the firmware bundle onto its USB drive.</p>
   <p>It runs the same <b>polymeter engine</b> and the same <b>program strings</b> as the web editor: design a
     groove on the site and <b>Save to device</b> over USB‑MIDI (or edit on the device's touchscreen — beats,
     lanes, playlists), and it plays standalone. Tap the screen, nudge tempo with the joystick; the RGB shows
-    run/stop and the beat pulse, and the buzzer clicks. Powered over the Pico's USB.</p>
+    run/stop and the beat pulse, and the speaker clicks. Powered over the Pico's USB.</p>
 </section>
 
 <details class="spec" open>
@@ -75,7 +75,7 @@
         <tr><td class="part">PSP joystick X / Y</td><td>ADC0 (GP26) / ADC1 (GP27)</td></tr>
         <tr><td class="part">Button A (play/stop) / Button B (tap)</td><td>GP15 / GP14</td></tr>
         <tr><td class="part">WS2812 RGB LED</td><td>GP12</td></tr>
-        <tr><td class="part">Buzzer</td><td>GP13</td></tr>
+        <tr><td class="part">Speaker</td><td>GP13</td></tr>
       </tbody>
     </table>
   </div>
@@ -89,7 +89,7 @@
       <thead><tr><th>Part</th><th class="q">Qty</th><th class="c">~$</th></tr></thead>
       <tbody>
         <tr><td class="part">Raspberry Pi Pico (or Pico W / Pico 2) <span class="spec">— the brain</span></td><td class="q">1</td><td class="c">5</td></tr>
-        <tr><td class="part">52Pi EP‑0172 "Pico Breadboard Kit Plus" <span class="spec">— 3.5″ ST7796 cap‑touch, GT911, PSP joystick, WS2812 RGB, buzzer, 2 buttons, breadboard, acrylic panel</span></td><td class="q">1</td><td class="c">38</td></tr>
+        <tr><td class="part">52Pi EP‑0172 "Pico Breadboard Kit Plus" <span class="spec">— 3.5″ ST7796 cap‑touch, GT911, PSP joystick, WS2812 RGB, speaker, 2 buttons, breadboard, acrylic panel</span></td><td class="q">1</td><td class="c">38</td></tr>
         <tr><td class="part">USB cable <span class="spec">— power + flashing</span></td><td class="q">1</td><td class="c">2</td></tr>
         <tr class="total"><td>Total (one‑off)</td><td class="q"></td><td class="c">≈ $45</td></tr>
       </tbody>
@@ -120,7 +120,7 @@
         then the set‑list <b>⋯</b> menu → <b>📟 Save to device</b>. It's pushed over USB‑MIDI and the device shows
         <b>Saved ✓</b>. (Fallback for any browser: it downloads <code>programs.json</code> — boot holding A and drag it on.)</li>
       <li><b>Play through your computer:</b> click <b>🎹 Device audio</b>, then press play on the device — the full
-        groove sounds through your speakers over USB‑MIDI, in sync; the screen shows a <b>MIDI</b> badge and the buzzer mutes.</li>
+        groove sounds through your speakers over USB‑MIDI, in sync; the screen shows a <b>MIDI</b> badge and the speaker mutes.</li>
       <li><b>Practice log:</b> plays over 5 s appear at the bottom of the screen (time · BPM · duration · track); tap a row twice to delete.</li>
       <li><b>Firmware updates:</b> ⋯ menu → <b>⬆ Update firmware</b> — it checks your version, pushes the latest over USB‑MIDI, and the device A/B‑updates with automatic rollback if a build won't boot.</li>
     </ol>
diff --git a/pico-cp/README.md b/pico-cp/README.md
index 6a48cd1..55eb6dc 100644
--- a/pico-cp/README.md
+++ b/pico-cp/README.md
@@ -6,7 +6,7 @@ It runs the same program‑string language as <https://metronome.varasys.io>. Th
 bricked (BOOTSEL → drag a MicroPython `.uf2` back).
 
 What it does: drives the 3.5″ touchscreen with a lanes/pads display + anti‑aliased text, plays the
-buzzer + RGB beat light, **logs your practice to `/history.json`**, accepts new set lists **pushed
+speaker + RGB beat light, **logs your practice to `/history.json`**, accepts new set lists **pushed
 from the web editor over USB‑MIDI**, and plays through your **computer's speakers** over USB‑MIDI.
 
 ## Two power‑on modes (set by `boot.py`)
@@ -58,7 +58,7 @@ rare. And the Pico is unbrickable as the ultimate backstop.)
 The Pico is a USB‑MIDI device and sends a note per click (GM drum note per lane, velocity by accent).
 In the editor click **🎹 Device audio**, grant MIDI access, and press play *on the device* — the editor
 voices the groove through its full synth, out your speakers, locked to the device's clock. While a host is
-listening the screen shows a green **MIDI** badge and the **buzzer auto‑mutes** (the computer plays instead).
+listening the screen shows a green **MIDI** badge and the **speaker auto‑mutes** (the computer plays instead).
 The editor also syncs the device clock, so the practice log gets real wall‑clock timestamps.
 
 ## Playlists, editing & Continue
@@ -88,7 +88,7 @@ The editor also syncs the device clock, so the practice log gets real wall‑clo
 - The firmware **performs** ramps (tempo steps every N bars) and gap-trainer cycles (silent rest bars).
 - **Touchscreen:** the bottom shows the **practice log for the current track** (time · BPM · duration · bars)
   — newest first. Plays under 5 s aren't logged. **Tap a row to arm it (turns amber), tap again to delete.**
-- **RGB LED** flashes the beat (amber accent / cyan normal / violet ghost); the **buzzer** clicks to match.
+- **RGB LED** flashes the beat (amber accent / cyan normal / violet ghost); the **speaker** clicks to match.
 - The log is saved to `/history.json` (next to `programs.json`) in appliance mode and survives power‑cycles.
 
 ## programs.json
@@ -108,7 +108,7 @@ Each `prog` is a program string from the editor (tempo, lanes, patterns, `/2` su
 - **Taps land wrong:** set `TOUCH_DEBUG = True`, read the raw coords over USB serial, then set
   `TOUCH_SWAP_XY` / `TOUCH_INVERT_X` / `TOUCH_INVERT_Y`.
 - **Joystick reversed:** toggle `JOY_INVERT_X` / `JOY_INVERT_Y`.
-- **Computer audio:** `MIDI_ENABLED` (default on); `MUTE_BUZZER` forces the buzzer off even standalone.
+- **Computer audio:** `MIDI_ENABLED` (default on); `MUTE_SPEAKER` forces the speaker off even standalone.
 - **LED too bright/dim:** `LED_BRIGHTNESS` (0..1, default 0.15).
 - **Screen tearing:** SPI panels have no tearing‑effect sync; `SPI_BAUD` (default 62.5 MHz) is pushed fast
   to minimise it — lower only if unstable.
diff --git a/pico-cp/__pycache__/app.cpython-312.pyc b/pico-cp/__pycache__/app.cpython-312.pyc
index 3b89247..191ef5e 100644
Binary files a/pico-cp/__pycache__/app.cpython-312.pyc and b/pico-cp/__pycache__/app.cpython-312.pyc differ
diff --git a/pico-cp/app.py b/pico-cp/app.py
index b0a258a..7d51def 100644
--- a/pico-cp/app.py
+++ b/pico-cp/app.py
@@ -1,6 +1,6 @@
 # VARASYS PolyMeter - PM_K-1 "Kit" firmware (CircuitPython edition)
 # Raspberry Pi Pico (Pico / Pico W / Pico 2) on the 52Pi EP-0172 "Pico Breadboard Kit Plus":
-#   3.5" ST7796 320x480 cap-touch (GT911), PSP joystick, WS2812 RGB, buzzer, 2 buttons.
+#   3.5" ST7796 320x480 cap-touch (GT911), PSP joystick, WS2812 RGB, speaker, 2 buttons.
 #
 # WHY CIRCUITPYTHON: the board then mounts as a USB drive (CIRCUITPY) carrying this code, your
 # tracks (programs.json) and a copy of the editor - edit on the web, "Save to device" writes
@@ -18,7 +18,7 @@
 
 import board, busio, digitalio, analogio, pwmio, displayio, vectorio, time, json, gc, os, supervisor
 supervisor.runtime.autoreload = False   # we write our own files (log + pushed programs); never self-restart
-APP_VERSION = "0.0.13"                   # firmware version (the A/B updater pushes/compares this)
+APP_VERSION = "0.0.14"                   # firmware version (the A/B updater pushes/compares this)
 try:
     import rtc                           # set from the editor's clock SysEx so the log has real timestamps
 except ImportError:
@@ -46,7 +46,11 @@ except ImportError:
 SPI_BAUD      = 62_500_000   # faster SPI = smaller tearing window; drop to 40_000_000 if unstable
 LED_BRIGHTNESS = 0.15        # WS2812 sits right next to you - keep it dim (0..1)
 MIDI_ENABLED  = True         # send a USB-MIDI note per click (play via the web editor's "Device audio")
-MUTE_BUZZER   = False        # silence the on-board buzzer (e.g. when using computer audio)
+MIDI_CHANNEL  = 10           # 1..16 - GM channel 10 is the drum channel (what DAWs auto-route to drums)
+MIDI_CLOCK_OUT          = False  # send 24 PPQN MIDI Clock so a DAW can slave its tempo to the metronome
+MIDI_CLOCK_OUT_TRANSPORT = True  # also send Start (0xFA) / Stop (0xFC) on play / stop (relevant if MIDI_CLOCK_OUT)
+MUTE_SPEAKER     = False     # always silence the on-board speaker
+SPEAKER_AUTO_MUTE = True     # auto-mute the speaker when a MIDI host is listening (computer plays it instead)
 WIDTH, HEIGHT = 320, 480
 MADCTL        = 0x48    # portrait; 0x48 swaps R/B for this BGR panel (cyan reads cyan). Use 0x40 if reversed.
 INVERT_COLORS = True    # most ST7796 modules need inversion ON; set False if colours look negative
@@ -63,7 +67,7 @@ JOY_DEADZONE = 9000
 # ----- pins (fixed by the EP-0172 board) -----
 P_SCK, P_MOSI, P_CS, P_DC, P_RST = board.GP2, board.GP3, board.GP5, board.GP6, board.GP7
 P_SDA, P_SCL = board.GP8, board.GP9
-P_RGB, P_BUZ, P_BTNA, P_BTNB = board.GP12, board.GP13, board.GP15, board.GP14
+P_RGB, P_SPK, P_BTNA, P_BTNB = board.GP12, board.GP13, board.GP15, board.GP14
 P_JOYX, P_JOYY = board.GP26, board.GP27
 
 # ----- BUILT-IN playlists: the standard defaults from the web editor, baked in here so they update with
@@ -405,8 +409,8 @@ class App:
         self._sx = bytearray(); self._sxon = False                 # USB-MIDI SysEx assembler (clock + pushed programs)
         self._fw = None                                            # chunked firmware transfer: staging file handle
         self.led = RGB(P_RGB)
-        self.buz = pwmio.PWMOut(P_BUZ, frequency=1600, variable_frequency=True, duty_cycle=0)
-        self.buz_off = 0
+        self.spk = pwmio.PWMOut(P_SPK, frequency=1600, variable_frequency=True, duty_cycle=0)
+        self.spk_off = 0
         self.btnA = self._btn(P_BTNA); self.btnB = self._btn(P_BTNB)
         self._aPrev = True; self._bPrev = True
         self.jx = analogio.AnalogIn(P_JOYX); self.jy = analogio.AnalogIn(P_JOYY)
@@ -416,6 +420,8 @@ class App:
         self.ramp = None; self.trainer = None; self._lastbar = -1; self._muted = False; self._ramp_base = 120
         self._dirty = False; self._overlay = None; self._ovbtns = []   # on-device editing: unsaved edits + modal
         self.continue_on = False; self._advance = False; self._grid = {}   # auto-advance + pad hit-test geometry
+        self._next_pending = None; self._seam_t = 0; self._need_redraw = False   # gapless seam between tracks
+        self._displayed_bpm = -1; self._clock_next = 0    # lazy BPM redraw + MIDI Clock Out tick scheduler
         self.sl = 0; self.rebuild_setlists()         # built-in playlists (baked) + user playlists (programs.json)
         self.dirty = True
         self.pad_pal = displayio.Palette(8)          # 0-3 idle levels (mute/normal/accent/ghost), 4-7 the lit playhead
@@ -506,6 +512,7 @@ class App:
         self.bpm, self.lanes, self.bars, self.ramp, self.trainer = parse_program(prog)
         self.master = self.lanes[0]; self._ramp_base = self.bpm; self._lastbar = -1; self._muted = False
         self._dirty = False; self._overlay = None     # fresh load -> no unsaved edits
+        self._next_pending = None; self._need_redraw = False    # discard any prepared seam (user navigated away)
         while len(self.g_overlay): self.g_overlay.pop()   # dismiss any open modal
         self._reset_clock(); self.draw_bpm(); self.draw_status(); self.draw_train()
         self.build_grid(); self.draw_log()
@@ -706,9 +713,9 @@ class App:
 
     # ---------- audio + light ----------
     def click(self, level):
-        self.buz.frequency = {2: 2300, 1: 1600, 3: 1050}.get(level, 1600)
-        self.buz.duty_cycle = {2: 42000, 1: 30000, 3: 14000}.get(level, 30000)
-        self.buz_off = time.monotonic_ns() + 22_000_000
+        self.spk.frequency = {2: 2300, 1: 1600, 3: 1050}.get(level, 1600)
+        self.spk.duty_cycle = {2: 42000, 1: 30000, 3: 14000}.get(level, 30000)
+        self.spk_off = time.monotonic_ns() + 22_000_000
     def _led_base(self):
         return LED_RUN if self.running else LED_IDLE   # dim red while playing / dim green when stopped
     def flash(self, level):
@@ -719,14 +726,23 @@ class App:
         self.led.set(*self.rgb)
     def midi_send(self, note, vel):                 # device-as-conductor: a note per click to the computer
         if self.midi is None: return
-        try: self.midi.write(bytes([0x90, note, vel]))   # Note On (percussive - no Note Off needed)
+        try: self.midi.write(bytes([0x90 | ((MIDI_CHANNEL - 1) & 0x0F), note, vel]))   # Note On, channel 1..16
         except Exception: pass
 
     # ---------- transport ----------
     def toggle(self):
         self.running = not self.running
-        if self.running: self._reset_clock(); self._start_play()
-        else: self.buz.duty_cycle = 0; self.reset_playheads(); self._log_play()
+        if self.running:
+            self._reset_clock(); self._start_play()
+            self._clock_next = time.monotonic_ns()         # start MIDI Clock Out from zero
+            if MIDI_CLOCK_OUT and MIDI_CLOCK_OUT_TRANSPORT and self.midi is not None:
+                try: self.midi.write(bytes([0xFA]))         # Start
+                except Exception: pass
+        else:
+            self.spk.duty_cycle = 0; self.reset_playheads(); self._log_play()
+            if MIDI_CLOCK_OUT and MIDI_CLOCK_OUT_TRANSPORT and self.midi is not None:
+                try: self.midi.write(bytes([0xFC]))         # Stop
+                except Exception: pass
         self.led_rest(); self.draw_meters()             # LED shows run state: red running / green stopped
     def set_bpm(self, v):
         v = max(30, min(300, v))
@@ -751,17 +767,25 @@ class App:
     # ---------- scheduler ----------
     def tick(self):
         now = time.monotonic_ns()
-        if self.buz_off and now >= self.buz_off: self.buz.duty_cycle = 0; self.buz_off = 0
+        if self.spk_off and now >= self.spk_off: self.spk.duty_cycle = 0; self.spk_off = 0
         if self.running:
             fired = []
             for li, L in enumerate(self.lanes):
+                if self._advance: break                              # seam armed - skip remaining lanes for THIS tick
                 adv = False
                 while now >= L['next']:
                     L['step'] = (L['step'] + 1) % L['steps']
                     if li == 0:
                         self._m_steps += 1                           # count master-lane steps -> bars
                         nb = self._m_steps // L['steps']
-                        if nb != self._lastbar: self._lastbar = nb; self._on_new_bar(nb)   # ramp + gap-trainer
+                        if nb != self._lastbar: self._lastbar = nb; self._on_new_bar(nb)
+                        if self._advance: break                      # seam armed - suppress this step's firing
+                        if self.ramp and L['steps'] > 0:             # CONTINUOUS ramp: interpolate bpm at every master step
+                            mlen = L['steps']
+                            bar_pos = self._m_steps / mlen
+                            seg_bar = (bar_pos % self.bars) if self.bars else bar_pos
+                            new_bpm = max(30, min(300, int(self._ramp_base + seg_bar / self.ramp['every'] * self.ramp['amt'])))
+                            if new_bpm != self.bpm: self.bpm = new_bpm
                     lvl = 0 if L['mute'] else L['levels'][L['step']]
                     if lvl > 0:
                         fired.append(lvl)
@@ -771,7 +795,8 @@ class App:
                 if adv and li < len(self.lane_pads): self._move_playhead(li, L['step'])
             if fired and not self._muted:
                 best = max(fired, key=lambda l: PRIO.get(l, 0))
-                if not MUTE_BUZZER and not self.midi_host: self.click(best)   # computer plays it instead
+                if not MUTE_SPEAKER and not (SPEAKER_AUTO_MUTE and self.midi_host):
+                    self.click(best)                         # speaker silent if user muted it / auto-mute on + host present
                 self.flash(best)
             base = self._led_base()                       # decay the beat pulse back down to the red running base
             if self.rgb != base:
@@ -780,18 +805,49 @@ class App:
                 b = base[2] + (self.rgb[2]-base[2])*7//10
                 if abs(r-base[0])+abs(g-base[1])+abs(b-base[2]) < 6: r, g, b = base
                 self.rgb = (r, g, b); self.led.set(r, g, b)
-            if self._advance:                              # Continue: roll to the next item at the segment end
+            if self._advance:                              # Continue: gapless swap to the prepared track at seam_t
                 self._advance = False
-                self.load((self.idx + 1) % len(self.setlists[self.sl]['items'])); self.led_rest()
+                self._do_advance()
+        # MIDI Clock Out (master): 24 PPQN; interval follows the live bpm (so continuous ramps carry through)
+        if self.running and MIDI_CLOCK_OUT and self.midi is not None:
+            while now >= self._clock_next:
+                try: self.midi.write(bytes([0xF8]))
+                except Exception: pass
+                self._clock_next += int(60_000_000_000 / max(1, self.bpm) / 24)
     def _on_new_bar(self, bar):
+        # Pre-parse the next track during the LAST bar of this segment, so the swap at the seam is allocation-free
+        if self.bars and self.continue_on and self._next_pending is None and bar == self.bars - 1:
+            self._prepare_next()
         if self.bars and bar > 0 and bar % self.bars == 0:        # segment boundary
             self._seg_start = time.monotonic()                    # timer resets with the bar counter
-            if self.ramp: self.set_bpm(self._ramp_base)           # ramp restarts each segment
-            if self.continue_on: self._advance = True             # Continue: roll to the next item
-        elif self.ramp and bar > 0 and bar % self.ramp['every'] == 0:
-            self.set_bpm(self.bpm + self.ramp['amt'])             # mid-segment ramp step
+            if self.continue_on and self._next_pending is not None:
+                self._seam_t = self.lanes[0]['next']              # the wall-clock time of THIS boundary step
+                self._advance = True                              # tick() will swap to the prepared track
+            # Note: per-master-step continuous ramp handles the bpm reset implicitly (seg_bar wraps to 0)
         t = self.trainer                                          # gap trainer: silence during the rest bars
         self._muted = bool(t and (t['play'] + t['mute']) and (bar % (t['play'] + t['mute'])) >= t['play'])
+    def _prepare_next(self):                                   # parse the next playlist item into a side holder
+        items = self.setlists[self.sl]['items']
+        nxt = (self.idx + 1) % len(items)
+        if nxt == self.idx: return                             # 1-item playlist -> just loop, no swap
+        name, prog = items[nxt]
+        bpm, lanes, bars, ramp, trainer = parse_program(prog)
+        self._next_pending = {'lanes': lanes, 'bpm': bpm, 'bars': bars, 'ramp': ramp,
+                              'trainer': trainer, 'name': name, 'idx': nxt}
+    def _do_advance(self):                                     # gapless seam: swap the prepared track in at seam_t
+        n = self._next_pending
+        if n is None: return
+        self._next_pending = None
+        self.lanes = n['lanes']; self.bpm = n['bpm']; self.bars = n['bars']
+        self.ramp = n['ramp']; self.trainer = n['trainer']; self.name = n['name']; self.idx = n['idx']
+        self._ramp_base = self.bpm; self._lastbar = -1; self._muted = False; self._m_steps = 0
+        self._dirty = False; self._overlay = None
+        while len(self.g_overlay): self.g_overlay.pop()
+        seam = self._seam_t
+        for L in self.lanes: L['next'] = seam; L['step'] = -1   # NEXT tick fires step 0 of the new track at seam_t
+        self._need_redraw = True                                # visuals (grid + draws) catch up on the next refresh
+        self._seg_start = time.monotonic()                      # reset the on-screen timer
+        self.led_rest()
 
     # ---------- inputs ----------
     def poll(self):
@@ -833,14 +889,16 @@ class App:
             host = bool(self.last_midi_in) and (nowms - self.last_midi_in) < 1.0
             if host != self.midi_host:
                 self.midi_host = host
-                if host: self.buz.duty_cycle = 0          # silence the buzzer when the computer takes over
+                if host and SPEAKER_AUTO_MUTE: self.spk.duty_cycle = 0   # auto-mute when the computer takes over
                 self.led_rest(); self.draw_icons()
         uc = bool(getattr(supervisor.runtime, "usb_connected", True))   # connected to a computer?
         if uc != self.usb_conn:
             self.usb_conn = uc; self.draw_icons()
 
     # ---------- drawing ----------
-    def draw_bpm(self):
+    def draw_bpm(self):                                  # lazy: skip the bitmap alloc if the displayed integer is unchanged
+        if self.bpm == self._displayed_bpm: return
+        self._displayed_bpm = self.bpm
         self._place(self.g_bpm, str(self.bpm), 0, 44, C_TXT, C_BG, FONT_L, right_edge=WIDTH-12)
     def draw_status(self):                              # set-list tab (tap=switch) + CONT toggle, above the item title
         sl = self.setlists[self.sl]
@@ -1068,9 +1126,13 @@ class App:
         except OSError: committed = True
         while True:
             self.tick(); self.poll()
+            if self._need_redraw:                               # post-seam: visuals catch up AFTER the audio swap
+                self._need_redraw = False
+                self.draw_bpm(); self.draw_status(); self.draw_train()
+                self.build_grid(); self.draw_log(); self.draw_meters()
             tnow = time.monotonic()
             if tnow >= self._uiNext:                            # ~4x/s: tick the stopwatch + bar counter
-                self._uiNext = tnow + 0.25; self.draw_meters()
+                self._uiNext = tnow + 0.25; self.draw_meters(); self.draw_bpm()  # bpm follows the continuous ramp
             if not committed and tnow - boot > 5:               # booted & ran fine for 5s -> confirm the update
                 try: os.remove("/trial")
                 except Exception: pass