Six enhancements: recompute, markers, vendoring, tests, nerd stats, DS18B20

1. POST /api/recompute re-derives every compensated column from the untouched
   raw values, removing the step a calibration otherwise leaves through the
   history. Possible because temp_raw, cpu_temp and hum are never overwritten.
   Idempotent by construction and tested per row: 0 of 6051 rows change on a
   second run. 6069 rows in 0.25 s here, so a few seconds on the Pi.

2. Calibration now emits a 'discontinuity' event alongside the calibration log,
   so downstream views can find the boundary without parsing prose.

3. Vendored Tailwind, Chart.js, hammer, the zoom plugin, KaTeX with its 20
   woff2 faces, and both Google fonts into ashvale/static, served by the
   station. 1.4 MB. Verified with every non-localhost request aborted in the
   browser: zero external requests, equations still render, fonts still load.
   The dashboard no longer needs internet.

4. 54 pytest cases over the pure numerics: physics closed forms and round
   trips, both compensator inverse properties, the Kalman covariance
   invariants and NIS consistency, the RLS trace cap under a deliberately
   unexcited regressor, conformal coverage, and the Zambretti ordering. Wired
   into CI after the seed step so the recompute cases have history. Writing
   them caught my own sign error on the conformal update: a hit raises alpha
   and narrows the band, which reads backwards until you follow it through.

5. Stats for Nerds gains the condition number of each head's covariance, a
   standardised innovation histogram per Kalman filter from a bounded 600
   sample ring buffer, and a reliability strip of realised against nominal
   coverage. All arithmetic on data already in memory.

6. OutdoorProbe reads a DS18B20 over the kernel 1-Wire driver, no new
   dependency. Polled on its own slower cadence because the sensor blocks for
   up to 750 ms during conversion, which would eat a third of the 2 s sample
   budget. Rejects the 85000 power-on sentinel and out-of-range values, and
   reports age so a dead probe cannot masquerade as fresh.

ashvale/storage.py

@@ -154,6 +154,52 @@ class Store:
 
     # ------------------------------------------------------------- reads
 
+    def all_for_recompute(self) -> Dict[str, np.ndarray]:
+        """Every stored row's *raw* inputs, oldest first.
+
+        Only the columns a re-derivation actually needs. The raw sensor values
+        are never overwritten, which is precisely what makes recomputation
+        possible after a calibration changes k or the humidity offset.
+        """
+        cols = ["ts", "temp_raw", "cpu_temp", "hum", "press"]
+        with self._conn() as conn:
+            rows = conn.execute(
+                f"SELECT {', '.join(cols)} FROM telemetry ORDER BY ts ASC").fetchall()
+        if not rows:
+            return {c: np.empty(0) for c in cols}
+        arr = np.array(rows, dtype=object)
+        out = {}
+        for i, c in enumerate(cols):
+            out[c] = np.array([np.nan if v is None else float(v) for v in arr[:, i]],
+                              dtype=float)
+        return out
+
+    def apply_recompute(self, ts: np.ndarray, updates: Dict[str, np.ndarray],
+                        chunk: int = 2000) -> int:
+        """Write recomputed derived columns back, in chunks.
+
+        Chunked because a year of tiered history is a six-figure row count and a
+        single statement would hold the whole parameter list in memory on a
+        512 MB board.
+        """
+        names = list(updates.keys())
+        sql = (f"UPDATE telemetry SET {', '.join(n + ' = ?' for n in names)} "
+               f"WHERE ts = ?")
+        n_written = 0
+        with self._conn() as conn:
+            for start in range(0, ts.size, chunk):
+                stop = min(start + chunk, ts.size)
+                batch = [
+                    tuple(
+                        [None if not np.isfinite(updates[n][i]) else float(updates[n][i])
+                         for n in names] + [float(ts[i])]
+                    )
+                    for i in range(start, stop)
+                ]
+                conn.executemany(sql, batch)
+                n_written += len(batch)
+        return n_written
+
     def window(self, hours: float, columns: Optional[Iterable[str]] = None) -> Dict[str, np.ndarray]:
         """Return the last `hours` of telemetry as column arrays, oldest first."""
         cols = list(columns) if columns else COLUMNS