@meri-imperiumi/signalk-passage-briefing 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-04
+
+### Added
+
+- Timezone change events along the route (work doc #19): the briefing now says when the clock itself changes — the moment a crew sets watches and re-plans arrival in local time. Offshore, the simulated track detects crossings of the 15° zone meridians (short-arc direction from the step's longitude delta, so the antimeridian reads "180°" either way) and the unified timeline renders them as `time` events (◷ glyph): "Crossing 165°E — solar time 1 h ahead/behind — clock change due", advising but never asserting what the crew does with the clock. Crossings inside territorial waters stay quiet — the local zone governs there — using distance stints folded from the plugin's enter/leave transitions. Territorial transitions (work doc #17) are now timezone-annotated: the IANA zone at the crossing point comes from vendored tz-lookup (CC0, ~72 KB single ES module under `public/vendor/tz-lookup/` — resolved by position, which sidesteps the multi-zone-country problem entirely, and consistent with signalk-ships-time's answer) and its UTC offset at the crossing instant from the platform's `Intl` database (DST handled, no dependency); `mergeTimeline` adds the "time zone UTC+13" line when the crossing's offset differs from the vessel's current zone, or when none is published. Stamps themselves stay in the current ship's zone.
+- No-sails semantics: slatting and survival regimes (work doc #26). On a cruising boat a logged `NO_SAILS` means one of three things the old pipeline could not tell apart — the slatting regime (apparent wind too low to keep flow attached: canvas down so it stops banging, the engine drives), the survival regime (wind very high: nothing set, nobody motors into it) — or a propulsion/non-passage state (motor-sailing nights, anchorage entries). The learning pipeline now enforces that reading. The regimes are defined in the physics module: `SAILS_FILL_MIN_AWS_KNOTS` (7 kt apparent, mirroring the upwind slatting gate in apparent rather than true wind — motoring into light air is exactly when canvas slats) and `SAILS_MAX_AWS_KNOTS` (45 kt apparent — Beaufort 9 territory, deliberately decoupled from the comfort bands whose 33 kt line marks seasickness, not the rig decision; the vessel carries working canvas standing well into the forties), with `noSailsRegime()` answering slatting / survival / null. The learning gate folds a `NO_SAILS` observation into a rig bin only when its wind window justifies it — the window's average TWS below the point-of-sail slatting gates (7 kt upwind, 12 kt downwind, from the comfort model) or its peak gust at the survival floor; a mid-scale bare-poles observation still caches its wind window (idempotency intact) and stays in the logbook record, but never wins the bin, and the backfill counts it in a new `skippedNoSails` the UI reports ("7 bare-poles entries kept out of the matrix"). The simulation only accepts a `NO_SAILS` suggestion when the step's real apparent wind (boat speed and heading included) sits in a regime, so already-poisoned learned cells cannot depower a passage. The drive under an accepted canvas-down follows one shared rule for rows and events: survival — no drive, the water moves the boat, and the timeline names the decision "Storm tactics" rather than claiming a tactic (heave to, drogue, run off — proper storm tactics are their own work document, #27); becalmed with drift mode enabled — drift on the current alone; otherwise the engine pushes at motor speed with honest motor hours and fuel. A plan holding `NO_SAILS` no longer makes phantom polar speed with zero motor hours. The one-time migration on plugin start clears the learned matrix, its wind-history cache and the recorded events (guarded by `PRAGMA user_version`, logbook files untouched) so the next backfill rebuilds every bin under the new rules — the recency rule had let single bare-poles entries erase a bin's real rig, and that loss is unrecoverable from the matrix alone; empty bins degrade safely to "keep the current rig". **Upgrading crews must run the Logbook Backfill once after starting this version** (the webapp card, or `POST /plugins/.../api/backfill`) — until then the learned plan is empty and the simulation keeps whatever rig the plan already had.
+
+### Changed
+
+- Slatting has a name wherever the comfort tier shows: timeline details at sail changes and sparkline titles read "slatting" instead of the escalated "rough" — a 10 kn afternoon in a residual swell was rendering as weather it isn't, sending someone looking for wind that isn't there. The comfort explainer (ℹ️) carries a SLATTING entry with its thresholds ("wind < 7–12 kn by point of sail · swell ≥ 0.6 m").
+
+### Fixed
+
+- Phone timeline layout: the when-gutter (relative hours + date stamp + moon glyph) squeezed the event text to the side on narrow screens. On phone (below the app's 700 px layout breakpoint) each entry now renders on two lines — the date/time gutter on top at full width, glyph and event data beneath with the whole row's width available. Desktop layout unchanged.
+- No more tacks and gybes with canvas down: the maneuver detector's sailing-step test now requires the plan's rig up — a course change under power or carried by the current is not a tack or gybe. This closes a real leak: drift rows carry `motoring: false` and can hold current-driven SOG above the sailing threshold, previously qualifying as sailing steps.
+
 ## [0.5.2] - 2026-10-04
 
 ### Fixed

package/package.json

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

package/plugin/history-backfill.js

@@ -334,17 +334,35 @@ function createHistoryWindStats({
  * window's peak wind. The preferred sail of a bin is the most recent
  * observation.
  *
+ * Canvas-off observations are gated (work doc #26): a `NO_SAILS`
+ * observation folds into the rig matrix only when the weather
+ * justifies it — the two-regime decision the rig actually encodes.
+ * A mid-scale one is a propulsion decision (the engine drives) or a
+ * non-passage state (anchorage, marina); folding it would teach the
+ * plan to hold bare poles through sail-carrying weather.
+ *
  * @param {object} params
  * @param {import("./sqlite-db.js").PassageDatabase} params.db
  * @param {{timestamp: string, eventType: string, sailState: string, night?: boolean, notes?: string}} params.event
  * @param {WindWindowStats} params.stats
  * @param {boolean} [params.night] - Day/night bucket of the event
  *   (defaults to the event's own flag, else day)
+ * @param {object} [params.physics] - The loaded sereno-physics module
+ *   (constants for the regime gates). Omitted, the gate stays
+ *   conservative: a `NO_SAILS` observation cannot be justified and is
+ *   kept out of the rig matrix.
  * @returns {{twsBin: number, twaBin: number, night: boolean,
  *   preferredSail: string, avgTwsTrigger: number, peakGustTrigger:
- *   number, sampleCount: number}}
+ *   number, sampleCount: number}|null} The learned cell, or null when
+ *   the observation was gated out of the rig matrix
  */
-function applySailEvent({ db, event, stats, night = event.night ?? false }) {
+function applySailEvent({
+  db,
+  event,
+  stats,
+  night = event.night ?? false,
+  physics = null,
+}) {
   db.upsertWindHistory({
     timestamp: event.timestamp,
     twsAvg: stats.twsAvg,
@@ -352,6 +370,13 @@ function applySailEvent({ db, event, stats, night = event.night ?? false }) {
     twaAvg: stats.twaAvg,
   });
 
+  if (
+    event.sailState === "NO_SAILS" &&
+    noSailsWindowRegime(stats, physics) == null
+  ) {
+    return null;
+  }
+
   const twsBin = twsBinIndex(stats.twsAvg);
   const twaBin = twaBinIndex(stats.twaAvg);
   const existing = db
@@ -377,6 +402,40 @@ function applySailEvent({ db, event, stats, night = event.night ?? false }) {
   return cell;
 }
 
+/**
+ * The canvas-off regime a wind window justifies (work doc #26): the
+ * rig is already down in these observations, so apparent wind ≈ true
+ * wind and the regimes read off the window stats. Light air uses the
+ * comfort model's point-of-sail slatting gates (work doc #14: 7 kt
+ * upwind, 12 kt downwind); survival reads the window's peak gust
+ * against the top of the Sereno AWS bands.
+ *
+ * @param {WindWindowStats} stats - Window statistics
+ * @param {object|null} physics - The sereno-physics module (regime
+ *   gate constants); null keeps the gate conservative
+ * @returns {"slatting"|"survival"|null}
+ */
+function noSailsWindowRegime(stats, physics) {
+  if (!stats || !physics) {
+    return null;
+  }
+  const { twsAvg, twsPeak, twaAvg } = stats;
+  if (!Number.isFinite(twsAvg)) {
+    return null;
+  }
+  const upwind = Math.abs(Number.isFinite(twaAvg) ? twaAvg : 0) < 90;
+  const lightFloor = upwind
+    ? physics.SLATTING_TWS_UPWIND_KNOTS
+    : physics.SLATTING_TWS_DOWNWIND_KNOTS;
+  if (twsAvg < lightFloor) {
+    return "slatting";
+  }
+  if (Number.isFinite(twsPeak) && twsPeak >= physics.SAILS_MAX_AWS_KNOTS) {
+    return "survival";
+  }
+  return null;
+}
+
 /**
  * Runs the backfill over a list of sail events (SPEC §4.2). Events are
  * processed chronologically; an event already present in
@@ -399,7 +458,8 @@ function applySailEvent({ db, event, stats, night = event.night ?? false }) {
  *   skippedNoData: number, cells: object[]}>}
  */
 async function backfillSailEvents({ db, events, getWindStats }) {
-  const { isNight } = await loadPhysics();
+  const physics = await loadPhysics();
+  const { isNight } = physics;
   const sorted = [...events].sort(
     (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
   );
@@ -407,6 +467,7 @@ async function backfillSailEvents({ db, events, getWindStats }) {
   let learned = 0;
   let skippedCached = 0;
   let skippedNoData = 0;
+  let skippedNoSails = 0;
   const cells = [];
 
   for (const event of sorted) {
@@ -433,7 +494,15 @@ async function backfillSailEvents({ db, events, getWindStats }) {
             event.position.longitude,
           )
         : false);
-    cells.push(applySailEvent({ db, event, stats, night }));
+    const cell = applySailEvent({ db, event, stats, night, physics });
+    if (cell) {
+      cells.push(cell);
+      learned++;
+    } else {
+      // Gated out of the rig matrix (work doc #26): still cached and
+      // recorded, but nothing was learned
+      skippedNoSails++;
+    }
     db.recordSailEvent({
       timestamp: event.timestamp,
       eventType: event.eventType,
@@ -441,7 +510,6 @@ async function backfillSailEvents({ db, events, getWindStats }) {
       night,
       notes: event.notes,
     });
-    learned++;
   }
 
   return {
@@ -449,6 +517,7 @@ async function backfillSailEvents({ db, events, getWindStats }) {
     learned,
     skippedCached,
     skippedNoData,
+    skippedNoSails,
     cells,
   };
 }

package/plugin/index.js

@@ -1443,6 +1443,17 @@ module.exports = (app) => {
     return join(configPath, "plugin-config-data", "signalk-logbook");
   }
 
+  /** Startup grace (ms) before the delta-fed path sources are
+   * recorded in the status registry (work doc #23, bergie session
+   * note): the server replays current values to new subscriptions a
+   * few seconds after start-up, and a snapshot taken before that
+   * replay would record a transient failure/absence for paths that
+   * are actually fine — navigation.state is the known case.
+   * Non-path sources (resources, plugin-provided) record from the
+   * first tick. */
+  const PATH_SOURCE_GRACE_MS = 2 * 60 * 1000;
+  let startedAt = Date.now();
+
   /**
    * Records the Signal K source availability in the source status
    * registry (work doc #23): the checklist also covers the server
@@ -1453,9 +1464,9 @@ module.exports = (app) => {
    * there (companion plugin not installed, no route being sailed)
    * records as absent — information, not an error.
    *
-   * Runs from the cron ticker: the first minute of uptime is the
-   * grace period in which the server replays current values to the
-   * new subscriptions.
+   * Runs from the cron ticker: delta-fed path sources are skipped
+   * during the startup grace period, in which the server replays
+   * current values to the new subscriptions.
    *
    * @param {Date} [now]
    */
@@ -1469,55 +1480,66 @@ module.exports = (app) => {
       typeof app.getSelfPath === "function"
         ? unwrap(app.getSelfPath(path))
         : null;
-    const pathSources = [
-      {
-        id: "sk-internet-state",
-        path: INTERNET_STATE_PATH,
-        label: "Internet state (signalk-internet)",
-        required: true,
-      },
-      {
-        id: "sk-navigation-state",
-        path: NAVIGATION_STATE_PATH,
-        label: "Navigation state",
-        required: true,
-      },
-      {
-        id: "sk-house-soc",
-        path: HOUSE_SOC_PATH,
-        label: "House battery SoC",
-        required: true,
-      },
-      {
-        id: "sk-active-route",
-        path: ACTIVE_ROUTE_PATH,
-        label: "Active route",
-        required: false,
-      },
-      {
-        id: "sk-energy-prediction",
-        path: ENERGY_FORECAST_PATH,
-        label: "Energy outlook (energy-predictor)",
-        required: false,
-      },
-    ];
-    for (const source of pathSources) {
-      const missing = observations[source.path] == null;
-      sourceStatus.record({
-        id: source.id,
-        label: source.label,
-        kind: "signalk",
-        url: source.path,
-        ...(missing
-          ? source.required
-            ? {
-                error: new Error("No value received since startup"),
-                errorClass: "unavailable",
-              }
-            : { absent: true }
-          : {}),
-        now,
-      });
+    // Delta-fed paths: during the startup grace the server has not
+    // replayed current values yet, so a snapshot here would lie about
+    // sources that are about to populate (navigation.state arrives a
+    // few seconds in). Skip them; they record from the next tick.
+    if (now.getTime() - startedAt >= PATH_SOURCE_GRACE_MS) {
+      const pathSources = [
+        {
+          id: "sk-internet-state",
+          path: INTERNET_STATE_PATH,
+          label: "Internet state (signalk-internet)",
+          required: true,
+        },
+        {
+          id: "sk-navigation-state",
+          path: NAVIGATION_STATE_PATH,
+          label: "Navigation state",
+          // Optional: many boats never publish navigation.state, and
+          // everything that reads it degrades gracefully — the state
+          // machine fetches regardless (unset ≠ moored), and the
+          // departure anchor treats unset as not underway (work doc
+          // #15). A FAIL here would be a permanent false alarm.
+          required: false,
+        },
+        {
+          id: "sk-house-soc",
+          path: HOUSE_SOC_PATH,
+          label: "House battery SoC",
+          required: true,
+        },
+        {
+          id: "sk-active-route",
+          path: ACTIVE_ROUTE_PATH,
+          label: "Active route",
+          required: false,
+        },
+        {
+          id: "sk-energy-prediction",
+          path: ENERGY_FORECAST_PATH,
+          label: "Energy outlook (energy-predictor)",
+          required: false,
+        },
+      ];
+      for (const source of pathSources) {
+        const missing = observations[source.path] == null;
+        sourceStatus.record({
+          id: source.id,
+          label: source.label,
+          kind: "signalk",
+          url: source.path,
+          ...(missing
+            ? source.required
+              ? {
+                  error: new Error("No value received since startup"),
+                  errorClass: "unavailable",
+                }
+              : { absent: true }
+            : {}),
+          now,
+        });
+      }
     }
     // Resource-side sources
     const routesAvailable =
@@ -1600,6 +1622,11 @@ module.exports = (app) => {
     description:
       "Offshore passage daily briefing: multi-model weather outlook, comfort " +
       "physics and learned sail preferences",
+    // Test seam: shift the start-up instant so the source-status grace
+    // period can be traversed deterministically
+    __setStartedAt: (value) => {
+      startedAt = value;
+    },
 
     schema: {
       type: "object",

package/plugin/sqlite-db.js

@@ -193,6 +193,33 @@ class PassageDatabase {
         PRIMARY KEY (tws_bin, twa_bin, night)
       );
     `);
+    this.resetLearnedMatrix();
+  }
+
+  /**
+   * One-time migration (work doc #26): clears the learned matrix and
+   * its derived stores so the next backfill rebuilds everything under
+   * the new learning rules — the no-sails gate, and a learning engine
+   * whose recency rule no longer lets one bare-poles entry erase a
+   * bin's real rig. Classifying and dropping just the poisoned cells
+   * was considered, but whatever rig they had overwritten is
+   * unrecoverable from the matrix alone: the honest move is a full
+   * re-learn from the logbook. The logbook files themselves are
+   * untouched — this only empties the derived store. Until a backfill
+   * runs the matrix is empty and suggestions degrade to "keep the
+   * current rig".
+   */
+  resetLearnedMatrix() {
+    const version = this.db.prepare("PRAGMA user_version").get().user_version;
+    if (version >= 1) {
+      return;
+    }
+    this.db.exec(`
+      DELETE FROM learned_sail_matrix;
+      DELETE FROM wind_history_cache;
+      DELETE FROM logbook_sail_events;
+    `);
+    this.db.prepare("PRAGMA user_version = 1").run();
   }
 
   /**

package/public/components/backfill-controls.js

@@ -83,6 +83,9 @@ class BackfillControls extends HTMLElement {
       this._out.textContent =
         `Learned ${summary.learned} of ${summary.total} sail changes` +
         (skipped > 0 ? ` (skipped ${skipped})` : "") +
+        (summary.skippedNoSails > 0
+          ? `, ${summary.skippedNoSails} bare-poles entries kept out of the matrix`
+          : "") +
         `, ${summary.cells.length} matrix cells`;
     } catch (error) {
       this._out.classList.add("err");

package/public/components/comfort-info.js

@@ -84,6 +84,23 @@ class ComfortInfo extends HTMLElement {
       row.appendChild(band);
       this._pop.appendChild(row);
     }
+    const slatting = document.createElement("div");
+    slatting.className = "row";
+    const slattingName = document.createElement("span");
+    slattingName.className = "name";
+    slattingName.textContent = "SLATTING";
+    const slattingText = document.createElement("span");
+    slattingText.textContent =
+      " — Light air over a residual swell: the sails slat and bang, " +
+      "snap-rolling the boat.";
+    slatting.appendChild(slattingName);
+    slatting.appendChild(slattingText);
+    const slattingBand = document.createElement("span");
+    slattingBand.className = "band";
+    slattingBand.textContent =
+      "wind < 7–12 kn by point of sail · swell ≥ 0.6 m";
+    slatting.appendChild(slattingBand);
+    this._pop.appendChild(slatting);
   }
 }
 

package/public/components/horizon-sparkline.js

@@ -33,10 +33,10 @@ class HorizonSparkline extends HTMLElement {
       <svg viewBox="0 0 240 96" preserveAspectRatio="none" role="img"
         aria-label="24 hour comfort and wind outlook">
         <defs>
-          <!-- Slatting hatch (work doc #14): Rough blocks triggered by
-            light air in a residual swell render striped — heavy-weather
-            rough keeps its solid colour. Transparent background lets
-            the card colour show between the stripes. -->
+          <!-- Slatting hatch: rough comfort triggered by light air in
+            a residual swell renders striped — heavy-weather rough keeps
+            its solid colour. Transparent background lets the card
+            colour show between the stripes. -->
           <pattern id="slatting-hatch" width="6" height="6"
             patternUnits="userSpaceOnUse" patternTransform="rotate(45)">
             <rect width="6" height="6" fill="none"></rect>

package/public/components/models.mjs

@@ -306,7 +306,7 @@ export function sparklineColumns(hourlyComfort, hours = 24, options = {}) {
       awsKnots: aws,
       heightPct: Math.max(4, Math.round((aws / maxAws) * 100)),
       color: comfortColor(b.comfortLevel),
-      title: `${stamp(b.hoursFromNow)}: ${fmtKn(aws)} AWS, ${b.comfortLevel ?? "?"}${b.slatting ? " (slatting)" : ""}`,
+      title: `${stamp(b.hoursFromNow)}: ${fmtKn(aws)} AWS, ${b.slatting ? "slatting" : (b.comfortLevel ?? "?")}`,
     };
   });
 }
@@ -641,15 +641,22 @@ export function sailStateLabel(key) {
 
 /**
  * Label for one sail-change event: bare "No sails" says WHY the
- * canvas is down — the plan drifts (`No sails - drifting`) or the
- * engine pushes (`Motoring`) — instead of implying bare-pole sailing.
+ * canvas is down — the plan drifts (`No sails - drifting`), the
+ * engine pushes (`Motoring`), or the weather demands the canvas-off
+ * regime (`Storm tactics`: at survival wind the tactic — heave to,
+ * drogue, run off — is the crew's call, not the simulator's; work
+ * doc #27 will pick it up) — instead of implying bare-pole sailing.
  *
- * @param {{sailState: string|null, propulsion?: string|null}} event
+ * @param {{sailState: string|null, propulsion?: string|null,
+ *   canvasOffRegime?: string|null}} event
  * @returns {string} Human label
  */
 function sailEventLabel(event) {
   const label = sailStateLabel(event.sailState);
   if (label === "No sails") {
+    if (event.canvasOffRegime === "survival") {
+      return "Storm tactics";
+    }
     if (event.propulsion === "adrift") {
       return "No sails - drifting";
     }
@@ -707,8 +714,9 @@ function episodeDetail(episode, parts) {
  * to one chronological shape — `{hoursFromNow, timestamp, stamp,
  * kind, severity, label, detail}` — sorted by time, undated last.
  * Kinds: `sail`, `maneuver`, `convective`, `sea`, `zone`, `space`,
- * `hazard`; new event sources become new kinds instead of new blocks
- * (work doc #1's lines of interest will ride in as `line`).
+ * `hazard`, `time`; new event sources become new kinds instead of
+ * new blocks (work doc #1's lines of interest will ride in as
+ * `line`).
  * Severities: `info`, `warn`, `severe` — the renderer's colour
  * scale. The tactical dashboard renders the 24 h slice of this list,
  * the strategic outlook the whole passage.
@@ -724,7 +732,7 @@ function episodeDetail(episode, parts) {
  * @param {object|null} exceptions - Worker exception view
  * @param {object|null} payload - Briefing payload
  *   (UnifiedWeatherPayload; optional `spaceEvents`,
- *   `zoneTransitions`, `celestialNights`)
+ *   `zoneTransitions`, `celestialNights`, `timeZoneChanges`)
  * @returns {Array<{hoursFromNow: number|null, timestamp: string|null, stamp: string, kind: string, severity: string, label: string, detail: string, night: boolean, moon: string|null}>}
  */
 /**
@@ -982,7 +990,10 @@ export function mergeTimeline(exceptions, payload = null) {
     // 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
-    // enriched conditions block.
+    // 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;
     // Why the change sits where it sits: watch handover when a watch
@@ -1009,7 +1020,7 @@ export function mergeTimeline(exceptions, payload = null) {
         conditions?.hsMeters != null
           ? `Hs ${conditions.hsMeters.toFixed(1)} m`
           : null,
-        conditions?.comfortLevel ?? null,
+        conditions?.slatting ? "slatting" : (conditions?.comfortLevel ?? null),
         anchorText,
       ]
         .filter(Boolean)
@@ -1105,6 +1116,9 @@ export function mergeTimeline(exceptions, payload = null) {
   // (summary), falling back to the payload's undated transitions;
   // the timeline kind is always `zone`. Leaving territorial waters
   // carries the connectivity note — the metered-ocean boundary.
+  // When the crossing lands in another timezone than the vessel's
+  // current one, the event says so (work doc #19) — exactly the
+  // moment a crew sets watches and re-plans arrival in local time.
   for (const z of summary.zoneTransitions ?? payload?.zoneTransitions ?? []) {
     const territory = z.territory?.name ?? "?";
     push({
@@ -1120,12 +1134,32 @@ export function mergeTimeline(exceptions, payload = null) {
         z.distanceFromStartNm != null
           ? `${Math.round(z.distanceFromStartNm)} nm from departure`
           : null,
+        z.zoneOffsetMinutes != null &&
+        (shipTime == null || z.zoneOffsetMinutes !== shipTime.offsetMinutes)
+          ? `time zone ${offsetLabel(z.zoneOffsetMinutes)}`
+          : null,
       ]
         .filter(Boolean)
         .join(" · "),
     });
   }
 
+  // Zone meridian crossings offshore (work doc #19): solar time
+  // drifts 1 h per 15° of longitude, so watch schedules quietly
+  // desynchronize from the sun unless the clock follows. The event
+  // advises; what the crew does with the clock is the master's
+  // discretion.
+  for (const c of summary.timeZoneChanges ?? payload?.timeZoneChanges ?? []) {
+    push({
+      hoursFromNow: c.hoursFromNow ?? relHours(c.timestamp, fetchMs),
+      timestamp: c.timestamp ?? null,
+      kind: "time",
+      severity: "info",
+      label: `Crossing ${c.meridian ?? "a zone meridian"}`,
+      detail: `solar time 1 h ${c.eastbound ? "ahead" : "behind"} — clock change due`,
+    });
+  }
+
   // Night indicators for every dated item (work doc #17 session
   // feedback): interpolate the crew's position at the item's hour
   // from the simulated track and test the sun — one uniform answer

package/public/components/passage-timeline.js

@@ -31,6 +31,7 @@ const GLYPHS = {
   line: "⌀",
   energy: "🔋",
   departure: "⚓",
+  time: "◷",
 };
 
 /**
@@ -71,6 +72,16 @@ class PassageTimeline extends HTMLElement {
         .sev-severe .glyph, .sev-severe .label { color: var(--color-red); }
         .sev-info .glyph { color: var(--color-teal); }
         .none { color: var(--text-muted); font-size: 0.85rem; }
+        /* Phone: the when gutter is too wide and squeezes the event
+         * text, so the date line goes on top at full width and the
+         * event data flows beneath it. Matches the 700px layout
+         * breakpoint used across the app. */
+        @media (max-width: 699px) {
+          .entry { grid-template-columns: auto 1fr; }
+          .when { grid-area: 1 / 1 / 2 / 3; }
+          .glyph { grid-area: 2 / 1 / 3 / 2; }
+          .body { grid-area: 2 / 2 / 3 / 3; }
+        }
       </style>
       <div id="list"></div>
     `;
@@ -117,6 +128,7 @@ class PassageTimeline extends HTMLElement {
       glyph.title = item.kind ?? "";
 
       const body = document.createElement("span");
+      body.className = "body";
       const label = document.createElement("span");
       label.className = "label";
       label.textContent = item.label ?? "?";