Discord: log node-reported stream state; remove a radio channel or a server

- handle_actual logs every node-reported state TRANSITION (not heartbeats)
  with stream/node/guild/channel/token ids and the node's error text: info
  for connected/connecting/stopped, warning for error, and a dedicated
  "radio bot X failed to log in on node N: <reason>" line for login_failed.
  The node's reason code is now stored in actual.code and shown next to the
  error on Settings > Discord and the node page.
- Remove a radio channel permanently: streams.delete_stream stops it through
  desired state first (node republished without it, token -> releasing per
  #216, freed on the node's ack), then deletes the doc in a transaction that
  refuses if the channel was restarted in between. DELETE
  /discord/streams/{id} (platform admin) and DELETE
  /discord/nodes/{node}/streams/{id} (admin or org owner, same org + node
  only; operators can still stop, not remove). Audited.
- Remove a server: DELETE /discord/guilds/{id} (admin) deletes every radio
  channel in it the same way, then tombstones discord_guilds (org_id None +
  unlinked_at, #218 semantics, plus removed_at) so it never falls back to
  DISCORD_UNLINKED_GUILD_ORG_ID; the admin page hides it, and /drb link or the
  admin link brings it back. Optional leave_radio_bots makes pool bots and the
  server's org's own BYO bots leave via Discord REST; the DRB server bot stays
  until kicked, and the UI says so. Audited.
- UI: Remove (with confirm) on Radio channels, Servers and the node page list.

Refs #213, #221

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

drb-c2-core/app/internal/discord_leases.py

@@ -257,6 +257,30 @@ async def detach_stream(stream_id: str, stream_updates: Optional[dict] = None) -
     return await fstore.run_transaction(_txn)
 
 
+async def delete_stopped_stream(stream_id: str) -> bool:
+    """Delete a stream doc, but only while it is stopped and holds no token.
+
+    True when the doc is gone (deleted now, or already absent). False when it
+    is desired-on again or names a token — a concurrent start re-leased it,
+    and deleting it would leave that token's lease listing a stream nobody can
+    stop. ``lease_for_stream`` writes the stream doc in its own transaction,
+    so reading it here is enough to serialise against it."""
+    db = fstore.db
+
+    def _txn(txn):
+        ref = db.collection(STREAMS).document(stream_id)
+        snap = ref.get(transaction=txn)
+        if not snap.exists:
+            return True
+        stream = snap.to_dict() or {}
+        if stream.get("desired") == "on" or stream.get("token_id"):
+            return False
+        txn.delete(ref)
+        return True
+
+    return await fstore.run_transaction(_txn)
+
+
 async def stamp_release_seq(node_id: str, seq: int) -> None:
     """Record the desired-state version that dropped each releasing token, so a
     stale actual report (from before the node saw the drop) can never free it."""
@@ -411,3 +435,42 @@ async def refresh_membership(token_ids: list[str]) -> int:
             changed += 1
         await fstore.doc_update(TOKENS, tok_id, updates)
     return changed
+
+
+async def leave_guild(guild_id: str, org_id: Optional[str]) -> list[dict]:
+    """Make the radio bots DRB holds tokens for leave one Discord server
+    (Discord REST ``DELETE /users/@me/guilds/{id}``, the bot's own token).
+
+    Only platform-pool bots and ``org_id``'s own BYO bots — never another
+    org's branded bot. Bots whose cached membership says they are not in the
+    server are skipped; unknown membership is tried (404 = not a member).
+    The DRB *server* bot (the discord-bot service) is not in this pool, so it
+    stays in the server until someone kicks it. Returns one row per bot tried:
+    ``{token_id, name, left, error}``. Never raises for a Discord failure."""
+    import httpx
+    guild_id = str(guild_id)
+    out: list[dict] = []
+    for tok in await fstore.collection_list(TOKENS):
+        tok_id = tok.get("token_id")
+        if not tok_id or not tok.get("token"):
+            continue
+        if tok.get("org_id") is not None and tok.get("org_id") != org_id:
+            continue
+        members = tok.get("guild_ids")
+        if members is not None and guild_id not in members:
+            continue
+        row = {"token_id": tok_id, "name": tok.get("name") or tok_id, "left": False, "error": None}
+        try:
+            async with httpx.AsyncClient(timeout=10, base_url=DISCORD_API,
+                                         headers={"Authorization": f"Bot {tok['token']}"}) as client:
+                r = await client.delete(f"/users/@me/guilds/{guild_id}")
+            if r.status_code in (200, 204, 404):     # 404: Unknown Guild — not a member
+                row["left"] = True
+            else:
+                row["error"] = f"Discord answered {r.status_code}"
+        except Exception as e:  # network — report, do not fail the removal
+            row["error"] = str(e)[:200]
+        if row["left"] and members is not None:
+            await fstore.doc_update(TOKENS, tok_id, {"guild_ids": [g for g in members if g != guild_id]})
+        out.append(row)
+    return out