A path field means two different things, and now says which

No, it isn't the ack — ACK is its own payload class and was never in the match.
Both symptoms come from the same place: a packet header's route type, which we
never recorded, decides what its `path` field *is*.

A FLOOD packet accumulates: every relay appends its hash, so the path is the
route it travelled to reach us. A DIRECT packet is the opposite — the path is a
routing instruction the sender wrote and the relays consume — so it says where
the packet is going, and an empty one means the route was used up, not that the
packet arrived in a single leap. Reading every path the first way is what drew a
message from five hops out as having appeared from nowhere.

The evidence is in your own log. The four-hop route on those sends is identical
across four consecutive messages, where a flood-accumulated path varies every
time; it ends on 40ef0f, which is the first hop of everything hairu sends *us*;
and a PATH frame carrying exactly those four hops crosses the log seconds before
the first message that uses it. That is a learned route to hairu being announced
and then used — not a route anything took to us.

So route_typename is stored (schema v15, a `route` column beside the crypto and
addressing ones added for the same reason), and an Arrival carries whether it
was routed. A routed frame with no path has route_known False: it is kept as a
copy that reached us — the count and the time are real — but it is drawn as
"routed · route not carried" instead of a confident zero hops, and it puts no
lane in the fan, because an empty lane there is a claim of adjacency the frame
never made. Frames from before the column read None and fall back to the old
behaviour rather than to a guess.

The round trip is a second bug and needed no new data. The path line closed on
our own ★ unconditionally, and for an outgoing message its head is our ★ too —
so every send drew ★ ▶ … ▶ ★. The graph did the same, DST_NODE having been
hardcoded to us. Both now take a destination: the far end for a message we sent,
ourselves for one we received. It is the rule the line's head already followed —
a path runs between the nodes it went between — applied at last to its tail. A
channel broadcast keeps us at both ends, because there the copies we log really
are our own message coming back.

collapse now keys on the route type as well as the hops, so a route travelled
and a route intended never fold into one row even when the hashes match.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jean-Pierre MartineauandClaude Opus 5 committed 2026-09-02 00:16:55 -04:00
1 parent c8c7eab128
commit 211f38255b
8 files changed
+280 -33

No files matched your search

+19 -2
View File
@@ -10,7 +10,7 @@ from __future__ import annotations
import sqlite3
from pathlib import Path
SCHEMA_VERSION = 14
SCHEMA_VERSION = 15
_SCHEMA = """
CREATE TABLE IF NOT EXISTS schema_meta (
@@ -138,7 +138,8 @@ CREATE TABLE IF NOT EXISTS observations (
dest TEXT, -- …the recipient's key hash, for an addressed class (hex)
src TEXT, -- …the sender's key hash, or its whole key (anon request)
tag TEXT, -- …the frame's own token: an ack's checksum, a trace's tag
trace_snrs TEXT -- TRACE rows: comma-separated per-hop SNR readings (dB)
trace_snrs TEXT, -- TRACE rows: comma-separated per-hop SNR readings (dB)
route TEXT -- 'packet' rows: FLOOD/DIRECT/… — what `path` MEANS here
);
-- One chat message, sent or received, on a channel or with a contact. Unlike the other
@@ -316,3 +317,19 @@ def _migrate(conn: sqlite3.Connection) -> None:
# them a replayed row would show a trace's links blank, the same gap the crypto
# trio and the addressing columns above were added to close.
conn.execute("ALTER TABLE observations ADD COLUMN trace_snrs TEXT")
if "route" not in observation_cols:
# v14 -> v15: a frame's route type, which says what its `path` field *means* — and
# without it the field was being read one way for packets that meant it two.
#
# A FLOOD packet accumulates: every relay appends its hash, so the path is the route
# the packet actually travelled to reach us. A DIRECT packet is the opposite — the
# path is a routing *instruction* the sender wrote and the relays consume, so it
# describes where the packet is going, not where it has been, and an empty one means
# "route used up", not "arrived in zero hops".
#
# Reading every path as a travelled route therefore drew a direct-routed message as
# having reached us out of nowhere, and drew our own outgoing route as if it were an
# inbound one (JP, 2026-09-02). Older rows carry NULL and are read as unknown rather
# than assumed flooded; the raw headers they arrived in were never persisted, so this
# cannot be filled in from history.
conn.execute("ALTER TABLE observations ADD COLUMN route TEXT")
+11 -5
View File
@@ -93,7 +93,8 @@ def _packet_raw(row: sqlite3.Row) -> Optional[dict]:
src = _row_value(row, "src")
tag = _row_value(row, "tag")
trace_snrs = _row_value(row, "trace_snrs")
if not any((typename, chan_hash, cipher_mac, dest, src, tag, trace_snrs)):
route = _row_value(row, "route")
if not any((typename, chan_hash, cipher_mac, dest, src, tag, trace_snrs, route)):
return None
raw: dict = {}
if typename:
@@ -116,6 +117,8 @@ def _packet_raw(row: sqlite3.Row) -> Optional[dict]:
raw["trace_tag" if typename == "TRACE" else "ack_crc"] = tag
if trace_snrs:
raw["trace_snrs"] = [float(v) for v in str(trace_snrs).split(",") if v]
if route:
raw["route_typename"] = route
return raw
@@ -1024,12 +1027,14 @@ class Repository:
# class keeps relay hashes — so they get their own column rather than `path`.
readings = raw.get("trace_snrs") if typename == "TRACE" else None
trace_snrs = ",".join(f"{v:g}" for v in readings) if readings else None
# What the frame's `path` means — see the v15 migration. Only a packet row has one.
route = raw.get("route_typename") if obs.kind == "packet" else None
self._conn.execute(
"INSERT INTO observations "
"(run_id, node, public_key, name, kind, node_type, snr, rssi, lat, lon, path, "
"observed_at, chan_hash, cipher_mac, crypted, payload_typename, dest, src, tag, "
"trace_snrs) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
"trace_snrs, route) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(
run_id,
obs.node,
@@ -1051,6 +1056,7 @@ class Repository:
src,
tag,
trace_snrs,
route,
),
)
self._conn.commit()
@@ -1088,7 +1094,7 @@ class Repository:
"""
rows = self._conn.execute(
"SELECT node, name, kind, node_type, snr, rssi, lat, lon, path, observed_at, "
"chan_hash, cipher_mac, crypted, payload_typename, dest, src, tag, trace_snrs "
"chan_hash, cipher_mac, crypted, payload_typename, dest, src, tag, trace_snrs, route "
"FROM observations WHERE observed_at >= ? ORDER BY observed_at DESC LIMIT ?",
(since.isoformat(), limit),
).fetchall()
@@ -1114,7 +1120,7 @@ class Repository:
"""
rows = self._conn.execute(
"SELECT node, name, kind, node_type, snr, rssi, lat, lon, path, observed_at, "
"chan_hash, cipher_mac, crypted, payload_typename, dest, src, tag, trace_snrs "
"chan_hash, cipher_mac, crypted, payload_typename, dest, src, tag, trace_snrs, route "
"FROM observations WHERE kind = 'packet' AND observed_at >= ? "
"AND observed_at <= ? ORDER BY observed_at ASC LIMIT ?",
(start.isoformat(), end.isoformat(), limit),
+45 -6
View File
@@ -61,6 +61,12 @@ _DIRECT_WINDOW = timedelta(seconds=90)
#: midpoint between them would otherwise leave one of them nothing at all.
_MIN_HALF_WINDOW = timedelta(seconds=2)
#: Route types whose ``path`` field is a routing *instruction* rather than a record of
#: where the packet has been — the sender writes the route and the relays consume it. The
#: library names the header's two route bits (see its ``ROUTE_TYPENAMES``); the flooded
#: ones accumulate instead, which is the reading every path here used to get.
_ROUTED_TYPES = frozenset({"DIRECT", "TC_DIRECT"})
#: Frame classes that carry a direct (addressed) text message — the payload class the
#: meshcore library names, spelled exactly as it reports it (see
#: :data:`~meshterm.core.frames.ADDRESSED_CLASSES`, the packet viewer's lane, the
@@ -83,6 +89,13 @@ class Arrival:
snr: Reception SNR in dB — of the *last relay*, as with every packet row.
resend: The sender's resend counter for this copy (0 = the original send),
recovered from a decrypted channel frame; always 0 for direct frames.
routed: Whether the frame was **direct-routed** rather than flooded, which decides
what :attr:`hops` even means. A flooded packet accumulates its path — every
relay appends itself — so the hops are the route it travelled to reach us. A
direct-routed packet carries a route its sender wrote and its relays consume,
so the hops are where it was *going*, and an empty one means the route was used
up rather than that the packet arrived in a single leap. ``None`` for history
recorded before the route type was kept.
copies: How many logged frames this row stands for — always ``1`` as the matchers
produce them, and more once :func:`collapse` folds a path heard several times
into one row. A direct send is retried, and each retry is overheard off every
@@ -95,14 +108,32 @@ class Arrival:
hops: tuple[str, ...]
snr: Optional[float]
resend: int = 0
routed: Optional[bool] = None
copies: int = 1
@property
def route_known(self) -> bool:
"""Whether :attr:`hops` says anything about how this copy actually travelled.
False for a direct-routed frame carrying no path: its route was consumed on the way
and the field is empty because there is nothing left of it, not because the packet
crossed no relays. Drawing that as a zero-hop arrival claimed a neighbour we do not
have — the "impossible direct path" (JP, 2026-09-02).
"""
return bool(self.hops) or not self.routed
def _frame_hops(observation: Observation) -> tuple[str, ...]:
"""An observation's relay path as hop hashes (empty = direct)."""
"""An observation's path field as hop hashes (see :attr:`Arrival.routed` for what it means)."""
return tuple(h for h in (observation.path or "").split(",") if h)
def _frame_routed(raw: dict) -> Optional[bool]:
"""Whether a frame was direct-routed, or ``None`` where its route type wasn't kept."""
name = str(raw.get("route_typename") or "").upper()
return name in _ROUTED_TYPES if name and name != "UNK" else None
def _texts_match(wire: str, stored: str) -> bool:
"""Whether an on-air text and a stored chat text are the same message body.
@@ -164,6 +195,7 @@ def channel_arrivals(
hops=_frame_hops(frame),
snr=frame.snr,
resend=decrypted.attempt,
routed=_frame_routed(raw),
)
)
return arrivals
@@ -306,7 +338,10 @@ def direct_arrivals(
src, dest = _addressed(raw)
if (want_src and src != want_src) or (want_dest and dest != want_dest):
continue
arrival = Arrival(when=frame.observed_at, hops=_frame_hops(frame), snr=frame.snr)
arrival = Arrival(
when=frame.observed_at, hops=_frame_hops(frame), snr=frame.snr,
routed=_frame_routed(raw),
)
mac = str(raw.get("cipher_mac") or "").lower()
if mac:
groups.setdefault(mac, []).append(arrival)
@@ -336,16 +371,20 @@ def collapse(arrivals: Sequence[Arrival]) -> list[Arrival]:
One :class:`Arrival` per distinct path, in first-heard order, each carrying its
:attr:`~Arrival.copies` count.
"""
folded: dict[tuple[str, ...], Arrival] = {}
# Keyed on the route type as well as the hops: the same hashes mean two different
# things under the two types, so folding them together would merge a route travelled
# with a route intended.
folded: dict[tuple, Arrival] = {}
for arrival in arrivals:
seen = folded.get(arrival.hops)
key = (arrival.hops, arrival.routed)
seen = folded.get(key)
if seen is None:
folded[arrival.hops] = replace(arrival, copies=1)
folded[key] = replace(arrival, copies=1)
continue
best = seen.snr if arrival.snr is None else (
arrival.snr if seen.snr is None else max(seen.snr, arrival.snr)
)
folded[arrival.hops] = replace(seen, snr=best, copies=seen.copies + 1)
folded[key] = replace(seen, snr=best, copies=seen.copies + 1)
return list(folded.values())
+12 -4
View File
@@ -1264,11 +1264,18 @@ async def _make_paths_presenter(
if peer_key and self_key
else "direct frames are encrypted — matched by time alone"
)
# The graph's left endpoint: who the message set out from. Our own sends are
# us; an inbound channel message names its sender on the wire; a direct chat's
# origin is the conversation's peer (billed as time-matched by the summary).
# The path's two ends: who the message set out from, and who it was addressed to.
# Our own sends leave us for the peer; an inbound channel message names its sender
# on the wire and is addressed to everyone, so it lands on us; a direct chat's
# inbound origin is the conversation's peer.
destination: Optional[str] = self_name
if message.outbound:
source = self_name
# A channel broadcast is addressed to nobody in particular, and the copies we
# log are its rebroadcasts coming back — so it really does end on us. A direct
# send does not: it was going to one node, and that is where its route ends.
if not conversation.is_channel:
destination = conversation.label
elif conversation.is_channel:
source, _body = _split_channel_sender(message.text)
else:
@@ -1277,7 +1284,8 @@ async def _make_paths_presenter(
MessagePathsScreen(
message, arrivals, matched=matched, resolve=resolve,
prefix_bytes=prefix_bytes, self_name=self_name, summary=summary,
source=source or None, type_of=type_of, key_of=key_of,
source=source or None, destination=destination or None,
type_of=type_of, key_of=key_of,
)
)
+54 -10
View File
@@ -91,6 +91,7 @@ class MessagePathsScreen(Screen):
self_name: Optional[str],
summary: str,
source: Optional[str] = None,
destination: Optional[str] = None,
type_of: Optional[TypeOf] = None,
key_of: Optional["NameKeyResolver"] = None,
) -> None:
@@ -110,6 +111,11 @@ class MessagePathsScreen(Screen):
source: Display name of the message's origin — the sender parsed from a
channel message, us for an outbound one, the peer for a direct chat
(``None`` reads as an unknown ``?`` origin).
destination: Display name of the node the message was *addressed to* — the far
end for a message we sent, ourselves for one we received. It closes the
path line, so an outgoing message reads ``★ ▶ … ▶ Bob`` rather than
starting and ending on our own star, which is what made every send look
like a round trip (JP, 2026-09-02). ``None`` closes on our own ``★``.
type_of: Maps a relay hash to its node type, so the graph marks a repeater
``▲`` (etc.) instead of a generic dot; ``None`` keeps the plain dots.
key_of: Maps the origin's display name back to its node's key, so the
@@ -126,6 +132,7 @@ class MessagePathsScreen(Screen):
self._self_name = self_name
self._summary = summary
self._source = source
self._destination = destination
self._type_of = type_of
self._key_of = key_of
self._index = 0
@@ -207,12 +214,17 @@ class MessagePathsScreen(Screen):
# No blank line above the graph: its canvas already opens with air over the
# topmost lane, so a spacer here would read as two rows of margin.
lines.extend(self._graph_lines(width))
caption = Text("origin → you · white = selected path · labels = hash byte",
style="faint")
lines.append(render_to_ansi(caption, width, no_wrap=True))
lines.append(render_to_ansi(node_type_legend(), width, no_wrap=True))
lines.extend(self._revisit_line(width))
graph = self._graph_lines(width)
if graph:
lines.extend(graph)
far = "you" if not self._destination else self._destination
caption = Text(
f"origin → {far} · white = selected path · labels = hash byte",
style="faint",
)
lines.append(render_to_ansi(caption, width, no_wrap=True))
lines.append(render_to_ansi(node_type_legend(), width, no_wrap=True))
lines.extend(self._revisit_line(width))
lines.append("")
for i, arrival in enumerate(self._arrivals):
if i == self._index:
@@ -260,7 +272,25 @@ class MessagePathsScreen(Screen):
prefix_bytes=self._prefix_bytes, self_name=self._self_name,
hash_as_name=True,
).hops
return PathLine([self._origin_hop(), *relays, PathHop(SELF_GLYPH, you=True)]).text()
return PathLine([self._origin_hop(), *relays, self._far_hop()]).text()
def _far_hop(self) -> PathHop:
"""The node the path ends on — where the message was addressed, not always us.
The line used to close on our own ``★`` unconditionally, which is right for a
message we *received* and wrong for one we sent: with our star opening the line too
(:meth:`_origin_hop`), every outgoing message drew ``★ ▶ … ▶ ★`` and read as a round
trip. It is the same rule the line already follows at its head — a path runs between
the nodes it went *between* — applied at last to its tail.
"""
if not self._destination:
return PathHop(SELF_GLYPH, you=True)
if self._self_name and self._destination == self._self_name:
return PathHop(SELF_GLYPH, you=True)
return PathHop(
self._destination,
key=self._key_of(self._destination) if self._key_of else None,
)
def _origin_hop(self) -> PathHop:
"""The node the message set out from — the route's true head.
@@ -294,7 +324,17 @@ class MessagePathsScreen(Screen):
fill the list with a dozen identical lines. The SNR is the best that path managed,
which is what it is capable of.
"""
text = hops_atom(len(arrival.hops))
# What the hop count *is* depends on the route type, so the lane says which: a
# flooded frame's path is where it has been, a direct-routed one's is where it was
# going, and a routed frame carrying none has had its route consumed — which is not
# the same as having arrived in zero hops, however much an empty field looks like it.
if not arrival.route_known:
text = Text("routed", style="warn")
text.append(" · route not carried", style="muted")
else:
text = hops_atom(len(arrival.hops))
if arrival.routed:
text.append(" routed", style="muted")
text.append(" ")
text.append(arrival.when.astimezone().strftime("%H:%M:%S"), style="muted")
if arrival.copies > 1:
@@ -346,7 +386,9 @@ class MessagePathsScreen(Screen):
"""The distinct relay paths across the arrivals, in first-heard order."""
seen: list[tuple[str, ...]] = []
for arrival in self._arrivals:
if arrival.hops not in seen:
# A frame whose route was consumed has nothing to draw: an empty lane in the fan
# would be a claim of adjacency the frame never made.
if arrival.route_known and arrival.hops not in seen:
seen.append(arrival.hops)
return seen
@@ -369,6 +411,8 @@ class MessagePathsScreen(Screen):
"""
selected = self._arrivals[self._index].hops
paths = self._paths()
if not paths:
return []
layers = [
PathLayer(
hops=path,
@@ -380,7 +424,7 @@ class MessagePathsScreen(Screen):
]
glyph_of, label_of, label_rgb_of = route_graph_style(
resolve=self._resolve, self_name=self._self_name, source=self._source,
type_of=self._type_of, key_of=self._key_of,
destination=self._destination, type_of=self._type_of, key_of=self._key_of,
)
return render_path_graph(
layers, width,
+17 -5
View File
@@ -576,6 +576,7 @@ def route_graph_style(
resolve: NodeResolver,
self_name: Optional[str],
source: Optional[str],
destination: Optional[str] = None,
type_of: Optional[TypeOf] = None,
key_of: Optional[NameKeyResolver] = None,
) -> tuple[GlyphOf, LabelOf, LabelRgbOf]:
@@ -586,8 +587,13 @@ def route_graph_style(
plus the first byte of its hash, and each label takes its node's own name hue (us the
pure-white ``you``) so a byte reads as the mesh name it stands for. It maps the graph's
two endpoint sentinels — :data:`~meshterm.ui.pathgraph.SRC_NODE` on the left,
:data:`~meshterm.ui.pathgraph.DST_NODE` (always us) on the right — plus every relay
hash, to a glyph, a label, and a label colour.
:data:`~meshterm.ui.pathgraph.DST_NODE` on the right — plus every relay hash, to a
glyph, a label, and a label colour.
The right endpoint is *usually* us, and was once unconditionally so. That is right for
a route we walked or a message we received, and wrong for one we sent: with our own
name on both ends, every outgoing message's graph drew a round trip (JP, 2026-09-02).
``destination`` names it when it is somebody else.
Args:
resolve: Maps a relay's hash to a friendly name when one is known.
@@ -595,6 +601,9 @@ def route_graph_style(
source: The left endpoint's display name (a message's origin, or us for a walk
that starts at home — pass ``self_name`` to draw both ends as us). ``None``
reads as an unknown ``?`` origin.
destination: The right endpoint's display name, when the route does not end at us —
the recipient of a message we sent. ``None`` (the default) draws us, which is
what a walk and every received message want.
type_of: Maps a relay's hash to its node type, so a relay draws its own map marker
(``▲`` repeater, ``■`` room, ``◉`` sensor) in the shared palette instead of a
generic dot. ``None``, or a hash whose type it can't resolve, keeps the old
@@ -609,11 +618,12 @@ def route_graph_style(
:func:`~meshterm.ui.pathgraph.render_path_graph`.
"""
src_is_self = bool(source) and source == self_name
dst_is_self = not destination or destination == self_name
def glyph_of(node: str) -> tuple[str, str]:
"""Us a star, a typed relay its map marker, a named node a dot, else a ring."""
if node == DST_NODE:
return SELF_MARK
return SELF_MARK if dst_is_self else NODE_MARK
if node == SRC_NODE:
return SELF_MARK if src_is_self else (NODE_MARK if source else UNKNOWN_MARK)
if type_of is not None:
@@ -626,7 +636,7 @@ def route_graph_style(
def label_of(node: str) -> Optional[str]:
"""Endpoints by name, relays by their first hash byte."""
if node == DST_NODE:
return self_name or "you"
return (self_name or "you") if dst_is_self else destination
if node == SRC_NODE:
return source or "?"
return node[:2]
@@ -639,7 +649,9 @@ def route_graph_style(
resolves whatever ``glyph_of`` hands back, style name or hex alike.
"""
if node == DST_NODE:
return _SELF_RGB
if dst_is_self:
return _SELF_RGB
return _name_rgb(destination, key_of(destination) if key_of else None)
if node == SRC_NODE:
if src_is_self:
return _SELF_RGB
+66 -1
View File
@@ -114,7 +114,7 @@ def test_channel_arrivals_ignore_frames_outside_the_window(tmp_path: Path) -> No
repo.close()
def _direct_raw(dest: str = "", src: str = "", mac: str = "") -> dict:
def _direct_raw(dest: str = "", src: str = "", mac: str = "", route: str = "") -> dict:
"""A direct-message frame's raw payload, spelled as the meshcore library reports it."""
raw: dict = {"payload_typename": "TEXT_MSG"}
if dest:
@@ -123,6 +123,8 @@ def _direct_raw(dest: str = "", src: str = "", mac: str = "") -> dict:
raw["src_hash"] = src
if mac:
raw["cipher_mac"] = mac
if route:
raw["route_typename"] = route
return raw
@@ -280,3 +282,66 @@ def test_collapse_folds_a_repeated_path_into_one_counted_row(tmp_path: Path) ->
assert folded[0].when == base, "the first sighting is when the path first worked"
assert folded[0].snr == 13.5, "the best reading is what the path can do"
def test_a_routed_frames_path_is_where_it_was_going_not_where_it_has_been(
tmp_path: Path,
) -> None:
"""The route type decides what ``path`` means, and an empty routed one means nothing.
A flooded packet accumulates its path — every relay appends itself — so the hops are the
route it travelled to us. A direct-routed packet carries a route its sender wrote and
its relays consume, so an empty path means the route was used up, not that the packet
crossed no relays. Read the second as the first and a message from five hops away is
drawn as having arrived out of thin air: the "impossible direct path" (JP, 2026-09-02).
"""
repo, run = _repo(tmp_path)
now = utcnow()
_record_frame( # flooded, one relay: it really did come to us that way
repo, run, when=now + timedelta(seconds=1), path="3d63",
raw=_direct_raw(dest="a1", src="d4", mac="beef", route="FLOOD"),
)
_record_frame( # direct-routed, route consumed: says nothing about how it got here
repo, run, when=now + timedelta(seconds=2), path="",
raw=_direct_raw(dest="a1", src="d4", mac="beef", route="DIRECT"),
)
message = ChatMessage(text="hi", outbound=False, peer="d4e5f6a7", created_at=now)
arrivals, _exact = direct_arrivals(
repo, message, self_key="a1" + "0" * 62, peer_key="d4e5f6a7"
)
flooded, routed = arrivals
assert flooded.routed is False and flooded.route_known is True
assert routed.routed is True and routed.route_known is False, (
"an empty routed path is not a zero-hop arrival"
)
repo.close()
def test_history_without_a_route_type_is_unknown_rather_than_assumed(tmp_path: Path) -> None:
"""Frames recorded before the route type was kept read as before, not as guesses."""
repo, run = _repo(tmp_path)
now = utcnow()
_record_frame(
repo, run, when=now + timedelta(seconds=1), path="",
raw=_direct_raw(dest="a1", src="d4", mac="beef"),
)
message = ChatMessage(text="hi", outbound=False, peer="d4e5f6a7", created_at=now)
arrivals, _exact = direct_arrivals(
repo, message, self_key="a1" + "0" * 62, peer_key="d4e5f6a7"
)
assert arrivals[0].routed is None
assert arrivals[0].route_known is True, "unknown falls back to the old reading"
repo.close()
def test_collapse_keeps_a_routed_path_apart_from_the_same_hops_flooded(tmp_path: Path) -> None:
"""Identical hashes mean two different things under the two route types."""
from meshterm.services.message_paths import Arrival
base = utcnow()
folded = collapse([
Arrival(when=base, hops=("3d63",), snr=1.0, routed=False),
Arrival(when=base + timedelta(seconds=1), hops=("3d63",), snr=2.0, routed=True),
])
assert len(folded) == 2, "a route travelled is not a route intended"
assert [a.routed for a in folded] == [False, True]
+56
View File
@@ -273,3 +273,59 @@ def test_paths_screen_direct_arrival_and_empty_state() -> None:
body = _plain(empty.render_body(76))
assert "No direct-message frames logged in the window." in body
assert empty.footer_hint == "Esc close"
def test_an_outgoing_message_ends_on_its_recipient_not_on_us() -> None:
"""THE round-trip fix: our own sends stopped starting and ending on our own star.
The path line always closed on our ``★``, which is right for a message we received and
wrong for one we sent — with our star opening it too, every outgoing message drew
``★ ▶ … ▶ ★`` and read as having gone out and come back (JP, 2026-09-02). It is the same
rule the head already followed: a path runs between the nodes it went *between*.
"""
now = utcnow()
sent = ChatMessage(text="on my way", outbound=True, peer="d4e5", created_at=now)
screen = MessagePathsScreen(
sent, [Arrival(when=now, hops=("3d63",), snr=4.0)],
matched=True, resolve=_resolve, prefix_bytes=1, self_name="Homestead",
summary="heard once", source="Homestead", destination="Bob",
)
body = _plain(screen.render_body(72))
assert "YUL-Cartierville" in body
assert body.count("Homestead") == 1, "our name belongs at one end of a send, not both"
assert "Bob" in body, "the far end is the recipient"
# The caption names the same far end the line ends on.
assert "origin → Bob" in body
def test_a_received_message_still_ends_on_us() -> None:
"""The default is unchanged: what we receive does end at our own star."""
now = utcnow()
got = ChatMessage(text="on my way", outbound=False, peer="d4e5", created_at=now)
screen = MessagePathsScreen(
got, [Arrival(when=now, hops=("3d63",), snr=4.0)],
matched=True, resolve=_resolve, prefix_bytes=1, self_name="Homestead",
summary="heard once", source="Alice",
)
body = _plain(screen.render_body(72))
assert "Alice" in body and "Homestead" in body
assert "origin → you" in body
def test_a_routed_frame_with_no_path_draws_no_graph_and_says_why() -> None:
"""An empty routed path is not a zero-hop arrival, and must not be drawn as one.
Its route was consumed on the way, so there is nothing to put in the fan — an empty lane
would be a claim of adjacency the frame never made — and the row says so in words rather
than showing a confident ``0 hops``.
"""
now = utcnow()
got = ChatMessage(text="on my way", outbound=False, peer="d4e5", created_at=now)
screen = MessagePathsScreen(
got, [Arrival(when=now, hops=(), snr=4.0, routed=True)],
matched=True, resolve=_resolve, prefix_bytes=1, self_name="Homestead",
summary="heard once", source="Alice",
)
body = _plain(screen.render_body(72))
assert "route not carried" in body
assert "origin →" not in body, "no graph, so nothing for the caption to label"