@meri-imperiumi/signalk-dead-reckoning 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -5,6 +5,198 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.9.0] - 2026-09-10
+
+### Added
+- **Derived-current tier (SPEC §6.2 tier 2)**: an exponentially-weighted
+  mean of the boat's own GPS-vs-water-track residual, sampled every
+  tick while GPS is trusted and the water track is usable (STW floor,
+  interval, glitch/outlier bounds), carried forward with exponential
+  decay when GPS degrades and TTL-bounded (24 h) so the resolver falls
+  through to the model tiers after. Zero-configuration: it outranks
+  the Weather API and pilot charts as soon as ~10 samples exist (the
+  first minutes of a passage), `environment.current` and `/status`
+  surface it as source `derived`, and the uncertainty cone uses a
+  tighter per-tier residual (0.2 kn). Sea-trial replay
+  (Aitutaki→Niue 2026-08-30→09-05): final DR error 10.9 nm over 622 nm
+  vs 47.3 nm for the live tier-3 configuration and 85.2 nm for the
+  zero vector — landfall-visible DR on a trade-wind passage.
+
+### Fixed
+- **The weather-current client calls the Weather API in-process**
+  (`app.weatherApi.getForecasts()`, the same instance the REST routes
+  wrap — mirrors signalk-energy-predictor) instead of an HTTP loopback
+  that defaulted to `localhost:3000` — a port Grafana answers on this
+  install, so every poll 404ed and tier 3 never resolved
+  ("Weather current fetch failed: weather API returned 404 — using
+  zero current"). No base URL, ports or auth tokens involved; the
+  `weatherCurrent.baseUrl` config option is gone.
+- **The celestial sight plausibility gate measures the distance from
+  the DR origin, not from the sight's assumed position** (sea trial
+  2026-08-31 root-cause follow-up): a small intercept at a wrong
+  assumed position drew the LOP an ocean away and the gate never saw
+  it. Non-noon sights now gate on the perpendicular distance from the
+  DR origin to the LOP (floored by the intercept magnitude), mirroring
+  the `/fix/lop` bearing gate; noon sights gate on the origin-vs-
+  reduction latitude difference.
+- **The fix-confirm sanity cap now grows with DR time-since-origin**
+  instead of being a flat 100 NM: legitimate fixes after days GPS-less
+  (DR drifts ~0.5–1 NM/h; the trials measured 47 NM in 4.5 days with a
+  current tier, 85 NM cold) were being rejected, training crews to
+  habitually force-confirm — defeating the guard for the teleport
+  case it exists for. The cap is now `max(100 NM, 1.5 kn × hours since
+  origin)`, mirrored in `/fix/resolve`'s `gross` preview flag.
+- **Training Mode is suspended while the resolved current is tier 5
+  (zero vector — current unknown)** (SPEC §6.1/§6.2): training with an
+  unknown current bakes it into the leeway/speed bins as fake
+  corrections and over-applies them later (Huahine→Aitutaki backtest:
+  72 vs 65 nm cold; both trials' regressions). With the new tier-2
+  derived current self-bootstrapping in the first minutes of a
+  passage, a current-resolved matrix train no longer requires a
+  weather provider. The replay tool's learning variants accordingly
+  run with the derived current ("training with zero current" is no
+  longer a reachable live configuration), and a new `derived` variant
+  (cold + tier 2, no training) isolates the tier's contribution in
+  backtests.
+- **Logbook write-through no longer floods the server when
+  authentication cannot be obtained** (reported 2026-09-11 on
+  lille-oe-pi: a continuous ~10 req/s stream of
+  `POST /plugins/signalk-logbook/logs` 401s at anchor; the 91-byte
+  bodies identified the server's plugin-route admin gate answering a
+  tokenless "open server" probe). The access-request client read
+  *any* non-OK response (403 disallowed device requests, 429 rate
+  limit, 400 duplicate, 503, …) as "no access-request flow", built a
+  tokenless client, ate the admin gate's 401, and re-ran the whole
+  cycle forever. The client now distinguishes: 403 → "forbidden"
+  (park; the plugin status names the two ways out — allow device
+  access requests on the server, or paste a token); 404/501 → a
+  single tokenless probe, terminal on rejection; everything else →
+  "unreachable", retried on an exponential backoff (30 s doubling to
+  a 16 min cap, configurable via `logbook.retryBackoffMs`) — never an
+  open-server assumption, never a loop. A rejected config token or
+  tokenless probe parks instead of resurrecting the same credentials
+  in a loop. A pending access request is persisted and resumed across
+  restarts instead of re-filed (the server rejects duplicates), and an
+  approval granted while the plugin was down is picked up on the
+  first poll. Queued entries are never dropped by any of this.
+- **The "paddlewheel appears fouled" alert no longer fires on breeze
+  over a moored boat** while `navigation.state` hasn't landed in the
+  delta cache yet (or on installs without an autostate source): a live
+  SOG reading below the moving threshold is now an outright "not
+  making way" verdict, and wind only corroborates fouling when GPS is
+  silent.
+
+### Added
+- **Polar speed fallback now also works without
+  signalk-polar-performance-plugin**: when its `performance.polarSpeed`
+  feed is absent, DR computes the speed in-process from the active
+  `polars` resource (the signalk-polar-management contract — the
+  `polars.activePolar` pointer and `polars.performanceFactor` derating
+  multiplier) interpolated from water-referenced true wind
+  (`environment.wind.speedTrue` / `angleTrueWater`). The resource path
+  shares the existing running-average window and staleness cutoff, is
+  zero-configuration (engages when an active polar is selected, stays
+  dormant otherwise), and a live `performance.polarSpeed` feed still
+  outranks it. The DR state's `speedSource` distinguishes `polar`
+  (delta feed) from `polar-resource`, the sensor-health alert names the
+  active resource id, and GET /status mirrors the loaded polar. A dead
+  wind instrument ages the average out to the honest idle branch
+  instead of integrating a frozen wind at a frozen speed.
+
+## [0.8.0] - 2026-09-09
+
+### Fixed
+- **Celestial sights are no longer silently forced through the noon
+  (meridian-altitude) reducer** (sea trial 2026-08-31, Aitutaki→Niue:
+  both Sun sights reduced to −69.3°/−31.9°). The sight panel's
+  `readForm()` read checkboxes via `el.value` — always the string
+  `"on"` regardless of checked state — so every sight was POSTed with
+  `noon: true`. Checkboxes are now read via `el.checked` (both panels).
+- **The webapp no longer overwrites its own-vessel GPS position with
+  the DR shadow boat's** (sea trial: the map boat flipped ~50 NM
+  between GPS and the ghost, and fix #9 recorded the ghost position as
+  a "GNSS" fix 87.5 km from the boat). Deltas whose context is the
+  shadow vessel now route to neither the AIS target store nor the
+  own-vessel view-model.
+
+### Changed
+- **The uncertainty cone now grows with current-knowledge**, not just
+  distance run (sea trial: 88 km of DR-vs-GPS divergence while the
+  polygon "expected" ~2 NM). Radius combines the distance-run error
+  and a per-tier current residual (manual 0.25 kn, weather/pilot
+  0.3 kn, zero-vector 1.0 kn) root-sum-square; the fallback margin
+  rose from 1° to 4° per NM run (measured open-loop rates were
+  7–12× the old value); the empirical rate is now a median with a
+  2 kn per-row cap (the spec's original intent — a garbage 3058 NM
+  correction previously poisoned an EWMA at "145 kn"); the floor rose
+  to 0.05 NM and the origin's own error radius seeds it (a celestial
+  fix is realistically ~5 nm — the cone never claims GPS confidence
+  below that).
+- **The divergence advisory no longer flaps after every fix or print
+  "0.27 nm exceeds expected 0.27 nm"**: the exceedance deadband is
+  instrument-scale (0.005 NM) instead of float epsilon, and the alert
+  message states the exceedance margin.
+- **"Tack/gybe in progress" no longer latches open for the whole
+  passage** in ss3–4 seaway: rate-of-turn is measured over a 6 s
+  rolling window (a single second of wave yaw can't open it), the
+  re-stabilization tolerances scale with sea state, and a window still
+  open after 5 minutes force-closes without classifying a maneuver.
+  The pre-maneuver AWA for tack/gybe classification is now taken from
+  the base of the ROT window (the previous tick's AWA has already
+  flipped with the bow by the time the window opens).
+
+### Added
+- **Passage replay backtest tool** (`tools/replay-passage.js`, minimal
+  SPEC §10.2 scope): replays a historical passage from the Signal K
+  History API through the real DR engine and reports how the shadow
+  boat diverged from GPS. Fetches a range in chunks at native 10s
+  resolution, forward-fills sparse sensors (unwrapping the signed AWA
+  across ±π through gybes), queries `navigation.attitude.roll`
+  (radians) directly — the attitude object itself is not recorded, only
+  its component paths — so heel reaches the matrix bins, seeds the DR
+  origin at the first GPS fix and never re-anchors it. Four variants run side by side: cold (no
+  training, tier-5 zero current), learning (Training Mode on, mirroring
+  a first live passage), plus the same two with a SCUD satellite-derived
+  current source — daily 0.25° fields from the PacIOOS ERDDAP,
+  nearest-cell in space, time-interpolated over source holes (and held
+  at the span ends), resolved at the shadow boat's own position. Also
+  derives the implied current (ground vector minus water-track vector)
+  as a diagnostic of what DR is missing. Outputs an hourly divergence
+  table, an implied-vs-SCUD current comparison, a GeoJSON track file,
+  full-resolution samples, and a self-contained SVG HTML report. A
+  `--stw-scale` option multiplies STW end-to-end (engine, training,
+  matrix lookup) to test paddlewheel-calibration hypotheses against a
+  passage.
+  Smoketests cover URL building, row parsing/filling, the current-grid
+  interpolation, and three synthetic passages (no-drift, known-current,
+  leeway absorbed by training).
+- **Observation submission is speed-plausibility-gated**: a sight,
+  bearing or vertical-angle observation whose reduction implies the
+  vessel traveled faster than 50 kn since the last fix (e.g. the
+  trial's 3058 NM Antarctica sight ≈ 140 kn) is rejected with an
+  explanatory message in the form, so the user can fix the entry.
+  Displacements within realistic observation quality (~5 NM) always
+  pass.
+- **Noon sights carry meridian and sanity guards**: a sight whose Sun
+  is more than 20° from the meridian (LHA), or whose computed latitude
+  lands more than 12° from the assumed/DR position, is refused rather
+  than reduced into garbage.
+- **Fix confirmation carries a gross-displacement guard**: confirming
+  a fix more than 100 NM (configurable, `fixes.maxDisplacementNm`)
+  from the current DR origin is rejected with 422 unless the request
+  carries `force: true`; `/fix/resolve` previews the candidate's
+  displacement and flags gross candidates.
+- **Raw sight inputs are persisted** (`raw_hs_deg`, index correction,
+  eye height, limb, computed Ho/Hc on lines_of_position; angle/height
+  on circular_position_lines) so reductions can be re-run and
+  backtested — reconstructing the trial's sights from the stored
+  noon results required algebraic archaeology.
+- **`elapsedSinceOriginS` and the origin error radius survive plugin
+  restarts** (persisted alongside `last_known_good_fix`), so "since
+  last fix" and the cone no longer reset mid-excursion on a restart.
+
 ## [0.7.0] - 2026-08-29
 
 ### Added
@@ -137,6 +329,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   anchors: a from-scratch Meeus reduction for the Sun (≤0.7′, the
   anchor's own accuracy class), the AA low-precision series for the
   Moon (≤20′), and paper-almanac star values.
+
 - **The webapp's "Ghost Track" heading above the map is gone.** It
   wasted vertical space the map could use — the map card now opens with
   no chrome above it, so the chart starts higher on the page. The

package/SPEC.md

@@ -269,7 +269,7 @@ Worker Thread (DR Physics)
 
 ### 6.1 Training Mode vs. Inference Mode
 
-**Training Mode** — active when `isGpsReliable = true` AND `propulsion.main.state = stopped` AND paddlewheel not fouled (§6.3):
+**Training Mode** — active when `isGpsReliable = true` AND `propulsion.main.state = stopped` AND paddlewheel not fouled (§6.3) AND the resolved current is not the zero vector (§6.2 tier < 5 — training with an unknown current bakes it into the leeway/speed bins as fake corrections):
 - Computes error vectors: GPS SOG/COG vs. sensor STW/heading, minus the resolved current vector (§6.2), updated into matching `dr_matrix_bins` via EMA, learning rate modulated by effective `hit_count`.
 
 **Inference Mode** — active when `isGpsReliable = false` OR OVERRIDE is manually engaged:
@@ -286,8 +286,8 @@ The paddlewheel-failure fallback is a distinct branch from the "GPS unreliable"
 ### 6.2 Current Hierarchy of Truth
 
 1. Manual Override — watchstander input with valid TTL (`environment.current`).
-2. Live High-Res — Starlink-cached coastal NetCDF vectors.
-3. Sparse Forecast — bilinear/temporal-interpolated radio GRIB vectors.
+2. Derived Residual — exponentially-weighted mean of the boat's own GPS-vs-water-track residual (`derived-current.js`), sampled while GPS is trusted and the water track is usable; carried forward with exponential decay when GPS degrades, TTL-bounded. The boat's own observation outranks model products (sea trial 2026-08-30→09-05, Aitutaki→Niue: ~11 nm DR error over 622 nm vs 47 nm for tier 3, 85 nm for tier 5).
+3. Sparse Forecast — bilinear/temporal-interpolated radio GRIB vectors (Signal K Weather API).
 4. Offline Pilot Charts — static SQLite monthly historical averages (`offline_pilot_currents`).
 5. Zero Vector — pure inertial water track (U: 0, V: 0).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-dead-reckoning",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Offline-first dead reckoning and sensor fusion engine for Signal K",
   "main": "plugin/index.js",
   "scripts": {
@@ -34,7 +34,8 @@
     "recommends": [
       "@meri-imperiumi/signalk-autostate",
       "@meri-imperiumi/signalk-logbook",
-      "signalk-polar-performance-plugin"
+      "signalk-polar-performance-plugin",
+      "signalk-polar-management"
     ],
     "screenshots": [
       "./doc/dr-map.png",

package/plugin/celestial.js

@@ -57,6 +57,22 @@ const MOON_RADIUS_KM = 1737.4;
 /** Earth equatorial radius, km. */
 const EARTH_EQ_RADIUS_KM = 6378.14;
 
+/**
+/**
+ * Maximum distance of the Sun's LHA from the meridian (deg) for a
+ * sight to be accepted as a noon sight (sea trial 2026-08-31 guard).
+ * ~20° ≈ 80 minutes from transit — generous versus the ~30 min a
+ * navigator would actually shoot around LAN, but far below the ~100°
+ * the trial's 07:05-local sights carried.
+ */
+const NOON_MAX_LHA_DEG = 20;
+
+/**
+ * Maximum computed-vs-assumed latitude discrepancy (deg) accepted from
+ * a noon sight before it is refused as implausible (~720 NM).
+ */
+const NOON_MAX_LAT_DELTA_DEG = 12;
+
 /**
  * Reduces an ecliptic longitude/latitude to right ascension (degrees),
  * for a given obliquity (degrees).
@@ -437,6 +453,18 @@ function reduceNoonSight(input) {
   const gp = sunGeographicPosition(epochMs);
   const dec = gp.declination_deg;
 
+  // 1b. Meridian-transit guard (sea trial 2026-08-31): a sight taken
+  // hours from local noon reduces to garbage latitudes (both trial
+  // sights were morning sights that landed at −69°/−32°). LHA is 0
+  // (or 360) exactly on the meridian; refuse sights far from transit.
+  const lhaDeg = normalizeDeg360(gp.gha_deg + assumed.longitude);
+  const fromMeridianDeg = Math.min(lhaDeg, 360 - lhaDeg);
+  if (fromMeridianDeg > NOON_MAX_LHA_DEG) {
+    throw new Error(
+      `Sun is ${fromMeridianDeg.toFixed(0)}° from the meridian (LHA ${lhaDeg.toFixed(1)}°) at the sight time — not a noon sight. Uncheck "Noon sight" for an intercept-method reduction, or verify the sight time`,
+    );
+  }
+
   // 2. Ho from Hs (same corrections as a normal sight; limb sights apply).
   const sd = 0.2666;
   const semiDiameterDeg =
@@ -462,6 +490,17 @@ function reduceNoonSight(input) {
   const sunSouth = dec < assumed.latitude;
   const latitude = sunSouth ? dec + z : dec - z;
 
+  // 3b. Computed-vs-assumed sanity (sea trial 2026-08-31): even a sight
+  // near transit can be mis-entered (wrong limb, IC, time). A computed
+  // latitude a whole ocean away from the assumed/DR position is far
+  // more likely a bad sight than a 700 NM DR error — refuse it.
+  const latDeltaDeg = Math.abs(latitude - assumed.latitude);
+  if (latDeltaDeg > NOON_MAX_LAT_DELTA_DEG) {
+    throw new Error(
+      `Noon sight latitude ${latitude.toFixed(1)}° is ${latDeltaDeg.toFixed(1)}° from the assumed ${assumed.latitude.toFixed(1)}° — check the sight altitude, limb and index correction`,
+    );
+  }
+
   // Azimuth: 180° (due south) when the Sun is south of the observer,
   // 0° (due north) when it's north. Either yields an east-west LOP.
   const azimuth = sunSouth ? 180 : 0;
@@ -484,6 +523,8 @@ function reduceNoonSight(input) {
 }
 
 module.exports = {
+  NOON_MAX_LHA_DEG,
+  NOON_MAX_LAT_DELTA_DEG,
   raFromEcliptic,
   decFromEcliptic,
   sunGeographicPosition,

package/plugin/current.js

@@ -7,7 +7,11 @@
  *  1. **Manual override** — watchstander input with a valid TTL
  *     (`environment.current`). Not yet wired to an input path; the
  *     resolver accepts it so the precedence is explicit and testable.
- *  2. Live high-res NetCDF (Starlink-cached coastal) — future.
+ *  2. **Derived residual** — EWMA of the boat's own GPS-vs-water-track
+ *     residual (`derived-current.js`), learned while GPS is trusted and
+ *     carried forward with decay when GPS degrades. The boat's own
+ *     observation outranks model products (sea trial 2026-08-30→09-05:
+ *     ~11 nm DR error over 622 nm vs 47 nm for tier 3).
  *  3. **Signal K Weather API** (`/signalk/v2/api/weather/forecasts/point`)
  *     — a provider (e.g. a GRIB another process already downloaded)
  *     serves point forecasts carrying `current: {set (rad), drift (m/s)}`.
@@ -102,13 +106,17 @@ function parseWeatherCurrent(points, nowMs) {
  * @param {object} [input]
  * @param {{setTrue: number, drift: number, validUntilMs: number}|null} [input.manual]
  *   tier 1: watchstander override, honored while its TTL lasts
+ * @param {{setTrue: number, drift: number, validUntilMs: number}|null} [input.derived]
+ *   tier 2: EWMA of the boat's own GPS-vs-water-track residual
+ *   (`derived-current.js`), TTL-bounded and decayed while GPS is
+ *   degraded — the boat's own observation outranks model products
  * @param {{setTrue: number, drift: number, validUntilMs: number}|null} [input.weather]
  *   tier 3: Weather API cache entry from `WeatherCurrentClient.currentAt`
  * @param {((ctx: object) => ({setTrue: number, drift: number}|null))|null} [input.pilotLookup]
  *   tier 4: (month,lat,lon)→vector lookup into `offline_pilot_currents`
  * @param {object} [input.pilotCtx] - context for the pilot lookup
  * @param {number} [input.nowMs] - epoch ms; defaults to Date.now()
- * @returns {{setTrue: number, drift: number, tier: 1|3|4|5, source: string}}
+ * @returns {{setTrue: number, drift: number, tier: 1|2|3|4|5, source: string}}
  *   drift in knots, setTrue in deg true (direction the current flows toward)
  */
 function resolveCurrent(input = {}) {
@@ -125,6 +133,15 @@ function resolveCurrent(input = {}) {
       source: "manual",
     };
   }
+  // Tier 2: derived residual — the boat's own GPS-vs-water-track EWMA.
+  if (valid(input.derived)) {
+    return {
+      setTrue: normalizeDeg360(input.derived.setTrue ?? 0),
+      drift: input.derived.drift,
+      tier: 2,
+      source: "derived",
+    };
+  }
   // Tier 3: Weather API (sparse forecast GRIB via a weather provider).
   if (valid(input.weather)) {
     return {
@@ -157,34 +174,40 @@ function resolveCurrent(input = {}) {
  * 30 min) with a hard timeout, failures keep the previous cache until
  * its TTL lapses, and `currentAt` is a synchronous cache read.
  *
+ * The call is **in-process** (mirrors signalk-energy-predictor): the
+ * plugin always talks to the Signal K server it runs inside —
+ * `app.weatherApi.getForecasts()` is the same WeatherApi instance the
+ * `/signalk/v2/api/weather` REST routes wrap — so weather providers
+ * (e.g. a GRIB provider) registered by other plugins answer without
+ * HTTP, auth tokens or port guessing. The old HTTP loopback defaulted
+ * to `localhost:3000`, which on this install is Grafana and 404s every
+ * `/signalk/...` path. On servers without the Weather API the client
+ * stays idle and the §6.2 resolver never sees tier 3.
+ *
  * The response is a WeatherDataModel array; `current.set` is radians
  * and `current.drift` m/s (converted here to deg/kn).
  */
 class WeatherCurrentClient {
   /**
    * @param {object} [opts]
-   * @param {string} [opts.baseUrl] - server base URL (no trailing slash)
+   * @param {object} [opts.weatherApi] - the server's `app.weatherApi`
+   *   (needs a `getForecasts` function)
    * @param {number} [opts.intervalMs=1800000] - poll interval
    * @param {number} [opts.count=6] - forecast entries to request
-   * @param {number} [opts.timeoutMs=10000] - per-fetch abort timeout
+   * @param {number} [opts.timeoutMs=10000] - per-fetch timeout
    * @param {number} [opts.validityFactor=4] - cache TTL = interval × this
    * @param {() => ({latitude: number, longitude: number}|null)} [opts.getPosition]
    * @param {(message: string) => void} [opts.onStatus]
-   * @param {typeof fetch} [opts.fetchFn=globalThis.fetch]
    * @param {() => number} [opts.now=Date.now]
    */
   constructor(opts = {}) {
-    this.baseUrl = (opts.baseUrl ?? "http://localhost:3000").replace(
-      /\/+$/,
-      "",
-    );
+    this.weatherApi = opts.weatherApi ?? null;
     this.intervalMs = opts.intervalMs ?? 30 * 60 * 1000;
     this.count = opts.count ?? 6;
     this.timeoutMs = opts.timeoutMs ?? 10000;
     this.validityFactor = opts.validityFactor ?? 4;
     this.getPosition = opts.getPosition ?? (() => null);
     this.onStatus = opts.onStatus ?? null;
-    this.fetchFn = opts.fetchFn ?? globalThis.fetch?.bind(globalThis);
     this.now = opts.now ?? (() => Date.now());
     /** @type {{setTrue: number, drift: number, fetchedAt: number, validUntilMs: number}|null} */
     this.cache = null;
@@ -226,48 +249,51 @@ class WeatherCurrentClient {
    * @returns {Promise<void>}
    */
   async poll() {
-    if (this.fetching || !this.fetchFn) return;
+    if (this.fetching) return;
+    if (
+      !this.weatherApi ||
+      typeof this.weatherApi.getForecasts !== "function"
+    ) {
+      return; // server has no Weather API — tier 3 simply never resolves
+    }
     const pos = this.getPosition();
     if (!pos) return; // no position yet — retry on the next interval
     this.fetching = true;
     try {
-      const url = new URL(
-        `${this.baseUrl}/signalk/v2/api/weather/forecasts/point`,
-      );
-      url.searchParams.set("lat", String(pos.latitude));
-      url.searchParams.set("lon", String(pos.longitude));
-      url.searchParams.set("count", String(this.count));
-
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
-      try {
-        const res = await this.fetchFn(url.toString(), {
-          signal: controller.signal,
-        });
-        if (!res.ok) {
-          throw new Error(`weather API returned ${res.status}`);
-        }
-        const data = await res.json();
-        if (!Array.isArray(data)) {
-          throw new Error("weather API response is not an array");
-        }
-        const parsed = parseWeatherCurrent(data, this.now());
-        if (!parsed) {
-          throw new Error("forecast carries no current data");
-        }
-        const now = this.now();
-        this.cache = {
-          setTrue: parsed.setTrue,
-          drift: parsed.drift,
-          fetchedAt: now,
-          validUntilMs: now + this.intervalMs * this.validityFactor,
-        };
-        this.onStatus?.(
-          `Weather current: set ${parsed.setTrue.toFixed(0)}° true, drift ${parsed.drift.toFixed(2)} kn`,
-        );
-      } finally {
-        clearTimeout(timeoutId);
+      // In-process (same object the REST routes wrap): providers
+      // registered by other plugins answer directly. The timeout guards
+      // a provider doing its own network fetch under the hood.
+      let timeoutId;
+      const data = await Promise.race([
+        this.weatherApi.getForecasts(
+          { latitude: pos.latitude, longitude: pos.longitude },
+          "point",
+          { maxCount: this.count },
+        ),
+        new Promise((_resolve, reject) => {
+          timeoutId = setTimeout(
+            () => reject(new Error("weather API timed out")),
+            this.timeoutMs,
+          );
+        }),
+      ]).finally(() => clearTimeout(timeoutId));
+      if (!Array.isArray(data)) {
+        throw new Error("weather API response is not an array");
+      }
+      const parsed = parseWeatherCurrent(data, this.now());
+      if (!parsed) {
+        throw new Error("forecast carries no current data");
       }
+      const now = this.now();
+      this.cache = {
+        setTrue: parsed.setTrue,
+        drift: parsed.drift,
+        fetchedAt: now,
+        validUntilMs: now + this.intervalMs * this.validityFactor,
+      };
+      this.onStatus?.(
+        `Weather current: set ${parsed.setTrue.toFixed(0)}° true, drift ${parsed.drift.toFixed(2)} kn`,
+      );
     } catch (err) {
       // Keep any previous cache; the TTL decides when it stops being
       // trusted. Surface the failure once per poll cycle.

package/plugin/db.js

@@ -88,6 +88,12 @@ const SCHEMA_DDL = [
     body_or_object TEXT,
     confirmed_by TEXT,
     used_in_fix_id INTEGER,
+    raw_hs_deg REAL,
+    index_correction_deg REAL,
+    eye_height_m REAL,
+    limb TEXT,
+    ho_deg REAL,
+    hc_deg REAL,
     FOREIGN KEY (used_in_fix_id) REFERENCES fixes(fix_id)
   )`,
 
@@ -102,6 +108,8 @@ const SCHEMA_DDL = [
     source_object TEXT,
     confirmed_by TEXT,
     used_in_fix_id INTEGER,
+    raw_angle_deg REAL,
+    object_height_m REAL,
     FOREIGN KEY (used_in_fix_id) REFERENCES fixes(fix_id)
   )`,
 
@@ -193,20 +201,88 @@ function openDatabase(dbPath) {
   for (const stmt of SCHEMA_DDL) {
     db.exec(stmt);
   }
-  // v1 → v2: running-fix provenance column on `fixes`. Fresh databases
-  // get the column from the DDL above; existing ones are altered in
-  // place. The stored version is read *after* the DDL (it creates
-  // dr_state_store on a fresh database, where there is nothing to
-  // migrate) and *before* the new version is recorded below.
-  const storedVersion = getState(db, "schema_version");
-  if (storedVersion != null && Number(storedVersion) < 2) {
-    db.exec("ALTER TABLE fixes ADD COLUMN derived_from_fix_id INTEGER");
-  }
+  migrate(db);
   // Record schema version so future migrations can branch on it.
   setState(db, "schema_version", String(SCHEMA_VERSION));
   return db;
 }
 
+/**
+ * Column additions applied via ALTER TABLE, guarded by PRAGMA table_info
+ * so each is idempotent. Run unconditionally on open — the sea-trial
+ * database carried a schema_version written by a build whose numbering
+ * doesn't match this tree's history, so version-gated migrations would
+ * silently skip. Each step is cheap (one PRAGMA read).
+ *
+ * @type {Array<{table: string, column: string, ddl: string}>}
+ */
+const COLUMN_MIGRATIONS = [
+  // Schema v2 (running fix): provenance for single-observation running
+  // fixes advanced from a previous confirmed fix.
+  {
+    table: "fixes",
+    column: "derived_from_fix_id",
+    ddl: "ALTER TABLE fixes ADD COLUMN derived_from_fix_id INTEGER",
+  },
+  // Schema v2 (sea trial 2026-09-06): persist the raw user-entered sight
+  // inputs so reductions can be re-run/backtested without algebraic
+  // archaeology.
+  {
+    table: "lines_of_position",
+    column: "raw_hs_deg",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN raw_hs_deg REAL",
+  },
+  {
+    table: "lines_of_position",
+    column: "index_correction_deg",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN index_correction_deg REAL",
+  },
+  {
+    table: "lines_of_position",
+    column: "eye_height_m",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN eye_height_m REAL",
+  },
+  {
+    table: "lines_of_position",
+    column: "limb",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN limb TEXT",
+  },
+  {
+    table: "lines_of_position",
+    column: "ho_deg",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN ho_deg REAL",
+  },
+  {
+    table: "lines_of_position",
+    column: "hc_deg",
+    ddl: "ALTER TABLE lines_of_position ADD COLUMN hc_deg REAL",
+  },
+  {
+    table: "circular_position_lines",
+    column: "raw_angle_deg",
+    ddl: "ALTER TABLE circular_position_lines ADD COLUMN raw_angle_deg REAL",
+  },
+  {
+    table: "circular_position_lines",
+    column: "object_height_m",
+    ddl: "ALTER TABLE circular_position_lines ADD COLUMN object_height_m REAL",
+  },
+];
+
+/**
+ * Applies pending column migrations.
+ *
+ * @param {import("node:sqlite").DatabaseSync} db
+ * @returns {void}
+ */
+function migrate(db) {
+  for (const step of COLUMN_MIGRATIONS) {
+    const columns = db.prepare(`PRAGMA table_info(${step.table})`).all();
+    const exists = columns.some((c) => c.name === step.column);
+    if (!exists) db.exec(step.ddl);
+  }
+}
+
 /**
  * Reads a scalar value from `dr_state_store`.
  *
@@ -348,8 +424,9 @@ function recordLineOfPosition(db, r) {
   const stmt = db.prepare(
     `INSERT INTO lines_of_position (
        timestamp, lop_type, assumed_lat, assumed_lon, azimuth_true,
-       intercept_nm, body_or_object, confirmed_by
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+       intercept_nm, body_or_object, confirmed_by,
+       raw_hs_deg, index_correction_deg, eye_height_m, limb, ho_deg, hc_deg
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   const info = stmt.run(
     r.timestamp,
@@ -360,6 +437,14 @@ function recordLineOfPosition(db, r) {
     r.intercept_nm ?? null,
     r.body_or_object ?? null,
     r.confirmed_by ?? null,
+    // Raw user-entered sight inputs (schema v2): so a reduction can be
+    // re-run/backtested later without reconstructing Hs from the result.
+    r.raw_hs_deg ?? null,
+    r.index_correction_deg ?? null,
+    r.eye_height_m ?? null,
+    r.limb ?? null,
+    r.ho_deg ?? null,
+    r.hc_deg ?? null,
   );
   return Number(info.lastInsertRowid);
 }
@@ -386,8 +471,9 @@ function recordCircularPositionLine(db, r) {
   const stmt = db.prepare(
     `INSERT INTO circular_position_lines (
        timestamp, cpl_type, center_lat, center_lon, radius_nm,
-       radius_uncertainty_nm, source_object, confirmed_by
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+       radius_uncertainty_nm, source_object, confirmed_by,
+       raw_angle_deg, object_height_m
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   const info = stmt.run(
     r.timestamp,
@@ -398,6 +484,8 @@ function recordCircularPositionLine(db, r) {
     r.radius_uncertainty_nm ?? null,
     r.source_object ?? null,
     r.confirmed_by ?? null,
+    r.raw_angle_deg ?? null,
+    r.object_height_m ?? null,
   );
   return Number(info.lastInsertRowid);
 }