signalk-pypilot-newui 3.4.0 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,92 @@
 # Changelog
 
+## 3.6.0 — 2026-10-19 — AUTO WIND and a logbook button on the rose
+
+Rolls up Rev517 → Rev520 on top of 3.5.0. Minor bump: new AUTO WIND
+pseudo-mode. No breaking changes; AUTO WIND is off until chosen.
+
+### Added
+- **AUTO WIND pseudo-mode**: apparent wind below 120° TWA, true wind
+  above (hysteresis ±5°, 10 s sustained, at most one switch per 30 s;
+  never during a tack, head-to-wind, head-downwind or with the AP off).
+  Each side has its own pypilot profile, chosen in the mode window, so
+  the true-wind side can be the more reactive one. Runs in the backend
+  (works with the visor closed); picking any other mode, or compass from
+  the remote, turns it off. Mode button shows "AUTO · REAL / APPARENT".
+  Without GPS pypilot offers no true wind: the entry is shown greyed out
+  ("needs GPS for true wind"), and pypilot's own drop to compass on a
+  GPS loss does not turn AUTO WIND off.
+  Listed right below compass / GPS in the mode window.
+- **Logbook button**: while a trip is being recorded it opens that trip;
+  in port it opens the logbook list.
+- **Logbook button on the rose**: a helm icon on the left, mirroring the
+  tide button on the right, opens the Logbook full screen; its x goes
+  back to the rose.
+
+## 3.5.0 — 2026-10-19 — Fixes from two sea trials, logbook while sailing
+
+Rolls up Rev509 → Rev516 on top of 3.4.0. Minor bump: live logbook,
+heading in the compass tack summary, trace pruning. No breaking changes.
+
+Rev515 comes from the sail of 2026-10-19: it reverts two changes that
+made things worse (Rev510 compass-until-6°, Rev512 head-to-wind in
+compass) and fixes what the sail showed. Audit:
+`docs/_audit_sail_2026-10-19.md`.
+
+### Changed
+- **Maneuver traces keep the newest 60 files** (pruned when a new trace
+  opens). 201 files / 888 MB had piled up on the Tunatunes.
+- **Stuck pilot recovery only on a real false end stop**: it now needs
+  pypilot's directional overcurrent fault. 0 A is not evidence (the
+  TinyPilot reads 0 A while driving, `DRIVER_TIMEOUT`), it never acts
+  during pypilot's own tack or for 20 s after, and a target change of
+  more than 10° restarts its clock. On 2026-10-19 it cycled the AP three
+  times by mistake, twice in the middle of a tack from the remote.
+- **Gybe confirmation only right after a cancel**: the long-way gybe
+  question (> 180°) now appears only within 20 s of cancelling a tack -
+  the 2026-10-18 accident - not on deliberate gybes. Yes / No buttons
+  are translated.
+
+### Added
+- **Logbook while sailing**: the trip being recorded appears in the
+  logbook with an "IN PROGRESS" badge, live statistics (distance, time,
+  speeds, wind, tacks, energy...) and the track on the chart up to now.
+- **Tack summary in compass mode** shows the mean heading before / after
+  instead of the apparent wind angle.
+- **Confirmation before a gybe the long way** (see above).
+
+### Fixed
+- **Cancelling a virtual tack left a "ghost" target**: pypilot processes
+  the mode change in its own loop and overwrote our "stay here" target
+  with one recomputed from the compass error (2026-10-19: 56° -> 3.9°,
+  bow into the wind). The cancel now waits for the mode change, writes
+  the target, checks it and rewrites it if pypilot moved it.
+- **Remote tack HUD turning the wrong way**: pypilot overwrites
+  `ap.tack.direction` with the wind side ~0.5 s after the remote starts a
+  tack; the HUD now keeps the direction it had at the start. It also stays
+  open until the boat is within 10° of the new target (max 15 s), not only
+  until pypilot's 50 % threshold.
+- **Tack countdown**: shows the distance from the wind arrow to the target
+  diamond along the turn (what the rose shows), no "ajustando" text.
+- **Two screens showing different modes after a tack**: the mode now
+  comes from the backend (plain mode label, no "TACKING ->" prefix).
+- **Previous manoeuvre's summary popping up during the next one**.
+- **Settings tab**: dragging a slider no longer darkens the whole tab
+  (only the other rows), and the darkening clears if the touch is
+  interrupted. A value the sailor writes stays on screen until the
+  backend confirms it (or reports a different one).
+- **`ap.tack.direction` noise in standby**: published as `none` once
+  while the AP is off (pypilot flips it ~40 times a minute there).
+- **Gust ghost arrow almost never visible**: the fade started in the
+  same frame the ghost was created, so the browser skipped it.
+
+### Reverted
+- Rev510 "virtual tack holds compass until 6° of the final heading": the
+  apparent wind at the final heading is not the mirror, so wind mode then
+  swung back 40-50° (S-turn); handover is at 20° again.
+- Rev512 "head to wind holds in compass": head to wind is always in
+  apparent wind, as before.
+
 ## 3.4.0 — 2026-10-18 — The sailor always wins, and the pilot gets unstuck
 
 Rolls up Rev506 → Rev508 on top of 3.3.0, from the strong-wind sea

package/README.md

@@ -131,7 +131,8 @@ up automatically.
 13. **Tide at a glance** (with `signalk-mareas-ihm`) — button on the
     rose opens a popup with an interactive tide curve, current height,
     trend, next HW/LW and coefficient, and can open the anchor-watch
-    visor inside the rose.
+    visor inside the rose. A helm button on the other side opens the
+    logbook (the trip in progress while sailing).
 
 ### Autopilot enhancements — 12 new added functions
 
@@ -142,17 +143,21 @@ up automatically.
     original stays one tap away.
 15. **Smart Pilot — auto profile by wind** — switches the pypilot
     profile between Light / Medium / Heavy according to the averaged
-    TWS.
+    TWS. **AUTO WIND pseudo-mode**: apparent wind below 120° TWA, true
+    wind above (with hysteresis), one pypilot profile for each side so
+    the true-wind side can be the more reactive one. Needs GPS (pypilot
+    only offers true wind with it).
 16. **Smart Pilot — gust strategy** — freeze target, boost D +20%
     for 20 s, temporarily switch to the Heavy profile for 30 s, or
     just warn.
 17. **Auto-disengage on lost authority** — RMS heading error > 30°
     with servo duty > 90% sustained 10 s. **Stuck pilot recovery**
     (opt-in): with no rudder sensor, pypilot treats an overcurrent as
-    the end of rudder travel and stops driving that way; when the error
-    keeps growing and the servo is not pushing, the plugin turns the AP
-    off and on (same mode and target) to clear it, at most 3 times per
-    minute.
+    the end of rudder travel and stops driving that way; when pypilot
+    reports that directional overcurrent fault and the error keeps
+    growing, the plugin turns the AP off and on (same mode and target)
+    to clear it, at most 3 times per minute. Never during pypilot's own
+    tack.
 18. **Pre-departure Autopilot Check** — a single READY / CAVEATS /
     DO-NOT-ENGAGE verdict aggregating every sensor, servo, voltage
     and link signal.
@@ -200,6 +205,8 @@ up automatically.
     split, min voltage, AP-engaged %), OpenSeaMap trace coloured by
     SOG with markers on peak gust, peak SOG, min voltage and every
     detected tack. Share as portrait PNG report card or as plain text.
+    The trip in progress can be opened while sailing (live statistics
+    and the track so far).
 27. **Chart tab** — 9 live Trip Stats cards, history with
     30 s / 2 min / 10 min windows and hover-freeze, plus a Servo
     Health card.

package/dist/autopilot-provider.js

@@ -26,6 +26,7 @@ const TARGET_PENDING_MS = 2500;
 // value the user had just replaced. 0.1° covers float32 → double
 // rounding on the wire without accidentally consuming a stale echo.
 const TARGET_ECHO_TOL_RAD = 0.1 * DEG_TO_RAD;
+const LONG_JIBE_CONFIRM_AFTER_CANCEL_MS = 20000;
 // Rev272 (audit R07): bounded-cost normalisation. The previous while
 // loop could spin forever on pathological inputs (e.g. |a-b| >= 1e15
 // where 2π is below the mantissa's precision, so subtracting a full
@@ -113,6 +114,8 @@ class AutopilotProvider {
         /** Rev506: recovery cycles (steer-recovery) toggle the AP off/on on
          *  purpose; that must NOT annul the tack the cycle is trying to save. */
         this._recoveryCycleUntil = 0;
+        /** Rev515: last cancel of a running virtual tack (any source). */
+        this._lastVtCancelTs = 0;
         if (opts?.allowDodge)
             this.allowDodge = true;
         this.onDataChanged = opts?.onDataChanged;
@@ -766,6 +769,24 @@ class AutopilotProvider {
             && Number.isFinite(opts.finalAngleRadOverride)
             && Math.abs(opts.finalAngleRadOverride) <= Math.PI
             ? opts.finalAngleRadOverride : null;
+        // Rev511: same geometry the FSM will compute; refuse a long-way gybe
+        // unless the sailor confirmed it. Rev515 (Carlos 2026-10-19: 7 asks
+        // in a sail of deliberate gybes): only right after a cancel, which is
+        // the 2026-10-18 18:11:44 accident (second tap 3 s after cancelling).
+        if (!opts.confirmLongJibe && Date.now() - this._lastVtCancelTs < LONG_JIBE_CONFIRM_AFTER_CANCEL_MS) {
+            const g = (0, virtual_tack_1.computeTackGeometry)({
+                angleStartRad: awaRad,
+                hStartRad: headingRad,
+                direction: opts.direction,
+                angleNewRadOverride: finalAngleOverride ?? undefined,
+            });
+            if ((0, virtual_tack_1.needsLongJibeConfirm)(g)) {
+                const err = new Error(`virtual-tack: gybe the long way (${(g.deltaHRad * RAD_TO_DEG).toFixed(0)} deg) needs confirmation`);
+                err.code = "confirm_long_jibe";
+                err.deltaDeg = g.deltaHRad * RAD_TO_DEG;
+                throw err;
+            }
+        }
         this._runVirtualTack(opts.direction, windMode, headingRad, awaRad, finalAngleOverride).catch((e) => {
             // eslint-disable-next-line no-console
             console.log(`[startVirtualTack] driver threw: ${e?.message || e}`);
@@ -1302,13 +1323,32 @@ class AutopilotProvider {
                 }
                 catch { /* noop */ }
                 if (awaRad !== null) {
-                    this._vtInternalWrite = true;
-                    try {
-                        await this.setTarget(awaRad);
-                    }
-                    catch { /* best-effort */ }
-                    finally {
-                        this._vtInternalWrite = false;
+                    // Rev515 (sail 2026-10-19 19:08:24, 19:15:44, 19:17:10): pypilot
+                    // processes the mode change in its own loop and "keeps the
+                    // heading" by recomputing heading_command from the compass error
+                    // - AFTER our target had landed, so it overwrote it (56 -> 3.9,
+                    // -57 -> 4.8: bow into the wind, "target fantasma"). Wait for
+                    // the mode echo plus a few pypilot loops, write, check, rewrite.
+                    await this._waitValue("ap.mode", windMode, 1500);
+                    await sleep(400);
+                    for (let attempt = 0; attempt < 2; attempt++) {
+                        this._vtInternalWrite = true;
+                        try {
+                            await this.setTarget(awaRad);
+                        }
+                        catch { /* best-effort */ }
+                        finally {
+                            this._vtInternalWrite = false;
+                        }
+                        await sleep(1200);
+                        const cmdDeg = Number((this.client.getValues?.() || {})["ap.heading_command"]);
+                        if (!Number.isFinite(cmdDeg))
+                            break;
+                        const diff = Math.abs(((cmdDeg - awaRad * RAD_TO_DEG) % 360 + 540) % 360 - 180);
+                        if (diff <= 2)
+                            break;
+                        // eslint-disable-next-line no-console
+                        console.log(`[virtual-tack ${vtId}] cancel: pypilot moved the target to ${cmdDeg.toFixed(1)}deg, rewriting ${(awaRad * RAD_TO_DEG).toFixed(1)}deg`);
                     }
                 }
             }
@@ -1361,6 +1401,7 @@ class AutopilotProvider {
             return;
         // eslint-disable-next-line no-console
         console.log(`[virtual-tack] external cancel at phase=${this._virtualTack.phase} (${reason})`);
+        this._lastVtCancelTs = Date.now();
         this._virtualTack.phase = "cancelling";
         this._virtualTack.outcomeReason = reason;
         this.notifyChanged("all");
@@ -1382,6 +1423,18 @@ class AutopilotProvider {
         this.notifyChanged("virtualTack");
         return true;
     }
+    /** Rev515: wait until pypilot reports key === expected (no cancel check;
+     *  used by the cancel path itself). */
+    async _waitValue(key, expected, timeoutMs) {
+        const t0 = Date.now();
+        while (Date.now() - t0 < timeoutMs) {
+            const v = this.client.getValues?.() || {};
+            if (v[key] === expected)
+                return true;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return false;
+    }
     /** Rev506: true while a virtual tack is running (not terminal). */
     isVirtualTackActive() {
         const vt = this._virtualTack;

package/dist/autowind.js

@@ -0,0 +1,71 @@
+"use strict";
+// Rev518 (Carlos 2026-10-19): pseudo-mode AUTOWIND. Apparent wind
+// (pypilot "wind") when |TWA| < threshold, true wind ("true wind") when
+// above: downwind the apparent angle swings with boat speed and the
+// pilot chases it (2026-10-19 18:48: +-40 deg in apparent at TWA ~140,
+// steady in true wind). Each side has its own pypilot profile, so the
+// true-wind side can be the more reactive one.
+//
+// Pure decision logic: fed once per second, no I/O.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutowindDecider = exports.AUTOWIND_MIN_GAP_MS = exports.AUTOWIND_SUSTAIN_MS = exports.AUTOWIND_HYSTERESIS_DEG = exports.AUTOWIND_DEFAULT_THRESHOLD_DEG = void 0;
+exports.desiredSubMode = desiredSubMode;
+exports.AUTOWIND_DEFAULT_THRESHOLD_DEG = 120;
+exports.AUTOWIND_HYSTERESIS_DEG = 5; // +-5 around the threshold
+exports.AUTOWIND_SUSTAIN_MS = 10000; // condition held this long
+exports.AUTOWIND_MIN_GAP_MS = 30000; // between two switches
+/** Side of the threshold the wind is on, with hysteresis; null in the band. */
+function desiredSubMode(twaDeg, thresholdDeg = exports.AUTOWIND_DEFAULT_THRESHOLD_DEG) {
+    const a = Math.abs(twaDeg);
+    if (a >= thresholdDeg + exports.AUTOWIND_HYSTERESIS_DEG)
+        return "true wind";
+    if (a <= thresholdDeg - exports.AUTOWIND_HYSTERESIS_DEG)
+        return "wind";
+    return null;
+}
+class AutowindDecider {
+    constructor() {
+        this.pending = null;
+        this.pendingSince = null;
+        this.lastSwitchMs = null;
+    }
+    /** Returns the mode to switch to now, or null. */
+    tick(i) {
+        const cur = String(i.mode || "").toLowerCase();
+        const curSub = cur === "true wind" ? "true wind" : cur === "wind" ? "wind" : null;
+        if (!i.engaged || i.blocked || typeof i.twaDeg !== "number" || !isFinite(i.twaDeg)) {
+            this.pending = null;
+            this.pendingSince = null;
+            return null;
+        }
+        const want = desiredSubMode(i.twaDeg, i.thresholdDeg);
+        if (want == null || want === curSub) {
+            this.pending = null;
+            this.pendingSince = null;
+            return null;
+        }
+        if (this.pending !== want) {
+            this.pending = want;
+            this.pendingSince = i.nowMs;
+            return null;
+        }
+        if (this.pendingSince != null && i.nowMs - this.pendingSince < exports.AUTOWIND_SUSTAIN_MS)
+            return null;
+        if (this.lastSwitchMs != null && i.nowMs - this.lastSwitchMs < exports.AUTOWIND_MIN_GAP_MS)
+            return null;
+        this.pending = null;
+        this.pendingSince = null;
+        this.lastSwitchMs = i.nowMs;
+        return want;
+    }
+    /** Called when Autowind is switched on: no sustain, no gap. */
+    initial(twaDeg, thresholdDeg) {
+        this.pending = null;
+        this.pendingSince = null;
+        if (typeof twaDeg !== "number" || !isFinite(twaDeg))
+            return "wind";
+        return Math.abs(twaDeg) >= (thresholdDeg ?? exports.AUTOWIND_DEFAULT_THRESHOLD_DEG) ? "true wind" : "wind";
+    }
+    noteSwitch(nowMs) { this.lastSwitchMs = nowMs; }
+}
+exports.AutowindDecider = AutowindDecider;