fix(roomlog): self means this device, not this account (#94)

Closes #93, found during the first live session of an agent following a
room.

An agent and the person it works for share one Matrix account. `self`
compared the sender to the configured `user_id`, so it was true for both
of them:

```json
{"seq": 6, "type": "m.text",   "sender": "@user:example.org", "self": true, "text": "… hey, claude? liest du mit?"}
{"seq": 7, "type": "reaction", "sender": "@user:example.org", "self": true, "text": "… reacted 👀"}
```

One of those is the human, one is the agent, and the flag that exists to
tell them apart says the same thing about both.

## Why it is not cosmetic

The flag is what an agent uses to avoid answering itself. As it stood:

- trusting it means ignoring the person addressing you
- ignoring it means answering yourself, which with autonomous replies
enabled is a loop with a homeserver in it

Neither shows up in a quiet room.

## The fix

A decrypted event carries `sender_key`, the curve25519 key of the
*device* that encrypted it, and the daemon knows its own via
`client.olm.account.identity_keys["curve25519"]`. `self` is now that
comparison.

An unencrypted room carries no `sender_key`. There the account
comparison is the only answer available, so the record also carries
`self_basis` — `"device"` or `"account"` — and a caller can tell which
question was actually answered instead of assuming the stronger one.

Own-device lines render as `Name (agent)`. The log is read by the agent
that wrote part of it, and same account means same display name.

## Verification

6 new tests, 41 in the file, including the two that carry the change:
the human's device on the same account is **not** self, and a missing
`sender_key` falls back to the account while saying so.

Live, against a running daemon in `#test`:

```json
{"seq": 3, "self": true, "self_basis": "device", "text": "[11:25] Sebastian Mendel (agent): 🤖 Prüfung: erkennt der Log jetzt sein eigenes Gerät?"}
```

**The negative case is covered by tests only.** Confirming it live needs
a message typed from the human's own device while the fixed daemon runs,
which this session could not produce on its own. Saying so rather than
implying the live check covered both.

Author: CybotTM

skills/matrix-communication/scripts/_lib/roomlog.py

@@ -57,6 +57,11 @@ def render_text(record: dict) -> str:
     when = datetime.fromtimestamp(record["ts"] / 1000, tz=timezone.utc).astimezone()
     stamp = when.strftime("%H:%M")
     who = record.get("sender_display") or record["sender"]
+    if record.get("self") and record.get("self_basis") == "device":
+        # The log is read by the agent that wrote part of it. Without this the
+        # agent's own lines are indistinguishable from its human's, because the
+        # account and therefore the display name are the same.
+        who = f"{who} (agent)"
     body = " ".join((record.get("body") or "").split())
 
     if record["type"] == "encrypted":
@@ -74,8 +79,34 @@ def render_text(record: dict) -> str:
     return f"[{stamp}] {who}: {prefix}{body}"
 
 
-def build_record(*, seq: int, event: dict, own_user_id: str, own_display_name) -> dict:
+def _is_own_device(event: dict, own_user_id: str, own_sender_key) -> tuple[bool, str]:
+    """Did THIS device send the event, and on what evidence.
+
+    An agent and the person it works for share one Matrix account, so comparing
+    the sender is not enough: it marks the human's messages as the agent's own.
+    An agent that then skips "its own" messages skips the person addressing it,
+    and one that does not can answer itself.
+
+    A decrypted event carries `sender_key`, the curve25519 key of the device
+    that encrypted it, and that is the answer. An unencrypted room has no such
+    key; the account comparison is then all there is, and the second return
+    value says which of the two was possible so a caller never mistakes one for
+    the other.
+    """
+    if event["sender"] != own_user_id:
+        return False, "device" if event.get(
+            "sender_key"
+        ) and own_sender_key else "account"
+    if event.get("sender_key") and own_sender_key:
+        return event["sender_key"] == own_sender_key, "device"
+    return True, "account"
+
+
+def build_record(
+    *, seq: int, event: dict, own_user_id: str, own_display_name, own_sender_key=None
+) -> dict:
     """One log record from one event."""
+    is_self, basis = _is_own_device(event, own_user_id, own_sender_key)
     record = {
         "seq": seq,
         "ts": event["ts"],
@@ -87,7 +118,8 @@ def build_record(*, seq: int, event: dict, own_user_id: str, own_display_name) -
         "body": event.get("body"),
         "reply_to": event.get("reply_to"),
         "thread_root": event.get("thread_root"),
-        "self": event["sender"] == own_user_id,
+        "self": is_self,
+        "self_basis": basis,
         "mentions_me": _mentions(event.get("body"), own_user_id, own_display_name),
     }
     if event.get("session_id"):

skills/matrix-communication/scripts/_lib/test_roomlog.py

@@ -301,5 +301,80 @@ def test_rewriting_the_bundle_does_not_duplicate_entries(self):
         self.assertNotIn("(b_example.org.md)", text)
 
 
+class SelfIsTheDeviceTests(unittest.TestCase):
+    """`self` has to mean "this device", not "this account".
+
+    Regression for #93: an agent and the person it works for share one Matrix
+    account, so comparing the sender alone marks the human's messages as the
+    agent's own. An agent that skips its own messages then skips the person
+    addressing it; one that does not risks answering itself.
+    """
+
+    MINE = "curve25519-of-my-device"
+    THEIRS = "curve25519-of-their-element"
+    USER = "@shared:example.org"
+
+    def _record(self, sender_key, **extra):
+        return build_record(
+            seq=1,
+            event={**EVENT, "sender": self.USER, "sender_key": sender_key, **extra},
+            own_user_id=self.USER,
+            own_display_name=None,
+            own_sender_key=self.MINE,
+        )
+
+    def test_our_own_device_is_self(self):
+        rec = self._record(self.MINE)
+        self.assertTrue(rec["self"])
+        self.assertEqual(rec["self_basis"], "device")
+
+    def test_the_humans_device_on_the_same_account_is_not_self(self):
+        rec = self._record(self.THEIRS)
+        self.assertFalse(rec["self"])
+        self.assertEqual(rec["self_basis"], "device")
+
+    def test_another_account_is_never_self(self):
+        rec = build_record(
+            seq=1,
+            event={**EVENT, "sender": "@someone:example.org", "sender_key": self.MINE},
+            own_user_id=self.USER,
+            own_display_name=None,
+            own_sender_key=self.MINE,
+        )
+        self.assertFalse(rec["self"])
+
+    def test_without_a_sender_key_it_falls_back_to_the_account_and_says_so(self):
+        """An unencrypted room carries no sender_key. The account comparison is
+        then the only answer available, and the record must not pretend it is
+        the device one."""
+        rec = build_record(
+            seq=1,
+            event={**EVENT, "sender": self.USER},
+            own_user_id=self.USER,
+            own_display_name=None,
+            own_sender_key=self.MINE,
+        )
+        self.assertTrue(rec["self"])
+        self.assertEqual(rec["self_basis"], "account")
+
+    def test_without_our_own_key_it_falls_back_too(self):
+        rec = build_record(
+            seq=1,
+            event={**EVENT, "sender": self.USER, "sender_key": self.THEIRS},
+            own_user_id=self.USER,
+            own_display_name=None,
+            own_sender_key=None,
+        )
+        self.assertTrue(rec["self"])
+        self.assertEqual(rec["self_basis"], "account")
+
+    def test_own_device_lines_are_marked_in_the_text(self):
+        """The log is read by the agent that wrote half of it."""
+        mine = self._record(self.MINE)
+        theirs = self._record(self.THEIRS)
+        self.assertIn("(agent)", mine["text"])
+        self.assertNotIn("(agent)", theirs["text"])
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

skills/matrix-communication/scripts/matrix-watchd.py

@@ -122,6 +122,10 @@ def event_to_dict(room, event) -> dict | None:
         else None,
         "ts": getattr(event, "server_timestamp", None) or int(time.time() * 1000),
         "room_id": room.room_id,
+        # The curve25519 key of the device that encrypted this, which is the
+        # only thing that distinguishes our own messages from our human's -
+        # they share the account. Absent in an unencrypted room.
+        "sender_key": getattr(event, "sender_key", None),
     }
     if not base["event_id"] or not base["sender"]:
         return None
@@ -167,6 +171,7 @@ def __init__(self, config: dict, credentials: dict):
         self.started = time.time()
         self.last_sync = None
         self.display_name = None
+        self.own_sender_key = None
         self.stopping = asyncio.Event()
         self.next_seq_by_room = {}
 
@@ -194,6 +199,7 @@ def record_event(self, room_id: str, event_dict: dict) -> None:
             event=event_dict,
             own_user_id=self.credentials["user_id"],
             own_display_name=self.display_name,
+            own_sender_key=self.own_sender_key,
         )
         append_record(path, record)
         self.next_seq_by_room[room_id] = seq + 1
@@ -377,6 +383,12 @@ async def run(self) -> int:
         name = await self.client.get_displayname()
         self.display_name = getattr(name, "displayname", None)
 
+        # Our own device's curve25519 key, read once. Without it every record
+        # falls back to the account comparison, which cannot tell this device
+        # from the human's on the same account.
+        if self.client.olm:
+            self.own_sender_key = self.client.olm.account.identity_keys["curve25519"]
+
         await self.resolve_rooms()
         self.client.add_event_callback(self.on_event, object)