diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75402326..975c3a44 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@
 ### Features
 * Web/Data: Reticulum gets its own visual identity - trifoil marker on violet `#7b61ff`, MeshCore's tile moves to `#1f2937`, a four-step role color ramp, hexagon shape, and a legend group under MeshCore (SPEC RD1-RD8)
 * Data: Reticulum node roles are derived from the announce aspect, so a multi-aspect peer no longer flips roles (SPEC RD4/RE10)
+* Data/Web: the Reticulum host appears on the map at the position set by the `latitude`, `longitude` and `height` keys of its RNS config's first RNodeInterface block (SPEC RP1-RP10); keys already in that block are published after upgrading; remove them and restart the ingestor to stop (README Reticulum)
 * Web: the federation table renders a Reticulum zero count as a dash instead of a tile (SPEC RD8)
 * Web: the map legend stacks Reticulum under MeshCore, two columns instead of three (SPEC LS1)
 * Web: mesh.dmz.pt joins the default federation seed nodes and potatomesh.jmrp.io leaves them
diff --git a/README.md b/README.md
index a319f49c..fb988b6a 100644
--- a/README.md
+++ b/README.md
@@ -365,7 +365,8 @@ when not already set.
 
 Reticulum support is experimental and announce-only. Set `PROTOCOL=reticulum`
 to file each announce on a Reticulum (RNS) network as a node. Messages,
-positions and telemetry are not ingested.
+telemetry and other nodes' positions are not ingested. The ingestor publishes
+only its own host's position, from your RNS config (below).
 
 The ingestor sends no announces, messages or polls, so `TX_ENABLED=0` (the
 default) is fine. `TX_ENABLED` does not gate the RNS stack, which transmits
@@ -438,13 +439,36 @@ Meshtastic mesh; otherwise it shows `SF8/BW125/CR5`. Values are read once at
 startup - change them in the RNS config and restart the ingestor, or the
 dashboard keeps showing the old ones.
 
+The ingestor publishes the `latitude`, `longitude` and `height` (metres) keys
+of the first `RNodeInterface` in your RNS config as this host's position, at
+startup and every hour, and the host appears on the map. If that block already
+sets them, for example for RNS interface discovery, they are published after
+the upgrade. Add them to that block and restart the ingestor:
+
+```
+    latitude = 52.5029
+    longitude = 13.4042
+    height = 34
+```
+
+Remove the keys and restart the ingestor to stop the updates. The dashboard
+keeps the last published position until you clear it; replace `27716218`
+with the node id from the startup line, without its `!`:
+
+```bash
+sqlite3 ~/.local/share/potato-mesh/mesh.db "UPDATE nodes SET latitude = NULL, longitude = NULL, altitude = NULL, position_time = NULL, location_source = NULL WHERE node_id = char(33) || '27716218'; DELETE FROM positions WHERE node_id = char(33) || '27716218';"
+```
+
+In Docker, prefix it with `docker compose exec web` and use the database at
+`/app/.local/share/potato-mesh/mesh.db`.
+
 A node is one row per identity - a peer running both LXMF and a nomadnet node
 is still one entry. Its destinations (addresses) are listed via
 `GET /api/destinations` and shown as sub-rows grouped under the identity in
 the dashboard table.
 
-Reticulum nodes show dashes for battery and position, stay off the map, and
-have no messages.
+Reticulum nodes show dashes for battery and have no messages. Other than this
+host, they also show dashes for position and stay off the map.
 
 ### Passive UDP transport
 
diff --git a/data/mesh_ingestor/CONTRACTS.md b/data/mesh_ingestor/CONTRACTS.md
index 3df195ea..8050e0fc 100644
--- a/data/mesh_ingestor/CONTRACTS.md
+++ b/data/mesh_ingestor/CONTRACTS.md
@@ -420,8 +420,8 @@ from the operator's own stack.
 
 - Source: the first `RNodeInterface` block of the shared RNS config
   (`frequency`, `bandwidth`, `spreadingfactor`, `codingrate`). Only those four
-  keys are read - the same file holds `rpc_key`, which is
-  never read or logged.
+  keys, and the host position keys below, are read - the same file holds
+  `rpc_key`, which is never read or logged.
 - RNS stores both frequencies in Hz; they are emitted as MHz and kHz.
 - `RETICULUM_FREQ` / `RETICULUM_PRESET` override the parsed values.
 - The preset is a Meshtastic preset name when the BW/SF/CR triple matches
@@ -467,6 +467,50 @@ connection that never recycles.
   7 days after its timestamp unless traffic flows through it), leaves the 0-hop
   table and is no longer refreshed.
 
+### Reticulum host position (SPEC RP1-RP6)
+
+Announces carry no position, so the provider publishes one for its own host
+only, from the operator's own RNS config.
+
+- Source: `latitude`, `longitude` and, if present, `height` (metres) in the
+  first `RNodeInterface` block of the shared RNS config, found by the same
+  block reader as the radio metadata above. Read whether or not `discoverable`
+  is set. `location_cmd` is never run, and no other key leaves the parser.
+- Read once per connect, as RNS's own config parser reads it: a key counts
+  only under its exact name once one pair of quotes is stripped from it
+  (`Latitude` is not read), and one matching pair of single or double quotes
+  is stripped from each value. The radio metadata keeps its own rule:
+  case-insensitive keys, values as written. No coordinates means no position. An
+  invalid coordinate means no position and one warning: one coordinate without
+  the other, a latitude or longitude that is not a finite number, a latitude
+  beyond 90 or a longitude beyond 180 degrees, or `0, 0`. A `height` that is
+  not a finite number drops only the altitude, with one warning that names the
+  key but not the value.
+- Published as written: no rounding and no `precisionBits`.
+- Node records: every record keyed on the registered host id, in the connect
+  snapshot and in every self-node report, carries `position` =
+  `{latitude, longitude, altitude?, time, locationSource: "LOC_MANUAL"}`, with
+  `time` the report time. No other node's record carries one.
+- Bare host record: when no record carries the registered host id, because
+  nothing on the stack announces (Docker's default volume), one record
+  `{nodeId, lastHeard, protocol, user: {shortName, longName, role: "PEER"}}`
+  named with the node's own placeholder carries the position. It has no
+  `destination`, and there is none without a position.
+- Positions rows: each self-node report, the first at connect and then hourly,
+  posts one `POST /api/positions` row for the host: `id` (the first 7 bytes of
+  SHA-256 over `reticulum:<node_id>:<time>`, masked to 53 bits), `rx_time` and
+  `position_time` (the report time), `rx_iso`, `node_id`, `from_id` and
+  `ingestor` (the host id), `node_num`, `latitude`, `longitude`, `altitude`
+  when set, `location_source: "LOC_MANUAL"`, `protocol: "reticulum"`, and the
+  configured `lora_freq` / `modem_preset`. They count in the `telemetry`
+  umbrella of `GET /api/stats`.
+- The row is queued before the report's node records. If it reaches a web app
+  that has no row for the host yet, the unknown-node placeholder it creates is
+  completed by the record that follows.
+- Removal: with the keys deleted, the next connect publishes nothing. A stored
+  node position stays, because the node upsert keeps one when a record omits
+  it, until it is cleared in the database; no API deletes a position.
+
 ### GET /api/nodes placeholder flag (SPEC MR4)
 
 `GET /api/nodes` and `GET /api/nodes/:id` emit `synthetic: true` on a name-derived MeshCore placeholder row - a channel sender not yet matched to a keyed contact - and omit the key on every other row (no `synthetic: false`). Placeholders come only from ingested chat senders (see the `POST /api/nodes` placeholder note), never from mentions, and the reconciliation merge folds them into the real node once its contact is stored and the name is unambiguous (SPEC MR2).
diff --git a/data/mesh_ingestor/protocols/reticulum.py b/data/mesh_ingestor/protocols/reticulum.py
index dfbd0e80..c8e72f15 100644
--- a/data/mesh_ingestor/protocols/reticulum.py
+++ b/data/mesh_ingestor/protocols/reticulum.py
@@ -22,7 +22,8 @@ admitted announce is converted into a ``POST /api/nodes`` upsert with
 ``protocol="reticulum"``.  The host's own destinations are also read from the
 stack's 0-hop path table, and its ``rns.transport`` destination, when the stack
 has transport enabled, from the transport identity (SPEC RE8/RE9).  No LXMF
-message, position or telemetry is ingested.
+message, position or telemetry is ingested; the host's own position comes from
+the RNS config (:mod:`.reticulum_position`, SPEC RP1).
 
 Like :class:`~data.mesh_ingestor.protocols.meshtastic_udp.MeshtasticUdpProvider`
 this provider is receive-only: the provider itself never transmits and has no
@@ -105,7 +106,6 @@ the node id when that hash is unusable (SPEC RA10).  It names the
 from __future__ import annotations
 
 import math
-import os
 import threading
 import time
 
@@ -113,7 +113,7 @@ import RNS
 from RNS.vendor import umsgpack
 
 from .. import config, handlers
-from . import reticulum_interfaces
+from . import reticulum_interfaces, reticulum_position
 
 _ASPECT_ROLES: dict[str, str] = {
     "lxmf.propagation": "PROPAGATION",
@@ -763,6 +763,8 @@ class _ReticulumInterface:
     def __init__(self, *, target: str | None) -> None:
         """Initialise an unconnected interface bound to *target*."""
         self._target = target
+        # Read from the RNS config at connect (SPEC RP1); None publishes none.
+        self.host_position: reticulum_position.HostPosition | None = None
         self._rns: object | None = None
         self._announce_handlers: list[_ReticulumAnnounceHandler] = []
         self._nodes_lock = threading.Lock()
@@ -873,11 +875,11 @@ def _reticulum_preset_label(
 def _parse_rnode_radio_config(text: str) -> dict | None:
     """Extract radio parameters from the first ``RNodeInterface`` in *text*.
 
-    Parses the RNS config's indented ``[[name]]`` interface blocks looking for
-    ``type = RNodeInterface`` and its ``frequency`` / ``bandwidth`` /
-    ``spreadingfactor`` / ``codingrate`` keys.  **Only those four keys are
-    read** — the file also holds the shared-instance RPC key, which must never
-    be logged or carried anywhere (SPEC RL1).
+    The block is found by :func:`.reticulum_position.rnode_block_entries`, the
+    reader the host position uses too (SPEC RP1), asked for the ``frequency`` /
+    ``bandwidth`` / ``spreadingfactor`` / ``codingrate`` keys.  **Only those
+    four keys are read** — the file also holds the shared-instance RPC key,
+    which must never be logged or carried anywhere (SPEC RL1).
 
     RNS stores both frequencies in **Hz** (its own annotated example reads
     ``frequency = 867200000`` for 867.2 MHz and ``bandwidth = 125000`` for
@@ -890,33 +892,17 @@ def _parse_rnode_radio_config(text: str) -> dict | None:
         ``{"frequency_mhz", "bandwidth_khz", "sf", "cr"}`` for the first
         RNodeInterface found, or ``None`` when there is none.
     """
-    current: dict = {}
-    best: dict | None = None
-    for raw in text.splitlines():
-        line = raw.split("#", 1)[0].strip()
-        if not line:
-            continue
-        if line.startswith("["):
-            # A new section ends the one being collected.
-            if current.get("_is_rnode") and best is None:
-                best = current
-            current = {}
-            continue
-        if "=" not in line:
-            continue
-        key, _, value = line.partition("=")
-        key, value = key.strip().lower(), value.strip()
-        if key == "type":
-            current["_is_rnode"] = value == "RNodeInterface"
-        elif key in ("frequency", "bandwidth", "spreadingfactor", "codingrate"):
-            try:
-                current[key] = int(value)
-            except ValueError:
-                continue
-    if current.get("_is_rnode") and best is None:
-        best = current
-    if not best:
+    entries = reticulum_position.rnode_block_entries(
+        text, frozenset({"frequency", "bandwidth", "spreadingfactor", "codingrate"})
+    )
+    if entries is None:
         return None
+    best: dict = {}
+    for key, value in entries:
+        try:
+            best[key] = int(value)
+        except ValueError:
+            continue
     frequency = best.get("frequency")
     bandwidth = best.get("bandwidth")
     return {
@@ -984,17 +970,10 @@ def _read_reticulum_radio_metadata() -> tuple[object, str | None]:
     preset: str | None = config.RETICULUM_PRESET
     if frequency is not None and preset is not None:
         return frequency, preset
-    parsed = None
-    config_dir = config.RETICULUM_CONFIG_DIR
-    if isinstance(config_dir, str) and config_dir.strip():
-        try:
-            path = os.path.join(os.path.expanduser(config_dir), "config")
-            with open(path, "r", encoding="utf-8", errors="replace") as handle:
-                parsed = _parse_rnode_radio_config(handle.read())
-        except OSError:
-            # Absent or unreadable config: every downstream field keeps its
-            # dash rather than inventing a number.
-            parsed = None
+    # Absent or unreadable config: every downstream field keeps its dash
+    # rather than inventing a number.
+    text = reticulum_position.rns_config_text(config.RETICULUM_CONFIG_DIR)
+    parsed = None if text is None else _parse_rnode_radio_config(text)
     if parsed:
         if frequency is None:
             frequency = parsed["frequency_mhz"]
@@ -1283,6 +1262,26 @@ def _host_destination_nodes(identity_hash: str) -> list[dict]:
     return records
 
 
+def _bare_host_record(node_id: str, report_time: int) -> dict:
+    """Return the host's record when no destination carries its position.
+
+    Nothing announces on Docker's default volume (SPEC RP6), so the record has
+    no ``destination``, the node's own placeholder name (RA10(a)) and the
+    Reticulum base role (RA9); without a role the node API would serve
+    Meshtastic's ``CLIENT``.
+
+    Parameters:
+        node_id: The registered host node id.
+        report_time: Unix seconds of the report.
+
+    Returns:
+        Node dict for ``POST /api/nodes``.
+    """
+    short, name = _reticulum_short_name(node_id), _reticulum_placeholder_name(node_id)
+    record = {"nodeId": node_id, "lastHeard": report_time, "protocol": "reticulum"}
+    return {**record, "user": {"shortName": short, "longName": name, "role": "PEER"}}
+
+
 def _transport_enabled() -> bool:
     """Report whether the running stack relays other nodes' traffic.
 
@@ -1405,6 +1404,9 @@ class ReticulumProvider:
             config.LORA_FREQ = radio_freq
         if radio_preset is not None and getattr(config, "MODEM_PRESET", None) is None:
             config.MODEM_PRESET = radio_preset
+        # The host position (SPEC RP1/RP2): read once per connect, from the
+        # same RNodeInterface block as the radio metadata.
+        iface.host_position = reticulum_position.read_host_position(configdir)
         # Resolve the host id for the log rather than reading
         # +iface.host_node_id+, which is a constant None: the startup line
         # printed node_id=None on every run regardless of what discovery would
@@ -1559,7 +1561,8 @@ class ReticulumProvider:
             if node["destination"]["id"] in seen_destinations:
                 continue
             items.append((node["nodeId"], node))
-        return items
+        # The host's position (SPEC RP4/RP6); the report at connect posts its row.
+        return reticulum_position.with_host_position(items, iface, _bare_host_record)
 
     def self_node_items(self, iface: object) -> list[tuple[str, dict]]:
         """Return the host's own destinations for the periodic self-node report.
@@ -1578,21 +1581,25 @@ class ReticulumProvider:
         move ``rns.transport`` onto its own node row, because the web tier's
         destination upsert takes the incoming node id.
 
+        Each report also positions the host and posts its row (SPEC RP4-RP6).
+
         Parameters:
-            iface: Unused; the records are read from the running stack.
+            iface: The active :class:`_ReticulumInterface`, for the position
+                read at connect; the records are read from the running stack.
 
         Returns:
             ``(node_id, node_dict)`` pairs, or an empty list while no host id
-            is registered or the primary identity does not map to it.
+            is registered or, with no position, none maps to it.
         """
         host_id = handlers.host_node_id()
         if not host_id:
             return []
-        return [
+        items = [
             (node["nodeId"], node)
             for node in self.host_destination_nodes()
             if node["nodeId"] == host_id
         ]
+        return reticulum_position.report_host_position(items, iface, _bare_host_record)
 
 
 __all__ = [
diff --git a/data/mesh_ingestor/protocols/reticulum_position.py b/data/mesh_ingestor/protocols/reticulum_position.py
new file mode 100644
index 00000000..7190de7e
--- /dev/null
+++ b/data/mesh_ingestor/protocols/reticulum_position.py
@@ -0,0 +1,467 @@
+# Copyright © 2025-26 l5yth & contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""The Reticulum host's own position, read from the RNS config (SPEC RP1-RP6).
+
+A Reticulum announce carries no position, so no RNS peer can be placed on the
+map.  The ingestor's own host is the one node it can answer for: RNS 1.5
+defines per-interface ``latitude``, ``longitude`` and ``height`` keys, and this
+module publishes the ones in the first ``RNodeInterface`` block of the shared
+RNS config as the host's position.
+
+**The RNS config, read-only.**  :func:`rns_config_text` and
+:func:`rnode_block_entries` are also the source of the radio metadata (SPEC
+RL1): both features read the same block by the same line rules.  A caller names
+the keys it wants and receives only those, so nothing else in the file -- the
+shared instance's ``rpc_key``, an interface ``passphrase`` -- ever leaves the
+parser.  RNS itself reads the position keys only when the interface sets
+``discoverable = yes``; they are read here whether or not it does, and
+``location_cmd`` is never run.
+
+**Read once per connect.**  :func:`read_host_position` runs at connect.  Keys
+and values are read as RNS's own config parser reads them: a key counts only
+under its exact name, after one pair of quotes is stripped from it, and one
+matching pair of quotes is stripped from each value.  RL1 keeps its own,
+case-insensitive key rule.  Missing coordinates mean no position and log one
+debug line; an invalid latitude or longitude logs one warning and also means no
+position; an invalid ``height`` logs one warning and drops only the altitude.
+A line is logged only when the outcome changes, so a connection that recycles
+hourly on a quiet mesh does not repeat it.
+
+**Published as written.**  No rounding and no ``precisionBits``: the operator
+typed the value into their own config.  The host's records carry it as the node
+record's ``position`` (:func:`with_host_position`), and every self-node report,
+the first of which runs at connect, also posts one ``POST /api/positions`` row
+(:func:`report_host_position`), the way a MeshCore host does.  Peer records are
+never touched.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import time
+from collections.abc import Callable
+from typing import NamedTuple
+
+from .. import config, handlers
+from .. import queue as _queue
+from ..handlers.radio import _apply_radio_metadata
+from ..node_identity import node_num_from_id
+from ..serialization import _coerce_float, _iso, _normalize_lat_lon
+
+POSITION_KEYS: frozenset[str] = frozenset({"latitude", "longitude", "height"})
+"""The ``RNodeInterface`` keys the host position reads.
+
+``location_cmd`` is deliberately absent: it names a command to run, and the
+ingestor never runs one.
+"""
+
+LOCATION_SOURCE = "LOC_MANUAL"
+"""``locationSource`` of a position typed into a config file by hand."""
+
+_ROW_ID_MASK = (1 << 53) - 1
+"""Positions-row ids fit 53 bits, so they round-trip through the frontend."""
+
+_last_outcome: str | None = None
+"""Outcome of the last read that was logged, so a repeat stays quiet."""
+
+
+class HostPosition(NamedTuple):
+    """The host's position as written in the RNS config."""
+
+    latitude: float
+    """Latitude in decimal degrees."""
+
+    longitude: float
+    """Longitude in decimal degrees."""
+
+    altitude: float | None
+    """Height in metres, or ``None`` when the config sets none."""
+
+
+def rns_config_text(config_dir: object) -> str | None:
+    """Return the contents of the RNS config file in *config_dir*.
+
+    Parameters:
+        config_dir: The RNS config directory, normally
+            :data:`~data.mesh_ingestor.config.RETICULUM_CONFIG_DIR`.
+
+    Returns:
+        The text of ``<config_dir>/config``, or ``None`` when the directory is
+        unset or the file cannot be read.
+    """
+    if not isinstance(config_dir, str) or not config_dir.strip():
+        return None
+    path = os.path.join(os.path.expanduser(config_dir), "config")
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+            return handle.read()
+    except OSError:
+        return None
+
+
+def rnode_block_entries(
+    text: str, keys: frozenset[str]
+) -> list[tuple[str, str]] | None:
+    """Return the *keys* lines of the first ``RNodeInterface`` block in *text*.
+
+    Walks the RNS config's indented ``[[name]]`` interface blocks: any line
+    starting with ``[`` closes the block being collected, ``#`` starts a
+    comment, a line without ``=`` is skipped, and keys compare lower-cased.  A
+    block is an RNode block when its ``type`` is ``RNodeInterface``.
+
+    Parameters:
+        text: Contents of the RNS config file.
+        keys: Lower-case keys to return; every other line is dropped here.
+
+    Returns:
+        ``(key, value)`` pairs in file order, values stripped, or ``None`` when
+        the config holds no ``RNodeInterface`` block.
+    """
+    entries: list[tuple[str, str]] = []
+    is_rnode = False
+    for raw in text.splitlines():
+        line = raw.split("#", 1)[0].strip()
+        if not line:
+            continue
+        if line.startswith("["):
+            # A new section ends the one being collected.
+            if is_rnode:
+                return entries
+            entries, is_rnode = [], False
+            continue
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip().lower(), value.strip()
+        if key == "type":
+            is_rnode = value == "RNodeInterface"
+        elif key in keys:
+            entries.append((key, value))
+    return entries if is_rnode else None
+
+
+def _unquote(value: str) -> str:
+    """Strip one matching pair of single or double quotes, as RNS does.
+
+    RNS's own config parser reads ``latitude = "52.5"`` as ``52.5``, and the
+    host position must read what RNS reads.  Only the position unquotes:
+    :func:`rnode_block_entries` and the radio metadata (SPEC RL1) keep every
+    value as written.
+
+    Parameters:
+        value: A stripped value from :func:`rnode_block_entries`.
+
+    Returns:
+        *value* without one surrounding pair of matching quotes, if it has one.
+    """
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+        return value[1:-1]
+    return value
+
+
+def parse_host_position(
+    entries: list[tuple[str, str]] | None,
+) -> tuple[HostPosition | None, str | None]:
+    """Validate the position keys of the first ``RNodeInterface`` block.
+
+    Each value loses one matching pair of quotes first (:func:`_unquote`).
+
+    Parameters:
+        entries: Output of :func:`rnode_block_entries` for
+            :data:`POSITION_KEYS`; the last occurrence of a key wins.
+
+    Returns:
+        ``(position, None)`` for a valid position, ``(None, None)`` when the
+        block sets neither coordinate, and ``(None, problem)`` when a
+        coordinate is invalid: one coordinate alone, a value that is not a
+        finite number, a latitude beyond 90 or a longitude beyond 180 degrees,
+        or ``0, 0``.  A ``height`` that is not a finite number drops only the
+        altitude: ``(position, problem)``, the position without altitude.
+    """
+    values = {key: _unquote(value) for key, value in entries or ()}
+    lat_text, lon_text = values.get("latitude"), values.get("longitude")
+    if lat_text is None and lon_text is None:
+        return None, None
+    if lat_text is None or lon_text is None:
+        return None, "only one of latitude and longitude is set"
+    latitude, longitude = _coerce_float(lat_text), _coerce_float(lon_text)
+    if latitude is None or longitude is None:
+        return None, "latitude and longitude must be numbers"
+    if abs(latitude) > 90:
+        return None, "latitude is outside -90..90"
+    if abs(longitude) > 180:
+        return None, "longitude is outside -180..180"
+    if _normalize_lat_lon(latitude, longitude) == (None, None):
+        # The shared sentinel rule (CONTRACTS, issue #782): 0, 0 is no fix.
+        return None, "0, 0 is not a position"
+    if "height" not in values:
+        return HostPosition(latitude, longitude, None), None
+    altitude = _coerce_float(values["height"])
+    if altitude is None:
+        # The coordinates are what the map needs; only the altitude goes.
+        return HostPosition(latitude, longitude, None), "height must be a number"
+    return HostPosition(latitude, longitude, altitude), None
+
+
+def _log_outcome(position: HostPosition | None, problem: str | None) -> None:
+    """Log the outcome of a read, once per change of outcome.
+
+    The coordinates themselves are never logged.
+
+    Parameters:
+        position: The position read, or ``None``.
+        problem: Why the keys were rejected, or ``None``.
+    """
+    global _last_outcome
+    if position is not None and problem is not None:
+        outcome = "valid without altitude: " + problem
+    elif position is not None:
+        outcome = "valid"
+    elif problem is not None:
+        outcome = "invalid: " + problem
+    else:
+        outcome = "missing"
+    if outcome == _last_outcome:
+        return
+    _last_outcome = outcome
+    if position is not None and problem is not None:
+        # Names the key only: neither the bad value nor the coordinates.
+        config._debug_log(
+            "Publishing the host position from the RNS config without altitude: "
+            f"{problem}; fix or remove height in its first RNodeInterface block",
+            context="reticulum.position",
+            severity="warn",
+        )
+    elif position is not None:
+        config._debug_log(
+            "Publishing the host position from the RNS config",
+            context="reticulum.position",
+            severity="info",
+            altitude=position.altitude is not None,
+        )
+    elif problem is not None:
+        config._debug_log(
+            "Ignoring the host position in the RNS config: "
+            f"{problem}; fix or remove latitude, longitude and height in its "
+            "first RNodeInterface block",
+            context="reticulum.position",
+            severity="warn",
+        )
+    else:
+        config._debug_log(
+            "No host position in the first RNodeInterface block of the RNS config",
+            context="reticulum.position",
+        )
+
+
+def _rns_spelled_keys(text: str) -> str:
+    """Spell the position keys in *text* the way RNS's config parser matches them.
+
+    RNS's ``ConfigObj`` matches a key exactly once one pair of quotes is
+    stripped from it: it reads ``latitude`` and ``"latitude"``, and ignores
+    ``Latitude``.  The shared reader lower-cases keys and keeps their quotes,
+    which is RL1's rule and stays unchanged, so the position path rewrites a
+    quoted position key to its bare name and drops every other spelling of one
+    before the shared reader sees the text.
+
+    Parameters:
+        text: Contents of the RNS config file.
+
+    Returns:
+        *text* with each position key as RNS reads it, and no other spelling.
+    """
+    lines = []
+    for raw in text.splitlines():
+        content = raw.split("#", 1)[0]
+        if "=" in content and not content.strip().startswith("["):
+            key, _, rest = raw.partition("=")
+            name = _unquote(key.strip())
+            if name in POSITION_KEYS:
+                raw = f"{name} ={rest}"
+            elif name.lower() in POSITION_KEYS:
+                continue
+        lines.append(raw)
+    return "\n".join(lines)
+
+
+def read_host_position(config_dir: object) -> HostPosition | None:
+    """Read the host position from the RNS config (SPEC RP1/RP2).
+
+    Keys count only under the name RNS reads (:func:`_rns_spelled_keys`).
+
+    Parameters:
+        config_dir: The RNS config directory, as passed to RNS.
+
+    Returns:
+        The position, or ``None`` when the config sets none or an invalid one.
+    """
+    text = rns_config_text(config_dir)
+    entries = (
+        None
+        if text is None
+        else rnode_block_entries(_rns_spelled_keys(text), POSITION_KEYS)
+    )
+    position, problem = parse_host_position(entries)
+    _log_outcome(position, problem)
+    return position
+
+
+def node_position(position: HostPosition, report_time: int) -> dict:
+    """Return the node record's ``position`` mapping (SPEC RP3/RP4).
+
+    Parameters:
+        position: The host position.
+        report_time: Unix seconds of the report; becomes ``time``.
+
+    Returns:
+        ``{latitude, longitude, altitude?, time, locationSource}``.
+    """
+    mapping: dict = {
+        "latitude": position.latitude,
+        "longitude": position.longitude,
+        "time": report_time,
+        "locationSource": LOCATION_SOURCE,
+    }
+    if position.altitude is not None:
+        mapping["altitude"] = position.altitude
+    return mapping
+
+
+def position_row(node_id: str, position: HostPosition, report_time: int) -> dict:
+    """Build the host's ``POST /api/positions`` payload (SPEC RP5).
+
+    The id is a stable 53-bit hash of the node and the report time, so a row
+    posted twice within one second is stored once.
+
+    Parameters:
+        node_id: The registered host node id.
+        position: The host position.
+        report_time: Unix seconds of the report.
+
+    Returns:
+        Positions payload, enriched with the configured radio metadata.
+    """
+    digest = hashlib.sha256(f"reticulum:{node_id}:{report_time}".encode()).digest()
+    row = {
+        "id": int.from_bytes(digest[:7], "big") & _ROW_ID_MASK,
+        "rx_time": report_time,
+        "rx_iso": _iso(report_time),
+        "node_id": node_id,
+        "node_num": node_num_from_id(node_id),
+        "from_id": node_id,
+        "latitude": position.latitude,
+        "longitude": position.longitude,
+        "position_time": report_time,
+        "location_source": LOCATION_SOURCE,
+        "ingestor": node_id,
+        "protocol": "reticulum",
+    }
+    if position.altitude is not None:
+        row["altitude"] = position.altitude
+    return _apply_radio_metadata(row)
+
+
+def _host_and_position(iface: object) -> tuple[str | None, HostPosition | None]:
+    """Return the registered host id and the position read at connect.
+
+    Parameters:
+        iface: The active Reticulum interface, which holds ``host_position``.
+
+    Returns:
+        ``(host_id, position)``, either of which may be ``None``.
+    """
+    return handlers.host_node_id(), getattr(iface, "host_position", None)
+
+
+def with_host_position(
+    items: list[tuple[str, dict]],
+    iface: object,
+    bare_record: Callable[[str, int], dict],
+    *,
+    report_time: int | None = None,
+) -> list[tuple[str, dict]]:
+    """Put the host position on every record of the host (SPEC RP4/RP6).
+
+    Only a record keyed on the registered host id gains ``position``; peer
+    records pass through untouched.  When no record carries the host id --
+    Docker's default volume announces nothing, so the host has no destination
+    -- one bare host record is appended to carry the position.
+
+    Parameters:
+        items: ``(node_id, node)`` pairs about to be upserted.
+        iface: The active Reticulum interface, which holds the position read
+            at connect; ``None`` or no position leaves *items* as they are.
+        bare_record: Builds the host's record when no item carries it, from the
+            host id and the report time.
+        report_time: Unix seconds of the report; defaults to now.
+
+    Returns:
+        A new list when the host is positioned; *items* and its node dicts are
+        never modified.
+    """
+    host_id, position = _host_and_position(iface)
+    if position is None or not host_id:
+        return items
+    now = int(time.time()) if report_time is None else int(report_time)
+    if not any(node_id == host_id for node_id, _node in items):
+        items = [*items, (host_id, bare_record(host_id, now))]
+    mapping = node_position(position, now)
+    return [
+        (node_id, {**node, "position": mapping} if node_id == host_id else node)
+        for node_id, node in items
+    ]
+
+
+def report_host_position(
+    items: list[tuple[str, dict]],
+    iface: object,
+    bare_record: Callable[[str, int], dict],
+) -> list[tuple[str, dict]]:
+    """Position the host's records for a report and post its row (SPEC RP5).
+
+    The row is queued before the daemon upserts the returned records.  Should
+    it reach the web app first on the host's very first report, the web app
+    creates the node row from it, and the record that follows completes it.
+
+    Parameters:
+        items: The report's ``(node_id, node)`` pairs.
+        iface: As for :func:`with_host_position`.
+        bare_record: As for :func:`with_host_position`.
+
+    Returns:
+        The records, positioned as :func:`with_host_position` does.
+    """
+    host_id, position = _host_and_position(iface)
+    if position is None or not host_id:
+        return items
+    now = int(time.time())
+    positioned = with_host_position(items, iface, bare_record, report_time=now)
+    _queue._queue_post_json("/api/positions", position_row(host_id, position, now))
+    return positioned
+
+
+__all__ = [
+    "HostPosition",
+    "LOCATION_SOURCE",
+    "POSITION_KEYS",
+    "node_position",
+    "parse_host_position",
+    "position_row",
+    "read_host_position",
+    "report_host_position",
+    "rnode_block_entries",
+    "rns_config_text",
+    "with_host_position",
+]
diff --git a/tests/test_reticulum_docs.py b/tests/test_reticulum_docs.py
index abd51c8b..61061be1 100644
--- a/tests/test_reticulum_docs.py
+++ b/tests/test_reticulum_docs.py
@@ -70,10 +70,48 @@ def test_feature_bullets_mark_reticulum_experimental():
 
 
 def test_section_states_experimental_and_announce_only():
-    """The Reticulum section opens with its scope and what it does not ingest."""
+    """The Reticulum section opens with its scope and what it does not ingest.
+
+    The host's own position is the one exception (SPEC RP8), so the sentence
+    names other nodes' positions rather than positions in general.
+    """
     section = _section("Reticulum")
     assert "experimental and announce-only" in section
-    assert re.search(r"Messages,\s+positions and telemetry are not ingested", section)
+    assert re.search(
+        r"Messages,\s+telemetry and other nodes'\s+positions are not ingested", section
+    )
+
+
+def test_section_states_the_host_position_and_how_to_stop_it():
+    """The section says the RNS keys are published and how to stop it (RP8).
+
+    Peers still stay off the map, so the closing line keeps saying so for them
+    and no longer claims it for every Reticulum node.
+    """
+    section = _section("Reticulum")
+    assert re.search(
+        r"publishes the `latitude`, `longitude` and `height` \(metres\) keys\s+"
+        r"of the first `RNodeInterface` in your RNS config",
+        section,
+    )
+    assert re.search(
+        r"Remove the keys and restart the ingestor to stop the updates", section
+    )
+    assert re.search(
+        r"If that block already\s+sets them, for example for RNS interface discovery,"
+        r"\s+they are published after\s+the upgrade",
+        section,
+    )
+    assert "DELETE FROM positions" in section
+    # A `!` inside double quotes is history expansion in bash and zsh, so the
+    # pasted command spells the id's `!` as char(33) and carries none.
+    command = next(line for line in section.splitlines() if line.startswith("sqlite3 "))
+    assert "WHERE node_id = char(33) || '27716218'" in command
+    assert "!" not in command
+    assert re.search(r"Other than this\s+host, they also show dashes", section)
+    assert not re.search(
+        r"Reticulum nodes show dashes for battery and position", section
+    )
 
 
 def test_docs_name_what_the_rns_stack_transmits():
diff --git a/tests/test_reticulum_host_position.py b/tests/test_reticulum_host_position.py
new file mode 100644
index 00000000..f04767ca
--- /dev/null
+++ b/tests/test_reticulum_host_position.py
@@ -0,0 +1,429 @@
+# Copyright © 2025-26 l5yth & contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""The Reticulum provider publishes its host's position (SPEC RP1-RP6).
+
+Drives :class:`ReticulumProvider` at connect, through the node snapshot and the
+self-node report, and end to end through the daemon loop on the fake stack of
+``tests/test_reticulum_host_refresh.py``: the host's records carry the position
+from the RNS config, peers never do, every report posts one positions row, and
+a host with nothing announcing rides on one bare record.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:  # pragma: no cover - conftest adds it
+    sys.path.insert(0, str(REPO_ROOT))
+
+import data.mesh_ingestor.protocols.reticulum as _mod  # noqa: E402
+import data.mesh_ingestor.protocols.reticulum_position as rp  # noqa: E402
+from daemon_fakes import make_state  # noqa: E402 - shared daemon doubles
+from data.mesh_ingestor import config, handlers, queue  # noqa: E402
+from data.mesh_ingestor.handlers import _state as handler_state  # noqa: E402
+from data.mesh_ingestor.protocols.reticulum import (  # noqa: E402
+    ReticulumProvider,
+    _ReticulumInterface,
+)
+from test_reticulum_host_refresh import (  # noqa: E402,F401 - shared fixture
+    _HOST,
+    _WALL_OFFSET,
+    _busy_pass,
+    world,
+)
+from test_reticulum_position_unit import (  # noqa: E402 - shared config text
+    _CONFIG,
+    _PASSPHRASE,
+    _SECRET,
+)
+from test_reticulum_unit import (  # noqa: E402 - shared Reticulum doubles
+    _FIELD_LXMF,
+    _FIELD_NOMADNET,
+    _FIELD_PRIMARY,
+    _fake_rns,
+    _local_stack,
+)
+
+_PEER = "!aabbccdd"
+"""Node id of the remote peer ``_busy_pass`` lands an announce from."""
+
+_POSITION = rp.HostPosition(52.5029, 13.4042, 34.0)
+"""The position :data:`_CONFIG` sets."""
+
+_WITHOUT_POSITION = "\n".join(
+    line
+    for line in _CONFIG.splitlines()
+    if not line.strip().startswith(("latitude", "longitude", "height"))
+)
+""":data:`_CONFIG` with the position keys deleted."""
+
+
+@pytest.fixture(autouse=True)
+def quiet(monkeypatch):
+    """Silence the logs and start each test with no logged position outcome."""
+    monkeypatch.setattr(rp, "_last_outcome", None)
+    monkeypatch.setattr(config, "_debug_log", lambda *_a, **_k: None)
+
+
+@pytest.fixture
+def registered(monkeypatch):
+    """Register :data:`_HOST` as the host, restoring the handler state after."""
+    for name in (
+        "_host_node_id",
+        "_host_telemetry_last_rx",
+        "_host_nodeinfo_last_seen",
+    ):
+        monkeypatch.setattr(handler_state, name, None)
+    handlers.register_host_node_id(_HOST)
+
+
+def _positioned_iface() -> _ReticulumInterface:
+    """Return an interface holding the position read at connect.
+
+    Returns:
+        A fresh :class:`_ReticulumInterface` with :data:`_POSITION`.
+    """
+    iface = _ReticulumInterface(target=None)
+    iface.host_position = _POSITION
+    return iface
+
+
+# ---------------------------------------------------------------------------
+# connect: read once, onto the connection (SPEC RP1/RP2)
+# ---------------------------------------------------------------------------
+
+
+def test_connect_reads_the_host_position_from_the_rns_config(monkeypatch, tmp_path):
+    """The position in the first RNode block lands on the new interface."""
+    fake, _state = _fake_rns(existing_instance=object())
+    monkeypatch.setattr(_mod, "RNS", fake)
+    monkeypatch.setattr(config, "RETICULUM_CONFIG_DIR", str(tmp_path))
+    for name in (
+        "RETICULUM_FREQ",
+        "RETICULUM_PRESET",
+        "LORA_FREQ",
+        "MODEM_PRESET",
+        "INGESTOR_NODE_ID",
+        "CONNECTION",
+    ):
+        monkeypatch.setattr(config, name, None)
+
+    iface, _target, _next = ReticulumProvider().connect(active_candidate=None)
+    assert iface.host_position is None  # no config file: no position
+
+    (tmp_path / "config").write_text(_CONFIG, encoding="utf-8")
+    iface, _target, _next = ReticulumProvider().connect(active_candidate=None)
+    assert iface.host_position == _POSITION
+    assert config.LORA_FREQ == 867  # the radio metadata reads the same block
+
+
+def test_quotes_and_a_bad_height_still_publish_the_coordinates(
+    monkeypatch, tmp_path, registered
+):
+    """Quoted keys read as RNS reads them; a bad height drops the altitude only."""
+    fake, _state = _fake_rns(existing_instance=object())
+    monkeypatch.setattr(_mod, "RNS", fake)
+    monkeypatch.setattr(config, "RETICULUM_CONFIG_DIR", str(tmp_path))
+    monkeypatch.setattr(config, "INGESTOR_NODE_ID", _HOST)
+    monkeypatch.setattr(config, "CONNECTION", None)
+    posts: list[tuple[str, dict]] = []
+    monkeypatch.setattr(
+        queue,
+        "_queue_post_json",
+        lambda path, payload, **_k: posts.append((path, payload)),
+    )
+    quoted = (
+        _CONFIG.replace("latitude = 52.5029", 'latitude = "52.5029"')
+        .replace("longitude = 13.4042", "longitude = '13.4042'")
+        .replace("height = 34", "height = sky-high")
+    )
+    (tmp_path / "config").write_text(quoted, encoding="utf-8")
+    provider = ReticulumProvider()
+    iface, _target, _next = provider.connect(active_candidate=None)
+    assert iface.host_position == rp.HostPosition(52.5029, 13.4042, None)
+    position = provider.self_node_items(iface)[0][1]["position"]
+    assert (position["latitude"], position["longitude"]) == (52.5029, 13.4042)
+    assert "altitude" not in position
+    assert "altitude" not in posts[0][1]
+
+
+def test_removing_the_keys_stops_the_refresh(monkeypatch, tmp_path, registered):
+    """Delete the keys and reconnect: the reports post no position (SPEC RP8)."""
+    fake, _state = _fake_rns(existing_instance=object())
+    monkeypatch.setattr(_mod, "RNS", fake)
+    monkeypatch.setattr(config, "RETICULUM_CONFIG_DIR", str(tmp_path))
+    monkeypatch.setattr(config, "INGESTOR_NODE_ID", _HOST)
+    monkeypatch.setattr(config, "CONNECTION", None)
+    posts: list[tuple[str, dict]] = []
+    monkeypatch.setattr(
+        queue,
+        "_queue_post_json",
+        lambda path, payload, **_k: posts.append((path, payload)),
+    )
+    (tmp_path / "config").write_text(_CONFIG, encoding="utf-8")
+    provider = ReticulumProvider()
+    iface, _target, _next = provider.connect(active_candidate=None)
+    assert provider.self_node_items(iface)[0][1]["position"]["latitude"] == 52.5029
+    assert [path for path, _payload in posts] == ["/api/positions"]
+
+    (tmp_path / "config").write_text(_WITHOUT_POSITION, encoding="utf-8")
+    iface, _target, _next = provider.connect(active_candidate=None)
+    assert iface.host_position is None
+    assert provider.self_node_items(iface) == []
+    assert len(posts) == 1  # no second row
+
+
+# ---------------------------------------------------------------------------
+# The node snapshot (SPEC RP4/RP6)
+# ---------------------------------------------------------------------------
+
+
+def test_snapshot_positions_the_host_records_and_never_a_peer(monkeypatch, registered):
+    """Every record keyed on the host carries the position; a peer's never does.
+
+    The host's ``lxmf.delivery`` was also heard live at 0 hops, so one host
+    record comes from the stored announces and one from discovery.
+    """
+    _local_stack(
+        monkeypatch, {_FIELD_LXMF: _FIELD_PRIMARY, _FIELD_NOMADNET: _FIELD_PRIMARY}
+    )
+    monkeypatch.setattr(_mod.time, "time", lambda: 1_791_000_000.0)
+    iface = _positioned_iface()
+    peer = {"nodeId": _PEER, "user": {"longName": "Remote Peer"}}
+    heard = {"nodeId": _HOST, "lastHeard": 1, "destination": {"id": _FIELD_LXMF}}
+    iface._update_node(_PEER, peer)
+    iface._update_node(_HOST, heard)
+
+    items = ReticulumProvider().node_snapshot_items(iface)
+
+    by_id: dict[str, list[dict]] = {}
+    for node_id, node in items:
+        by_id.setdefault(node_id, []).append(node)
+    assert len(by_id[_HOST]) == 2  # the heard lxmf.delivery, the found nomadnet
+    for node in by_id[_HOST]:
+        assert node["position"] == rp.node_position(_POSITION, 1_791_000_000)
+    assert by_id[_PEER] == [peer]
+    assert "position" not in heard  # the stored announce is not mutated
+
+
+def test_snapshot_is_unchanged_without_a_position(monkeypatch, registered):
+    """No keys in the RNS config: the records are exactly what they were."""
+    _local_stack(monkeypatch, {_FIELD_LXMF: _FIELD_PRIMARY})
+    items = ReticulumProvider().node_snapshot_items(_ReticulumInterface(target=None))
+    assert len(items) == 1
+    assert "position" not in items[0][1]
+
+
+def test_a_host_with_nothing_announcing_gets_one_bare_record(monkeypatch, registered):
+    """Docker's default volume: a pinned host id and no destination (SPEC RP6)."""
+    _local_stack(monkeypatch, {})
+    monkeypatch.setattr(_mod.time, "time", lambda: 1_791_000_000.0)
+    items = ReticulumProvider().node_snapshot_items(_positioned_iface())
+    assert items == [
+        (
+            _HOST,
+            {
+                "nodeId": _HOST,
+                "lastHeard": 1_791_000_000,
+                "protocol": "reticulum",
+                # The node's own placeholder (RA10(a)): the head of its id.
+                "user": {
+                    "shortName": "2771",
+                    "longName": "Reticulum 2771",
+                    "role": "PEER",
+                },
+                "position": rp.node_position(_POSITION, 1_791_000_000),
+            },
+        )
+    ]
+    # Without a position the snapshot stays empty, as before.
+    assert (
+        ReticulumProvider().node_snapshot_items(_ReticulumInterface(target=None)) == []
+    )
+
+
+def test_the_snapshot_posts_no_row(monkeypatch, registered):
+    """The row is the report's job, so connect posts one row, not two."""
+    _local_stack(monkeypatch, {_FIELD_LXMF: _FIELD_PRIMARY})
+    posts: list[str] = []
+    monkeypatch.setattr(
+        queue, "_queue_post_json", lambda path, *_a, **_k: posts.append(path)
+    )
+    ReticulumProvider().node_snapshot_items(_positioned_iface())
+    assert posts == []
+
+
+# ---------------------------------------------------------------------------
+# The self-node report (SPEC RP4-RP6)
+# ---------------------------------------------------------------------------
+
+
+def test_the_report_positions_the_host_and_posts_its_row(monkeypatch, registered):
+    """Each report: positioned host records and one positions row."""
+    _local_stack(monkeypatch, {_FIELD_LXMF: _FIELD_PRIMARY})
+    posts: list[tuple[str, dict]] = []
+    monkeypatch.setattr(
+        queue,
+        "_queue_post_json",
+        lambda path, payload, **_k: posts.append((path, payload)),
+    )
+    items = ReticulumProvider().self_node_items(_positioned_iface())
+    assert [node["destination"]["aspect"] for _nid, node in items] == ["lxmf.delivery"]
+    assert items[0][1]["position"]["altitude"] == 34.0
+    assert [(path, payload["node_id"]) for path, payload in posts] == [
+        ("/api/positions", _HOST)
+    ]
+
+
+def test_the_report_still_needs_a_registered_host_id(monkeypatch):
+    """No host id yet: nothing to report, positioned or not."""
+    monkeypatch.setattr(handler_state, "_host_node_id", None)
+    assert ReticulumProvider().self_node_items(_positioned_iface()) == []
+
+
+# ---------------------------------------------------------------------------
+# End to end through the daemon loop (SPEC RP4-RP6, ACCEPTANCE RP-A3)
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def mesh(world, monkeypatch, tmp_path):
+    """The RE-A14 world with the host position in its RNS config.
+
+    Returns:
+        The ``world`` namespace plus ``posts``: every ``(path, payload)``
+        queued, in order.
+    """
+    (tmp_path / "config").write_text(_CONFIG, encoding="utf-8")
+    posts: list[tuple[str, dict]] = []
+    monkeypatch.setattr(
+        queue,
+        "_queue_post_json",
+        lambda path, payload, **_k: posts.append((path, payload)),
+    )
+    world.posts = posts
+    return world
+
+
+def _records(posts, node_id: str) -> list[dict]:
+    """Return every posted node record of *node_id*, in order.
+
+    Parameters:
+        posts: Captured ``(path, payload)`` pairs.
+        node_id: Node whose records to collect.
+
+    Returns:
+        The node dicts.
+    """
+    return [p[node_id] for path, p in posts if path == "/api/nodes" and node_id in p]
+
+
+def _rows(posts) -> list[dict]:
+    """Return every posted positions row, in order.
+
+    Parameters:
+        posts: Captured ``(path, payload)`` pairs.
+
+    Returns:
+        The positions payloads.
+    """
+    return [payload for path, payload in posts if path == "/api/positions"]
+
+
+def test_the_host_is_positioned_at_connect_and_every_hour(mesh):
+    """One row at connect and one per report; the peer is never positioned.
+
+    Against the tree before this feature it fails with ``assert [] == [...]``:
+    no positions row is posted and no host record carries a position.
+    """
+    state = make_state(provider=ReticulumProvider(), inactivity_reconnect_secs=3600.0)
+    connected_at = _WALL_OFFSET + int(mesh.clock["mono"])
+    _busy_pass(state, mesh)  # connect: snapshot, then the first report
+    assert [row["position_time"] for row in _rows(mesh.posts)] == [connected_at]
+    for _ in range(61):  # one report interval, plus one loop
+        _busy_pass(state, mesh)
+
+    rows = _rows(mesh.posts)
+    assert [row["position_time"] for row in rows] == [connected_at, connected_at + 3600]
+    assert {(row["node_id"], row["protocol"], row["latitude"]) for row in rows} == {
+        (_HOST, "reticulum", 52.5029)
+    }
+    host = _records(mesh.posts, _HOST)
+    assert len(host) == 6  # two aspects: snapshot, connect report, hourly report
+    assert all(node["position"]["longitude"] == 13.4042 for node in host)
+    peer = _records(mesh.posts, _PEER)
+    assert peer and all("position" not in node for node in peer)
+    assert mesh.sent == []  # local reads only (SPEC RN5, MA7)
+
+
+def test_a_host_with_nothing_announcing_is_positioned_hourly(mesh, monkeypatch):
+    """Docker: the bare record latches the snapshot, so the report runs hourly."""
+    mesh.stack.local.clear()  # nothing announces on the default volume
+    monkeypatch.setattr(config, "INGESTOR_NODE_ID", _HOST)
+    state = make_state(provider=ReticulumProvider(), inactivity_reconnect_secs=3600.0)
+    _busy_pass(state, mesh)
+
+    assert state.initial_snapshot_sent  # before this feature: nothing to latch on
+    host = _records(mesh.posts, _HOST)
+    assert len(host) == 2  # the snapshot and the connect report
+    for node in host:
+        assert node["user"] == {
+            "shortName": "2771",
+            "longName": "Reticulum 2771",
+            "role": "PEER",
+        }
+        assert "destination" not in node
+        assert node["position"]["latitude"] == 52.5029
+    assert len(_rows(mesh.posts)) == 1
+    for _ in range(61):
+        _busy_pass(state, mesh)
+    assert len(_rows(mesh.posts)) == 2
+
+
+def test_no_secret_from_the_rns_config_reaches_a_post(mesh):
+    """``rpc_key`` and an interface ``passphrase`` never leave the parser (RP1)."""
+    state = make_state(provider=ReticulumProvider(), inactivity_reconnect_secs=3600.0)
+    _busy_pass(state, mesh)
+    flat = json.dumps(mesh.posts)
+    assert _rows(mesh.posts)  # the position was published...
+    assert _SECRET not in flat and _PASSPHRASE not in flat  # ...and nothing else
+
+
+def test_without_the_keys_the_loop_posts_no_position(mesh, tmp_path):
+    """A config with no position keys behaves exactly as before (SPEC RP2)."""
+    (tmp_path / "config").write_text(
+        "[interfaces]\n  [[RNode]]\n    type = RNodeInterface\n", encoding="utf-8"
+    )
+    state = make_state(provider=ReticulumProvider(), inactivity_reconnect_secs=3600.0)
+    for _ in range(3):
+        _busy_pass(state, mesh)
+    assert _rows(mesh.posts) == []
+    assert all("position" not in node for node in _records(mesh.posts, _HOST))
+    assert _records(mesh.posts, _HOST)  # the host is still reported (SPEC RE8)
+
+
+def test_the_bare_record_is_wired_into_the_provider():
+    """The provider's own builder, as the integration tests above exercise it."""
+    record = _mod._bare_host_record(_HOST, 7)
+    assert record == {
+        "nodeId": _HOST,
+        "lastHeard": 7,
+        "protocol": "reticulum",
+        "user": {"shortName": "2771", "longName": "Reticulum 2771", "role": "PEER"},
+    }
diff --git a/tests/test_reticulum_position_unit.py b/tests/test_reticulum_position_unit.py
new file mode 100644
index 00000000..499a65a8
--- /dev/null
+++ b/tests/test_reticulum_position_unit.py
@@ -0,0 +1,681 @@
+# Copyright © 2025-26 l5yth & contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Unit tests for :mod:`data.mesh_ingestor.protocols.reticulum_position`.
+
+Covers the RNS config reader shared with the radio metadata (SPEC RL1), the
+position keys' validation and logging (SPEC RP1-RP3), and the record and row
+builders (SPEC RP4-RP6).  The provider and daemon wiring is covered in
+``tests/test_reticulum_host_position.py``.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+import pytest
+from RNS.vendor.configobj import ConfigObj
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:  # pragma: no cover - conftest adds it
+    sys.path.insert(0, str(REPO_ROOT))
+
+import data.mesh_ingestor.protocols.reticulum as reticulum  # noqa: E402
+import data.mesh_ingestor.protocols.reticulum_position as rp  # noqa: E402
+from data.mesh_ingestor import config, handlers, queue  # noqa: E402
+from data.mesh_ingestor.handlers import _state as handler_state  # noqa: E402
+
+_HOST = "!27716218"
+"""The field host's node id (SPEC RE8)."""
+
+_SECRET = "deadbeefdeadbeefdeadbeefdeadbeef"
+"""A shared-instance ``rpc_key`` that must never leave the parser."""
+
+_PASSPHRASE = "correct horse battery staple"
+"""An interface ``passphrase`` (IFAC secret) that must never leave it either."""
+
+_MARKER = "potato-location-cmd-ran"
+"""File a ``location_cmd`` would create if anything ran it."""
+
+_CONFIG = f"""
+[reticulum]
+  enable_transport = No
+  share_instance = Yes
+  rpc_key = {_SECRET}
+
+[interfaces]
+  [[Default Interface]]
+    type = AutoInterface
+    enabled = yes
+    latitude = 1.0
+    longitude = 2.0
+
+  [[RNode LoRa Interface]]
+    type = RNodeInterface
+    enabled = yes
+    port = /dev/ttyUSB0
+    passphrase = {_PASSPHRASE}
+    frequency = 867200000
+    bandwidth = 125000
+    spreadingfactor = 8
+    codingrate = 5
+    latitude = 52.5029   # Berlin
+    longitude = 13.4042
+    height = 34
+    location_cmd = touch {_MARKER}
+    potatomesh_latitude = 1.5
+    reachable_on = 127.0.0.1
+
+  [[Second RNode]]
+    type = RNodeInterface
+    latitude = 48.1
+    longitude = 11.5
+"""
+"""An RNS config with the position keys in the first RNode block and decoys
+elsewhere: an ``AutoInterface`` before it and a second RNode after it."""
+
+
+@pytest.fixture(autouse=True)
+def fresh_log_state(monkeypatch):
+    """Start every test with no logged outcome and a recording ``_debug_log``.
+
+    Returns:
+        The list of ``(message, fields)`` pairs logged.
+    """
+    logged: list[tuple[str, dict]] = []
+    monkeypatch.setattr(rp, "_last_outcome", None)
+    monkeypatch.setattr(
+        config, "_debug_log", lambda msg, **kw: logged.append((msg, kw))
+    )
+    return logged
+
+
+def _block(lines: str) -> str:
+    """Wrap *lines* in one ``RNodeInterface`` block.
+
+    Parameters:
+        lines: Key lines for the block.
+
+    Returns:
+        RNS config text.
+    """
+    return "[interfaces]\n  [[RNode]]\n    type = RNodeInterface\n" + lines
+
+
+def _parse(text: str):
+    """Parse the position keys of *text*'s first RNode block.
+
+    Parameters:
+        text: RNS config text.
+
+    Returns:
+        ``(position, problem)`` from :func:`rp.parse_host_position`.
+    """
+    return rp.parse_host_position(rp.rnode_block_entries(text, rp.POSITION_KEYS))
+
+
+# ---------------------------------------------------------------------------
+# The shared block reader (SPEC RL1/RP1)
+# ---------------------------------------------------------------------------
+
+
+def test_block_reader_returns_only_the_requested_keys_of_the_first_rnode():
+    """The first RNode block, in file order, and nothing a caller did not ask for.
+
+    The ``AutoInterface`` block before it and the second RNode after it are
+    both decoys; the ``passphrase``, ``location_cmd`` and the ``[reticulum]``
+    section's ``rpc_key`` never leave the reader.
+    """
+    entries = rp.rnode_block_entries(_CONFIG, rp.POSITION_KEYS)
+    assert entries == [
+        ("latitude", "52.5029"),
+        ("longitude", "13.4042"),
+        ("height", "34"),
+    ]
+    flat = repr(rp.rnode_block_entries(_CONFIG, frozenset({"latitude"})))
+    assert _SECRET not in flat and _PASSPHRASE not in flat
+
+
+def test_block_reader_is_none_without_an_rnode_block():
+    """No ``RNodeInterface`` anywhere: nothing to read."""
+    only_auto = "[interfaces]\n  [[Default]]\n    type = AutoInterface\n"
+    assert rp.rnode_block_entries(only_auto, rp.POSITION_KEYS) is None
+    assert rp.rnode_block_entries("", rp.POSITION_KEYS) is None
+
+
+def test_block_reader_keeps_an_rnode_block_with_none_of_the_keys():
+    """An RNode block without the keys is an empty block, not a missing one."""
+    assert rp.rnode_block_entries(_block("    port = /dev/x\n"), rp.POSITION_KEYS) == []
+
+
+def test_block_reader_keeps_values_as_written():
+    """Quotes survive the reader: unquoting is the position parser's job alone."""
+    text = _block("    latitude = \"52.5\"\n    longitude = '13.4'\n")
+    assert rp.rnode_block_entries(text, rp.POSITION_KEYS) == [
+        ("latitude", '"52.5"'),
+        ("longitude", "'13.4'"),
+    ]
+
+
+def _legacy_parse_rnode_radio_config(text: str) -> dict | None:
+    """The radio parser exactly as it read before the block reader was shared.
+
+    Kept verbatim as a test oracle: the refactor must not change what SPEC RL1
+    reports for any config.
+
+    Parameters:
+        text: RNS config text.
+
+    Returns:
+        What the pre-refactor ``_parse_rnode_radio_config`` returned.
+    """
+    current: dict = {}
+    best: dict | None = None
+    for raw in text.splitlines():
+        line = raw.split("#", 1)[0].strip()
+        if not line:
+            continue
+        if line.startswith("["):
+            if current.get("_is_rnode") and best is None:
+                best = current
+            current = {}
+            continue
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip().lower(), value.strip()
+        if key == "type":
+            current["_is_rnode"] = value == "RNodeInterface"
+        elif key in ("frequency", "bandwidth", "spreadingfactor", "codingrate"):
+            try:
+                current[key] = int(value)
+            except ValueError:
+                continue
+    if current.get("_is_rnode") and best is None:
+        best = current
+    if not best:
+        return None
+    frequency = best.get("frequency")
+    bandwidth = best.get("bandwidth")
+    return {
+        "frequency_mhz": int(frequency // 1_000_000) if frequency else None,
+        "bandwidth_khz": int(bandwidth / 1000) if bandwidth else None,
+        "sf": best.get("spreadingfactor"),
+        "cr": best.get("codingrate"),
+    }
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        _CONFIG,
+        "",
+        "frequency = 867200000\ntype = RNodeInterface\n",
+        _block("    frequency = 867200000\n    frequency = bogus\n"),
+        _block("    frequency = bogus\n    frequency = 868000000\n"),
+        _block("    FREQUENCY = 869525000\n    BandWidth = 250000\n"),
+        _block("    frequency = 867200000\n    type = AutoInterface\n"),
+        "[[A]]\n type = AutoInterface\n frequency = 1\n[[B]]\n"
+        " type = RNodeInterface\n codingrate = 6\n",
+        _block("    spreadingfactor = 12 # comment\n    bare-token\n    = 5\n"),
+        _block("    frequency = 0\n    bandwidth = 0\n"),
+        "[[A]]\n type = RNodeInterface\n[[B]]\n type = RNodeInterface\n sf = 7\n",
+        _block(
+            "    frequency = \"867200000\"\n    bandwidth = '125000'\n    codingrate = 5\n"
+        ),
+    ],
+    ids=[
+        "full-config",
+        "empty",
+        "before-any-section",
+        "valid-then-invalid",
+        "invalid-then-valid",
+        "upper-case-keys",
+        "type-changes-away",
+        "rnode-second",
+        "comment-bare-token-blank-key",
+        "zero-values",
+        "first-rnode-empty",
+        "quoted-values",
+    ],
+)
+def test_radio_parser_reads_exactly_what_it_read_before_the_refactor(text):
+    """SPEC RL1 is unchanged: the shared reader yields the same radio values."""
+    assert reticulum._parse_rnode_radio_config(
+        text
+    ) == _legacy_parse_rnode_radio_config(text)
+
+
+def test_config_text_is_none_for_an_unset_dir_or_a_missing_file(tmp_path):
+    """No directory or no readable file: no text, and no exception."""
+    assert rp.rns_config_text(None) is None
+    assert rp.rns_config_text("   ") is None
+    assert rp.rns_config_text(str(tmp_path)) is None
+    (tmp_path / "config").write_text("[reticulum]\n", encoding="utf-8")
+    assert rp.rns_config_text(str(tmp_path)) == "[reticulum]\n"
+
+
+# ---------------------------------------------------------------------------
+# Validation (SPEC RP2/RP3)
+# ---------------------------------------------------------------------------
+
+
+def test_a_valid_position_is_published_as_written():
+    """No rounding: the values are the floats the operator typed (SPEC RP3)."""
+    position, problem = _parse(_CONFIG)
+    assert problem is None
+    assert position == rp.HostPosition(52.5029, 13.4042, 34.0)
+
+
+def test_height_is_optional():
+    """Latitude and longitude alone are a position without altitude."""
+    position, problem = _parse(
+        _block("    latitude = -33.8688\n    longitude = 151.2093\n")
+    )
+    assert (position, problem) == (rp.HostPosition(-33.8688, 151.2093, None), None)
+
+
+@pytest.mark.parametrize(
+    "lines",
+    [
+        "",
+        "    port = /dev/ttyUSB0\n",
+        "    height = 34\n",
+        f"    location_cmd = touch {_MARKER}\n",
+    ],
+    ids=["empty-block", "port-only", "height-only", "command-only"],
+)
+def test_no_coordinates_mean_no_position_and_no_problem(lines):
+    """Missing keys, or height or location_cmd alone, are not an error."""
+    assert _parse(_block(lines)) == (None, None)
+
+
+def test_keys_outside_the_first_rnode_block_are_not_read():
+    """An ``AutoInterface`` position is not this host's radio position."""
+    text = "[interfaces]\n  [[Auto]]\n    type = AutoInterface\n    latitude = 1\n"
+    assert _parse(text + "    longitude = 2\n") == (None, None)
+
+
+def test_discoverable_does_not_matter():
+    """RNS reads the keys only for a discoverable interface; this reads them always."""
+    for flag in ("", "    discoverable = no\n", "    discoverable = yes\n"):
+        position, _ = _parse(_block(flag + "    latitude = 10\n    longitude = 20\n"))
+        assert position == rp.HostPosition(10.0, 20.0, None)
+
+
+@pytest.mark.parametrize(
+    ("lines", "problem"),
+    [
+        ("    latitude = 52.5\n", "only one of latitude and longitude is set"),
+        ("    longitude = 13.4\n", "only one of latitude and longitude is set"),
+        ("    latitude = north\n    longitude = 13.4\n", "must be numbers"),
+        ("    latitude = 52.5\n    longitude = 13,4\n", "must be numbers"),
+        ("    latitude =\n    longitude = 13.4\n", "must be numbers"),
+        ("    latitude = nan\n    longitude = 13.4\n", "must be numbers"),
+        ("    latitude = 52.5\n    longitude = inf\n", "must be numbers"),
+        ("    latitude = \"52.5'\n    longitude = 13.4\n", "must be numbers"),
+        ('    latitude = "52.5\n    longitude = 13.4\n', "must be numbers"),
+        ('    latitude = ""52.5""\n    longitude = 13.4\n', "must be numbers"),
+        ('    latitude = ""\n    longitude = 13.4\n', "must be numbers"),
+        ('    latitude = "north"\n    longitude = 13.4\n', "must be numbers"),
+        ("    latitude = 90.0001\n    longitude = 13.4\n", "latitude is outside"),
+        ("    latitude = -91\n    longitude = 13.4\n", "latitude is outside"),
+        ("    latitude = 52.5\n    longitude = 180.5\n", "longitude is outside"),
+        ("    latitude = 52.5\n    longitude = -181\n", "longitude is outside"),
+        ("    latitude = 0\n    longitude = 0\n", "0, 0 is not a position"),
+        ("    latitude = 0.0\n    longitude = -0.0\n", "0, 0 is not a position"),
+        (
+            "    latitude = 95\n    longitude = 2\n    height = high\n",
+            "latitude is outside",
+        ),
+    ],
+    ids=[
+        "latitude-alone",
+        "longitude-alone",
+        "word",
+        "decimal-comma",
+        "empty-value",
+        "nan",
+        "inf",
+        "mismatched-quotes",
+        "unbalanced-quote",
+        "two-pairs-of-quotes",
+        "empty-quotes",
+        "quoted-word",
+        "latitude-above-90",
+        "latitude-below-minus-90",
+        "longitude-above-180",
+        "longitude-below-minus-180",
+        "null-island",
+        "null-island-signed",
+        "bad-latitude-wins-over-bad-height",
+    ],
+)
+def test_an_invalid_value_means_no_position(lines, problem):
+    """Each invalid shape is rejected with a reason (SPEC RP2)."""
+    position, reason = _parse(_block(lines))
+    assert position is None
+    assert problem in reason
+
+
+@pytest.mark.parametrize(
+    "value",
+    ['"52.5029"', "'52.5029'", '" 52.5029 "'],
+    ids=["double-quotes", "single-quotes", "quoted-with-spaces"],
+)
+def test_one_pair_of_quotes_is_stripped_as_rns_does(value):
+    """A quoted value reads as RNS's own ConfigObj reads it (SPEC RP2)."""
+    text = _block(
+        f"    latitude = {value}\n    longitude = '13.4042'\n    height = \"34\"\n"
+    )
+    section = ConfigObj(text.splitlines())["interfaces"]["RNode"]
+    rns = tuple(section.as_float(key) for key in ("latitude", "longitude", "height"))
+    assert _parse(text) == (rp.HostPosition(*rns), None)
+
+
+@pytest.mark.parametrize(
+    "height",
+    ["high", "", "nan", "inf", '"tall"'],
+    ids=["word", "empty", "nan", "inf", "quoted-word"],
+)
+def test_an_invalid_height_drops_only_the_altitude(height):
+    """The coordinates still publish; only the altitude is left out (SPEC RP2)."""
+    text = _block(f"    latitude = 52.5\n    longitude = 13.4\n    height = {height}\n")
+    assert _parse(text) == (
+        rp.HostPosition(52.5, 13.4, None),
+        "height must be a number",
+    )
+
+
+@pytest.mark.parametrize(
+    "lines",
+    [
+        "    Latitude = 52.5029\n    Longitude = 13.4042\n",
+        "    LATITUDE = 52.5029\n    longitude = 13.4042\n",
+        "    latitude = 52.5029\n    longitude = 13.4042\n    Latitude = 1\n    HEIGHT = 34\n",
+        '    "latitude" = 52.5029\n    \'longitude\' = 13.4042\n    "height" = 34\n',
+        '    "Latitude" = 52.5029\n    longitude = 13.4042\n',
+        "    latitude = 52.5029\n    longitude = 13.4042\n    Height = sky-high\n",
+    ],
+    ids=[
+        "capitalised",
+        "upper-case-latitude",
+        "case-variant-after-the-key",
+        "quoted-keys",
+        "quoted-capitalised-key",
+        "case-variant-of-a-bad-height",
+    ],
+)
+def test_keys_match_as_rns_matches_them(tmp_path, fresh_log_state, lines):
+    """A key counts only under the exact name RNS reads (SPEC RP2).
+
+    RNS's ConfigObj matches a key exactly after stripping one pair of quotes:
+    ``Latitude`` is a different key, ``"latitude"`` is ``latitude``.  RNS's own
+    parser is the oracle: the ingestor publishes what RNS would read, and warns
+    exactly when RNS's view of the keys is invalid, never about a key RNS ignores.
+    """
+    text = _block(lines)
+    section = ConfigObj(text.splitlines())["interfaces"]["RNode"]
+    rns_view = [
+        (k, section[k]) for k in ("latitude", "longitude", "height") if k in section
+    ]
+    (tmp_path / "config").write_text(text, encoding="utf-8")
+    expected, problem = rp.parse_host_position(rns_view)
+    assert rp.read_host_position(str(tmp_path)) == expected
+    warnings = [kw.get("severity") for _msg, kw in fresh_log_state].count("warn")
+    assert warnings == (0 if problem is None else 1)
+
+
+def test_the_boundaries_and_one_zero_axis_are_valid():
+    """The poles, the antimeridian, the equator and the prime meridian are real."""
+    for lat, lon in (("90", "180"), ("-90", "-180"), ("0", "13.4"), ("52.5", "0")):
+        position, problem = _parse(
+            _block(f"    latitude = {lat}\n    longitude = {lon}\n")
+        )
+        assert problem is None
+        assert position == rp.HostPosition(float(lat), float(lon), None)
+
+
+def test_a_negative_height_is_valid():
+    """Below sea level is a height, not an error."""
+    position, _ = _parse(
+        _block("    latitude = 31.5\n    longitude = 35.5\n    height = -430\n")
+    )
+    assert position.altitude == -430.0
+
+
+def test_the_last_occurrence_of_a_key_wins():
+    """RNS rejects duplicates; if one slips through, the later line wins."""
+    text = _block("    latitude = 1\n    longitude = 2\n    latitude = 3\n")
+    assert _parse(text)[0] == rp.HostPosition(3.0, 2.0, None)
+
+
+# ---------------------------------------------------------------------------
+# read_host_position: once per connect, logged once per outcome (SPEC RP2)
+# ---------------------------------------------------------------------------
+
+
+def test_read_logs_a_valid_position_once_and_never_its_coordinates(
+    tmp_path, fresh_log_state
+):
+    """One info line, then silence while the outcome holds."""
+    (tmp_path / "config").write_text(_CONFIG, encoding="utf-8")
+    assert rp.read_host_position(str(tmp_path)) == rp.HostPosition(
+        52.5029, 13.4042, 34.0
+    )
+    assert rp.read_host_position(str(tmp_path)) == rp.HostPosition(
+        52.5029, 13.4042, 34.0
+    )
+    assert [(msg, kw["severity"]) for msg, kw in fresh_log_state] == [
+        ("Publishing the host position from the RNS config", "info")
+    ]
+    flat = repr(fresh_log_state)
+    for leak in ("52.5029", "13.4042", _SECRET, _PASSPHRASE):
+        assert leak not in flat
+
+
+def test_read_logs_missing_keys_once_at_debug(tmp_path, fresh_log_state):
+    """No keys, no file or no directory: one debug line, no warning spam."""
+    assert rp.read_host_position(str(tmp_path)) is None
+    (tmp_path / "config").write_text(_block(""), encoding="utf-8")
+    assert rp.read_host_position(str(tmp_path)) is None
+    assert rp.read_host_position(None) is None
+    assert len(fresh_log_state) == 1
+    message, fields = fresh_log_state[0]
+    assert "No host position" in message
+    assert fields.get("severity", "debug") == "debug"
+
+
+def test_read_warns_once_per_problem(tmp_path, fresh_log_state):
+    """An invalid value warns once; a different problem warns again."""
+    config_file = tmp_path / "config"
+    config_file.write_text(
+        _block("    latitude = 95\n    longitude = 13\n"), encoding="utf-8"
+    )
+    assert rp.read_host_position(str(tmp_path)) is None
+    assert rp.read_host_position(str(tmp_path)) is None
+    config_file.write_text(_block("    latitude = 52\n"), encoding="utf-8")
+    assert rp.read_host_position(str(tmp_path)) is None
+    warnings = [msg for msg, kw in fresh_log_state if kw.get("severity") == "warn"]
+    assert len(warnings) == 2
+    assert "latitude is outside -90..90" in warnings[0]
+    assert "only one of latitude and longitude" in warnings[1]
+    assert "95" not in repr(fresh_log_state)
+
+
+def test_read_warns_once_about_an_invalid_height_and_never_its_value(
+    tmp_path, fresh_log_state
+):
+    """One warning names ``height``; the value and the coordinates stay out."""
+    text = _block(
+        "    latitude = 52.5029\n    longitude = 13.4042\n    height = sky-high\n"
+    )
+    (tmp_path / "config").write_text(text, encoding="utf-8")
+    expected = rp.HostPosition(52.5029, 13.4042, None)
+    assert rp.read_host_position(str(tmp_path)) == expected
+    assert rp.read_host_position(str(tmp_path)) == expected
+    assert [kw.get("severity") for _msg, kw in fresh_log_state] == ["warn"]
+    message = fresh_log_state[0][0]
+    assert "height" in message and "without altitude" in message
+    flat = repr(fresh_log_state)
+    for leak in ("sky-high", "52.5029", "13.4042"):
+        assert leak not in flat
+
+
+def test_read_never_runs_location_cmd(tmp_path, monkeypatch):
+    """``location_cmd`` names a command; the reader never runs it (SPEC RP1)."""
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "config").write_text(_CONFIG, encoding="utf-8")
+    rp.read_host_position(str(tmp_path))
+    assert not (tmp_path / _MARKER).exists()
+
+
+# ---------------------------------------------------------------------------
+# Builders (SPEC RP3-RP6)
+# ---------------------------------------------------------------------------
+
+_POSITION = rp.HostPosition(52.5029, 13.4042, 34.0)
+_FLAT = rp.HostPosition(52.5029, 13.4042, None)
+
+
+def test_node_position_is_the_record_mapping():
+    """``{latitude, longitude, altitude?, time, locationSource}`` (SPEC RP4)."""
+    assert rp.node_position(_POSITION, 1_791_000_000) == {
+        "latitude": 52.5029,
+        "longitude": 13.4042,
+        "altitude": 34.0,
+        "time": 1_791_000_000,
+        "locationSource": "LOC_MANUAL",
+    }
+    assert "altitude" not in rp.node_position(_FLAT, 1)
+    assert "precisionBits" not in rp.node_position(_POSITION, 1)
+
+
+def test_position_row_carries_the_host_and_its_radio(monkeypatch):
+    """One row per report: a stable 53-bit id, the reticulum stamp (SPEC RP5)."""
+    monkeypatch.setattr(config, "LORA_FREQ", 867)
+    monkeypatch.setattr(config, "MODEM_PRESET", "SF8/BW125/CR5")
+    row = rp.position_row(_HOST, _POSITION, 1_791_000_000)
+    assert row == {
+        "id": row["id"],
+        "rx_time": 1_791_000_000,
+        "rx_iso": "2026-10-03T04:00:00Z",
+        "node_id": _HOST,
+        "node_num": 0x27716218,
+        "from_id": _HOST,
+        "latitude": 52.5029,
+        "longitude": 13.4042,
+        "altitude": 34.0,
+        "position_time": 1_791_000_000,
+        "location_source": "LOC_MANUAL",
+        "ingestor": _HOST,
+        "protocol": "reticulum",
+        "lora_freq": 867,
+        "modem_preset": "SF8/BW125/CR5",
+    }
+    assert 0 <= row["id"] < 1 << 53
+    assert rp.position_row(_HOST, _POSITION, 1_791_000_000)["id"] == row["id"]
+    assert rp.position_row(_HOST, _POSITION, 1_791_000_001)["id"] != row["id"]
+    assert "altitude" not in rp.position_row(_HOST, _FLAT, 1)
+
+
+@pytest.fixture
+def host(monkeypatch):
+    """Register :data:`_HOST` and record every queued POST.
+
+    Returns:
+        Namespace with ``posts`` (``(path, payload)`` pairs) and ``iface``
+        (an interface holding :data:`_POSITION`).
+    """
+    for name in (
+        "_host_node_id",
+        "_host_telemetry_last_rx",
+        "_host_nodeinfo_last_seen",
+    ):
+        monkeypatch.setattr(handler_state, name, None)
+    handlers.register_host_node_id(_HOST)
+    posts: list[tuple[str, dict]] = []
+    monkeypatch.setattr(
+        queue,
+        "_queue_post_json",
+        lambda path, payload, **_k: posts.append((path, payload)),
+    )
+    monkeypatch.setattr(rp.time, "time", lambda: 1_791_000_000.4)
+    return types.SimpleNamespace(
+        posts=posts, iface=types.SimpleNamespace(host_position=_POSITION)
+    )
+
+
+def _bare(node_id: str, report_time: int) -> dict:
+    """Stand-in for the provider's bare host record.
+
+    Parameters:
+        node_id: Host node id.
+        report_time: Unix seconds.
+
+    Returns:
+        A minimal node dict.
+    """
+    return {"nodeId": node_id, "lastHeard": report_time, "user": {"longName": "bare"}}
+
+
+def test_only_the_host_records_are_positioned(host):
+    """Peers pass through untouched, and nothing is mutated (SPEC RP4)."""
+    peer = {"nodeId": "!aabbccdd", "user": {"longName": "Peer"}}
+    own = {"nodeId": _HOST, "destination": {"aspect": "lxmf.delivery"}}
+    items = [("!aabbccdd", peer), (_HOST, own)]
+    out = rp.with_host_position(items, host.iface, _bare)
+    assert out[0] == ("!aabbccdd", peer) and out[0][1] is peer
+    assert out[1][1]["position"] == rp.node_position(_POSITION, 1_791_000_000)
+    assert out[1][1]["destination"] == {"aspect": "lxmf.delivery"}
+    assert "position" not in own and len(items) == 2
+    assert host.posts == []  # the snapshot posts no row
+
+
+def test_a_bare_record_carries_the_position_when_no_record_is_the_host(host):
+    """Docker: nothing announces, so the host rides on a bare record (SPEC RP6)."""
+    out = rp.with_host_position(
+        [("!aabbccdd", {"nodeId": "!aabbccdd"})], host.iface, _bare
+    )
+    assert [node_id for node_id, _node in out] == ["!aabbccdd", _HOST]
+    bare = out[1][1]
+    assert bare["user"] == {"longName": "bare"}
+    assert bare["lastHeard"] == 1_791_000_000
+    assert bare["position"]["time"] == 1_791_000_000
+
+
+@pytest.mark.parametrize("missing", ["position", "host"])
+def test_nothing_changes_without_a_position_or_a_host_id(host, missing):
+    """No position, or a host id not yet resolved: the records pass as they are."""
+    items = [(_HOST, {"nodeId": _HOST})]
+    iface = host.iface
+    if missing == "position":
+        iface = types.SimpleNamespace(host_position=None)
+    else:
+        handlers.register_host_node_id(None)
+    assert rp.with_host_position(items, iface, _bare) is items
+    assert rp.report_host_position(items, iface, _bare) is items
+    assert rp.with_host_position(items, None, _bare) is items
+    assert host.posts == []
+
+
+def test_a_report_positions_its_records_and_posts_one_row(host):
+    """The report is what posts the row, at connect and hourly (SPEC RP5)."""
+    out = rp.report_host_position([], host.iface, _bare)
+    assert [node_id for node_id, _node in out] == [_HOST]
+    assert out[0][1]["position"]["latitude"] == 52.5029
+    assert [path for path, _payload in host.posts] == ["/api/positions"]
+    assert host.posts[0][1]["node_id"] == _HOST
+    assert host.posts[0][1]["position_time"] == 1_791_000_000
diff --git a/web/public/assets/js/app/__tests__/reticulum-host-position.test.js b/web/public/assets/js/app/__tests__/reticulum-host-position.test.js
new file mode 100644
index 00000000..91a5f2ff
--- /dev/null
+++ b/web/public/assets/js/app/__tests__/reticulum-host-position.test.js
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2025-26 l5yth & contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The Reticulum host's position reaches the map and the node page (SPEC RP7).
+ *
+ * The map and the spec sheet are protocol-neutral, so no renderer changed:
+ * these tests pin that the host the ingestor positions from its RNS config is
+ * drawn with Reticulum's hexagon (RD6, no longer a reserved slot) and gains a
+ * Position group by RA6's rule, while a peer keeps neither.
+ *
+ * @module __tests__/reticulum-host-position
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { withAppAndLeaflet } from './main-app-leaflet-stub.js';
+import { renderSingleNodeTable } from '../node-page/single-node-table.js';
+
+const NOW = 1_791_000_000;
+
+/** The host as `/api/nodes` serves it once its report carried a position. */
+const HOST = Object.freeze({
+  node_id: '!27716218',
+  short_name: '2771',
+  long_name: 'Department of Decentralization',
+  role: 'NODE',
+  protocol: 'reticulum',
+  latitude: 52.5029,
+  longitude: 13.4042,
+  altitude: 34,
+  position_time: NOW - 60,
+  location_source: 'LOC_MANUAL',
+  last_heard: NOW - 60,
+  first_heard: NOW - 86_400,
+});
+
+/** A peer as `/api/nodes` serves it: an announce carries no position. */
+const PEER = Object.freeze({
+  node_id: '!aabbccdd',
+  short_name: 'aabb',
+  long_name: 'Remote Peer',
+  role: 'PEER',
+  protocol: 'reticulum',
+  last_heard: NOW - 30,
+  first_heard: NOW - 3_600,
+});
+
+/** The host's destinations, as `/api/destinations` serves them. */
+const DESTINATIONS = Object.freeze([
+  {
+    id: '9c59da5e1516745d74cc908243e0ba2b', node_id: '!27716218',
+    identity_hash: '27716218762cfd2864141ef286c39940', aspect: 'nomadnetwork.node',
+    role: 'NODE', name: 'Department of Decentralization',
+    interface: 'LocalInterface[rns/default]', first_heard: NOW - 86_400, last_heard: NOW - 60,
+  },
+]);
+
+/**
+ * List the group titles a rendered spec sheet carries, in order.
+ *
+ * @param {string} html Spec-sheet markup.
+ * @returns {Array<string>} Group titles.
+ */
+function groupTitles(html) {
+  return [...html.matchAll(/<h3 class="node-detail-sheet__group-title">([^<]+)<\/h3>/g)].map(m => m[1]);
+}
+
+test('the Reticulum host reaches the map as a hexagon; a peer stays off it (RD6)', () => {
+  withAppAndLeaflet(({ testUtils, leaflet }) => {
+    leaflet._map._setZoom(12);
+    leaflet._recorded.circleMarkers.length = 0;
+    leaflet._recorded.markers.length = 0;
+    testUtils.renderMap([HOST, PEER], NOW);
+    // Only the host has coordinates, and Reticulum's shape is a divIcon chip.
+    assert.equal(leaflet._recorded.circleMarkers.length, 0);
+    assert.equal(leaflet._recorded.markers.length, 1);
+    const marker = leaflet._recorded.markers[0];
+    assert.deepEqual(marker._latLng, [52.5029, 13.4042]);
+    assert.match(marker.options.icon.options.html, /node-marker-chip__fill--hexagon/);
+  });
+});
+
+test('the host node page renders its Position group (RA5 by RA6)', () => {
+  const html = renderSingleNodeTable(HOST, () => '', NOW, { destinations: DESTINATIONS });
+  assert.deepEqual(groupTitles(html), ['Identity', 'Activity', 'Position']);
+  assert.match(html, /<dt>Latitude<\/dt><dd>52\.50290<\/dd>/);
+  assert.match(html, /<dt>Longitude<\/dt><dd>13\.40420<\/dd>/);
+  assert.match(html, /<dt>Altitude<\/dt>/);
+  assert.match(html, /<dt>Last Position<\/dt>/);
+});
+
+test('a peer node page renders no Position group', () => {
+  const html = renderSingleNodeTable(PEER, () => '', NOW, { destinations: [] });
+  assert.deepEqual(groupTitles(html), ['Activity']);
+  assert.doesNotMatch(html, /Latitude/);
+});
diff --git a/web/public/assets/js/app/main/__tests__/node-marker.test.js b/web/public/assets/js/app/main/__tests__/node-marker.test.js
index 716e73cf..35661bdb 100644
--- a/web/public/assets/js/app/main/__tests__/node-marker.test.js
+++ b/web/public/assets/js/app/main/__tests__/node-marker.test.js
@@ -71,9 +71,8 @@ test('reticulum resolves to hexagon, case-insensitively (RD6)', () => {
 });
 
 test('the reticulum chip is equal-area and shape-modified (RD6)', () => {
-  // A reserved slot: RNS announces carry no position, so nothing reaches this
-  // on the map today. Built correctly now so the shape channel is complete the
-  // moment positions exist.
+  // Reached for an ingestor's own host, positioned from its RNS config (SPEC
+  // RP7); __tests__/reticulum-host-position.test.js drives it through renderMap.
   const { L, calls } = leafletStub();
   createNodeMarker(L, [52.5, 13.4], {
     protocol: 'reticulum',
diff --git a/web/public/assets/js/app/main/node-marker.js b/web/public/assets/js/app/main/node-marker.js
index 3d217d2e..df6dd299 100644
--- a/web/public/assets/js/app/main/node-marker.js
+++ b/web/public/assets/js/app/main/node-marker.js
@@ -30,12 +30,10 @@
 /**
  * Resolve the marker shape for a protocol.
  *
- * Reticulum returns `hexagon` (SPEC RD6). That branch is a **reserved slot** on
- * the map: a Reticulum announce carries no position, so no RNS node currently
- * reaches {@link createNodeMarker}. It is implemented rather than stubbed so
- * the shape channel is complete the moment positions exist, and because the
- * legend swatch — which *is* live — derives its shape from this same function
- * (SPEC LC1).
+ * Reticulum returns `hexagon` (SPEC RD6). A Reticulum announce carries no
+ * position, so the one RNS node that reaches {@link createNodeMarker} is an
+ * ingestor's own host, positioned from its RNS config (SPEC RP7). The legend
+ * swatch derives its shape from this same function (SPEC LC1).
  *
  * @param {?string} protocol Node protocol identifier.
  * @returns {'square' | 'hexagon' | 'circle'} Marker shape.
diff --git a/web/public/assets/js/app/role-helpers.js b/web/public/assets/js/app/role-helpers.js
index fc04f2fe..49e42b8c 100644
--- a/web/public/assets/js/app/role-helpers.js
+++ b/web/public/assets/js/app/role-helpers.js
@@ -241,10 +241,10 @@ export const meshcoreRoleRenderOrder = Object.freeze({
  * the higher it draws. Mirrors the role ramp's own ordering
  * (`PEER < NODE < TRANSPORT < PROPAGATION`).
  *
- * A **reserved slot**, like the hexagon marker it stacks: Reticulum announces
- * carry no position, so nothing reaches this table yet. Without it every RNS
- * role would fall through to `0` and draw beneath every Meshtastic node —
- * `CLIENT_HIDDEN` included — the moment positions existed.
+ * Reticulum announces carry no position, so only an ingestor's own host,
+ * positioned from its RNS config (SPEC RP7), reaches this table. Without it
+ * every RNS role would fall through to `0` and draw beneath every Meshtastic
+ * node — `CLIENT_HIDDEN` included.
  *
  * @type {Readonly<Record<string, number>>}
  */
diff --git a/web/public/assets/styles/base.css b/web/public/assets/styles/base.css
index 90e5127c..5a3e429c 100644
--- a/web/public/assets/styles/base.css
+++ b/web/public/assets/styles/base.css
@@ -3148,9 +3148,9 @@ button.legend-item[aria-pressed="true"] {
   transform: rotate(45deg);
 }
 
-/* Reticulum map chip (SPEC RD6) — a reserved slot: RNS announces carry no
-   position, so nothing reaches this rule yet. It overrides the diamond rather
-   than restructuring it, so MeshCore's chip is untouched (FU-A3). */
+/* Reticulum map chip (SPEC RD6) — drawn for an ingestor's own host, the one
+   RNS node with a position (SPEC RP7). It overrides the diamond rather than
+   restructuring it, so MeshCore's chip is untouched (FU-A3). */
 .node-marker-chip__fill--hexagon {
   border: none;
   border-radius: 0;
diff --git a/web/spec/reticulum_host_position_spec.rb b/web/spec/reticulum_host_position_spec.rb
new file mode 100644
index 00000000..817effea
--- /dev/null
+++ b/web/spec/reticulum_host_position_spec.rb
@@ -0,0 +1,243 @@
+# Copyright © 2025-26 l5yth & contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+# The Reticulum host's own position (SPEC RP4-RP7). The web app stores and
+# serves positions protocol-neutrally, so these examples pin that the records
+# and rows the Reticulum ingestor posts for its host land like any other
+# protocol's, and that an announce-derived peer stays position-less.
+RSpec.describe "Reticulum host position" do
+  let(:app) { Sinatra::Application }
+  let(:api_token) { "test-token" }
+  let(:auth_headers) do
+    {
+      "CONTENT_TYPE" => "application/json",
+      "HTTP_AUTHORIZATION" => "Bearer #{api_token}",
+    }
+  end
+  let(:now) { Time.now.to_i }
+  let(:host_id) { "!27716218" }
+  let(:peer_id) { "!aabbccdd" }
+  let(:position) do
+    {
+      "latitude" => 52.5029,
+      "longitude" => 13.4042,
+      "altitude" => 34.0,
+      "time" => now,
+      "locationSource" => "LOC_MANUAL",
+    }
+  end
+
+  before do
+    @original_token = ENV.fetch("API_TOKEN", nil)
+    ENV["API_TOKEN"] = api_token
+    clear_tables
+    PotatoMesh::App::ApiCache.invalidate_all
+  end
+
+  after do
+    ENV["API_TOKEN"] = @original_token
+    clear_tables
+  end
+
+  # Open a database connection for direct inspection.
+  #
+  # @param readonly [Boolean] whether to open in read-only mode.
+  # @yieldparam db [SQLite3::Database] open database handle.
+  # @return [void]
+  def with_db(readonly: false)
+    db = PotatoMesh::Application.open_database(readonly: readonly)
+    db.results_as_hash = true
+    yield db
+  ensure
+    db&.close
+  end
+
+  # Remove all rows from the tables these examples write.
+  #
+  # @return [void]
+  def clear_tables
+    with_db do |db|
+      %w[positions nodes destinations ingestors].each { |table| db.execute("DELETE FROM #{table}") }
+    end
+  end
+
+  # A host destination record as the ingestor posts it at connect and on
+  # every self-node report: the announce shape plus the host position.
+  #
+  # @return [Hash] node record.
+  def host_record
+    {
+      "lastHeard" => now,
+      "protocol" => "reticulum",
+      "identityHash" => "27716218762cfd2864141ef286c39940",
+      "user" => { "shortName" => "2771", "longName" => "Department of Decentralization", "role" => "NODE" },
+      "destination" => { "id" => "9c59da5e1516745d74cc908243e0ba2b", "aspect" => "nomadnetwork.node", "role" => "NODE" },
+      "position" => position,
+    }
+  end
+
+  # The bare host record for a host with nothing announcing (SPEC RP6).
+  #
+  # @return [Hash] node record.
+  def bare_host_record
+    {
+      "lastHeard" => now,
+      "protocol" => "reticulum",
+      "user" => { "shortName" => "2771", "longName" => "Reticulum 2771", "role" => "PEER" },
+      "position" => position,
+    }
+  end
+
+  # An announce-derived peer record: never positioned (SPEC RP4).
+  #
+  # @return [Hash] node record.
+  def peer_record
+    {
+      "lastHeard" => now,
+      "protocol" => "reticulum",
+      "user" => { "shortName" => "aabb", "longName" => "Remote Peer", "role" => "PEER" },
+      "destination" => { "id" => "c0ffee00222222222222222222222222", "aspect" => "lxmf.delivery", "role" => "PEER" },
+    }
+  end
+
+  # The positions row the ingestor posts on each report (SPEC RP5).
+  #
+  # @return [Hash] positions payload.
+  def position_row
+    {
+      "id" => 4_503_599_627_370_495,
+      "rx_time" => now,
+      "rx_iso" => Time.at(now).utc.iso8601,
+      "node_id" => host_id,
+      "node_num" => 0x27716218,
+      "from_id" => host_id,
+      "latitude" => 52.5029,
+      "longitude" => 13.4042,
+      "altitude" => 34.0,
+      "position_time" => now,
+      "location_source" => "LOC_MANUAL",
+      "ingestor" => host_id,
+      "protocol" => "reticulum",
+    }
+  end
+
+  # POST node records the way the ingestor batches them.
+  #
+  # @param records [Hash{String => Hash}] node id to node record.
+  # @return [Rack::MockResponse] the response.
+  def post_nodes(records)
+    post "/api/nodes", records.merge("ingestor" => host_id, "protocol" => "reticulum").to_json, auth_headers
+    last_response
+  end
+
+  # POST the host's positions row.
+  #
+  # @return [Rack::MockResponse] the response.
+  def post_position_row
+    post "/api/positions", position_row.to_json, auth_headers
+    last_response
+  end
+
+  describe "the host node record" do
+    it "stores the position on the host and none on the peer" do
+      expect(post_nodes(host_id => host_record, peer_id => peer_record).status).to eq(201)
+
+      with_db(readonly: true) do |db|
+        host = db.get_first_row("SELECT * FROM nodes WHERE node_id = ?", [host_id])
+        expect(host.values_at("latitude", "longitude", "altitude")).to eq([52.5029, 13.4042, 34.0])
+        expect(host.values_at("position_time", "location_source")).to eq([now, "LOC_MANUAL"])
+        expect(host["precision_bits"]).to be_nil
+        peer = db.get_first_row("SELECT * FROM nodes WHERE node_id = ?", [peer_id])
+        expect(peer.values_at("latitude", "longitude", "position_time")).to eq([nil, nil, nil])
+      end
+    end
+
+    it "serves the position on /api/nodes and /api/nodes/:id" do
+      post_nodes(host_id => host_record, peer_id => peer_record)
+
+      get "/api/nodes?protocol=reticulum"
+      nodes = JSON.parse(last_response.body).to_h { |node| [node["node_id"], node] }
+      expect(nodes[host_id].values_at("latitude", "longitude", "altitude")).to eq([52.5029, 13.4042, 34.0])
+      expect(nodes[host_id]["location_source"]).to eq("LOC_MANUAL")
+      expect(nodes[peer_id]).not_to have_key("latitude")
+
+      get "/api/nodes/#{host_id}"
+      expect(JSON.parse(last_response.body)["latitude"]).to eq(52.5029)
+    end
+
+    it "stores the bare record under the host's placeholder with no destination" do
+      expect(post_nodes(host_id => bare_host_record).status).to eq(201)
+
+      with_db(readonly: true) do |db|
+        host = db.get_first_row("SELECT * FROM nodes WHERE node_id = ?", [host_id])
+        expect(host.values_at("long_name", "short_name", "protocol")).to eq(["Reticulum 2771", "2771", "reticulum"])
+        expect(host.values_at("latitude", "longitude")).to eq([52.5029, 13.4042])
+        expect(db.get_first_value("SELECT COUNT(*) FROM destinations")).to eq(0)
+      end
+
+      # The node API fills a missing role with Meshtastic's CLIENT, which is
+      # why the bare record carries Reticulum's base role (SPEC RA9).
+      get "/api/nodes/#{host_id}"
+      expect(JSON.parse(last_response.body)["role"]).to eq("PEER")
+    end
+
+    it "keeps a stored position when a later record carries none" do
+      post_nodes(host_id => host_record)
+      later = host_record.reject { |key, _| key == "position" }.merge("lastHeard" => now + 1)
+      post_nodes(host_id => later)
+
+      with_db(readonly: true) do |db|
+        expect(db.get_first_value("SELECT latitude FROM nodes WHERE node_id = ?", [host_id])).to eq(52.5029)
+      end
+    end
+  end
+
+  describe "the host positions row" do
+    it "is stored and served under the reticulum protocol" do
+      post_nodes(host_id => host_record)
+      expect(post_position_row.status).to eq(201)
+
+      get "/api/positions?protocol=reticulum"
+      rows = JSON.parse(last_response.body)
+      expect(rows.length).to eq(1)
+      expect(rows.first.values_at("node_id", "protocol", "latitude", "longitude", "altitude", "location_source")).to eq([host_id, "reticulum", 52.5029, 13.4042, 34.0, "LOC_MANUAL"])
+      expect(rows.first["id"]).to eq(4_503_599_627_370_495)
+    end
+
+    it "counts in the reticulum telemetry umbrella of /api/stats (amends S3)" do
+      post_nodes(host_id => host_record)
+      post_position_row
+
+      get "/api/stats"
+      stats = JSON.parse(last_response.body)
+      expect(stats["reticulum"]["telemetry"]["hour"]).to eq(1)
+      expect(stats["reticulum"]["messages"]["hour"]).to eq(0)
+    end
+
+    it "lands first without harm: the record that follows completes the node" do
+      expect(post_position_row.status).to eq(201)
+      post_nodes(host_id => bare_host_record)
+
+      with_db(readonly: true) do |db|
+        host = db.get_first_row("SELECT * FROM nodes WHERE node_id = ?", [host_id])
+        expect(host.values_at("protocol", "short_name", "long_name", "role")).to eq(["reticulum", "2771", "Reticulum 2771", "PEER"])
+        expect(host.values_at("latitude", "longitude")).to eq([52.5029, 13.4042])
+      end
+    end
+  end
+end