pycentauri 0.6.2__tar.gz → 0.6.3__tar.gz

{pycentauri-0.6.2 → pycentauri-0.6.3}/CHANGELOG.md

@@ -6,33 +6,50 @@ Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.6.3] - 2026-07-05
+
+### Changed
+- **CC2 speed pinning now tells a human's balanced apart from a firmware
+  reset — no more Auto escape hatch.** The firmware resets speed_mode to
+  balanced as the leading edge of every Canvas filament switch, a few
+  seconds before the head parks; measured reset→park lead times are
+  tight (6–8 s, never above ~9 s). pycentauri uses that: a drop to
+  balanced followed by a park within ~12 s is the firmware and the
+  pinned mode is re-applied when the switch completes; a drop that sits
+  at balanced for ~12 s with no park is a human tapping balanced on the
+  touchscreen, so the pin is released and balanced is honored. A
+  sustained non-balanced touchscreen mode is still adopted as the pin
+  outright. Both paths live-verified 2026-07-05 (firmware re-apply and
+  human release, each with journal-logged decisions).
+- **Removed the `auto` speed mode / Auto button.** It existed only to
+  release the pin for the touchscreen-balanced case, which is now
+  detected automatically. `speed auto`, `{"mode": "auto"}`, and the web
+  UI Auto button are gone.
+
+
 ## [0.6.2] - 2026-07-05
 
 ### Changed
 - **CC2 speed-mode persistence redesigned as pin-and-enforce.** The
   0.6.1 snapshot-per-switch restore lost an arms race with the
-  firmware: after eight consecutive successful restores, a reset
-  arriving outside the covered window (late after a restore, or
-  mid-print with no switch at all — observed 2026-07-05 ~15:00)
-  poisoned the baseline and silently disabled every restore after it.
-  The firmware only ever resets TO balanced, so the model is now: the
-  mode you set is pinned (immediately via pycentauri; after holding
-  15 s when set from the touchscreen, since a non-balanced mode can
-  only come from a human), and any disagreement lasting 12 s while
+  firmware: after eight consecutive successful restores, a reset whose
+  lead time exceeded the debounce window poisoned the baseline and
+  silently disabled every restore after it. The firmware resets
+  `speed_mode` to balanced as part of every Canvas filament switch —
+  the reset fires several seconds before the head parks, while the
+  status still reads "printing", and its lead time varies — and it only
+  ever resets TO balanced. So the model is now timing-agnostic: the
+  mode you set is pinned (immediately via pycentauri; after holding a
+  few seconds when set from the touchscreen, since a non-balanced mode
+  can only come from a human), and any disagreement lasting 12 s while
   printing is re-applied, at most every 30 s. One consequence,
   deliberate: while a mode is pinned, selecting *balanced* from the
-  touchscreen is indistinguishable from a firmware reset and will be
-  reverted — switch to balanced through pycentauri instead, which
-  re-pins. Pins clear when the print ends, and ``speed auto`` (CLI),
-  ``{"mode": "auto"}`` (HTTP), or the web UI's Auto button release the
-  pin explicitly, returning speed control to the printer.
-- Root cause fully mapped (wire captures, 2026-07-05): every reset is
-  a **service operation** — full filament switches, plus brief nozzle
-  wipe / purge operations at the chute that are too short to register
-  as "switching" — and a human's touchscreen tap is byte-identical to
-  a firmware reset on the wire, so balanced-from-touchscreen cannot be
-  auto-detected while a pin is active. Use Auto or set balanced via
-  pycentauri instead.
+  touchscreen is byte-identical on the wire to a firmware reset and will
+  be reverted — switch to balanced through pycentauri instead (which
+  re-pins), or release the pin. Pins clear when the print ends, and
+  ``speed auto`` (CLI), ``{"mode": "auto"}`` (HTTP), or the web UI's
+  Auto button release the pin explicitly, returning speed control to
+  the printer.
 
 ## [0.6.1] - 2026-07-05
 

{pycentauri-0.6.2 → pycentauri-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.6.2
+Version: 0.6.3
 Summary: Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge
 Project-URL: Homepage, https://github.com/bjan/pycentauri
 Project-URL: Repository, https://github.com/bjan/pycentauri
@@ -166,6 +166,42 @@ are silently ignored by the firmware:
 
 Speed changes only take effect while a print is actively running.
 
+#### CC2 speed pinning (the firmware fights you, so pycentauri fights back)
+
+The CC2 firmware **resets the speed mode back to balanced on every
+Canvas filament switch.** On a multi-color print that switch happens
+every couple of minutes, so set sport once and the printer quietly
+drops you to balanced at the next color change. This is firmware
+behavior; it happens whether you set the speed from pycentauri or from
+the printer's own touchscreen.
+
+pycentauri works around it with **pin-and-enforce** (CC2 only, requires
+`--enable-control`):
+
+- **Whatever mode you select gets pinned.** Set it via pycentauri (pins
+  immediately) or on the touchscreen (pinned after it holds ~8 seconds —
+  the firmware never *resets* to a non-balanced mode, so a sustained
+  sport/ludicrous/silent must be a human).
+- **A firmware reset is re-applied.** The reset fires a few seconds
+  *before* the head parks at the chute, so when the speed drops to
+  balanced pycentauri waits to see what follows: a filament switch
+  (the head parking) within ~12 seconds means it was the firmware, and
+  the pinned mode is re-applied as soon as the switch completes.
+- **A human's balanced is honored.** If the speed drops to balanced and
+  *no* switch follows within ~12 seconds, that was you tapping balanced
+  on the touchscreen — the pin is released and balanced stays. (On the
+  wire a human tap is byte-identical to a firmware reset; the presence
+  or absence of the following switch is what tells them apart. Measured
+  reset→park lead times cluster at 6–8 s, well inside the window.)
+- **The pin clears when the print ends.**
+
+So both paths just work: set any speed from either the app or the
+printer and it sticks across filament switches, and you can always
+drop back to balanced from the touchscreen whenever you want.
+
+The CC1 has none of this — its speed mode stays where you put it, so
+`set_print_speed` is a plain one-shot there.
+
 ## Python library
 
 ```python
@@ -407,14 +443,12 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
-- **The firmware keeps resetting the speed mode to balanced.** Around
-  every Canvas filament switch (starting seconds *before* the head
-  parks), and occasionally mid-print with no switch at all. pycentauri
-  pins the mode you set and re-applies it whenever the printer drifts
-  from it for more than ~12 s while printing (needs
-  `--enable-control`). Caveat: while a mode is pinned, picking
-  *balanced* on the touchscreen looks identical to a firmware reset
-  and will be reverted — set balanced through pycentauri instead.
+- **The firmware resets the speed mode to balanced on every Canvas
+  filament switch.** pycentauri pins your chosen mode and re-applies it
+  automatically, while still honoring a deliberate balanced from the
+  touchscreen — see
+  [CC2 speed pinning](#cc2-speed-pinning-the-firmware-fights-you-so-pycentauri-fights-back)
+  above for how it tells the two apart.
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.2 → pycentauri-0.6.3}/README.md

@@ -116,6 +116,42 @@ are silently ignored by the firmware:
 
 Speed changes only take effect while a print is actively running.
 
+#### CC2 speed pinning (the firmware fights you, so pycentauri fights back)
+
+The CC2 firmware **resets the speed mode back to balanced on every
+Canvas filament switch.** On a multi-color print that switch happens
+every couple of minutes, so set sport once and the printer quietly
+drops you to balanced at the next color change. This is firmware
+behavior; it happens whether you set the speed from pycentauri or from
+the printer's own touchscreen.
+
+pycentauri works around it with **pin-and-enforce** (CC2 only, requires
+`--enable-control`):
+
+- **Whatever mode you select gets pinned.** Set it via pycentauri (pins
+  immediately) or on the touchscreen (pinned after it holds ~8 seconds —
+  the firmware never *resets* to a non-balanced mode, so a sustained
+  sport/ludicrous/silent must be a human).
+- **A firmware reset is re-applied.** The reset fires a few seconds
+  *before* the head parks at the chute, so when the speed drops to
+  balanced pycentauri waits to see what follows: a filament switch
+  (the head parking) within ~12 seconds means it was the firmware, and
+  the pinned mode is re-applied as soon as the switch completes.
+- **A human's balanced is honored.** If the speed drops to balanced and
+  *no* switch follows within ~12 seconds, that was you tapping balanced
+  on the touchscreen — the pin is released and balanced stays. (On the
+  wire a human tap is byte-identical to a firmware reset; the presence
+  or absence of the following switch is what tells them apart. Measured
+  reset→park lead times cluster at 6–8 s, well inside the window.)
+- **The pin clears when the print ends.**
+
+So both paths just work: set any speed from either the app or the
+printer and it sticks across filament switches, and you can always
+drop back to balanced from the touchscreen whenever you want.
+
+The CC1 has none of this — its speed mode stays where you put it, so
+`set_print_speed` is a plain one-shot there.
+
 ## Python library
 
 ```python
@@ -357,14 +393,12 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
-- **The firmware keeps resetting the speed mode to balanced.** Around
-  every Canvas filament switch (starting seconds *before* the head
-  parks), and occasionally mid-print with no switch at all. pycentauri
-  pins the mode you set and re-applies it whenever the printer drifts
-  from it for more than ~12 s while printing (needs
-  `--enable-control`). Caveat: while a mode is pinned, picking
-  *balanced* on the touchscreen looks identical to a firmware reset
-  and will be reverted — set balanced through pycentauri instead.
+- **The firmware resets the speed mode to balanced on every Canvas
+  filament switch.** pycentauri pins your chosen mode and re-applies it
+  automatically, while still honoring a deliberate balanced from the
+  touchscreen — see
+  [CC2 speed pinning](#cc2-speed-pinning-the-firmware-fights-you-so-pycentauri-fights-back)
+  above for how it tells the two apart.
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.2 → pycentauri-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycentauri"
-version = "0.6.2"
+version = "0.6.3"
 description = "Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge"
 readme = "README.md"
 license = "Apache-2.0"

{pycentauri-0.6.2 → pycentauri-0.6.3}/src/pycentauri/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "discover",
 ]
 
-__version__ = "0.6.2"
+__version__ = "0.6.3"

{pycentauri-0.6.2 → pycentauri-0.6.3}/src/pycentauri/cc2.py

@@ -40,20 +40,21 @@ log = logging.getLogger(__name__)
 MQTT_PORT = 1883
 CC2_USERNAME = "elegoo"
 PING_INTERVAL_S = 30.0
-# Speed-mode pinning. The firmware only ever resets speed_mode TO balanced
-# (1) — before filament switches (observed at T-6..10s before the head
-# parks), sometimes again after a restore, and occasionally mid-print with
-# no switch at all (observed 2026-07-05 ~15:00). A snapshot-per-switch
-# design lost that arms race, so instead the mode a user selects is PINNED
-# and enforced: a disagreement lasting ENFORCE_AFTER_S while printing gets
-# re-applied, at most once per ENFORCE_MIN_INTERVAL_S. A sustained
-# non-balanced mode from the touchscreen (held PIN_LEARN_S) adopts the pin,
-# since the firmware never resets to a non-balanced mode.
-# PIN_LEARN_S must be SHORTER than ENFORCE_AFTER_S: a touchscreen change to
-# a non-balanced mode has to be adopted as the new pin before enforcement
-# would revert it, or screen users could never override a pinned mode.
+# Speed-mode pinning. The firmware resets speed_mode TO balanced (1) — never
+# to any other mode — as the leading edge of every Canvas filament switch:
+# the reset fires a few seconds before the head parks at the chute, while the
+# status still reads "printing". Measured lead times (reset -> park) cluster
+# tightly at 6-10 s (2026-07-05). We exploit that to tell a firmware reset
+# apart from a human tapping "balanced" on the touchscreen (byte-identical on
+# the wire): a drop to balanced followed by a park within HUMAN_WINDOW_S is
+# the firmware and the pinned mode is re-applied when the switch completes;
+# a drop that sits at balanced for HUMAN_WINDOW_S with NO switch is a human,
+# and the pin is released. 12 s is ~1.5x the 8 s max lead time from the
+# precise (sub-second) captures on 2026-07-05. A non-balanced mode from the
+# touchscreen (held PIN_LEARN_S) is adopted as the new pin outright, since
+# the firmware never produces one.
 PIN_LEARN_S = 8.0
-ENFORCE_AFTER_S = 12.0
+HUMAN_WINDOW_S = 12.0
 ENFORCE_MIN_INTERVAL_S = 30.0
 # Lifecycle commands (start/pause/stop/resume) are answered only after the
 # firmware finishes the mechanical sequence — a resume reheats and unparks
@@ -284,7 +285,10 @@ class CC2Printer(Printer):
         self._pinned_mode: int | None = None
         self._pin_candidate: int | None = None
         self._pin_candidate_since: float = 0.0
-        self._mismatch_since: float | None = None
+        # Adjudicating a drop-to-balanced: when it started, and whether a
+        # filament switch (a park at the chute) has been seen since.
+        self._pending_since: float | None = None
+        self._switch_seen: bool = False
         self._last_enforce: float = float("-inf")
         self._enforce_task: asyncio.Task[None] | None = None
         self._now = time.monotonic  # overridable for tests
@@ -457,14 +461,6 @@ class CC2Printer(Printer):
 
     async def set_print_speed(self, mode: str | int) -> sdcp.ParsedMessage:
         self._require_control("set_print_speed")
-        if isinstance(mode, str) and mode.strip().lower() == "auto":
-            # Release the pin: stop enforcing and let the printer (and its
-            # touchscreen) own the speed mode again. No wire command needed.
-            self._pinned_mode = None
-            self._pin_candidate = None
-            self._mismatch_since = None
-            log.info("speed-mode pin released (auto)")
-            return self._wrap_result(1031, {"error_code": 0, "pin": "released"})
         if isinstance(mode, str):
             key = mode.strip().lower()
             if key not in self.PRINT_SPEED_MODES:
@@ -483,7 +479,8 @@ class CC2Printer(Printer):
         # An explicit choice through pycentauri pins the mode.
         self._pinned_mode = value
         self._pin_candidate = None
-        self._mismatch_since = None
+        self._pending_since = None
+        self._switch_seen = False
         return self._wrap_result(1031, result)
 
     async def set_fan_speed(
@@ -674,79 +671,112 @@ class CC2Printer(Printer):
     def _track_speed_mode(self, payload: dict[str, Any]) -> None:
         """Pin-and-enforce the user's speed mode (runs on the asyncio loop).
 
-        The firmware resets ``speed_mode`` to balanced around filament
-        switches and occasionally mid-print. Whatever mode the user set —
-        through pycentauri (pins immediately) or the touchscreen (pins
-        after holding ``PIN_LEARN_S``) — is re-applied whenever the
-        printer disagrees for ``ENFORCE_AFTER_S`` while printing. Only
-        non-balanced modes are learned from the wire, because a flip to
-        balanced is indistinguishable from a firmware reset.
+        See the module-level constants for the firmware behaviour this
+        works around. In short: a non-balanced mode set anywhere is pinned
+        (from the touchscreen after a brief hold) and re-applied after each
+        filament switch resets it; a drop to balanced is adjudicated by
+        whether a switch follows within ``HUMAN_WINDOW_S`` — switch means
+        firmware (re-apply), no switch means a human chose balanced
+        (release the pin).
         """
         print_status = payload.get("PrintInfo", {}).get("Status")
         speed_mode = payload.get("_cc2", {}).get("speed_mode")
         if not isinstance(speed_mode, int) or print_status is None:
             return
+
         if print_status in (0, 8, 9, 14):
             # Print over (idle/stopped/completed/error): the pin dies with it.
             self._pinned_mode = None
             self._pin_candidate = None
-            self._mismatch_since = None
+            self._pending_since = None
+            self._switch_seen = False
             return
+
         if print_status != 13:
-            # Switching filament, pausing, etc. — never learn or enforce
-            # here, and a mismatch clock from before doesn't carry across.
-            self._mismatch_since = None
+            # Filament switch (27) / pausing / etc. A park during an
+            # in-flight adjudication is the firmware signature.
+            if print_status == 27 and self._pending_since is not None:
+                self._switch_seen = True
             return
 
+        # --- printing (status 13) ---
         now = self._now()
 
-        # Learn a pin from the wire: only non-balanced modes qualify.
+        # A non-balanced mode we're not already pinned to can only be a
+        # human (the firmware never sets one) — adopt it after a brief hold.
         if speed_mode != 1 and speed_mode != self._pinned_mode:
             if self._pin_candidate == speed_mode:
                 if now - self._pin_candidate_since >= PIN_LEARN_S:
                     self._pinned_mode = speed_mode
                     self._pin_candidate = None
-                    self._mismatch_since = None
+                    self._pending_since = None
+                    self._switch_seen = False
             else:
                 self._pin_candidate = speed_mode
                 self._pin_candidate_since = now
-        elif speed_mode == self._pinned_mode:
-            self._pin_candidate = None
+            return
+
+        self._pin_candidate = None
 
-        # Enforce the pin.
+        # Nothing to defend, or the pin is satisfied.
         if self._pinned_mode is None or speed_mode == self._pinned_mode:
-            self._mismatch_since = None
+            self._pending_since = None
+            self._switch_seen = False
             return
-        if self._mismatch_since is None:
-            self._mismatch_since = now
+
+        # speed_mode == 1 (balanced) while pinned to a faster mode: the
+        # ambiguous case. Adjudicate by whether a switch follows.
+        if self._pending_since is None:
+            self._pending_since = now
+            self._switch_seen = False
             return
-        if now - self._mismatch_since < ENFORCE_AFTER_S:
+
+        if self._switch_seen:
+            # Firmware reset confirmed by the switch — re-apply, and keep
+            # re-applying (rate-limited) until it takes. Do NOT clear
+            # _pending_since here: only a match (above) clears it.
+            self._enforce(speed_mode, now)
             return
+
+        if now - self._pending_since >= HUMAN_WINDOW_S:
+            # Balanced held this long with no switch: a human chose it.
+            log.info(
+                "balanced held %0.0fs with no filament switch — releasing "
+                "the speed-mode pin (was %d)",
+                now - self._pending_since,
+                self._pinned_mode,
+            )
+            self._pinned_mode = None
+            self._pending_since = None
+            self._switch_seen = False
+            return
+        # Still inside the window with no switch yet — keep waiting.
+
+    def _enforce(self, current_mode: int, now: float) -> None:
+        assert self._pinned_mode is not None
         if self._enforce_task is not None and not self._enforce_task.done():
             return
         if now - self._last_enforce < ENFORCE_MIN_INTERVAL_S:
             return
         self._last_enforce = now
         if self.enable_control:
-            self._launch_enforce(self._pinned_mode)
+            self._enforce_task = asyncio.create_task(
+                self._apply_pinned_mode(self._pinned_mode),
+                name=f"pycentauri-cc2-speedpin-{self.host}",
+            )
         else:
             log.warning(
                 "speed_mode drifted to %d but pin is %d; enable_control is off "
                 "so it will not be re-applied",
-                speed_mode,
+                current_mode,
                 self._pinned_mode,
             )
 
-    def _launch_enforce(self, mode: int) -> None:
-        self._enforce_task = asyncio.create_task(
-            self._apply_pinned_mode(mode),
-            name=f"pycentauri-cc2-speedpin-{self.host}",
-        )
-
     async def _apply_pinned_mode(self, mode: int) -> None:
+        await asyncio.sleep(2.0)  # let the firmware settle after the switch
         try:
             await self._cc2_request(1031, {"mode": mode})
-            log.info("re-applied pinned speed_mode %d", mode)
+            log.info("re-applied pinned speed_mode %d after filament switch", mode)
         except Exception:
             log.warning("could not re-apply pinned speed_mode %d", mode, exc_info=True)
 

{pycentauri-0.6.2 → pycentauri-0.6.3}/src/pycentauri/cli.py

@@ -378,8 +378,7 @@ def cmd_speed(
         str,
         typer.Argument(
             help="Speed mode: silent | balanced | sport | ludicrous "
-            "(or the integer 50 | 100 | 130 | 160). On a CC2, 'auto' "
-            "releases the speed pin and stops enforcing a mode.",
+            "(or the integer 50 | 100 | 130 | 160).",
         ),
     ],
     host: HostOpt = None,

{pycentauri-0.6.2 → pycentauri-0.6.3}/src/pycentauri/web/index.html

@@ -79,10 +79,6 @@
           <button class="btn adj-mode" data-mode="ludicrous" type="button">
             <small>160%</small> Ludicrous
           </button>
-          <button class="btn adj-mode" data-mode="auto" type="button"
-                  title="Release the speed pin (CC2): stop enforcing a mode and let the printer/touchscreen own it.">
-            <small>CC2</small> Auto
-          </button>
         </div>
 
         <div class="adj-sub">Fans</div>

{pycentauri-0.6.2 → pycentauri-0.6.3}/src/pycentauri/web/styles.css

@@ -467,7 +467,7 @@ body {
 
 .adj-modes {
   display: grid;
-  grid-template-columns: repeat(5, 1fr);
+  grid-template-columns: repeat(4, 1fr);
   gap: 4px;
   margin-top: 6px;
 }

{pycentauri-0.6.2 → pycentauri-0.6.3}/tests/test_cc2_mapping.py

@@ -272,7 +272,7 @@ def test_canvas_parse_survives_malformed_payloads() -> None:
     assert CanvasStatus.from_payload({"canvas_info": {"canvas_list": "bogus"}}).tray_count == 0
 
 
-# --- speed-mode pin & enforce ---------------------------------------------
+# --- speed-mode pin, enforce & human/firmware adjudication ----------------
 
 
 def _payload(status: int, mode: int) -> dict[str, Any]:
@@ -284,7 +284,18 @@ def _printer(enable_control: bool = True) -> Any:
 
     p = CC2Printer("127.0.0.1", access_code="x", enable_control=enable_control)
     p._fired: list[int] = []
-    p._launch_enforce = p._fired.append  # record instead of spawning tasks
+    p._enforce_calls = 0
+
+    def fake_enforce(current_mode: int, now: float) -> None:
+        # Mirror the real rate-limit + record instead of spawning a task.
+        import pycentauri.cc2 as m
+
+        if now - p._last_enforce < m.ENFORCE_MIN_INTERVAL_S:
+            return
+        p._last_enforce = now
+        p._fired.append(p._pinned_mode)
+
+    p._enforce = fake_enforce
     t = [0.0]
     p._clock = t
     p._now = lambda: t[0]
@@ -296,63 +307,99 @@ def _tick(p: Any, dt: float, status: int, mode: int) -> None:
     p._track_speed_mode(_payload(status, mode))
 
 
-def test_api_set_pins_immediately_and_enforces_after_grace() -> None:
+# --- firmware reset: switch follows, mode is re-applied on resume ---------
+
+
+def test_firmware_reset_reenforced_after_switch() -> None:
     p = _printer()
-    p._pinned_mode = 2  # what set_print_speed() records
-    _tick(p, 0, 13, 2)
-    assert p._fired == []
-    # Firmware resets to balanced mid-print; not enforced until it holds 12 s
-    _tick(p, 5, 13, 1)
-    _tick(p, 5, 13, 1)
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)  # printing at sport
+    _tick(p, 3, 13, 1)  # pre-switch reset (T=3)
+    _tick(p, 4, 13, 1)  # still no park; within window, wait
     assert p._fired == []
-    _tick(p, 5, 13, 1)  # mismatch has now persisted 10 s... (first at t=10)
-    _tick(p, 5, 13, 1)  # 15 s since mismatch start -> fires
+    _tick(p, 2, 27, 1)  # head parks -> switch seen
+    _tick(p, 180, 27, 1)  # switch runs for 3 min
+    assert p._fired == []  # never released, never enforced mid-switch
+    _tick(p, 1, 13, 1)  # resume, still balanced -> re-apply sport
     assert p._fired == [2]
 
 
-def test_pre_switch_reset_window_never_fires() -> None:
-    """The 6-10 s balanced window before the head parks stays untouched."""
+def test_park_within_window_prevents_human_release() -> None:
+    """A park inside the window must stop the human-release clock."""
     p = _printer()
     p._pinned_mode = 2
     _tick(p, 0, 13, 2)
-    _tick(p, 3, 13, 1)  # pre-switch reset
-    _tick(p, 3, 13, 1)  # 6 s in
-    _tick(p, 3, 27, 1)  # head parks -> mismatch clock cleared
-    _tick(p, 60, 27, 1)  # switch runs
-    assert p._fired == []
-    # Resume: reset persists, enforcement kicks in after the grace period
-    _tick(p, 5, 13, 1)
-    _tick(p, 13, 13, 1)
+    _tick(p, 5, 13, 1)  # reset at T=5
+    _tick(p, 4, 27, 1)  # park inside the window -> switch seen
+    _tick(p, 20, 27, 1)  # long switch, we are not printing
+    _tick(p, 1, 13, 1)  # resume -> firmware, re-apply
+    assert p._pinned_mode == 2
     assert p._fired == [2]
 
 
+# --- human balanced: no switch, pin released ------------------------------
+
+
+def test_human_balanced_releases_pin_after_window() -> None:
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)  # printing at sport
+    _tick(p, 2, 13, 1)  # user taps balanced (T=2)
+    _tick(p, 5, 13, 1)  # T=7, no switch, still waiting
+    assert p._pinned_mode == 2
+    assert p._fired == []
+    _tick(p, 6, 13, 1)  # still waiting (inside the window)
+    assert p._pinned_mode == 2
+    _tick(p, 5, 13, 1)  # past the window, no switch -> release
+    assert p._pinned_mode is None
+    assert p._fired == []
+
+
+def test_human_balanced_never_yanked_during_window() -> None:
+    """The mode must stay balanced (no enforce) throughout the wait."""
+    p = _printer()
+    p._pinned_mode = 2
+    _tick(p, 0, 13, 2)
+    _tick(p, 1, 13, 1)
+    for _ in range(6):
+        _tick(p, 2, 13, 1)  # poll every 2s up to ~13s
+    assert p._fired == []  # never re-applied sport while adjudicating
+
+
+# --- touchscreen non-balanced override ------------------------------------
+
+
 def test_screen_change_to_nonbalanced_becomes_pin() -> None:
     p = _printer()
-    _tick(p, 0, 13, 1)  # printing at balanced, nothing pinned
+    _tick(p, 0, 13, 1)  # printing, nothing pinned
     _tick(p, 5, 13, 3)  # user picks ludicrous on the touchscreen
     assert p._pinned_mode is None
-    _tick(p, 16, 13, 3)  # held > PIN_LEARN_S -> adopted
+    _tick(p, 9, 13, 3)  # held > PIN_LEARN_S -> adopted
     assert p._pinned_mode == 3
     assert p._fired == []
 
 
-def test_balanced_is_never_learned_as_pin_while_pinned() -> None:
+def test_screen_override_beats_release_when_pinned() -> None:
+    """Screen change sport->ludicrous while sport is pinned: adopt ludicrous,
+    never release or enforce."""
     p = _printer()
     p._pinned_mode = 2
     _tick(p, 0, 13, 2)
-    # Sustained balanced (reset or screen tap) never displaces the pin...
-    _tick(p, 10, 13, 1)
-    _tick(p, 30, 13, 1)
-    assert p._pinned_mode == 2
-    # ...and enforcement fired for it
-    assert p._fired == [2]
+    _tick(p, 2, 13, 3)  # user picks ludicrous
+    _tick(p, 9, 13, 3)  # held -> adopted as new pin
+    assert p._pinned_mode == 3
+    assert p._fired == []
+
 
+# --- lifecycle ------------------------------------------------------------
 
-def test_no_pin_means_no_enforcement() -> None:
+
+def test_no_pin_no_action() -> None:
     p = _printer()
     _tick(p, 0, 13, 1)
     _tick(p, 60, 13, 1)
     assert p._fired == []
+    assert p._pinned_mode is None
 
 
 def test_print_end_clears_pin() -> None:
@@ -361,49 +408,20 @@ def test_print_end_clears_pin() -> None:
     _tick(p, 0, 13, 2)
     _tick(p, 5, 9, 1)  # completed
     assert p._pinned_mode is None
-    _tick(p, 5, 13, 1)  # a new print at balanced: nothing enforced
+    _tick(p, 5, 13, 1)  # a fresh print at balanced
     _tick(p, 60, 13, 1)
     assert p._fired == []
 
 
-def test_enforce_rate_limited() -> None:
+def test_enforce_rate_limited_across_repeated_switches() -> None:
     p = _printer()
     p._pinned_mode = 2
     _tick(p, 0, 13, 2)
-    _tick(p, 5, 13, 1)
-    _tick(p, 13, 13, 1)  # fires (mismatch held 13 s)
-    _tick(p, 5, 13, 1)  # still mismatched, but inside the 30 s cooldown
-    _tick(p, 5, 13, 1)
+    _tick(p, 3, 13, 1)  # reset
+    _tick(p, 4, 27, 1)  # park
+    _tick(p, 60, 13, 1)  # resume -> enforce (T=67)
     assert p._fired == [2]
-    _tick(p, 30, 13, 1)  # cooldown over -> fires again
+    _tick(p, 5, 13, 1)  # still balanced (enforce not "taken" in this fake)
+    assert p._fired == [2]  # within 30s cooldown, no repeat
+    _tick(p, 30, 13, 1)  # cooldown elapsed -> enforce again
     assert p._fired == [2, 2]
-
-
-def test_screen_override_beats_enforcement() -> None:
-    """A touchscreen change to a non-balanced mode must be learned BEFORE
-    enforcement of the old pin would revert it (PIN_LEARN_S < ENFORCE_AFTER_S)."""
-    p = _printer()
-    p._pinned_mode = 1  # balanced pinned via the API
-    _tick(p, 0, 13, 1)
-    _tick(p, 2, 13, 2)  # user picks sport on the screen (mismatch clock starts)
-    _tick(p, 5, 13, 2)  # 5 s held
-    _tick(p, 4, 13, 2)  # 9 s held: learned as the new pin, before 12 s enforcement
-    assert p._pinned_mode == 2
-    assert p._fired == []
-
-
-def test_auto_releases_pin() -> None:
-    import asyncio
-
-    p = _printer()
-    p._pinned_mode = 2
-
-    async def run() -> None:
-        result = await p.set_print_speed("auto")
-        assert result.inner["pin"] == "released"
-
-    asyncio.run(run())
-    assert p._pinned_mode is None
-    _tick(p, 0, 13, 1)
-    _tick(p, 60, 13, 1)  # balanced persists, nothing enforced
-    assert p._fired == []