speedandcurrent 2.2.1 → 2.3.1

package/README.md

@@ -66,7 +66,7 @@ Once configured, all consumers on the Signal K bus — KIP, OpenCPN, Instrument
 | `environment.current.drift` | m/s | Estimated current speed. |
 | `environment.current.setTrue` | rad | Estimated current direction (the direction the water moves *toward*). |
 
-A 60-second stabilisation period applies after startup. No output is published during this window; the status bar shows **Stabilizing**.
+A 60-second stabilisation period applies after startup. No output is published during this window.
 
 ---
 
@@ -132,7 +132,7 @@ The panel is organised into three groups:
 | Setting | Default | Description |
 |---------|---------|-------------|
 | **Estimate Boat Speed** | Off | Master toggle. Apply the correction table and publish corrected STW, leeway, and current. Turn on once the table has reasonable coverage. |
-| **Groundspeed Fallback** | Off | When the paddle wheel reads zero and SOG is above a minimum threshold, publish SOG as boatspeed. Primarily intended for clogged or stuck paddle wheels where the instrument is physically present but not turning — giving the rest of the instrument system a usable boat speed until the wheel is cleared. |
+| **Groundspeed Fallback** | Off | When the paddle wheel reads zero and SOG is above the current table speed-step threshold, publish SOG as boatspeed. Primarily intended for clogged or stuck paddle wheels where the instrument is physically present but not turning — giving the rest of the instrument system a usable boat speed until the wheel is cleared. |
 
 ---
 
@@ -148,11 +148,14 @@ When **Assume Current** is enabled, the smoothed current estimate is also shown
 
 Warnings appear here if any smoothed input is unavailable.
 
+The panel also shows whether learning is currently active, suspended, or skipped for the latest observation. Learning is automatically suspended when `navigation.state` is `anchored` or `moored` when that path is available. It can also be suspended for `motoring` if enabled in the settings. Observations below the current table speed-step threshold are skipped.
+
 ### Settings
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| **Update Correction Table** | On | Master toggle. Allow the table to update from current observations. Disable temporarily in conditions you do not want recorded — motoring, surf sailing, very confused seas. |
+| **Update Correction Table** | On | Master toggle. Allow the table to update from current observations. |
+| **Suspend on navigation.state = motoring** | Off | Suspend learning when `navigation.state` reports `motoring`. `anchored` and `moored` always suspend learning when that path is available. |
 | **Stability (1–20)** | 7 | How quickly the correction table adapts to new observations. Higher = slower, more conservative. Lower = faster but noisier. See the technical section for detail. |
 | **Assume Current (experimental)** | Off | Include the running current estimate in the table update calculation. Only enable once the current estimate has had time to stabilise and tidal conditions are relatively steady. |
 | **Show Statistics (σ)** | Off | Display standard deviation alongside each smoothed value. Useful for spotting noisy sensors. |
@@ -208,7 +211,7 @@ Multiple tables can coexist on disk; only the active one is used. This makes it
 
 **Be patient with the correction table.** A fresh table has no data and produces no corrections. Cover a range of speeds and heel angles over a few sails and the table fills in progressively. Upwind sailing covers the heel bins well; downwind and reaching fill the low-heel, varying-speed bins.
 
-**The table learns while sailing normally.** No dedicated calibration runs are needed. Just sail with **Update Correction Table** on.
+**The table learns while sailing normally.** No dedicated calibration runs are needed. Just sail with **Update Correction Table** on. Learning pauses automatically during startup stabilisation, when `navigation.state` indicates `anchored` or `moored`, optionally when it indicates `motoring`, and when SOG or STW are below the current table speed-step threshold.
 
 **Port and starboard are tracked independently.** Heel is signed: starboard positive, port negative. An asymmetric paddle wheel installation will show different corrections on each tack, and the table captures this naturally.
 

package/index.js

@@ -19,19 +19,134 @@ const {
 
 const { CorrectionTable } = require('./correctionTable.js');
 
+const LONG_STABILIZING_MS = 60 * 1000;
+const ALWAYS_BLOCKING_NAVIGATION_STATES = new Set(['anchored', 'moored']);
+const OPTIONAL_BLOCKING_NAVIGATION_STATES = new Set(['motoring']);
+
+function normalizeNavigationState(value) {
+  return typeof value === 'string' ? value.trim().toLowerCase() : null;
+}
+
+function getShortStabilizingMs(options = {}) {
+  return Math.max(0, Number(options.smootherTimeSpan) || 5) * 1000;
+}
+
+function isCogOverrideActive(groundSpeedPolar, speedThreshold) {
+  const sogHandler = groundSpeedPolar?.magnitudeHandler;
+  return !groundSpeedPolar?.ready
+    && sogHandler?.ready
+    && Number.isFinite(sogHandler.value)
+    && sogHandler.value < speedThreshold;
+}
+
+function evaluateLearningMode({ options = {}, navigationState, stabilizingUntil = 0, stabilizingReason = null, now = Date.now() }) {
+  const normalizedNavigationState = normalizeNavigationState(navigationState?.value);
+  const navigationGateReady = navigationState?.ready === true;
+  const navigationGateBlocking = navigationGateReady && (
+    ALWAYS_BLOCKING_NAVIGATION_STATES.has(normalizedNavigationState)
+    || (!!options.suspendLearningOnNavigationState && OPTIONAL_BLOCKING_NAVIGATION_STATES.has(normalizedNavigationState))
+  );
+
+  if (!options.updateCorrectionTable) {
+    return { state: 'off', reason: 'manual', navigationGateBlocking, normalizedNavigationState };
+  }
+
+  if (navigationGateBlocking) {
+    return { state: 'suspended', reason: 'nav_state', navigationGateBlocking, normalizedNavigationState };
+  }
+
+  if (now < stabilizingUntil) {
+    return { state: 'stabilizing', reason: stabilizingReason || 'startup', navigationGateBlocking, normalizedNavigationState };
+  }
+
+  return { state: 'active', reason: null, navigationGateBlocking, normalizedNavigationState };
+}
+
+function evaluateObservationGate({
+  learningMode,
+  inputsReady,
+  assumeCurrent,
+  currentReady,
+  stw,
+  sog,
+  speedThreshold,
+}) {
+  if (learningMode.state === 'off') {
+    return { state: 'skipped', reason: 'learning_off' };
+  }
+  if (learningMode.state === 'suspended') {
+    return { state: 'skipped', reason: learningMode.reason === 'cog_override' ? 'cog_override_active' : 'nav_state_blocked' };
+  }
+  if (learningMode.state === 'stabilizing') {
+    return { state: 'skipped', reason: 'stabilizing' };
+  }
+  if (!inputsReady) {
+    return { state: 'invalid', reason: assumeCurrent && !currentReady ? 'missing_current_when_required' : 'missing_input' };
+  }
+  if (!(stw > speedThreshold)) {
+    return { state: 'skipped', reason: 'stw_below_threshold' };
+  }
+  if (!(sog >= speedThreshold)) {
+    return { state: 'skipped', reason: 'sog_below_threshold' };
+  }
+  return { state: 'pending', reason: null };
+}
+
+function buildNavigationStateStatus(handler, gateEnabled) {
+  if (!handler) {
+    return {
+      enabled: !!gateEnabled,
+      path: 'navigation.state',
+      pathKnown: false,
+      ready: false,
+      value: null,
+      blocking: false
+    };
+  }
+
+  const state = handler.state;
+  const value = handler.value ?? null;
+  const normalized = normalizeNavigationState(value);
+  return {
+    enabled: !!gateEnabled,
+    path: handler.path,
+    pathKnown: state.pathKnown,
+    ready: state.ready,
+    isStale: state.isStale,
+    value,
+    blocking: state.ready && (
+      ALWAYS_BLOCKING_NAVIGATION_STATES.has(normalized)
+      || (!!gateEnabled && OPTIONAL_BLOCKING_NAVIGATION_STATES.has(normalized))
+    )
+  };
+}
+
+function getDerivedObservationStatus(learningMode, lastState, lastReason) {
+  if (learningMode.state === 'off') {
+    return { state: 'skipped', reason: 'learning_off' };
+  }
+  if (learningMode.state === 'stabilizing') {
+    return { state: 'skipped', reason: 'stabilizing' };
+  }
+  if (learningMode.state === 'suspended') {
+    return { state: 'skipped', reason: learningMode.reason === 'cog_override' ? 'cog_override_active' : 'nav_state_blocked' };
+  }
+  return { state: lastState, reason: lastReason };
+}
+
 module.exports = function (app) {
 
   const DEFAULT_DIMS = { maxSpeed: 9, speedStep: 1, maxHeel: 32, heelStep: 8 };
 
   let options = {};
   let changedOptions = {};
-  let hasPendingChanges = false;
   const defaultOptions = {
     sogFallback: true,
     estimateBoatSpeed: false,
     updateCorrectionTable: true,
     stability: 7,
     assumeCurrent: false,
+    suspendLearningOnNavigationState: false,
     tableName: 'correctionTable',
     configVersion: 2,
     smootherClass: 'MovingAverageSmoother',
@@ -67,7 +182,7 @@ module.exports = function (app) {
    * writes it back if anything changed. Called once on every start().
    */
   function migrateConfig() {
-    const obsoleteKeys = ['headingSource', 'boatSpeedSource', 'SOGSource', 'attitudeSource', 'preventDuplication'];
+    const obsoleteKeys = ['headingSource', 'boatSpeedSource', 'SOGSource', 'attitudeSource', 'preventDuplication', 'minSogForLearning'];
     const hadObsolete = obsoleteKeys.some(k => k in options);
     for (const k of obsoleteKeys) delete options[k];
     if (hadObsolete || (options.configVersion || 0) < 2) {
@@ -109,7 +224,7 @@ module.exports = function (app) {
 
   function swapTable(newTable) {
     table = newTable;
-    minSpeed = table.step[0] / 2;
+    minSpeed = table.step[0];
     if (reportFull) reportFull.setTables([table]);
     lastSave = Date.now(); // explicit table operations already save; defer next periodic save
   }
@@ -136,12 +251,67 @@ module.exports = function (app) {
   let noCurrent = null;
   let rawBoatSpeed = null;
   let rawGroundSpeed = null;
-  let started = null;
   let minSpeed = 0;
   let lastSave = 0;
+  let navigationStateHandler = null;
+  let lastNavigationStateValue = null;
+  let learningStabilizingUntil = 0;
+  let learningStabilizingReason = 'startup';
+  let lastObservationState = null;
+  let lastObservationReason = null;
   let lifecycleWarningMap = new Map();
   let lifecycleWarnings = [];
 
+  function setObservationStatus(state, reason = null) {
+    lastObservationState = state;
+    lastObservationReason = reason;
+    if (table) {
+      table.lastUpdateResult = state;
+      table.lastUpdateReason = reason;
+    }
+  }
+
+  function resetLearningStabilization(reason, durationMs) {
+    const delay = Math.max(0, Number(durationMs) || 0);
+    learningStabilizingUntil = Date.now() + delay;
+    learningStabilizingReason = reason;
+  }
+
+  function handleNavigationStateDelta() {
+    const normalized = normalizeNavigationState(navigationStateHandler?.value);
+    if (normalized === lastNavigationStateValue) return;
+    if (lastNavigationStateValue !== null) {
+      resetLearningStabilization('nav_state_change', LONG_STABILIZING_MS);
+    }
+    lastNavigationStateValue = normalized;
+  }
+
+  function getLearningStatePayload() {
+    const navigationState = buildNavigationStateStatus(navigationStateHandler, options.suspendLearningOnNavigationState);
+    const learningMode = evaluateLearningMode({
+      options,
+      navigationState,
+      stabilizingUntil: learningStabilizingUntil,
+      stabilizingReason: learningStabilizingReason,
+      now: Date.now()
+    });
+    if (learningMode.state === 'active' && isCogOverrideActive(rawGroundSpeed, minSpeed)) {
+      learningMode.state = 'suspended';
+      learningMode.reason = 'cog_override';
+    }
+    const observation = getDerivedObservationStatus(learningMode, lastObservationState, lastObservationReason);
+
+    return {
+      state: learningMode.state,
+      reason: learningMode.reason,
+      observationState: observation.state,
+      observationReason: observation.reason,
+      minStwForLearning: minSpeed,
+      minSogForLearning: minSpeed,
+      navigationState
+    };
+  }
+
   function setLifecycleWarning(id, status, path) {
     const safePath = path || 'unknown path';
     const message = status === 'idle'
@@ -212,6 +382,7 @@ module.exports = function (app) {
       } else {
         const payload = reportFull.report();
         payload.lifecycleWarnings = lifecycleWarnings;
+        payload.learningState = getLearningStatePayload();
         res.json(payload);
       }
     });
@@ -227,7 +398,7 @@ module.exports = function (app) {
 
 
     router.get('/api/status', (req, res) => {
-      res.json({ status: pluginStatus, isRunning, lifecycleWarnings });
+      res.json({ status: pluginStatus, isRunning, lifecycleWarnings, learningState: getLearningStatePayload() });
     });
 
     // --- Settings API ---
@@ -248,7 +419,6 @@ module.exports = function (app) {
         }
       }
       changedOptions = { ...changedOptions, ...body };
-      hasPendingChanges = true;
       res.json({ ...options, ...changedOptions });
     });
 
@@ -363,7 +533,7 @@ module.exports = function (app) {
     const tableName = options.tableName || 'correctionTable';
     const tableFilePath = path.join(app.getDataDirPath(), tableName + '.json');
     table = loadTable(options, tableFilePath);
-    minSpeed = table.step[0] / 2;
+    minSpeed = table.step[0];
 
     //#region Handler and Polar Initialization
     const { SmootherClass, smootherOptions } = resolveSmootherConfig();
@@ -382,7 +552,7 @@ module.exports = function (app) {
     });
     rawHeading = smoothedHeading.handler;
 
-    //attitude
+    // attitude
     smoothedAttitude = createSmoothedHandler({
       app, pluginId: plugin.id,
       id: 'attitude',
@@ -398,6 +568,13 @@ module.exports = function (app) {
     });
     rawAttitude = smoothedAttitude.handler;
 
+    navigationStateHandler = new MessageHandler(app, plugin.id, 'navigationState');
+    navigationStateHandler.configure('navigation.state');
+    navigationStateHandler.onDelta = () => {
+      handleNavigationStateDelta();
+    };
+    navigationStateHandler.subscribe();
+
 
     // current
     // send metadata for current
@@ -452,26 +629,26 @@ module.exports = function (app) {
         // Drain any pending option changes before calculating
         if (Object.keys(changedOptions).length) applyOptionChanges();
 
-        const wellUnderway = started < new Date() - 60 * 1000;
+        const learningMode = evaluateLearningMode({
+          options,
+          navigationState: buildNavigationStateStatus(navigationStateHandler, options.suspendLearningOnNavigationState),
+          stabilizingUntil: learningStabilizingUntil,
+          stabilizingReason: learningStabilizingReason,
+          now: Date.now()
+        });
 
-        setStatus(wellUnderway ? 'Running' : 'Stabilizing');
+        const wellUnderway = learningMode.state !== 'stabilizing';
+        setStatus(learningMode.state === 'stabilizing' ? 'Stabilizing' : 'Running');
         if (options.estimateBoatSpeed) correct(wellUnderway);
-        if (options.updateCorrectionTable) {
-          if (wellUnderway) {
-            updateTable();
-            // Save correction table periodically (skip if table is empty to avoid overwriting good data on disk)
-            const now = Date.now();
-            if (now - lastSave > 60_000) {
-              if (!isTableEmpty(table)) {
-                saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
-              }
-              lastSave = now;
+        updateTable();
+        if (lastObservationState === 'accepted' && options.updateCorrectionTable) {
+          const now = Date.now();
+          if (now - lastSave > 60_000) {
+            if (!isTableEmpty(table)) {
+              saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
             }
-          } else {
-            table.lastUpdateResult = 'stabilizing';
+            lastSave = now;
           }
-        } else {
-          table.lastUpdateResult = null;
         }
       }
       ,
@@ -572,8 +749,11 @@ module.exports = function (app) {
     //#endregion
 
     isRunning = true;
-    started = Date.now();
     lastSave = 0;
+    lastObservationState = null;
+    lastObservationReason = null;
+    lastNavigationStateValue = normalizeNavigationState(navigationStateHandler?.value);
+    resetLearningStabilization('startup', LONG_STABILIZING_MS);
     setStatus('Running');
     app.debug("Running");
 
@@ -592,6 +772,7 @@ module.exports = function (app) {
         smoothedAttitude = smoothedAttitude?.terminate();
         rawCurrent = rawCurrent?.terminate();
         smoothedCurrent = smoothedCurrent?.terminate?.();
+        navigationStateHandler = navigationStateHandler?.terminate();
         smoothedBoatSpeed = smoothedBoatSpeed?.terminate();
         correctedBoatSpeed = correctedBoatSpeed?.terminate();
         lrnBoatSpeed = lrnBoatSpeed?.terminate();
@@ -607,7 +788,11 @@ module.exports = function (app) {
         noCurrent = null;
         rawBoatSpeed = null;
         rawGroundSpeed = null;
-        started = null;
+        lastNavigationStateValue = null;
+        learningStabilizingUntil = 0;
+        learningStabilizingReason = 'startup';
+        lastObservationState = null;
+        lastObservationReason = null;
         app.setPluginStatus("Stopped");
         app.debug("Stopped");
 
@@ -642,7 +827,7 @@ module.exports = function (app) {
 
     // Priority 1: SOG fallback when STW is stuck at zero
     // (onChange only fires when STW is ready, so a missing STW cannot reach here)
-    if (options.sogFallback && rawGroundSpeed.ready && correctedBoatSpeed.magnitude === 0 && rawGroundSpeed.magnitude >= minSpeed) {
+    if (options.sogFallback && rawGroundSpeed.ready && rawBoatSpeed.ready && rawBoatSpeed.value === 0 && rawGroundSpeed.magnitude >= minSpeed) {
         correctedBoatSpeed.setVectorValue({ x: rawGroundSpeed.magnitude, y: 0 });
     }
     else if (rawAttitude.ready) {
@@ -653,11 +838,7 @@ module.exports = function (app) {
       }
       // Current estimation and residual also require heading (to rotate into ground frame).
       // Also handle near-zero SOG where COG is unavailable: treat groundspeed as zero vector.
-      const sogHandler = rawGroundSpeed.magnitudeHandler;
-      const nearZeroGroundSpeed = !rawGroundSpeed.ready &&
-        sogHandler.ready &&
-        Number.isFinite(sogHandler.value) &&
-        sogHandler.value < 0.3;
+      const nearZeroGroundSpeed = isCogOverrideActive(rawGroundSpeed, minSpeed);
       if (rawHeading.ready && (rawGroundSpeed.ready || nearZeroGroundSpeed)) {
         boatSpeedRefGround.copyFrom(correctedBoatSpeed);
         boatSpeedRefGround.rotate(rawHeading.value);
@@ -695,18 +876,43 @@ module.exports = function (app) {
    */
   function updateTable() {
     lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 }, { x: smoothedBoatSpeed.variance ?? 0, y: 0 });
-    if (!smoothedAttitude.ready || !smoothedBoatSpeed.ready || !smoothedHeading.ready || !smoothedGroundSpeed.ready || (options.assumeCurrent && !smoothedCurrent.ready)) {
-      table.lastUpdateResult = 'invalid';
-      return;
+    const learningMode = evaluateLearningMode({
+      options,
+      navigationState: buildNavigationStateStatus(navigationStateHandler, options.suspendLearningOnNavigationState),
+      stabilizingUntil: learningStabilizingUntil,
+      stabilizingReason: learningStabilizingReason,
+      now: Date.now()
+    });
+    if (learningMode.state === 'active' && isCogOverrideActive(rawGroundSpeed, minSpeed)) {
+      learningMode.state = 'suspended';
+      learningMode.reason = 'cog_override';
     }
-    
-    // update correction table
-    if (smoothedBoatSpeed.value > minSpeed) {
-      table.update(smoothedBoatSpeed.value, smoothedAttitude.value?.roll, smoothedGroundSpeed, options.assumeCurrent ? smoothedCurrent : noCurrent, lrnBoatSpeed, smoothedHeading.value);
-    } else {
-      table.lastUpdateResult = 'waiting';
+    const inputsReady = smoothedAttitude.ready && smoothedBoatSpeed.ready && smoothedHeading.ready && smoothedGroundSpeed.ready;
+    const currentReady = !options.assumeCurrent || smoothedCurrent.ready;
+    const observationGate = evaluateObservationGate({
+      learningMode,
+      inputsReady,
+      assumeCurrent: options.assumeCurrent,
+      currentReady,
+      stw: smoothedBoatSpeed.value,
+      sog: smoothedGroundSpeed.magnitude,
+      speedThreshold: minSpeed
+    });
+
+    if (observationGate.state !== 'pending') {
+      if (observationGate.state === 'invalid') {
+        resetLearningStabilization('observation_reset', getShortStabilizingMs(options));
+      }
+      return;
     }
 
+    table.update(smoothedBoatSpeed.value, smoothedAttitude.value?.roll, smoothedGroundSpeed, options.assumeCurrent ? smoothedCurrent : noCurrent, lrnBoatSpeed, smoothedHeading.value);
+    if (table.lastUpdateResult === 'accepted') {
+      setObservationStatus('accepted', 'accepted');
+    } else if (table.lastUpdateResult === 'rejected') {
+      setObservationStatus('rejected', 'estimator_outlier');
+      resetLearningStabilization('observation_reset', getShortStabilizingMs(options));
+    }
   }
 
   /**
@@ -812,7 +1018,6 @@ module.exports = function (app) {
           }
         }
       }
-
       // All other keys (sogFallback, estimateBoatSpeed, assumeCurrent,
       // stability, smootherClass, etc.) are read
       // directly from options.* so no extra action needed.
@@ -834,10 +1039,21 @@ module.exports = function (app) {
       }
       if (smoothedAttitude) { smoothedAttitude.setSmootherClass(SC); smoothedAttitude.setSmootherOptions(so); }
     }
-
-    hasPendingChanges = false;
     saveOptions();
   }
 
   return plugin;
 };
+
+module.exports._test = {
+  normalizeNavigationState,
+  getShortStabilizingMs,
+  evaluateLearningMode,
+  isCogOverrideActive,
+  evaluateObservationGate,
+  getDerivedObservationStatus,
+  buildNavigationStateStatus,
+  ALWAYS_BLOCKING_NAVIGATION_STATES,
+  OPTIONAL_BLOCKING_NAVIGATION_STATES,
+  LONG_STABILIZING_MS,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedandcurrent",
-  "version": "2.2.1",
+  "version": "2.3.1",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
@@ -34,6 +34,9 @@
       "./docs/correctionTable.png",
       "./docs/STW_estimation.png",
       "./docs/learning.png"
+    ],
+    "recommends": [
+      "@meri-imperiumi/signalk-autostate"
     ]
   },
   "dependencies": {

package/public/app.js

@@ -275,11 +275,8 @@ function _refreshMessage() {
     else el.textContent = _explicitMsg;
     return;
   }
-  const isRunningOk = (_pluginStatus === 'Running' || _pluginStatus === '');
+  const isRunningOk = (_pluginStatus === 'Running' || _pluginStatus === 'Stabilizing' || _pluginStatus === '');
   if (!isRunningOk) {
-    el.style.color =
-      _pluginStatus === 'Stabilizing'                    ? '#084298' :
-      _pluginStatus === 'Falling back to Speed Over Ground' ? '#664d03' : '#842029';
     el.textContent = _pluginStatus;
   } else {
     el.style.color = '';
@@ -292,6 +289,7 @@ function _refreshMessage() {
 const paramMeta = {
   estimateBoatSpeed:     { label: 'Estimate boat speed',                  type: 'boolean' },
   updateCorrectionTable: { label: 'Update correction table',              type: 'boolean' },
+  suspendLearningOnNavigationState: { label: 'Suspend on navigation.state = motoring', type: 'boolean', description: 'Suspend learning when navigation.state is motoring. Anchored and moored always suspend learning when the path is available.' },
   assumeCurrent:         { label: 'Assume current during update',         type: 'boolean', description: 'Experimental, works best when currents are relatively stable.' },
   sogFallback:           { label: 'Groundspeed fallback',                 type: 'boolean', description: 'Output Groundspeed as Boatspeed when the paddlewheel sensor is malfunctioning or stalled.' },
   stability:             { label: 'Stability (1–20)',                     type: 'number', min: 1, max: 20, step: 1, default: 7, description: 'How quickly the correction table adapts to new observations. Higher values mean slower, more stable changes.' },
@@ -323,14 +321,8 @@ const paramMeta = {
 };
 
 // Settings groups for each UI section
-const INPUTS_SETTING_KEYS     = [
-  'smootherClass',
-  { key: 'smootherTau',         showIf: cfg => cfg.smootherClass === 'ExponentialSmoother' },
-  { key: 'smootherTimeSpan',    showIf: cfg => (cfg.smootherClass || 'MovingAverageSmoother') === 'MovingAverageSmoother' },
-  { key: 'smootherSteadyState', showIf: cfg => cfg.smootherClass === 'KalmanSmoother' },
-];
 const ESTIMATION_SETTING_KEYS = ['sogFallback'];
-const LEARNING_SETTING_KEYS   = ['stability','assumeCurrent','showStatistics'];
+const LEARNING_SETTING_KEYS   = ['stability', 'suspendLearningOnNavigationState', 'assumeCurrent', 'showStatistics'];
 const SMOOTHER_SETTING_KEYS   = [
   'smootherClass',
   { key: 'smootherTau',         showIf: cfg => cfg.smootherClass === 'ExponentialSmoother' },
@@ -445,7 +437,6 @@ function renderSectionToggles() {
 
 function renderSettingsPanel() {
   if (!config) return;
-  renderSettingsRows('inputs-settings-table',     INPUTS_SETTING_KEYS);
   renderSettingsRows('estimation-settings-table', ESTIMATION_SETTING_KEYS);
   renderSettingsRows('smoother-settings-table',   SMOOTHER_SETTING_KEYS);
   renderSettingsRows('learning-settings-table',   LEARNING_SETTING_KEYS);
@@ -535,6 +526,7 @@ function renderGroupInto(elId, polars, deltas, attitudes) {
 }
 
 function renderLiveSections() {
+  const learningState = state.learningState || null;
   const inputPolars = filterById(state.polarsAll, ['groundSpeed']);
   const inputDeltas = filterById(state.deltasAll, ['heading.angle', 'boatSpeed']);
   const inputAttitudes = filterById(state.attitudesAll, ['attitude']);
@@ -583,31 +575,60 @@ function renderLiveSections() {
   );
   // Learning — warnings
   const learningWarnings = document.getElementById('learning-warnings');
-  if (learningWarnings) learningWarnings.innerHTML = '';
+  if (learningWarnings) {
+    learningWarnings.innerHTML = '';
+    const navState = learningState?.navigationState;
+    if (navState?.enabled && navState.pathKnown === false) {
+      const ul = document.createElement('ul');
+      ul.className = 'list-unstyled small ps-3';
+      const li = document.createElement('li');
+      li.textContent = 'navigation.state is not available; navigation-state learning gate is inactive.';
+      ul.appendChild(li);
+      learningWarnings.appendChild(ul);
+    }
+  }
   // Learning status section
   const statusTbody = document.querySelector('#learning-status-table tbody');
   if (statusTbody) {
-    const tableData = Object.values(state.tablesById)[0];
-    const result = tableData?.lastUpdateResult ?? null;
-    const learningText  = result === null          ? 'Off'
-                        : result === 'stabilizing' ? 'Stabilising'
-                        : 'Active';
-    const learningClass = result === null          ? 'text-muted'
-                        : result === 'stabilizing' ? 'text-warning'
-                        : 'text-success';
-    const obsText       = result === 'accepted'    ? 'Accepted'
-                        : result === 'rejected'    ? 'Rejected'
-                        : result === 'invalid'     ? 'Invalid'
-                        : result === 'waiting'     ? 'Below threshold'
-                        : '\u2014';
-    const obsClass      = result === 'accepted'    ? 'text-success'
-                        : result === 'rejected'    ? 'text-danger'
-                        : result === 'invalid'     ? 'text-warning'
-                        : result === 'waiting'     ? 'text-muted'
-                        : 'text-muted';
+    const learningTextMap = {
+      off: 'Off',
+      stabilizing: 'Stabilising',
+      active: 'Active',
+      suspended: 'Suspended',
+    };
+    const observationTextMap = {
+      accepted: 'Accepted',
+      rejected: 'Rejected',
+      invalid: 'Invalid',
+      skipped: 'Skipped',
+    };
+    const reasonTextMap = {
+      manual: 'Manual toggle off',
+      startup: 'Startup stabilising window',
+      observation_reset: 'Recent rejected or invalid observation',
+      nav_state_change: 'navigation.state changed',
+      nav_state: 'Blocked by navigation.state',
+      cog_override: 'Blocked by COG override',
+      accepted: 'Observation recorded',
+      estimator_outlier: 'Estimator rejected observation',
+      missing_input: 'Required learning input unavailable',
+      missing_current_when_required: 'Current estimate unavailable',
+      learning_off: 'Learning is off',
+      stabilizing: 'Stabilising window active',
+      nav_state_blocked: 'Learning blocked by navigation.state',
+      cog_override_active: 'Learning blocked by COG override',
+      stw_below_threshold: 'Below minimum STW for learning',
+      sog_below_threshold: 'Below minimum SOG for learning',
+    };
+    const learningText = learningTextMap[learningState?.state] || '\u2014';
+    const obsText = observationTextMap[learningState?.observationState] || '\u2014';
+    const reason = reasonTextMap[learningState?.observationReason]
+      || reasonTextMap[learningState?.reason]
+      || '\u2014';
     statusTbody.innerHTML =
-      `<tr><td class="text-muted small">Learning</td><td class="small fw-bold ${learningClass}">${learningText}</td></tr>` +
-      `<tr><td class="text-muted small">Observation</td><td class="small fw-bold ${obsClass}">${obsText}</td></tr>`;
+        `<tr><td class="text-muted small">Learning</td><td class="small">${learningText}</td></tr>` +
+        `<tr><td class="text-muted small">Observation</td><td class="small">${obsText}</td></tr>` +
+      `<tr><td class="text-muted small">Reason</td><td class="small">${reason}</td></tr>`;
   }
   // Correction table
   const tableEl = document.getElementById('table-container');
@@ -642,9 +663,11 @@ async function tick() {
     }
     lastTickOk = true;
     normaliseState(data);
+    state.learningState = data.learningState || null;
     renderLiveSections();
   } else {
     lastTickOk = false;
+    state.learningState = null;
   }
   // Always poll status separately so the message reflects plugin state
   // even when /api/report fails (plugin stopped/restarting).

package/public/index.html

@@ -13,22 +13,31 @@
         el.href = href;
         document.head.appendChild(el);
       };
+      let manifestFailure = 'manifest contained no CSS assets';
       try {
         const res = await fetch('/admin/.vite/manifest.json');
         if (res.ok) {
           const manifest = await res.json();
-          let found = false;
+          const stylesheets = new Set();
           for (const entry of Object.values(manifest)) {
-            if (!entry.isEntry) continue;
-            for (const css of entry.css ?? []) {
-              appendStylesheet('/admin/' + css);
-              found = true;
+            if (entry.file?.endsWith('.css')) {
+              stylesheets.add(entry.file);
             }
+            if (entry.isEntry) {
+              for (const css of entry.css ?? []) {
+                stylesheets.add(css);
+              }
+            }
+          }
+          if (stylesheets.size > 0) {
+            for (const css of stylesheets) appendStylesheet('/admin/' + css);
+            return;
           }
-          if (found) return;
+        } else {
+          manifestFailure = `manifest request returned ${res.status}`;
         }
       } catch (e) {
-        // fall through to legacy scrape
+        manifestFailure = `manifest request failed: ${e.message}`;
       }
       try {
         const res  = await fetch('/');
@@ -37,9 +46,11 @@
         const link = doc.querySelector('link[rel="stylesheet"]');
         if (link) {
           appendStylesheet(new URL(link.getAttribute('href'), res.url).href);
+          return;
         }
+        console.warn(`[webapp] Could not load SignalK admin stylesheet: ${manifestFailure}; legacy admin page contained no stylesheet link.`);
       } catch (e) {
-        console.warn('[webapp] Could not load SignalK admin stylesheet:', e);
+        console.warn(`[webapp] Could not load SignalK admin stylesheet: ${manifestFailure}; legacy fallback failed: ${e.message}`);
       }
     })();
   </script>
@@ -91,11 +102,7 @@
           <div class="card">
             <div class="card-header fw-bold text-uppercase">Inputs</div>
             <div class="card-body">
-              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mb-1 small">Settings</h6>
-              <table class="table table-sm table-borderless mb-0" id="inputs-settings-table">
-                <tbody></tbody>
-              </table>
-              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Live Values</h6>
+              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mb-1 small">Live Values</h6>
               <div id="inputs-values"></div>
               <div id="inputs-warnings"></div>
             </div>