signalk-electrical-engine-on 2.0.0

package/.editorconfig

@@ -0,0 +1,5 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2

package/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "airbnb-base",
+  "rules": {
+    "linebreak-style": "warn"
+  }
+}

package/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish Node.js Package
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.0.2
+      - uses: actions/setup-node@v3.1.1
+        with:
+          node-version: 20
+      - run: npm install
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.0.2
+      - uses: actions/setup-node@v3.1.1
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.github/workflows/signalk-ci.yml

@@ -0,0 +1,11 @@
+name: SignalK Plugin CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    uses: SignalK/signalk-server/.github/workflows/plugin-ci.yml@master

package/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Node CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Run test suite
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20.x]
+    steps:
+    - uses: actions/checkout@v3.0.2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3.1.1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm test
+      env:
+        CI: true

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## [2.0.0] - 2026-09-23
+
+Fork of [signalk-alternator-engine-on](https://github.com/meri-imperiumi/signalk-alternator-engine-on). Package renamed to `signalk-electrical-engine-on`.
+
+### Changed
+- Detect engine running from a configurable observe path, threshold, and polarity instead of hardcoded alternator power > 5 W
+- OFF-biased defaults for house-bank current (`electrical.batteries.277.current`, polarity `negative`, threshold 8 A)
+- Publish `stopped` on start until a qualifying engine-ON sample is held
+- Optional hysteresis and hold-off to reduce chatter
+
+### Added
+- Admin UI settings: observe path, threshold, polarity (`positive` / `negative` / `absolute`), output path
+
+## [1.2.1] - 2026-06-16
+### Changed
+- App icon for SK app store
+
+## [1.2.0] - 2025-02-16
+### Added
+- Added support for uppercase charging modes reported by some DC-DC chargers
+
+## [1.1.1] - 2024-05-31
+### Fixed
+- Prevent false state changes when receiving a `null` value
+
+## [1.1.0] - 2024-04-08
+### Added
+- Added support for utilizing `chargingMode` as populated by the Victron Orion XS DC-DC charger
+
+## [1.0.0] - 2022-02-04
+### Added
+- Initial release

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022 meri-imperiumi
+Copyright (c) 2026 David Place
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# signalk-electrical-engine-on
+
+Fork of [meri-imperiumi/signalk-alternator-engine-on](https://github.com/meri-imperiumi/signalk-alternator-engine-on) (MIT). This package is renamed so it can be installed next to `@meri-imperiumi/signalk-alternator-engine-on` without colliding.
+
+Publishes `started` | `stopped` on a Signal K propulsion path from a **configurable** electrical observe path, threshold, and polarity. Downstream tools (for example Trip Report) can prefer `propulsion.*.state` instead of inferring engine-on from raw electrical data.
+
+## Warning
+
+House-bank sensing can **false-positive** on solar, shore power, DC-DC charging, or other large loads that are not the engine. Validate on the vessel before relying on this for trip reports or engine hours. An alternator SmartShunt (the upstream plugin’s model) is more specific when you have one.
+
+## Defaults (OFF-biased)
+
+Until engine-ON samples are locked in, defaults are deliberately conservative so an idle house bank does not look like a running engine.
+
+Tequila Mockingbird’s observed OFF baseline on `electrical.batteries.277` is about **−1.4 A** (~−18 W). Defaults:
+
+| Setting | Default | Why |
+| --- | --- | --- |
+| Observe path | `electrical.batteries.277.current` | House battery current (A), not alternator power |
+| Polarity | `negative` | Charging/in from the engine is negative current on this shunt |
+| Threshold | `8` (amperes) | Started only when value **< −8 A**. −1.4 A is clearly `stopped` |
+| Output path | `propulsion.main.state` | Values: `started` \| `stopped` |
+| Hysteresis | `1` | Must recross 7 A equivalent before leaving `started` |
+| Hold-off | `1500` ms | Ignores brief spikes |
+
+The plugin publishes `stopped` as soon as it starts, then updates from the observe path.
+
+### Tequila Mockingbird example config
+
+ON-sample defaults are **not locked yet** (replace `threshold` after measuring engine-ON current):
+
+```json
+{
+  "observe_path": "electrical.batteries.277.current",
+  "polarity": "negative",
+  "threshold": 8,
+  "output_path": "propulsion.main.state",
+  "hysteresis": 1,
+  "holdoff_ms": 1500
+}
+```
+
+## Settings (Admin UI)
+
+Plugin Config settings apply on save (plugin stop/start). You do not need to reinstall.
+
+- **Observe path** — Signal K path for current or power
+- **Threshold** — number, same units as the observe path
+- **Polarity**
+  - `positive`: value > threshold ⇒ `started` (alternator power in watts)
+  - `negative`: value < −threshold ⇒ `started` (house-bank current into the battery)
+  - `absolute`: \|value\| > threshold ⇒ `started`
+- **Output path** — default `propulsion.main.state`
+- **Hysteresis** / **Hold-off** — optional chatter control
+- **Use charging mode** — optional Victron Orion XS `chargingMode` override (unchanged from upstream)
+
+## Install (Signal K on a Raspberry Pi)
+
+Install from git into the Signal K server prefix (`~/.signalk` on a typical Pi image). Prefer this over copying files by hand:
+
+```bash
+npm install --prefix ~/.signalk git+https://github.com/dgplace/signalk-electrical-engine-on.git
+sudo systemctl restart signalk.service
+```
+
+Equivalent, from the Signal K data directory:
+
+```bash
+cd ~/.signalk
+npm install git+https://github.com/dgplace/signalk-electrical-engine-on.git
+sudo systemctl restart signalk.service
+```
+
+In Admin UI: **Appstore** → install from that git URL if your server build supports git installs, then **Server → Plugin Config → Electrical Engine Status Detector**. Enable the plugin and set observe path / threshold / polarity.
+
+npm package name: `signalk-electrical-engine-on` (plugin id `signalk-electrical-engine-on`). Display name: Electrical Engine Status Detector.
+
+## License
+
+MIT. Copyright (c) 2022 meri-imperiumi; copyright (c) 2026 David Place. See [LICENSE](LICENSE).
+
+## Changes
+
+See [Changelog](CHANGELOG.md).

package/index.js

@@ -0,0 +1,293 @@
+const DEFAULTS = {
+  // OFF-biased for Tequila Mockingbird house bank (electrical.batteries.277):
+  // idle current is about -1.4 A. Threshold 8 A keeps that clearly stopped
+  // until engine-ON samples are used to tighten the setting.
+  observe_path: 'electrical.batteries.277.current',
+  threshold: 8,
+  polarity: 'negative',
+  output_path: 'propulsion.main.state',
+  hysteresis: 1,
+  holdoff_ms: 1500,
+  use_chargingmode: false,
+  chargingmodePath: 'electrical.chargers.alternator.chargingMode',
+};
+
+const POLARITIES = ['positive', 'negative', 'absolute'];
+
+function finiteNumber(value, fallback) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return fallback;
+}
+
+function resolveOptions(options = {}) {
+  const polarity = POLARITIES.includes(options.polarity)
+    ? options.polarity
+    : DEFAULTS.polarity;
+  const threshold = Math.abs(finiteNumber(options.threshold, DEFAULTS.threshold));
+  let hysteresis = finiteNumber(options.hysteresis, DEFAULTS.hysteresis);
+  if (hysteresis < 0) {
+    hysteresis = 0;
+  }
+  hysteresis = Math.min(hysteresis, threshold);
+
+  return {
+    observe_path: options.observe_path || DEFAULTS.observe_path,
+    threshold,
+    polarity,
+    output_path: options.output_path || options.engine_path || DEFAULTS.output_path,
+    hysteresis,
+    holdoff_ms: Math.max(0, finiteNumber(options.holdoff_ms, DEFAULTS.holdoff_ms)),
+    use_chargingmode: Boolean(options.use_chargingmode),
+    chargingmodePath: options.chargingmodePath || DEFAULTS.chargingmodePath,
+  };
+}
+
+function toFiniteNumber(value) {
+  return finiteNumber(value, null);
+}
+
+// Returns whether the engine should be considered started given the latest
+// sample. Invalid values leave the previous state unchanged (OFF if none).
+function isEngineStarted(value, options, currentlyStarted) {
+  const sample = toFiniteNumber(value);
+  if (sample === null) {
+    return currentlyStarted === true;
+  }
+
+  const { threshold, polarity, hysteresis } = options;
+  const stopThreshold = threshold - hysteresis;
+  const started = currentlyStarted === true;
+
+  if (polarity === 'negative') {
+    if (started) {
+      return sample < -stopThreshold;
+    }
+    return sample < -threshold;
+  }
+
+  if (polarity === 'absolute') {
+    const magnitude = Math.abs(sample);
+    if (started) {
+      return magnitude > stopThreshold;
+    }
+    return magnitude > threshold;
+  }
+
+  if (started) {
+    return sample > stopThreshold;
+  }
+  return sample > threshold;
+}
+
+function chargingModeStarted(value) {
+  if (value == null) {
+    return null;
+  }
+  if (value === 'off' || value === 'OFF') {
+    return false;
+  }
+  return true;
+}
+
+module.exports = (app) => {
+  const plugin = {};
+  let unsubscribes = [];
+  let holdoffTimer = null;
+
+  plugin.id = 'signalk-electrical-engine-on';
+  plugin.name = 'Electrical engine status detector';
+  plugin.description = 'Publishes propulsion started/stopped from electrical current or power';
+  const setStatus = app.setPluginStatus || app.setProviderStatus;
+
+  plugin.start = (options) => {
+    const opts = resolveOptions(options);
+    const subscribePaths = [
+      {
+        path: opts.observe_path,
+        period: 100,
+      },
+    ];
+    if (opts.use_chargingmode) {
+      subscribePaths.push({
+        path: opts.chargingmodePath,
+        period: 100,
+      });
+    }
+
+    const subscription = {
+      context: 'vessels.self',
+      subscribe: subscribePaths,
+    };
+
+    let publishedState = 'stopped';
+    let pendingState = null;
+
+    function clearHoldoff() {
+      if (holdoffTimer) {
+        clearTimeout(holdoffTimer);
+        holdoffTimer = null;
+      }
+      pendingState = null;
+    }
+
+    function setState(state) {
+      publishedState = state;
+      app.handleMessage(plugin.id, {
+        context: `vessels.${app.selfId}`,
+        updates: [
+          {
+            source: {
+              label: plugin.id,
+            },
+            timestamp: (new Date().toISOString()),
+            values: [
+              {
+                path: opts.output_path,
+                value: state,
+              },
+            ],
+          },
+        ],
+      });
+      if (setStatus) {
+        setStatus(`Detected engine state: ${state}`);
+      }
+    }
+
+    function consider(state) {
+      if (state === publishedState) {
+        clearHoldoff();
+        return;
+      }
+      if (state === pendingState) {
+        return;
+      }
+      clearHoldoff();
+      pendingState = state;
+      if (opts.holdoff_ms <= 0) {
+        pendingState = null;
+        setState(state);
+        return;
+      }
+      holdoffTimer = setTimeout(() => {
+        holdoffTimer = null;
+        pendingState = null;
+        setState(state);
+      }, opts.holdoff_ms);
+    }
+
+    app.subscriptionmanager.subscribe(
+      subscription,
+      unsubscribes,
+      (subscriptionError) => {
+        app.error(`Error:${subscriptionError}`);
+      },
+      (delta) => {
+        if (!delta.updates) {
+          return;
+        }
+        delta.updates.forEach((u) => {
+          if (!u.values) {
+            return;
+          }
+          u.values.forEach((v) => {
+            if (opts.use_chargingmode && v.path === opts.chargingmodePath) {
+              const started = chargingModeStarted(v.value);
+              if (started == null) {
+                return;
+              }
+              consider(started ? 'started' : 'stopped');
+              return;
+            }
+            if (!opts.use_chargingmode && v.path === opts.observe_path) {
+              const currentlyStarted = publishedState === 'started';
+              const started = isEngineStarted(v.value, opts, currentlyStarted);
+              consider(started ? 'started' : 'stopped');
+            }
+          });
+        });
+      },
+    );
+
+    // OFF-biased until a qualifying engine-ON sample is held long enough.
+    setState('stopped');
+  };
+
+  plugin.stop = () => {
+    if (holdoffTimer) {
+      clearTimeout(holdoffTimer);
+      holdoffTimer = null;
+    }
+    unsubscribes.forEach((f) => f());
+    unsubscribes = [];
+  };
+
+  plugin.schema = {
+    type: 'object',
+    properties: {
+      observe_path: {
+        type: 'string',
+        default: DEFAULTS.observe_path,
+        title: 'Observe path',
+        description: 'Signal K path for current or power used to detect engine-on',
+      },
+      threshold: {
+        type: 'number',
+        default: DEFAULTS.threshold,
+        title: 'Threshold',
+        description: 'Crossed according to polarity to publish started',
+      },
+      polarity: {
+        type: 'string',
+        enum: POLARITIES,
+        default: DEFAULTS.polarity,
+        title: 'Polarity',
+        description: 'positive: value > threshold => started; '
+          + 'negative: value < -threshold => started; '
+          + 'absolute: |value| > threshold => started',
+      },
+      output_path: {
+        type: 'string',
+        default: DEFAULTS.output_path,
+        title: 'Output path',
+        description: 'Signal K path to publish. Values are started or stopped.',
+      },
+      hysteresis: {
+        type: 'number',
+        default: DEFAULTS.hysteresis,
+        title: 'Hysteresis',
+        description: 'Band (same units as threshold) recrossed before leaving started',
+      },
+      holdoff_ms: {
+        type: 'number',
+        default: DEFAULTS.holdoff_ms,
+        title: 'Hold-off (ms)',
+        description: 'Milliseconds a new state must persist before it is published',
+      },
+      use_chargingmode: {
+        type: 'boolean',
+        default: DEFAULTS.use_chargingmode,
+        title: 'Use charging mode instead of observe path (Orion XS)',
+      },
+      chargingmodePath: {
+        type: 'string',
+        default: DEFAULTS.chargingmodePath,
+        title: 'Charging mode path (when charging mode is enabled)',
+      },
+    },
+  };
+
+  return plugin;
+};
+
+module.exports.DEFAULTS = DEFAULTS;
+module.exports.resolveOptions = resolveOptions;
+module.exports.isEngineStarted = isEngineStarted;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "signalk-electrical-engine-on",
+  "version": "2.0.0",
+  "description": "Signal K plugin that publishes propulsion started/stopped from a configurable electrical current or power path",
+  "main": "index.js",
+  "scripts": {
+    "pretest": "eslint .",
+    "test": "node --test test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dgplace/signalk-electrical-engine-on.git"
+  },
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-category-utility"
+  ],
+  "author": "Henri Bergius <henri.bergius@iki.fi>",
+  "contributors": [
+    "David Place"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dgplace/signalk-electrical-engine-on/issues"
+  },
+  "homepage": "https://github.com/dgplace/signalk-electrical-engine-on#readme",
+  "dependencies": {
+  },
+  "devDependencies": {
+    "eslint": "^8.14.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.18.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "signalk": {
+    "appIcon": "./doc/appicon.png",
+    "displayName": "Electrical Engine Status Detector",
+    "recommends": [
+      "@meri-imperiumi/signalk-autostate"
+    ]
+  }
+}

package/test/plugin.test.js

@@ -0,0 +1,246 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const pluginFactory = require('../index');
+
+const { DEFAULTS, isEngineStarted, resolveOptions } = pluginFactory;
+
+function publishedState(message) {
+  return message.delta.updates[0].values[0].value;
+}
+
+function publishedPath(message) {
+  return message.delta.updates[0].values[0].path;
+}
+
+function createApp() {
+  let onDelta = () => {};
+  let lastSubscription;
+  const messages = [];
+  const app = {
+    selfId: 'urn:mrn:signalk:uuid:test',
+    debug: () => {},
+    error: () => {},
+    setPluginStatus: () => {},
+    handleMessage: (id, delta) => {
+      messages.push({ id, delta });
+    },
+    subscriptionmanager: {
+      subscribe: (subscription, unsubscribes, _onError, cb) => {
+        lastSubscription = subscription;
+        onDelta = cb;
+        unsubscribes.push(() => {
+          onDelta = () => {};
+        });
+      },
+    },
+  };
+  return {
+    app,
+    messages,
+    getSubscription: () => lastSubscription,
+    send(path, value) {
+      onDelta({
+        updates: [{ values: [{ path, value }] }],
+      });
+    },
+    sendEmpty() {
+      onDelta({});
+    },
+  };
+}
+
+describe('plugin interface', () => {
+  const harness = createApp();
+  const plugin = pluginFactory(harness.app);
+
+  it('has required interface and renamed id', () => {
+    assert.equal(typeof plugin.start, 'function');
+    assert.equal(typeof plugin.stop, 'function');
+    assert.equal(plugin.id, 'signalk-electrical-engine-on');
+    assert.equal(plugin.name, 'Electrical engine status detector');
+  });
+
+  it('exposes schema for observe path, threshold, polarity, and output path', () => {
+    const { properties } = plugin.schema;
+    assert.equal(properties.observe_path.default, 'electrical.batteries.277.current');
+    assert.equal(properties.threshold.default, 8);
+    assert.deepEqual(properties.polarity.enum, ['positive', 'negative', 'absolute']);
+    assert.equal(properties.polarity.default, 'negative');
+    assert.equal(properties.output_path.default, 'propulsion.main.state');
+  });
+
+  it('starts and stops without error', () => {
+    plugin.start({}, () => {});
+    plugin.stop();
+  });
+});
+
+describe('isEngineStarted polarity', () => {
+  it('positive: value > threshold ⇒ started', () => {
+    const opts = resolveOptions({
+      polarity: 'positive',
+      threshold: 5,
+      hysteresis: 0,
+    });
+    assert.equal(isEngineStarted(5.1, opts, false), true);
+    assert.equal(isEngineStarted(5, opts, false), false);
+    assert.equal(isEngineStarted(4, opts, false), false);
+  });
+
+  it('negative: value < −threshold ⇒ started', () => {
+    const opts = resolveOptions({
+      polarity: 'negative',
+      threshold: 8,
+      hysteresis: 0,
+    });
+    assert.equal(isEngineStarted(-8.1, opts, false), true);
+    assert.equal(isEngineStarted(-8, opts, false), false);
+    assert.equal(isEngineStarted(8.1, opts, false), false);
+  });
+
+  it('absolute: |value| > threshold ⇒ started', () => {
+    const opts = resolveOptions({
+      polarity: 'absolute',
+      threshold: 5,
+      hysteresis: 0,
+    });
+    assert.equal(isEngineStarted(5.1, opts, false), true);
+    assert.equal(isEngineStarted(-5.1, opts, false), true);
+    assert.equal(isEngineStarted(1, opts, false), false);
+    assert.equal(isEngineStarted(-1, opts, false), false);
+  });
+
+  it('OFF baseline −1.4 A is stopped with default negative / 8 A threshold', () => {
+    const opts = resolveOptions({});
+    assert.equal(opts.observe_path, 'electrical.batteries.277.current');
+    assert.equal(opts.polarity, 'negative');
+    assert.equal(opts.threshold, 8);
+    assert.equal(isEngineStarted(-1.4, opts, false), false);
+    assert.equal(isEngineStarted(-1.4, opts, true), false);
+    assert.equal(isEngineStarted(-18 / 12.8, opts, false), false);
+  });
+
+  it('does not start on invalid samples', () => {
+    const opts = resolveOptions({});
+    assert.equal(isEngineStarted(null, opts, false), false);
+    assert.equal(isEngineStarted(undefined, opts, false), false);
+    assert.equal(isEngineStarted('not-a-number', opts, false), false);
+  });
+
+  it('hysteresis keeps started until the stop band is recrossed', () => {
+    const opts = resolveOptions({
+      polarity: 'negative',
+      threshold: 8,
+      hysteresis: 1,
+    });
+    assert.equal(isEngineStarted(-8.5, opts, false), true);
+    assert.equal(isEngineStarted(-7.5, opts, true), true);
+    assert.equal(isEngineStarted(-6.9, opts, true), false);
+  });
+});
+
+describe('subscribe → publish', () => {
+  it('publishes stopped on start (OFF-biased) to the output path', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({ holdoff_ms: 0 });
+    assert.equal(harness.messages.length, 1);
+    assert.equal(harness.messages[0].id, 'signalk-electrical-engine-on');
+    assert.equal(publishedState(harness.messages[0]), 'stopped');
+    assert.equal(publishedPath(harness.messages[0]), 'propulsion.main.state');
+    const sub = harness.getSubscription();
+    assert.equal(sub.context, 'vessels.self');
+    assert.equal(sub.subscribe[0].path, DEFAULTS.observe_path);
+    plugin.stop();
+  });
+
+  it('does not start the engine on TM OFF baseline current', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({ holdoff_ms: 0 });
+    harness.send('electrical.batteries.277.current', -1.4);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'stopped');
+    plugin.stop();
+  });
+
+  it('publishes started for negative polarity below −threshold', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({ holdoff_ms: 0 });
+    harness.send('electrical.batteries.277.current', -20);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'started');
+    plugin.stop();
+  });
+
+  it('publishes started for positive polarity above threshold', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({
+      observe_path: 'electrical.chargers.alternator.power',
+      polarity: 'positive',
+      threshold: 5,
+      hysteresis: 0,
+      holdoff_ms: 0,
+    });
+    harness.send('electrical.chargers.alternator.power', 6);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'started');
+    harness.send('electrical.chargers.alternator.power', 4);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'stopped');
+    plugin.stop();
+  });
+
+  it('publishes started for absolute polarity on either sign', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({
+      polarity: 'absolute',
+      threshold: 5,
+      hysteresis: 0,
+      holdoff_ms: 0,
+      output_path: 'propulsion.port.state',
+    });
+    assert.equal(publishedPath(harness.messages[0]), 'propulsion.port.state');
+    harness.send('electrical.batteries.277.current', -6);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'started');
+    harness.send('electrical.batteries.277.current', 6);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'started');
+    harness.send('electrical.batteries.277.current', 1);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'stopped');
+    plugin.stop();
+  });
+
+  it('ignores other paths and empty deltas', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({ holdoff_ms: 0 });
+    harness.sendEmpty();
+    harness.send('navigation.speedThroughWater', 3);
+    assert.equal(harness.messages.length, 1);
+    assert.equal(publishedState(harness.messages[0]), 'stopped');
+    plugin.stop();
+  });
+
+  it('hold-off delays started until the sample persists', () => {
+    const harness = createApp();
+    const plugin = pluginFactory(harness.app);
+    plugin.start({ holdoff_ms: 50, hysteresis: 0 });
+    harness.send('electrical.batteries.277.current', -20);
+    assert.equal(publishedState(harness.messages[harness.messages.length - 1]), 'stopped');
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        try {
+          assert.equal(
+            publishedState(harness.messages[harness.messages.length - 1]),
+            'started',
+          );
+          plugin.stop();
+          resolve();
+        } catch (err) {
+          plugin.stop();
+          reject(err);
+        }
+      }, 80);
+    });
+  });
+});