@meri-imperiumi/signalk-passage-briefing 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-14
+
+### Added
+- Rain-shower episodes on the unified timeline (probable squalls): Open-Meteo `precipitation` (hourly mm/h) and `precipitation_probability` join the fetch, ride `weatherAt`'s interpolation under the same unknown-stays-null rule as cloud cover, and hours at or over the shower bar (≥ 0.5 mm/h rate or ≥ 50 % probability — whichever the model still publishes at that horizon) merge into contiguous `rainEpisodes` carrying the peak rate and probability. They render as info-level 🌧 timeline entries (“Rain showers · 2.5 mm/h · 80 % · until …”) — tropical rain rarely arrives without squalls, so probable rain is the crew's probable-squall advisory without claiming convection's warning weight. The sky line on tactical and here gains the now rain segment above the same bars (🌧 65 %, or 🌧 0.8 mm/h when the model publishes only a rate — drier hours stay quiet); Weather API provider mode publishes no precipitation fields and degrades to absent rather than inventing them.
+
+### Changed
+- Two comfort tiers renamed for the project's modified Sereno scale — `coffee` is now `sporty` ("Lively enough that a hot coffee needs a firm grip.") and `sick` is now `miserable` ("Nobody is enjoying this. Seasickness very likely.") — the canonical identifiers everywhere: physics module, CSS tier tokens (`--comfort-sporty`/`--comfort-miserable`), the embed widget's color map, the status-tile example mapping, and the Signal K value the plugin publishes. Briefings compiled before the rename serve raw old tier names — unstyled, never wrong-colored — until their next compile rewrites them; no compatibility mapping, one unambiguous scale.
+- Sail-change and maneuver timeline entries name the point of sail: `Genoa 1 + Main — broad reach · 9.5 kn TWS · Hs 1.1 m · coffee · at dawn`. The signed TWA at the change point (nearest hourly step, wind-from-starboard positive, same convention as the maneuver tack calls) rides the event's conditions block as `twaDeg`; the timeline renders it as the standard angle-band text (close-hauled / close reach / beam reach / broad reach / running, sign-blind since the maneuver label already calls the tack). Payloads compiled before the field degrade to the previous detail line without inventing an angle.
+
+### Fixed
+- Conditions here showed two "Update now" buttons stacked when no cached conditions existed: the no-cached-conditions strip carried its own button while the conditions card head directly below always carries one. The strip now stays text-only in here mode (the card-head button is the refresh affordance there, present with and without cached data); the route-mode strip keeps its button, as the tab views have no other on-screen refresh.
+- The comfort-scale legend (the ℹ️ popover) opened past the right edge of a phone screen, dragging the page into a sideways scroll with half the legend unreachable. While open it now pins to the viewport — clamped inside the window on both axes, flipping above the summary when the space below runs out, internally scrollable when taller than the screen, and repositioning on scroll, resize and tier-highlight changes.
+- The conditions-here celestial & space events card rendered raw ISO timestamps (`2026-10-12T07:06:12.650Z Tiangong pass: …`) instead of the app's formatted stamps: the renderer read a `stamp` field the plugin never sets, falling through to the raw event timestamp. Events now render through the shared ship's-time formatter like every other view (`MM-DD HH:MM` with the zone offset, `MM-DD HH:MMZ` in UTC when the vessel publishes no timezone), per the Signal K visuals time-formatting rules.
+- Energy timeline events rendered their detail stamps in UTC (`battery depleted by 06-22 03:00Z`) while the same rows' timeline stamp renders in ship's time — a leftover from before the ship's-time work, forcing the crew to do arithmetic between two renderings of the same instant. The `until`/`battery depleted by` details now use the shared ship's-time formatter like every other stamp.
+
 ## [0.9.0] - 2026-10-12
 
 ### Added

package/README.md

@@ -7,14 +7,14 @@ Offshore passage daily briefing webapp for Signal K: a plugin that plans and rev
 - Simulates the passage hourly from the boat's actual position: speed from the vessel's polar, current added, ETA percentiles for the remaining route
 - Recommends sail changes hour by hour from what the crew actually did, learned from the electronic logbook
 - Rates every hour on the Sereno comfort scale and flags when light air in a residual swell will be worse than a gale
-- Renders one unified timeline: sail work, tacks and gybes, clock changes, territorial waters, official alerts, sky events and hazards in order
+- Renders one unified timeline: sail work, tacks and gybes, clock changes, territorial waters, official alerts, sky events, rain showers and hazards in order
 - Fetches bulletins, official structured alerts, global disaster events and synoptic charts for the waters the route actually crosses
 - Keeps working offline: everything fetches in the online window and survives the other 23 hours from the cache
 - Shows a mini summary on the chart plotter and learns from every logbook entry the crew writes
 
 The plugin fetches weather along the planned route — from the server's Weather API when a provider answers, Open-Meteo otherwise; fetched online, or via a GRIB/text spool when offline offshore. It runs a step-forward isochrone simulation with a monohull comfort model, learns the crew's sail preferences from the electronic logbook, and serves a two-screen webapp: a 24-hour tactical dashboard and a strategic passage summary. See [SPEC.md](SPEC.md) for the full design.
 
-Part of the Lille Ø offshore suite, alongside [@meri-imperiumi/signalk-energy-predictor](https://github.com/meri-imperiumi/signalk-energy-predictator) and [@meri-imperiumi/signalk-logbook](https://github.com/meri-imperiumi/signalk-logbook).
+Part of the Lille Ø offshore suite, alongside [@meri-imperiumi/signalk-energy-predictor](https://github.com/meri-imperiumi/signalk-energy-predictor) and [@meri-imperiumi/signalk-logbook](https://github.com/meri-imperiumi/signalk-logbook).
 
 ## Data sources
 
@@ -32,13 +32,13 @@ Part of the Lille Ø offshore suite, alongside [@meri-imperiumi/signalk-energy-p
 - [signalk-ships-time](https://github.com/meri-imperiumi/signalk-ships-time) — `environment.time.timezoneOffset` / `.timezoneRegion`, the vessel's published timezone: briefing stamps render in ship's time when available (the offset rides on every stamp), falling back to UTC `Z` when nothing is published
 - [signalk-watch-schedule](https://github.com/hoeken/signalk-watch-schedule) — `watch.state.onWatch`, `watch.state.startedAt`, `watch.system` and `watch.schedule`: the running watch rotation. While a watch is running, planned sail changes anchor to the previous watch handover (both teams awake) instead of sunrise/sunset; boundaries are extrapolated across the forecast horizon from the rotation cycle
 - [@signalk/sailsconfiguration](https://www.npmjs.com/package/@signalk/sailsconfiguration) — sail inventory used to filter free-text noise out of log entries
-- Weather API (`app.weatherApi`) — waypoint forecasts from the registered provider, the preferred source (`weather_source: auto`) whenever one answers; [signalk-weather-router-plus](https://github.com/motamman/signalk-weather-router-plus) serves it from its decoded ECMWF run, so briefing numbers match what the router planned with. That source carries combined sea only: swell/wind-sea partitions and the upper-air fields behind the convective warnings degrade to absent rather than being invented
+- Weather API (`app.weatherApi`) — waypoint forecasts from the registered provider, the preferred source (`weather_source: auto`) whenever one answers; [signalk-weather-router-plus](https://github.com/motamman/signalk-weather-router-plus) serves it from its decoded ECMWF run, so briefing numbers match what the router planned with. That source carries combined sea only: swell/wind-sea partitions, the upper-air fields behind the convective warnings and the precipitation fields behind the rain-shower episodes degrade to absent rather than being invented
 
 ### External
 
-The Open-Meteo entries below are the fallback weather source: used when no Weather API provider answers (or `weather_source` is `open-meteo`), and the only source of the partition and upper-air fields the Weather API providers don't publish.
+The Open-Meteo entries below are the fallback weather source: used when no Weather API provider answers (or `weather_source` is `open-meteo`), and the only source of the partition, upper-air and precipitation fields the Weather API providers don't publish.
 
-- [Open-Meteo Forecast API](https://open-meteo.com/en/docs) — surface wind, gusts, MSL pressure, CAPE and the pressure-layer fields behind the K-index (best-match model)
+- [Open-Meteo Forecast API](https://open-meteo.com/en/docs) — surface wind, gusts, MSL pressure, CAPE, precipitation (hourly rate and probability) and the pressure-layer fields behind the K-index (best-match model)
 - [NOAA SWPC planetary K-index forecast](https://services.swpc.noaa.gov/products/noaa-planetary-k-index-forecast.json) — geomagnetic activity behind the aurora advisories
 - [JPL SBDB query API](https://ssd-api.jpl.nasa.gov/doc/sbdb_query.html) — comet brightness parameters (M1/K1) behind the Sky Notes comets
 - [CelesTrak](https://celestrak.org/NORAD/elements/gp.php?GROUP=stations&FORMAT=tle) — two-line elements for the crewed stations (ISS, Tiangong); bright satellite passes are propagated locally from the fetched TLEs with SGP4, gated to nautical night, clear sky and a 15° haze line. The same service's per-catalog queries (`gp.php?CATNR=…`) supply the current elements of decaying satellites named by Space-Track's reentry predictions
@@ -64,7 +64,7 @@ All external fetches are online-gated and cached to the plugin data directory, s
 
 ## Acknowledgments
 
-The comfort model and the whole idea of "what will each departure actually feel like" come from SV Sabado's [passage-weather](https://github.com/sailing12388/passage-weather) ensemble departure planner by Ray Hendricks. The Sereno comfort scale (Champagne, Easy, Coffee, Rough, Sick), the encounter-period motion math, and the ISO 2631-1 comfort bands are adapted from it for a monohull (heel and waterline-pitch resonance instead of catamaran beam-roll and bridgedeck slam).
+The comfort model and the whole idea of "what will each departure actually feel like" come from SV Sabado's [passage-weather](https://github.com/sailing12388/passage-weather) ensemble departure planner by Ray Hendricks. Ours is a modified Sereno comfort scale, not a direct copy: the thresholds and the encounter-period motion math are adapted for a monohull (heel and waterline-pitch resonance instead of catamaran beam-roll and bridgedeck slam), the tier names with their meanings are our own — Champagne, Easy, Sporty, Rough, Miserable — and the slatting penalty (light air over a residual swell snap-rolling the boat, which raw acceleration scores as calm) is a vector upstream lacks entirely; a catamaran slats far less, and few models bother with light-air discomfort. The ISO 2631-1 comfort bands complete the model.
 
 ## License
 

package/SPEC.md

@@ -287,6 +287,8 @@ interface TimeStepForecast {
     twd: number;                // degrees true
     mslp: number;               // hPa
     cloudCover: number | null;  // percent (0-100); null when the source carries none
+    precip: number | null;      // mm/h; null when the source carries none
+    precipProbability: number | null; // percent (0-100); null when unknown
   };
   marine: {
     hsCombined: number;         // meters
@@ -439,15 +441,17 @@ Executed inside `public/worker.js` for time steps $\Delta t = 1.0\text{ hour}$:
 
 ### 5.2 Monohull Sereno Comfort Index Formulation
 
+A modified Sereno comfort scale, not a direct copy of the upstream planner's: the band thresholds and motion math derive from passage-weather, the tier names and their one-line meanings are this project's own, and the slatting & roll-dampening penalty below is a vector upstream has nothing of — a catamaran slats far less, and light-air discomfort rarely gets modeled.
+
 #### Vector 1: Apparent Wind Speed Rating
 
 $$AWS = \sqrt{TWS^2 + STW^2 + 2 \cdot TWS \cdot STW \cdot \cos(TWA)}$$
 
 * $AWS < 12\text{ kt} \implies \mathbf{Champagne}$
 * $12\text{ kt} \le AWS < 18\text{ kt} \implies \mathbf{Easy}$
-* $18\text{ kt} \le AWS < 23\text{ kt} \implies \mathbf{Coffee}$
+* $18\text{ kt} \le AWS < 23\text{ kt} \implies \mathbf{Sporty}$
 * $23\text{ kt} \le AWS < 33\text{ kt} \implies \mathbf{Rough}$
-* $AWS \ge 33\text{ kt} \implies \mathbf{Sick}$
+* $AWS \ge 33\text{ kt} \implies \mathbf{Miserable}$
 
 #### Vector 2: Monohull Vertical Acceleration ($a_z$)
 
@@ -482,9 +486,9 @@ $$a_z = a_{z,\text{base}} \cdot \mu_{\text{heel}} \cdot \mu_{\text{pitch}}$$
 
 * $a_z < 0.15\text{ m/s}^2 \implies \mathbf{Champagne}$
 * $0.15 \le a_z < 0.315\text{ m/s}^2 \implies \mathbf{Easy}$
-* $0.315 \le a_z < 0.630\text{ m/s}^2 \implies \mathbf{Coffee}$
+* $0.315 \le a_z < 0.630\text{ m/s}^2 \implies \mathbf{Sporty}$
 * $0.630 \le a_z < 1.250\text{ m/s}^2 \implies \mathbf{Rough}$
-* $a_z \ge 1.250\text{ m/s}^2 \implies \mathbf{Sick}$
+* $a_z \ge 1.250\text{ m/s}^2 \implies \mathbf{Miserable}$
 
 #### Slatting & Roll-Dampening Penalty (work doc #14)
 
@@ -527,9 +531,9 @@ $$\text{IntersectCount} = \sum_{j=1}^{k} \text{RayCrossesSegment}(P_{\text{inter
   --color-fg: #ffcc00;
   --color-champagne: #00ffcc;
   --color-easy: #00ff00;
-  --color-coffee: #ffcc00;
+  --color-sporty: #ffcc00;
   --color-rough: #ff6600;
-  --color-sick: #ff0000;
+  --color-miserable: #ff0000;
   --font-family: 'Courier New', Courier, monospace;
 }
 
@@ -565,6 +569,12 @@ function filterExceptions(simulationResult) {
       totalFuelGal: simulationResult.fuelConsumptionGal,
       macroSeaAnomalies: simulationResult.seaStateAnomalies.filter(a => a.steepnessRatio < 3.28),
       convectiveWarnings: simulationResult.upperAirAnomalies.filter(u => u.cape > 1000 || u.kIndex > 28),
+      // Rain-shower episodes: hours at or over the shower bar
+      // (precip ≥ 0.5 mm/h or probability ≥ 50 %) merged into one
+      // entry each with the peak rate and probability. The crew reads
+      // probable rain as probable squalls in the tropics — info-level
+      // timeline entries, not warnings
+      rainEpisodes: mergeEpisodes(simulationResult.rainHours),
       // Meteor-shower nights evaluated along the track (work doc #37):
       // per (shower, night) spaceEvents gated at the night's nautical-dusk
       // anchor, the radiant checked at the track's forecasted position;
@@ -605,7 +615,7 @@ Displays:
 
 #### `<horizon-sparkline>` (SVG Renderer)
 
-Renders a 24-column SVG bar chart where bar background color maps to `comfortLevel` (Champagne, Easy, Coffee, Rough, Sick) and bar height represents $AWS$.
+Renders a 24-column SVG bar chart where bar background color maps to `comfortLevel` (Champagne, Easy, Sporty, Rough, Miserable) and bar height represents $AWS$.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-passage-briefing",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Offshore passage daily briefing webapp for Signal K",
   "main": "plugin/index.js",
   "scripts": {

package/plugin/fetch-engine.js

@@ -5,9 +5,10 @@
  * Open-Meteo, the same source SV Sabado's passage-weather vetted
  * against raw ECMWF/NOAA GRIB:
  *
- * - forecast API: surface wind (kn), gusts, MSL pressure, CAPE, and
- *   the pressure-layer fields behind the K-index (computed here from
- *   T850/T700/T500 and dewpoints via Magnus);
+ * - forecast API: surface wind (kn), gusts, MSL pressure, CAPE,
+ *   precipitation (rate and probability), and the pressure-layer
+ *   fields behind the K-index (computed here from T850/T700/T500 and
+ *   dewpoints via Magnus);
  * - marine API (`ncep_gfswave025`): combined sea plus wind sea and
  *   swell partitions (the SPEC §3.1 marine block needs the split;
  *   ECMWF's split fields come back empty per passage-weather's
@@ -74,6 +75,8 @@ const FORECAST_HOURLY = [
   "relative_humidity_700hPa",
   "wind_speed_850hPa",
   "cloud_cover",
+  "precipitation",
+  "precipitation_probability",
 ].join(",");
 
 const WAVE_HOURLY = [
@@ -445,6 +448,8 @@ function buildTimeSteps(surfaceMap, marineMap, currentMap) {
         mslp: num(surface.pressure_msl),
         gust,
         cloudCover: num(surface.cloud_cover),
+        precip: num(surface.precipitation),
+        precipProbability: num(surface.precipitation_probability),
       },
       marine: {
         hsCombined: num(marine.wave_height),
@@ -533,6 +538,8 @@ async function fetchWeatherAlongTrack({
       "relative_humidity_700hPa",
       "wind_speed_850hPa",
       "cloud_cover",
+      "precipitation",
+      "precipitation_probability",
     ]);
     const marineMap = hourlyLookup(waveBlocks[index], [
       "wave_height",

package/plugin/weather-source.js

@@ -98,6 +98,10 @@ function weatherDataToTimeStep(item) {
       // The provider publishes no cloud cover; the celestial
       // visibility gate stays open (work doc #3 Phase 2)
       cloudCover: null,
+      // Nor any precipitation fields; rain-shower episodes degrade
+      // to absent rather than being invented
+      precip: null,
+      precipProbability: null,
     },
     marine: {
       hsCombined: Number.isFinite(item.water?.waveSignificantHeight)

package/public/brief-ext-widget.js

@@ -279,9 +279,9 @@ class BriefExtWidget extends HTMLElement {
       {
         champagne: "#8dfcbb",
         easy: "#8dfcbb",
-        coffee: "#fca847",
+        sporty: "#fca847",
         rough: "#fca847",
-        sick: "#ff5e5e",
+        miserable: "#ff5e5e",
       }[String(comfort).toLowerCase()] ?? "var(--text-main, #c4c4c4)";
     const stale = this.values["navigation.briefing.stale"] === true;
     const ageEl = root.querySelector("#age");

package/public/components/comfort-info.js

@@ -1,7 +1,7 @@
 /**
  * The ℹ️ next to the comfort tier: an expanding explainer for the
- * Sereno comfort scale (champagne → sick), highlighting the current
- * tier via the `tier` attribute. Used by the tactical dashboard and
+ * project's modified Sereno comfort scale (champagne → miserable),
+ * highlighting the current tier via the `tier` attribute. Used by the tactical dashboard and
  * the conditions-here view.
  *
  * @file components/comfort-info.js
@@ -32,6 +32,7 @@ class ComfortInfo extends HTMLElement {
           border: 1px solid var(--color-grey);
           font-family: var(--font-data, ui-monospace, monospace);
           font-size: 0.75rem; text-transform: none; letter-spacing: normal;
+          max-height: calc(100vh - 16px); overflow-y: auto;
         }
         .note { color: var(--color-grey); margin: 0 0 6px; }
         .row { margin: 4px 0; }
@@ -45,10 +46,66 @@ class ComfortInfo extends HTMLElement {
       </details>
     `;
     this._details = this.shadowRoot.querySelector("details");
+    this._summary = this.shadowRoot.querySelector("summary");
     this._pop = this.shadowRoot.getElementById("pop");
+    // Mobile-safe popover (viewport-clamped): anchored absolute it
+    // runs off the right edge of a phone screen and drags the page
+    // into a sideways scroll. While open it is pinned to the
+    // viewport instead, repositioning on scroll and resize.
+    this._details.addEventListener("toggle", () => {
+      if (this._details.open) {
+        requestAnimationFrame(() => this._positionPop());
+        window.addEventListener("scroll", this, true);
+        window.addEventListener("resize", this);
+      } else {
+        window.removeEventListener("scroll", this, true);
+        window.removeEventListener("resize", this);
+      }
+    });
     this.renderPop();
   }
 
+  /**
+   * Repositions the open popover as a viewport-fixed overlay clamped
+   * inside the window (handleEvent target for scroll/resize).
+   */
+  handleEvent() {
+    this._positionPop();
+  }
+
+  disconnectedCallback() {
+    window.removeEventListener("scroll", this, true);
+    window.removeEventListener("resize", this);
+  }
+
+  /** Pins the open popover inside the viewport, flipping above the
+   *  summary when the space below runs out. */
+  _positionPop() {
+    if (!this._details?.open || !this._pop) {
+      return;
+    }
+    const rect = this._summary.getBoundingClientRect();
+    const margin = 8;
+    const gap = 6;
+    const width = this._pop.offsetWidth;
+    const height = this._pop.offsetHeight;
+    const left = Math.min(
+      Math.max(rect.left, margin),
+      Math.max(window.innerWidth - width - margin, margin),
+    );
+    let top = rect.bottom + gap;
+    if (top + height > window.innerHeight - margin) {
+      top = rect.top - height - gap;
+    }
+    top = Math.min(
+      Math.max(top, margin),
+      Math.max(window.innerHeight - height - margin, margin),
+    );
+    this._pop.style.position = "fixed";
+    this._pop.style.left = `${left}px`;
+    this._pop.style.top = `${top}px`;
+  }
+
   attributeChangedCallback() {
     this.renderPop();
   }
@@ -101,6 +158,8 @@ class ComfortInfo extends HTMLElement {
       "wind < 7–12 kn by point of sail · swell ≥ 0.6 m";
     slatting.appendChild(slattingBand);
     this._pop.appendChild(slatting);
+    // Content changes (tier highlight) can resize the open popover
+    this._positionPop();
   }
 }
 

package/public/components/conditions-here.js

@@ -14,6 +14,7 @@
 
 import {
   fmtKn,
+  fmtShip,
   fmtUtc,
   hereEnergySummary,
   hereHourly,
@@ -318,6 +319,8 @@ class ConditionsHere extends HTMLElement {
       this._skyEl.innerHTML = "";
       for (const segment of skySegments(payload ?? null, {
         cloudCover: now.cloudCover ?? null,
+        precip: now.precipMmH ?? null,
+        precipProbability: now.precipProbability ?? null,
       })) {
         const span = document.createElement("span");
         span.textContent = segment.text;
@@ -353,7 +356,7 @@ class ConditionsHere extends HTMLElement {
     for (const event of events) {
       const el = document.createElement("div");
       el.textContent =
-        `${event.stamp ?? event.timestamp ?? ""} ${event.description ?? event.kind ?? ""}`.trim();
+        `${fmtShip(event.timestamp)} ${event.description ?? event.kind ?? ""}`.trim();
       // Provenance (work doc #31): satellite passes carry the live
       // tracker link; computed ephemeris carries none
       const provUrl = event.provenance?.url;

package/public/components/models.mjs

@@ -14,6 +14,7 @@ import {
   serenoComfort,
   travelDirection,
 } from "../sereno-physics.mjs";
+import { pointOfSail } from "../tack-gybe.js";
 
 const DEG = Math.PI / 180;
 
@@ -24,9 +25,9 @@ const DEG = Math.PI / 180;
 export const COMFORT_TIERS = [
   { level: "champagne", css: "var(--comfort-champagne)" },
   { level: "easy", css: "var(--comfort-easy)" },
-  { level: "coffee", css: "var(--comfort-coffee)" },
+  { level: "sporty", css: "var(--comfort-sporty)" },
   { level: "rough", css: "var(--comfort-rough)" },
-  { level: "sick", css: "var(--comfort-sick)" },
+  { level: "miserable", css: "var(--comfort-miserable)" },
 ];
 
 const TIER_BY_LEVEL = new Map(COMFORT_TIERS.map((t) => [t.level, t.css]));
@@ -538,6 +539,8 @@ export function hereNow(payload, rows = []) {
       mslpHpa: null,
       mslpTrend: null,
       cloudCover: null,
+      precipMmH: null,
+      precipProbability: null,
       stamp: "",
     };
   }
@@ -561,6 +564,8 @@ export function hereNow(payload, rows = []) {
     mslpHpa: mslpNow,
     mslpTrend,
     cloudCover: step.surface?.cloudCover ?? null,
+    precipMmH: step.surface?.precip ?? null,
+    precipProbability: step.surface?.precipProbability ?? null,
     stamp: fmtShip(step.timestamp),
   };
 }
@@ -866,12 +871,21 @@ function moonGlyphFor(timestamp, payload) {
  *   picked for (default: the payload's fetch time)
  * @param {number|null} [options.cloudCover] - Cloud cover percent at
  *   that instant
+ * @param {number|null} [options.precip] - Precipitation rate (mm/h) at
+ *   that instant
+ * @param {number|null} [options.precipProbability] - Precipitation
+ *   probability percent at that instant
  * @returns {Array<{text: string, title: string}>} Empty when the
  *   payload predates the sky data
  */
 export function skySegments(
   payload,
-  { timestamp = null, cloudCover = null } = {},
+  {
+    timestamp = null,
+    cloudCover = null,
+    precip = null,
+    precipProbability = null,
+  } = {},
 ) {
   const night = nearestNight(
     timestamp ?? payload?.metadata?.fetchedAt ?? null,
@@ -922,6 +936,26 @@ export function skySegments(
       title: `cloud cover ${Math.round(cloudCover)} %`,
     });
   }
+  // Rain rides the same line as the cloud it falls from — but only
+  // when it is probable: the segment speaks at the same shower bars
+  // the timeline's rain episodes use (route-sim.mjs RAIN_MM_PER_H /
+  // RAIN_PROBABILITY_PERCENT; mirrored here to keep this module
+  // dependency-light). A 10 % chance is noise, not weather.
+  const rainyRate = precip != null && Number.isFinite(precip) && precip >= 0.5;
+  const rainyProb =
+    precipProbability != null &&
+    Number.isFinite(precipProbability) &&
+    precipProbability >= 50;
+  if (rainyProb || rainyRate) {
+    segments.push({
+      text: rainyProb
+        ? `🌧 ${Math.round(precipProbability)}%`
+        : `🌧 ${precip.toFixed(1)}mm`,
+      title: rainyProb
+        ? `precipitation probability ${Math.round(precipProbability)} %`
+        : `precipitation ${precip.toFixed(1)} mm/h`,
+    });
+  }
   return segments;
 }
 
@@ -1271,15 +1305,16 @@ export function mergeTimeline(exceptions, payload = null) {
     const label = maneuver
       ? `${e.maneuver === "tack" ? "Tack" : "Gybe"} to ${e.toTack ?? tack ?? "?"}`
       : sailEventLabel(e) || state;
-    // Conditions at the change point (work doc #18): what the crew
-    // is rigging into — true wind, sea state, comfort tier. Falls
-    // back to the bare maneuver TWS for payloads without the
+    // Conditions at the change point (work doc #18): how the boat
+    // sits to the wind, then true wind, sea state, comfort tier.
+    // Falls back to the bare maneuver TWS for payloads without the
     // enriched conditions block. When the tier came from the
     // slatting penalty (work doc #14: light air over a residual
     // swell), the detail says so — "rough" alone would send someone
     // looking for wind that isn't there.
     const conditions = e.conditions ?? null;
     const tws = conditions?.twsKnots ?? e.twsAtManeuver ?? null;
+    const posText = pointOfSail(conditions?.twaDeg ?? null);
     // Why the change sits where it sits: watch handover when a watch
     // schedule runs, else the sunrise/sunset it waits for
     const anchorText =
@@ -1300,6 +1335,7 @@ export function mergeTimeline(exceptions, payload = null) {
         e.distanceFromStartNm != null
           ? `${Math.round(e.distanceFromStartNm)} nm`
           : null,
+        posText,
         tws != null ? `${fmtKn(tws)} TWS` : null,
         conditions?.hsMeters != null
           ? `Hs ${conditions.hsMeters.toFixed(1)} m`
@@ -1352,6 +1388,25 @@ export function mergeTimeline(exceptions, payload = null) {
     });
   }
 
+  // Rain-shower episodes (probable squalls in the tropics): peak
+  // hourly rate and probability over the range, info-level — rain
+  // informs where convection warns
+  for (const r of summary.rainEpisodes ?? []) {
+    push({
+      hoursFromNow: r.hoursFromNow ?? null,
+      timestamp: r.timestamp ?? null,
+      kind: "rain",
+      severity: "info",
+      label: "Rain showers",
+      detail: episodeDetail(r, [
+        r.precip != null ? `${r.precip.toFixed(1)} mm/h` : null,
+        r.precipProbability != null
+          ? `${Math.round(r.precipProbability)} %`
+          : null,
+      ]),
+    });
+  }
+
   // Hazard notes along the track (whole passage; the tactical slice
   // picks up its share by hoursFromNow). Provenance (work doc #31):
   // the note's url is the GDACS event page the note was built from
@@ -1582,10 +1637,10 @@ export function mergeTimeline(exceptions, payload = null) {
           ? `${e.netWh >= 0 ? "+" : "−"}${(Math.abs(e.netWh) / 1000).toFixed(1)} kWh`
           : null,
         e.timestamp != null && e.endTimestamp != null
-          ? `until ${fmtUtc(e.endTimestamp)}`
+          ? `until ${fmtShip(e.endTimestamp)}`
           : null,
         deficit && e.timeToEmpty != null
-          ? `battery depleted by ${fmtUtc(e.timeToEmpty)}`
+          ? `battery depleted by ${fmtShip(e.timeToEmpty)}`
           : null,
         e.type === "surplus" ? "run opportunistic loads" : null,
       ]

package/public/components/passage-outlook.js

@@ -671,15 +671,17 @@ class PassageOutlook extends HTMLElement {
       mode === "here"
         ? "No cached conditions yet"
         : "No cached briefing for this route";
-    const button = document.createElement("button");
-    button.textContent = "Update now";
-    button.disabled = this._status?.online !== true;
-    // Here mode refreshes the conditions payload; the route-select
-    // flow would target the selected route instead
-    button.addEventListener("click", () =>
-      mode === "here" ? this.refreshHereBriefing() : this.refreshBriefing(),
-    );
-    strip.append(text, button);
+    strip.append(text);
+    // Route mode has no other refresh affordance on screen; here mode
+    // carries its own Update now in the conditions card head (work
+    // doc #7) — a second button on the strip read as a duplicate
+    if (mode !== "here") {
+      const button = document.createElement("button");
+      button.textContent = "Update now";
+      button.disabled = this._status?.online !== true;
+      button.addEventListener("click", () => this.refreshBriefing());
+      strip.append(button);
+    }
     this._view.before(strip);
   }
 

package/public/components/passage-timeline.js

@@ -26,6 +26,7 @@ const GLYPHS = {
   sail: "⛵",
   maneuver: "⇄",
   convective: "⚡",
+  rain: "🌧",
   sea: "🌊",
   zone: "⚑",
   space: "✦",

package/public/components/tactical-dashboard.js

@@ -259,11 +259,12 @@ strong.sev {
       return;
     }
     el.innerHTML = "";
-    const nowCloud =
-      this._payload?.waypoints?.[0]?.forecasts?.[0]?.surface?.cloudCover ??
-      null;
+    const nowSurface =
+      this._payload?.waypoints?.[0]?.forecasts?.[0]?.surface ?? null;
     const segments = skySegments(this._payload ?? null, {
-      cloudCover: nowCloud,
+      cloudCover: nowSurface?.cloudCover ?? null,
+      precip: nowSurface?.precip ?? null,
+      precipProbability: nowSurface?.precipProbability ?? null,
     });
     for (const segment of segments) {
       const span = document.createElement("span");

package/public/css/visuals.css

@@ -18,9 +18,9 @@
   /* Comfort tiers (Sereno physics, SPEC §5.2) — night-lean defaults */
   --comfort-champagne: #33616b;
   --comfort-easy: #4a7555;
-  --comfort-coffee: #8a5318;
+  --comfort-sporty: #8a5318;
   --comfort-rough: #a05218;
-  --comfort-sick: #8f3333;
+  --comfort-miserable: #8f3333;
   --comfort-unknown: #333333;
 
   --color-green: #4a7555;
@@ -39,9 +39,9 @@
 :root[data-mode="day"] {
   --comfort-champagne: #66c6db;
   --comfort-easy: #8dfcbb;
-  --comfort-coffee: #fca847;
+  --comfort-sporty: #fca847;
   --comfort-rough: #ff8847;
-  --comfort-sick: #ff5e5e;
+  --comfort-miserable: #ff5e5e;
   --comfort-unknown: #666666;
 
   --color-green: #8dfcbb;

package/public/route-sim.mjs

@@ -39,7 +39,7 @@ import {
   suggestSailState,
   travelDirection,
 } from "./sereno-physics.mjs";
-import { detectManeuvers } from "./tack-gybe.js";
+import { detectManeuvers, wrap180 } from "./tack-gybe.js";
 import tzLookup from "./vendor/tz-lookup/tz-lookup.mjs";
 
 /**
@@ -389,6 +389,16 @@ export function weatherAt(forecasts, timestamp) {
         sa.cloudCover == null || sb.cloudCover == null
           ? null
           : mix(sa.cloudCover, sb.cloudCover),
+      // Rain fields follow the same honesty rule: unknown on either
+      // side of the span interpolates to null, never invented
+      precip:
+        sa.precip == null || sb.precip == null
+          ? null
+          : mix(sa.precip, sb.precip),
+      precipProbability:
+        sa.precipProbability == null || sb.precipProbability == null
+          ? null
+          : mix(sa.precipProbability, sb.precipProbability),
     },
     marine: {
       hsCombined: mix(ma.hsCombined, mb.hsCombined),
@@ -492,6 +502,22 @@ const CONVECTIVE_K_INDEX = 30;
  */
 const CONVECTIVE_K_INDEX_MARGINAL = 28;
 
+/**
+ * Hourly precipitation rate at which a rain-shower hour is captured
+ * (mm/h). Tropical rain rarely arrives without squalls, so the crew
+ * reads a shower band as probable squalls; below the bar an hour is a
+ * stray drop, not weather.
+ */
+const RAIN_MM_PER_H = 0.5;
+
+/**
+ * Precipitation probability at which a rain-shower hour is captured
+ * (%). The probability field extends detection into the later forecast
+ * days, where some models publish it long after they stop being
+ * confident about hourly rates.
+ */
+const RAIN_PROBABILITY_PERCENT = 50;
+
 /**
  * Maximum gap in hours between two hourly anomalies that still counts
  * as one continuing episode (covers hourly forecast steps and the
@@ -876,6 +902,7 @@ export function simulateRun({
   const positions = [];
   const seaStateAnomalies = [];
   const upperAirAnomalies = [];
+  const rainHours = [];
   const timeEvents = [];
   let arrivedHours = null;
   let distanceMadeGoodNm = 0;
@@ -1110,6 +1137,24 @@ export function simulateRun({
       });
     }
 
+    // Rain-shower hours (probable squalls): either the model's hourly
+    // rate crosses the shower bar or its probability does — the two
+    // fields have independent availability across the horizon
+    const precip = weather?.surface?.precip;
+    const precipProbability = weather?.surface?.precipProbability;
+    if (
+      (precip != null && precip >= RAIN_MM_PER_H) ||
+      (precipProbability != null &&
+        precipProbability >= RAIN_PROBABILITY_PERCENT)
+    ) {
+      rainHours.push({
+        hoursFromNow: Math.round(hours * 10) / 10,
+        timestamp: t.toISOString(),
+        precip,
+        precipProbability,
+      });
+    }
+
     // Waypoint progress
     if (arrivedNow) {
       if (targetIndex === track.length - 1) {
@@ -1175,6 +1220,7 @@ export function simulateRun({
     positions,
     seaStateAnomalies,
     upperAirAnomalies,
+    rainHours,
     timeEvents,
     hazardAlerts: hazardAlerts(notes, positions),
   };
@@ -1484,6 +1530,15 @@ export function simulatePassage({
               conditions: {
                 twsKnots: row.twsKnots ?? null,
                 awsKnots: row.awsKnots ?? null,
+                // Signed TWA at the change point (positive = wind
+                // from starboard, same convention as the maneuvers):
+                // the timeline names the point of sail, tiles and
+                // widgets read the precise angle
+                twaDeg:
+                  typeof row.headingDeg === "number" &&
+                  typeof row.twdDeg === "number"
+                    ? Math.round(wrap180(row.twdDeg - row.headingDeg) * 10) / 10
+                    : null,
                 hsMeters: row.hsMeters ?? null,
                 tpSeconds: row.tpSeconds ?? null,
                 comfortLevel: row.comfortLevel ?? null,
@@ -1509,6 +1564,7 @@ export function simulatePassage({
     hazardAlerts: nominal.hazardAlerts,
     seaStateAnomalies: nominal.seaStateAnomalies,
     upperAirAnomalies: nominal.upperAirAnomalies,
+    rainHours: nominal.rainHours,
     energy: energySummary(energyHourly, startTime),
     runs: runs.map((run, i) => ({
       twsFactor: ETA_FACTORS[i],
@@ -1687,6 +1743,19 @@ export function filterExceptions(simulationResult, simParams = {}) {
           (episode.kIndex != null && episode.kIndex >= CONVECTIVE_K_INDEX)
         ),
       })),
+      // Rain-shower episodes (probable squalls): contiguous wet hours
+      // merge into one entry carrying the episode's peak rate and
+      // probability; always info-level — rain informs, CAPE warns
+      rainEpisodes: mergeEpisodes(
+        simulationResult.rainHours ?? [],
+        (episode, r) => {
+          episode.precip = maxOf(episode.precip, r.precip);
+          episode.precipProbability = maxOf(
+            episode.precipProbability,
+            r.precipProbability,
+          );
+        },
+      ),
     },
   };
 }

package/public/sereno-physics.mjs

@@ -7,7 +7,7 @@
  * consumes the same file with `import()`.
  *
  * The comfort model rates a passage hour on the Sereno scale
- * (Champagne > Easy > Coffee > Rough > Sick) from two independent
+ * (Champagne > Easy > Sporty > Rough > Miserable) from two independent
  * vectors, the worse of which sets the level:
  *
  * 1. **Wind over the deck** — apparent wind speed bands derived from
@@ -23,8 +23,12 @@
  * (https://github.com/sailing12388/passage-weather, MIT), adapted for a
  * monohull: the catamaran beam-roll and bridgedeck-slam factors are
  * replaced by a heel multiplier and a waterline pitching resonance
- * term. Not calibrated against a logged passage until the backtest CLI
- * (SPEC §7) tunes k_heel/k_pitch against the vessel's own history.
+ * term. This is a modified Sereno scale, not a direct copy — the
+ * slatting penalty is this project's own addition, upstream has
+ * nothing like it (a catamaran slats far less, and light-air
+ * discomfort rarely gets modeled at all). Not calibrated against a
+ * logged passage until the backtest CLI (SPEC §7) tunes k_heel/k_pitch
+ * against the vessel's own history.
  *
  * Conventions:
  * - wind speeds and boat speeds in knots, angles in radians unless a
@@ -53,7 +57,13 @@ export const KN_TO_MS = 0.514444;
  * Comfort tiers, best first. The index in this array is the severity
  * rank used when combining vectors.
  */
-export const COMFORT_TIERS = ["champagne", "easy", "coffee", "rough", "sick"];
+export const COMFORT_TIERS = [
+  "champagne",
+  "easy",
+  "sporty",
+  "rough",
+  "miserable",
+];
 
 /**
  * One-line meaning per comfort tier, display order best first, with
@@ -74,10 +84,10 @@ export const COMFORT_SCALE_INFO = [
     text: "Comfortable: moving around below is easy.",
   },
   {
-    tier: "coffee",
+    tier: "sporty",
     maxAws: 23,
     maxAz: 0.63,
-    text: "You can still hold a hot coffee without wearing it.",
+    text: "Lively enough that a hot coffee needs a firm grip.",
   },
   {
     tier: "rough",
@@ -86,22 +96,22 @@ export const COMFORT_SCALE_INFO = [
     text: "One hand for the boat — loose objects go flying.",
   },
   {
-    tier: "sick",
+    tier: "miserable",
     maxAws: null,
     maxAz: null,
-    text: "Beyond rough: seasickness very likely — think shelter or a course change.",
+    text: "Nobody is enjoying this. Seasickness very likely.",
   },
 ];
 
 /**
  * Apparent wind speed (knots) at or above which each tier is lost
- * (Champagne, Easy, Coffee, Rough). SPEC §5.2 vector 1.
+ * (Champagne, Easy, Sporty, Rough). SPEC §5.2 vector 1.
  */
 export const AWS_BANDS_KNOTS = [12, 18, 23, 33];
 
 /**
  * RMS vertical acceleration (m/s²) at or above which each tier is lost
- * (Champagne, Easy, Coffee, Rough). SPEC §5.2 vector 2, ISO 2631-1.
+ * (Champagne, Easy, Sporty, Rough). SPEC §5.2 vector 2, ISO 2631-1.
  */
 export const AZ_BANDS_MS2 = [0.15, 0.315, 0.63, 1.25];
 

package/public/tack-gybe.js

@@ -51,6 +51,37 @@ export function tackSide(signedTwaDeg) {
   return signedTwaDeg >= 0 ? "starboard" : "port";
 }
 
+/**
+ * Point of sail for a signed TWA, by the standard true-wind-angle
+ * bands: close-hauled (≤ 60°), close reach (≤ 80°), beam reach
+ * (≤ 100°), broad reach (≤ 150°), running beyond. The sign is
+ * deliberately ignored — tack side is `tackSide`'s business — so a
+ * timeline detail can name how the boat sits to the wind without
+ * duplicating the maneuver label's tack call.
+ *
+ * @param {number|null} signedTwaDeg
+ * @returns {string|null} Band name, or null without usable input
+ */
+export function pointOfSail(signedTwaDeg) {
+  if (typeof signedTwaDeg !== "number" || !Number.isFinite(signedTwaDeg)) {
+    return null;
+  }
+  const abs = Math.abs(signedTwaDeg);
+  if (abs <= 60) {
+    return "close-hauled";
+  }
+  if (abs <= 80) {
+    return "close reach";
+  }
+  if (abs <= 100) {
+    return "beam reach";
+  }
+  if (abs <= 150) {
+    return "broad reach";
+  }
+  return "running";
+}
+
 /**
  * Whether a simulation hour is a sailing step: not motoring, actually
  * making way (drift-mode hours sit at SOG 0) and the plan's rig up —

package/status-tiles-examples.json

@@ -19,9 +19,9 @@
               "map": [
                 { "value": "champagne", "state": "green" },
                 { "value": "easy", "state": "green" },
-                { "value": "coffee", "state": "amber" },
+                { "value": "sporty", "state": "amber" },
                 { "value": "rough", "state": "amber" },
-                { "value": "sick", "state": "red" }
+                { "value": "miserable", "state": "red" }
               ],
               "default": "neutral",
               "reason": "Comfort tier unknown",

package/tests/backtest.test.js

@@ -404,7 +404,7 @@ test("backtest CLI runs against a local history server", async () => {
 
   // Matrix rendering
   const rendered = renderMatrix({
-    tiers: ["champagne", "easy", "coffee", "rough", "sick"],
+    tiers: ["champagne", "easy", "sporty", "rough", "miserable"],
     matrix: [
       [3, 1, 0, 0, 0],
       [0, 4, 0, 0, 0],

package/tests/fetch-engine.test.js

@@ -166,7 +166,15 @@ describe("fetchWeatherAlongTrack", () => {
       mslp: 1013,
       gust: 18,
       cloudCover: 25,
+      precip: 0,
+      precipProbability: 10,
     });
+    // Second step carries the wet hour of the fixture
+    assert.equal(payload.waypoints[0].forecasts[1].surface.precip, 2.4);
+    assert.equal(
+      payload.waypoints[0].forecasts[1].surface.precipProbability,
+      80,
+    );
     assert.deepEqual(step.marine, {
       hsCombined: 1.2,
       tpCombined: 7,

package/tests/openmeteo-mock.js

@@ -29,6 +29,8 @@ function forecastFixture() {
       relative_humidity_700hPa: [60, 65],
       wind_speed_850hPa: [20, 22],
       cloud_cover: [25, 75],
+      precipitation: [0, 2.4],
+      precipitation_probability: [10, 80],
     },
   };
 }

package/tests/plugin.test.js

@@ -1170,7 +1170,7 @@ describe("plugin", () => {
 
       // Brief meta serves the same view the tile publishes
       const meta = await call("/api/brief-meta");
-      assert.equal(meta.payload.comfort, "coffee");
+      assert.equal(meta.payload.comfort, "sporty");
       assert.equal(meta.payload.stale, false);
       assert.equal(meta.payload.ageHours, 0);
 

package/tests/route-sim.test.js

@@ -33,6 +33,7 @@ function buildPayload({
   set = 0,
   steepHour = null,
   convectiveHour = null,
+  rainHour = null,
 } = {}) {
   const track = sampleRoutePoints(route);
   const waypoints = track.map((w) => ({
@@ -47,6 +48,8 @@ function buildPayload({
           twd,
           mslp: 1013,
           gust: tws + 5,
+          precip: h === rainHour ? 2.5 : 0,
+          precipProbability: h === rainHour ? 80 : 10,
         },
         marine: {
           hsCombined: steep ? 3 : hs,
@@ -175,7 +178,7 @@ describe("simulateRun", () => {
     // Comfort evaluated every hour
     for (const block of run.hourly) {
       assert.ok(
-        ["champagne", "easy", "coffee", "rough", "sick"].includes(
+        ["champagne", "easy", "sporty", "rough", "miserable"].includes(
           block.comfortLevel,
         ),
       );
@@ -293,6 +296,26 @@ describe("simulateRun", () => {
     assert.ok(run.upperAirAnomalies.some((a) => a.kIndex > 28));
   });
 
+  test("collects rain-shower hours over the shower bar", async () => {
+    const { simulateRun } = await simPromise;
+    // START is 06:00Z, so fixture hour 7 is simulated hour 1
+    const run = simulateRun({
+      payload: buildPayload({ rainHour: 7 }),
+      startTime: START,
+      maxHours: 12,
+    });
+    assert.equal(run.rainHours.length, 1);
+    assert.equal(run.rainHours[0].precip, 2.5);
+    assert.equal(run.rainHours[0].precipProbability, 80);
+    // Dry fixture hours stay under the bar
+    const dry = simulateRun({
+      payload: buildPayload({}),
+      startTime: START,
+      maxHours: 12,
+    });
+    assert.equal(dry.rainHours.length, 0);
+  });
+
   test("current pushes the boat off the heading line", async () => {
     const { simulateRun } = await simPromise;
     const withCurrent = simulateRun({
@@ -419,6 +442,14 @@ describe("simulatePassage", () => {
     for (const change of exceptions.passageSummary.sailChanges) {
       if (change.conditions) {
         assert.equal(change.conditions.cloudCover, null);
+        // Signed TWA at the change point (work doc #5): the angle
+        // behind the timeline's point-of-sail text — within ±180°
+        assert.ok(
+          change.conditions.twaDeg == null ||
+            (change.conditions.twaDeg > -180 &&
+              change.conditions.twaDeg <= 180),
+          `twaDeg ${change.conditions.twaDeg} out of range`,
+        );
       }
     }
     assert.equal(
@@ -427,6 +458,7 @@ describe("simulatePassage", () => {
     );
     assert.ok(exceptions.passageSummary.macroSeaAnomalies.length === 0);
     assert.ok(exceptions.passageSummary.convectiveWarnings.length === 0);
+    assert.ok(exceptions.passageSummary.rainEpisodes.length === 0);
     assert.ok(Array.isArray(exceptions.passageSummary.hazards));
   });
 
@@ -492,6 +524,21 @@ describe("simulatePassage", () => {
     assert.equal(exceptions.passageSummary.convectiveWarnings[0].cape, 1800);
   });
 
+  test("rain episodes surface in the passage summary", async () => {
+    const { filterExceptions, simulatePassage } = await simPromise;
+    const result = simulatePassage({
+      payload: buildPayload({ rainHour: 7 }),
+      startTime: new Date("2026-06-21T06:00:00Z"),
+    });
+    const exceptions = filterExceptions(result);
+    assert.ok(exceptions.passageSummary.rainEpisodes.length >= 1);
+    assert.equal(exceptions.passageSummary.rainEpisodes[0].precip, 2.5);
+    assert.equal(
+      exceptions.passageSummary.rainEpisodes[0].precipProbability,
+      80,
+    );
+  });
+
   test("anomalies merge into episodes with peak values, marginal band drops", async () => {
     const { filterExceptions } = await simPromise;
     const result = {

package/tests/sereno-physics.test.js

@@ -18,9 +18,9 @@ describe("comfort bands (SPEC §5.2)", () => {
     assert.deepEqual(p.COMFORT_TIERS, [
       "champagne",
       "easy",
-      "coffee",
+      "sporty",
       "rough",
-      "sick",
+      "miserable",
     ]);
     assert.deepEqual(p.STEEPNESS_RATIO_THRESHOLD, 3.28);
   });
@@ -29,18 +29,18 @@ describe("comfort bands (SPEC §5.2)", () => {
     const { rateApparentWind } = await physics();
     assert.equal(rateApparentWind(11.9), "champagne");
     assert.equal(rateApparentWind(12), "easy");
-    assert.equal(rateApparentWind(18), "coffee");
+    assert.equal(rateApparentWind(18), "sporty");
     assert.equal(rateApparentWind(23), "rough");
-    assert.equal(rateApparentWind(33), "sick");
+    assert.equal(rateApparentWind(33), "miserable");
   });
 
   test("acceleration bands", async () => {
     const { rateAcceleration } = await physics();
     assert.equal(rateAcceleration(0.149), "champagne");
     assert.equal(rateAcceleration(0.15), "easy");
-    assert.equal(rateAcceleration(0.315), "coffee");
+    assert.equal(rateAcceleration(0.315), "sporty");
     assert.equal(rateAcceleration(0.63), "rough");
-    assert.equal(rateAcceleration(1.25), "sick");
+    assert.equal(rateAcceleration(1.25), "miserable");
   });
 });
 
@@ -241,8 +241,8 @@ describe("serenoComfort", () => {
       { twsKnots: 6, twaRad: 0.3 },
     );
     assert.ok(
-      ["rough", "sick"].includes(rough.comfort),
-      `expected rough/sick, got ${rough.comfort}`,
+      ["rough", "miserable"].includes(rough.comfort),
+      `expected rough/miserable, got ${rough.comfort}`,
     );
     // Champagne glass conditions: light following breeze, gentle swell
     const idyllic = serenoComfort(

package/tests/statustilesexamples.test.js

@@ -29,7 +29,7 @@ test("bundled example set parses and references published paths", () => {
   const comfortCheck = tile.checks[0];
   assert.deepEqual(
     comfortCheck.map.map((m) => m.value),
-    ["champagne", "easy", "coffee", "rough", "sick"],
+    ["champagne", "easy", "sporty", "rough", "miserable"],
   );
   const footerPaths = tile.footer.map((f) => f.path);
   assert.ok(footerPaths.includes("navigation.briefing.ageHours"));

package/tests/tack-gybe.test.js

@@ -220,4 +220,19 @@ describe("tack & gybe detection", () => {
     assert.equal(events.length, 1);
     assert.equal(events[0].sailState, "@port");
   });
+
+  test("pointOfSail names the true-wind-angle band, sign-blind", async () => {
+    const { pointOfSail } = await tgPromise;
+    assert.equal(pointOfSail(45), "close-hauled");
+    assert.equal(pointOfSail(-60), "close-hauled");
+    assert.equal(pointOfSail(70), "close reach");
+    assert.equal(pointOfSail(-90), "beam reach");
+    assert.equal(pointOfSail(120), "broad reach");
+    assert.equal(pointOfSail(-170), "running");
+    assert.equal(pointOfSail(180), "running");
+    // Without usable input there is nothing to say — old payloads
+    // without a conditions TWA degrade to the bare detail line
+    assert.equal(pointOfSail(null), null);
+    assert.equal(pointOfSail(undefined), null);
+  });
 });

package/tests/weather-source.test.js

@@ -50,6 +50,9 @@ describe("weatherDataToTimeStep", () => {
     assert.equal(step.surface.twd, 45);
     assert.equal(step.surface.mslp, 1013);
     assert.equal(step.surface.gust, 18);
+    // Provider mode carries no precipitation fields — degrade, never invent
+    assert.equal(step.surface.precip, null);
+    assert.equal(step.surface.precipProbability, null);
     assert.equal(step.marine.hsCombined, 1.2);
     assert.equal(step.marine.tpCombined, 7);
     assert.equal(step.marine.dirCombined, 160);

package/tests/webapp.test.js

@@ -154,7 +154,7 @@ test("webapp view models", async (t) => {
       const blocks = [
         { hoursFromNow: 0, comfortLevel: "champagne", awsKnots: 10 },
         { hoursFromNow: 1, comfortLevel: "rough", awsKnots: 20 },
-        { hoursFromNow: 2, comfortLevel: "sick", awsKnots: 0 },
+        { hoursFromNow: 2, comfortLevel: "miserable", awsKnots: 0 },
       ];
       const cols = sparklineColumns(blocks);
       assert.equal(cols.length, 3);
@@ -162,7 +162,7 @@ test("webapp view models", async (t) => {
       assert.equal(cols[1].heightPct, 100);
       assert.equal(cols[2].heightPct, 4); // Floor
       assert.match(cols[0].color, /champagne/);
-      assert.match(cols[2].color, /sick/);
+      assert.match(cols[2].color, /miserable/);
       assert.ok(cols[1].title.includes("20.0 kn"));
     },
   );
@@ -192,7 +192,7 @@ test("webapp view models", async (t) => {
   await t.test("comfort tiers cover the Sereno scale", () => {
     assert.deepEqual(
       COMFORT_TIERS.map((tier) => tier.level),
-      ["champagne", "easy", "coffee", "rough", "sick"],
+      ["champagne", "easy", "sporty", "rough", "miserable"],
     );
     assert.match(comfortColor("unknown"), /unknown/);
   });
@@ -203,7 +203,7 @@ test("webapp view models", async (t) => {
         comfortBlocks: [
           {
             hoursFromNow: 0,
-            comfortLevel: "coffee",
+            comfortLevel: "sporty",
             awsKnots: 14.2,
             timestamp: "2026-06-21T06:00:00Z",
           },
@@ -211,10 +211,10 @@ test("webapp view models", async (t) => {
       },
     };
     const now = tacticalNow(exceptions);
-    assert.equal(now.comfortLevel, "coffee");
+    assert.equal(now.comfortLevel, "sporty");
     assert.equal(now.awsKnots, 14.2);
     assert.equal(now.stamp, "06-21 06:00Z");
-    assert.match(now.color, /coffee/);
+    assert.match(now.color, /sporty/);
 
     assert.equal(tacticalNow(null).comfortLevel, null);
     assert.match(tacticalNow(null).color, /unknown/);
@@ -280,7 +280,14 @@ test("webapp view models", async (t) => {
             timestamp: new Date(
               new Date("2026-09-27T00:00:00.000Z").getTime() + i * 3600000,
             ).toISOString(),
-            surface: { tws: 12, twd: 45, mslp: 1013, gust: 18 },
+            surface: {
+              tws: 12,
+              twd: 45,
+              mslp: 1013,
+              gust: 18,
+              precip: 1.2,
+              precipProbability: 65,
+            },
             marine: {
               hsCombined: 1.2,
               tpCombined: 7,
@@ -311,6 +318,9 @@ test("webapp view models", async (t) => {
     assert.equal(now.comfortLevel, rows[0].comfortLevel);
     // Now cloud cover (work doc #33): from the first forecast step
     assert.equal(now.cloudCover, null);
+    // Now rain fields ride the same step
+    assert.equal(now.precipMmH, 1.2);
+    assert.equal(now.precipProbability, 65);
   });
 
   await t.test("hereNow and hereHourly handle empty payloads", () => {
@@ -450,6 +460,24 @@ test("webapp view models", async (t) => {
     // No cloud field (provider mode): no cloud segment, never invented
     const clearSky = skySegments(payload, { cloudCover: null });
     assert.ok(!clearSky.some((s) => s.text.startsWith("☁")));
+    // Rain rides the line as probability, or as the hourly rate when
+    // the model publishes no probability
+    const wetSky = skySegments(payload, {
+      cloudCover: 40,
+      precipProbability: 65,
+    });
+    assert.ok(
+      wetSky.some((s) => s.text === "🌧 65%"),
+      wetSky.map((s) => s.text).join(" "),
+    );
+    const rateSky = skySegments(payload, { precip: 0.8 });
+    assert.ok(
+      rateSky.some((s) => s.text === "🌧 0.8mm"),
+      rateSky.map((s) => s.text).join(" "),
+    );
+    // Dry hours stay quiet
+    const drySky = skySegments(payload, { precip: 0.1, precipProbability: 10 });
+    assert.ok(!drySky.some((s) => s.text.startsWith("🌧")));
     // A payload predating the sky data degrades to empty
     assert.deepEqual(skySegments({}, {}), []);
     assert.deepEqual(skySegments(null, {}), []);
@@ -534,6 +562,32 @@ test("webapp view models", async (t) => {
     },
   );
 
+  await t.test("mergeTimeline carries rain episodes as info items", () => {
+    const timeline = mergeTimeline(
+      {
+        passageSummary: {
+          rainEpisodes: [
+            {
+              hoursFromNow: 4,
+              timestamp: "2026-06-21T10:00:00.000Z",
+              untilHoursFromNow: 7,
+              untilTimestamp: "2026-06-21T13:00:00.000Z",
+              precip: 2.5,
+              precipProbability: 80,
+            },
+          ],
+        },
+      },
+      null,
+    );
+    const rain = timeline.filter((i) => i.kind === "rain");
+    assert.equal(rain.length, 1);
+    assert.equal(rain[0].severity, "info");
+    assert.equal(rain[0].label, "Rain showers");
+    assert.match(rain[0].detail, /2\.5 mm\/h/);
+    assert.match(rain[0].detail, /80 %/);
+  });
+
   await t.test(
     "mergeTimeline passes source provenance through (doc #31)",
     () => {
@@ -708,9 +762,10 @@ test("webapp view models", async (t) => {
             conditions: {
               twsKnots: 14.2,
               awsKnots: 18.4,
+              twaDeg: 75,
               hsMeters: 1.5,
               tpSeconds: 8,
-              comfortLevel: "coffee",
+              comfortLevel: "sporty",
             },
           },
           {
@@ -722,8 +777,14 @@ test("webapp view models", async (t) => {
         ],
       },
     });
-    assert.equal(timeline[0].detail, "14.2 kn TWS · Hs 1.5 m · coffee");
-    // Missing sea state degrades without inventing values
+    // The point of sail leads the conditions: how the boat sits to
+    // the wind is the first thing the crew reads when rigging
+    assert.equal(
+      timeline[0].detail,
+      "close reach · 14.2 kn TWS · Hs 1.5 m · sporty",
+    );
+    // Missing sea state degrades without inventing values; a
+    // pre-TWA payload just loses the point of sail, not the line
     assert.equal(timeline[1].detail, "8.0 kn TWS · champagne");
 
     // The slatting regime names itself: "rough" alone would send
@@ -737,6 +798,7 @@ test("webapp view models", async (t) => {
             sailState: "GENOA_1",
             conditions: {
               twsKnots: 10,
+              twaDeg: -170,
               hsMeters: 1.7,
               comfortLevel: "rough",
               slatting: true,
@@ -745,7 +807,10 @@ test("webapp view models", async (t) => {
         ],
       },
     });
-    assert.equal(slatting[0].detail, "10.0 kn TWS · Hs 1.7 m · slatting");
+    assert.equal(
+      slatting[0].detail,
+      "running · 10.0 kn TWS · Hs 1.7 m · slatting",
+    );
   });
 
   await t.test("mergeTimeline carries the conditions tier for the tab", () => {
@@ -766,7 +831,7 @@ test("webapp view models", async (t) => {
             hoursFromNow: 10,
             lat: -18.9,
             lon: 174.5,
-            comfortLevel: "coffee",
+            comfortLevel: "sporty",
             slatting: false,
           },
           {
@@ -792,18 +857,18 @@ test("webapp view models", async (t) => {
             hoursFromNow: 19,
             timestamp: "2026-06-22T01:00:00.000Z",
             sailState: "MAIN_2_REEF",
-            conditions: { twsKnots: 22, comfortLevel: "sick" },
+            conditions: { twsKnots: 22, comfortLevel: "miserable" },
           },
         ],
       },
     });
     const sea = timeline.find((item) => item.kind === "sea");
-    assert.equal(sea.comfortLevel, "coffee");
+    assert.equal(sea.comfortLevel, "sporty");
     assert.equal(sea.slatting, false);
     // The sail change's own enriched conditions block wins over the
     // nearest track hour — it is the reefing logic's tier
     const sail = timeline.find((item) => item.kind === "sail");
-    assert.equal(sail.comfortLevel, "sick");
+    assert.equal(sail.comfortLevel, "miserable");
     // No track: the tier degrades to unknown, not invented
     const bare = mergeTimeline({
       passageSummary: {