Fix print.push_status parsing, and stop losing reports silently

Pointed at a real H2C that was 20% into a job, `print_status()` returned
nothing at all. The printer was in fact pushing a full status object every
second; every one was arriving, failing to deserialize, and being dropped
invisibly by an `if let Ok(report) = ..` with no `else`.

That silence produced two confidently-wrong claims in our own comments,
both corrected here:

- `pushall`'s doc said whether v2 emits `push_status` unprompted was "an
  open question". It is not: v2 pushes a full 97-field object roughly once
  a second from the moment you subscribe, no trigger needed. There is no
  missing "other trigger" to hunt for.
- The "sequence gap" warning blamed the network for dropped v1 updates.
  Those updates were not dropped in transit - they failed to parse, so
  they never reached the counter, making the next one that did look like a
  skip. Confirmed: seq 57, 62, 64 and 69 all arrived. After the fix, zero
  gaps and zero parse failures across a 25s run against both printers.

Two concrete causes, both found with captured payloads:

- v1 trays carry `tray_temp`/`tray_time`; v2 trays carry
  `drying_temp`/`drying_time`. All four were required, so *every* v1 push
  carrying AMS data failed.
- A third tray shape existed that nothing modelled: an empty v2 slot sends
  `{"id": "2", "state": 0}`, which matched neither `EmptyTray` (it denies
  unknown fields, deliberately) nor `LoadedTray` (16 fields short).

A parse failure now reports itself, naming the printer, the sequence id and
the serde error. A report this process cannot parse is a defect in
`PrintReport`, and the only way to fix it is to be told which field.

`PrintReport` itself modelled 9 of 97 top-level fields, and none of them
were progress or temperature - it was built from a truncated example. It
now carries gcode_state, percent, layer counts, remaining time, nozzle/bed
temperatures, fan gears, wifi and HMS entries. `merge_from`'s two dozen
four-line blocks collapse to `newer.x.or(self.x.take())` one-liners: the
old shape made adding a field a three-place edit, and forgetting the merge
half produced a field that silently never survived a partial update.

Two scale traps documented where they bite: reported fan speeds are 0-15
gears, not percent and not the 0-255 PWM we send (`set_fan_speed(50)`
reads back as "7"); and v2 pins `sequence_id` to one value for minutes
while contents change, so it orders and identifies nothing there.

Two examples, and the distinction between them is the point. `live_reports`
is read-only and safe against a printer mid-job. `bambu_idle_checks`
writes, so it requires an explicit printer id and refuses to run unless
that printer reports `gcode_state: "IDLE"`.

Regression fixtures are verbatim captures off both printers, hardware
identifiers scrubbed - the only way to keep this from regressing without a
printer plugged in.

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

tests/push_status_parsing.rs

@@ -0,0 +1,88 @@
+//! Does `PrintReport` actually parse what real printers really send?
+//!
+//! The fixtures in `tests/fixtures/` are verbatim `print.push_status`
+//! payloads captured off real hardware on 2026-10-03 via
+//! `cargo run --example live_reports` (hardware identifiers scrubbed):
+//!
+//! - `push_status_v1_p1p_idle.json` - a P1P on BambuMQTT v1, idle.
+//! - `push_status_v2_h2c_printing.json` - an H2C on BambuMQTT v2, 13% into
+//!   a real job.
+//!
+//! These exist because the struct was originally built from a *truncated*
+//! example payload, and the gap between that and reality turned out to be
+//! the cause of two live misbehaviours (silently empty `print_status()`, and
+//! bogus "sequence gap" warnings). A fixture is the only way to keep that
+//! from regressing without a printer plugged in.
+
+use continuum_proxy::printer::PrintReport;
+
+fn load(name: &str) -> serde_json::Value {
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/");
+    let text = std::fs::read_to_string(format!("{path}{name}")).expect("fixture should exist");
+    serde_json::from_str(&text).expect("fixture should be valid JSON")
+}
+
+/// The failure mode that mattered: `handle_incoming_report` does
+/// `if let Ok(report) = serde_json::from_value::<PrintReport>(..)`, so a
+/// parse error doesn't just lose that one update - it's invisible. Assert on
+/// the error text, not just `is_ok()`, so a regression says *what* broke.
+fn assert_parses(name: &str) {
+    let value = load(name);
+    match serde_json::from_value::<PrintReport>(value) {
+        Ok(_) => {}
+        Err(err) => panic!("{name} failed to parse as PrintReport: {err}"),
+    }
+}
+
+#[test]
+fn parses_v1_idle_push_status() {
+    assert_parses("push_status_v1_p1p_idle.json");
+}
+
+#[test]
+fn parses_v2_printing_push_status() {
+    assert_parses("push_status_v2_h2c_printing.json");
+}
+
+/// The whole point of consuming these at all: a print farm needs progress
+/// and temperatures. If the struct parses but drops these, it's no more
+/// useful than not parsing.
+#[test]
+fn v2_printing_report_carries_progress_and_temperatures() {
+    let value = load("push_status_v2_h2c_printing.json");
+    let report: PrintReport = serde_json::from_value(value).expect("should parse");
+
+    assert_eq!(report.gcode_state.as_deref(), Some("RUNNING"));
+    assert_eq!(report.mc_percent, Some(13));
+    assert_eq!(report.layer_num, Some(2));
+    assert_eq!(report.total_layer_num, Some(50));
+    assert_eq!(report.mc_remaining_time, Some(102));
+    assert_eq!(report.nozzle_temper, Some(230.0));
+    assert_eq!(report.subtask_name.as_deref(), Some("\u{15b}wieczka-24.stl"));
+}
+
+/// An idle printer still has to produce a coherent report - just with
+/// nothing printing.
+#[test]
+fn v1_idle_report_reads_as_idle() {
+    let value = load("push_status_v1_p1p_idle.json");
+    let report: PrintReport = serde_json::from_value(value).expect("should parse");
+
+    assert_eq!(report.gcode_state.as_deref(), Some("IDLE"));
+    assert_eq!(report.mc_percent, Some(0));
+}
+
+/// v1 and v2 disagree about tray field names (`tray_temp`/`tray_time` vs
+/// `drying_temp`/`drying_time`) - this is the specific mismatch that made
+/// every v1 push carrying AMS data fail. Both spellings have to work.
+#[test]
+fn both_protocol_generations_parse_their_ams_trays() {
+    for name in ["push_status_v1_p1p_idle.json", "push_status_v2_h2c_printing.json"] {
+        let value = load(name);
+        let report: PrintReport = serde_json::from_value(value).unwrap_or_else(|err| {
+            panic!("{name}: {err}");
+        });
+        let ams = report.ams.expect("fixture should carry AMS state");
+        assert!(!ams.ams.is_empty(), "{name}: expected at least one AMS unit");
+    }
+}