Merge pull request 'Container TZ: Europe/Warsaw so cron hours are local (v0.21.10)' (#53) from fix/tz-warsaw into main

Owner request: 'now add #help with short list of all command'. Registered in
the CommandService constructor next to #ping; returns a SINGLE multi-line
string (one packet, ~203 chars) — not an array, which would drip-feed one
spaced packet per line through the v0.21.5 MESH_MULTI_SEND_DELAY_MS loop.

Also hardened the v0.21.5 multi-send-spacing spec: its wall-clock assertion
('first send < 8 ms after t0') flaked under full-suite load — replaced with
fake timers, which assert deterministically that line 1 is out before any time
elapses and lines 2-3 land exactly one delay apart.

AGENTS.md

@@ -12,7 +12,7 @@
 ## Verification
 
 1. **Local checks** — `npm run build` (nest build) and `npm test` (vitest; no e2e suite yet). Both must pass before a PR is opened.
-2. **Docker** — `docker compose build`, then after `docker compose up -d`: `curl -s -H "Host: bot.dev.kkhost.pl" http://localhost/api/status` returns JSON (`{ connected, myNodeNum, host, port }`). `"connected":false` is normal while the bridge/device is down — the service retries every 5 s.
+2. **Docker** — `docker compose build`, then after `docker compose up -d`: `curl -s -H "Host: bot.dev.kkhost.pl" http://localhost/api/status` returns JSON (`{ connected, myNodeNum, host, port }`). `"connected":false` is normal while the bridge/device is down — the service retries every 5 s. An idle watchdog also force-reconnects an ESTABLISHED-but-silent connection (zombie bridge: outbound works, inbound dead) when no DECODED FRAME arrives from the bridge for `MESH_IDLE_TIMEOUT_MS` ms (default 60000 = 1 min; checked every 30 s — raw non-frame bytes do NOT count), an undecoded frame buffer over `MESH_MAX_FRAME_BUFFER` bytes (default 256000) forces a reconnect as a stream-desync backstop, and the socket has TCP keepalive enabled (30 s). A lazy periodic autoreconnect additionally unconditionally re-establishes every `MESH_RECONNECT_INTERVAL_MS` ms (default 300000 = 5 min) for a fresh sync.
 
 ## API
 
@@ -27,4 +27,5 @@
 
 - MESHTASTIC.md — rules for Meshtastic communication (owner authority, language, response protocol); read before acting on mesh messages.
 - Hourly cron weather report job (`src/weather`): fetches Open-Meteo current conditions and broadcasts a one-line report to the mesh on the pinned send channel; env `WEATHER_CRON`/`WEATHER_LAT`/`WEATHER_LON`/`WEATHER_CITY`.
-- Channel-2 auto-responder (`src/commands`): event-driven — `CommandService.onRx()` is called by `MeshService` for every decoded rx text (right after the notify gate) and dispatches exact, case-sensitive `#command` matches on `COMMAND_CHANNEL` (env, default 2) through a single-registration-point registry (handlers registered in the constructor via `register(name, fn)`; handler gets `{ text, from?, id? }`, returns reply string or void = no reply). First command: `#ping` → replies `#pong!`. Replies ride `COMMAND_CHANNEL`: directed DM back to the sender when present, else broadcast. A failing handler/send only logs a warn. DI: provided by `CommandModule`'s factory (injects `MeshService`, attaches itself via `attachCommands()`) — no constructor-level cycle; `forwardRef` was tried and left one side null in NestJS 12's injector.
+- Channel-2 auto-responder (`src/commands`): event-driven — `CommandService.onRx()` is called by `MeshService` for every decoded rx text (right after the notify gate) and dispatches exact, case-sensitive `#command` matches on `COMMAND_CHANNEL` (env, default 2) through a single-registration-point registry (handlers registered in the constructor via `register(name, fn)`; handler gets `{ text, from?, id? }`, returns a reply string — or an array of lines, sent as one message per line through the same routing, spaced `MESH_MULTI_SEND_DELAY_MS` ms apart (default 5000) so each packet has time to land in RF — or void = no reply). First commands: `#ping` → replies `#pong!`; `#loser` → worst packet delivery record over directed sends only (groups our own tx history by destination, counts delivered vs failed per node; broadcasts excluded — firmware strips want_ack so they stay pending and the broadcast addr is never a real destination; loser = most failures, tie-break worse failure ratio; destination resolved to long/short name with `@!xxxxxxxx` mention fallback when unknown; three reply shapes: `worst delivery: <name> (@!hex) - N failed / M delivered`, "no failed sends yet", or "not enough data yet" explaining only directed sends count); `#help` → short single-message list of all available commands. Replies go through `MeshService.respond(id, reply)`: auto-routed (rx → DM back to the original sender unless the original was a broadcast; tx → its destination), riding the original record's channel with `replyId = id` so the recipient app renders it as a threaded quote — `COMMAND_CHANNEL` is only the trigger/listen gate. Only when the trigger has no packet id does it fall back to legacy sendText routing on `COMMAND_CHANNEL`. A failing handler/respond only logs a warn. DI: provided by `CommandModule`'s factory (injects `MeshService`, attaches itself via `attachCommands()`) — no constructor-level cycle; `forwardRef` was tried and left one side null in NestJS 12's injector. Prefix dispatch (`registerPrefix(name, fn)`) lets one handler own a whole family: the `#rss` subcommands live in `src/rss` (`RssService.handle`, registered as prefix `'rss'` from the CommandModule factory — exact matches still win over prefixes). Subcommands: `#rss help`; `#rss add <url> <name>` (validates URL, fetches with 15 s timeout, requires ≥1 titled item, rejects duplicate names case-insensitively; LLM generates 2-4 lowercase tags from up to 8 latest titles — on LLM failure the source is added with empty tags and the reply says so); `#rss remove <name>`; `#rss tags` (all distinct tags); `#rss sources`; `#rss get <name|#tag>` (LLM headline summary as 3-5 SEPARATE mesh messages: prompt asks for exactly 3-5 lines, one item per line, `<short header>: <one or two short sentences>` with ≤20-char header, no intro/outro/numbering; reply parsed into items — drop empty/separator-less lines, cap at 5, fewer than 3 → send what we got (no retry), zero → no message; each item sent via its own respond() threaded to the trigger packet id, per-line backstop `fitOneLine()` hard-cuts >185-char lines at a word boundary near 180 so every item fits one packet; maxTokens 2500 is headroom because the LLM server's reasoning tokens count against it — see rss.service.ts comment; `#tag` collects items across ALL sources carrying that tag — one dead feed does not sink the summary). Storage: `rss_sources(name TEXT PRIMARY KEY, url, tags, created_at)` table in the EXISTING MESH_DB_PATH file via a second node:sqlite connection (names matched case-insensitively); feed parsing via `fast-xml-parser` (RSS 2.0 + Atom; malformed/no-items → "not a valid feed"); LLM via injected `LlmService.chat()` with explicit maxTokens (50 tags / 2500 summary headroom).
+- LLM client (`src/llm`): `LlmService` wraps the local OpenAI-compatible server (default `http://192.168.1.70:1111/v1`, no auth) with native fetch — plain feature module, no Mesh/Schedule dependency. Methods: `listModels()` → `data[].id`; `chat(messages, { maxTokens?, temperature? })` → `choices[0].message.content` (non-2xx throws with status + body snippet); `summarize(text)` = chat() with system prompt "Summarize the following text concisely." Env: `LLM_API_BASE`, `LLM_MODEL` (default `qwen3.8-27b`), `LLM_TIMEOUT_MS` (default 180000, via `AbortSignal.timeout`).

CHANGELOG.md

@@ -1,5 +1,96 @@
 # Changelog
 
+## v0.21.10 — 2026-09-30 05:46
+
+- Container now runs with `TZ=Europe/Warsaw` (new line in the bot service's `environment:` block, hardcoded like MESH_HOST/MESH_PORT): scheduled jobs and log timestamps use local Polish time instead of UTC — the weather cron (`WEATHER_CRON=0 6,12,18 * * *`) previously fired at 06/12/18 UTC = 08/14/20 CEST. DST-aware via the IANA zone (CEST +2 / CET +1). Deployment-config only — no application code changed; takes effect on the next `docker compose up -d --build`.
+
+## v0.21.9 — 2026-09-29 20:56
+
+- New `#loser` command (owner request): replies with which user/node has the worst packet delivery record, over directed sends only. Meshtastic shares no mesh-wide loss stats, so it groups our own tx history by destination and counts delivered vs failed per node; broadcasts are excluded (firmware strips want_ack pre-TX, they stay pending — and the broadcast addr is never a real destination even if a NACK lands on it). Loser = most failures, tie-break worse failure ratio. Node resolved to `longName`/`shortName`, falling back to the `@!xxxxxxxx` mention when unknown. Three reply shapes: worst delivery line (`worst delivery: <name> (@!hex) - N failed / M delivered`), a "no failed sends yet" line, and a "not enough data yet — only directed sends count (broadcasts have no acks)" line. Registered in the CommandService constructor next to `#ping`; listed in `#help`.
+- Tests: 175 → 180 — new `#loser` specs cover all three reply cases, broadcast/pending exclusion, the unknown-node `@!hex` fallback, and the failure-ratio tie-break; the `#help` spec now also asserts `#loser` is listed.
+
+## v0.21.8 — 2026-09-27 07:13
+
+- Fixed `npm test` exiting 1 with "Errors 2" even though all tests pass (every CI run red since v0.21.2): the two watchdog specs that force a reconnect destroy the service's socket while data is still pending in its receive buffer (the overflow spec floods 300 KB and destroys on the first ~64 KB chunk; the garbage spec destroys right after its last write), so the kernel sends RST instead of FIN and the fake bridge's accepted server-side sockets emit `read ECONNRESET`. Those test-owned sockets had no `'error'` handler, so Node threw it as an uncaught exception that vitest counts as a run-level failure. `startBridge()` now attaches a no-op `'error'` handler to every accepted socket (single registration point, covers all four spec files using the fake bridge). Test-only change — `fake-bridge.ts` is imported by specs only; no runtime diff, no deploy needed.
+
+## v0.21.7 — 2026-09-27 06:50
+
+- Fixed double registration of scheduled jobs: `ScheduleModule.forRoot()` was called from both `WeatherModule` and `BatteryAlertModule`, so Nest created two ScheduleExplorers, each scanning all providers — every @Cron/@Interval job (hourly weather broadcast, per-minute battery check) fired twice. Removed the call from `battery.module.ts`; the single registration in `weather.module.ts` remains.
+- Tests: 174 → 175 — new regression spec (`src/schedule-singleton.spec.ts`) asserts `ScheduleModule.forRoot(` appears exactly once across all `src/**/*.module.ts`.
+
+## v0.21.6 — 2026-09-26 10:37
+
+- New `#help` command (owner request): replies with a short list of all available commands as ONE multi-line message (single packet, not one spaced packet per line) — `#ping`, the `#rss help/add/remove/get/sources/tags` family. Registered in the CommandService constructor next to `#ping`.
+- Tests: 173 → 174 — `#help` dispatches through respond() exactly once with text containing both `#ping` and `#rss`. (Also hardened the v0.21.5 multi-send-spacing spec, which flaked under full-suite load: it now uses fake timers to assert deterministically that line 1 goes out before any time elapses and lines 2-3 land exactly one delay apart.)
+
+## v0.21.5 — 2026-09-26 10:26
+
+- Multi-line command replies are now spaced apart: `CommandService.onRx` waits `MESH_MULTI_SEND_DELAY_MS` (new env, default **5000** = 5 s, read at construction) between consecutive lines of an array reply — no delay before the first line. Production incident: `#rss get lublin` sent its items back-to-back within the same second and 3 of 4 were dropped in RF (the owner saw only the last one); each packet now gets time to land.
+- Tests: 172 → 173 — a 3-line reply with an overridden short delay asserts all lines are sent, the first goes out immediately (no pre-delay), and each subsequent line lands ≥ the configured gap after the previous one; existing specs pin `MESH_MULTI_SEND_DELAY_MS=0` in `beforeEach` so they stay fast.
+
+## v0.21.4 — 2026-09-26 09:51
+
+- `LLM_TIMEOUT_MS` default raised from 60000 (60 s) to **180000** (3 min): production incident — `#rss get lublin` at 9:41 AM failed with "The operation was aborted due to timeout" because the local OpenAI-compatible server (qwen3.8-27b, uncontrollable reasoning tokens) was slow/busy on that call; the same endpoint answers a trivial prompt in ~1 s when idle, so this is latency variance, not a dead endpoint. Still env-overridable (`LLM_TIMEOUT_MS`), only the fallback changed.
+
+## v0.21.3 — 2026-09-26 09:31
+
+- Idle timeout default lowered from 10 min to **1 min** (`MESH_IDLE_TIMEOUT_MS` fallback `600000` → `60000`) — the v0.21.2 frame-based watchdog works in production (it fired today and the reconnect delivered queued packets), but the bridge/radio side at 192.168.1.4 keeps killing inbound RX within ~20 min of a fresh sync, so a shorter detection window is wanted.
+- New **lazy periodic autoreconnect**: `MESH_RECONNECT_INTERVAL_MS` (new env, default **300000** = 5 min, read at construction) — an interval that unconditionally logs ("periodic reconnect — MESH_RECONNECT_INTERVAL_MS elapsed") and destroys the socket so the existing close→scheduleReconnect loop re-establishes with a fresh sync on schedule. When not connected at tick time, destroy is a no-op and the retry loop owns recovery (no special-casing). Started in `onModuleInit`, cleared in `onModuleDestroy`.
+- Tests: 171 → 172 — periodic reconnect observed end-to-end with an overridden short interval (fake bridge disconnect + re-establish); existing watchdog tests pass unchanged, comments updated to the new 60 s default.
+
+## v0.21.2 — 2026-09-26 08:47
+
+- Idle watchdog now tracks DECODED FRAMES, not raw bytes (fixes a second production zombie that slipped past v0.21.1): text+telemetry RX was dead for >1 h while TX worked and the watchdog never fired — /proc/net/snmp showed InSegs delta = 2 segments per 30 s, i.e. the bridge peer keeps dribbling small NON-frame bytes (~every 15 s) that kept resetting `lastPacketAt` on every socket chunk even though zero valid Meshtastic frames decoded. The `'data'` handler no longer updates `lastPacketAt` per chunk; it is updated only when `extractFrames` yields ≥1 valid packet (the reset in the `'connect'` handler is unchanged), so a stream that decodes nothing trips the watchdog after `MESH_IDLE_TIMEOUT_MS` even while raw bytes keep arriving.
+- Buffer-overflow backstop: if the undecoded frame buffer exceeds `MESH_MAX_FRAME_BUFFER` (new env, default **256000** = 250 KB) the service logs ERROR ("frame buffer overflow — stream desync, forcing reconnect") and destroys the socket → existing close→scheduleReconnect self-heals a desynced stream. The undecoded buffer is also reset on every (re)connect so leftover garbage from a dead session can't re-trigger the backstop or corrupt the first frames of a healthy new stream.
+- Tests: 169 → 171 — raw non-frame bytes do NOT keep the watchdog alive (garbage-only stream forces disconnect + reconnect, exactly today's incident shape), and an undecoded chunk over `MESH_MAX_FRAME_BUFFER` triggers destroy + a fresh session that decodes normally. The existing valid-frames-reset-the-clock test now exercises frame-based tracking unchanged.
+
+## v0.21.1 — 2026-09-26 06:47
+
+- Bridge zombie-connection fix (production incident: outbound sends kept working ~10 h while inbound packets stopped entirely and `/api/status` stayed `connected:true`). New **idle watchdog**: the service tracks `lastPacketAt`, updated on EVERY chunk received from the bridge in the lowest-level socket `'data'` path (any frame kind, decodable or not) and reset when a connection successfully starts. A 30 s interval checks: if connected AND no inbound traffic for `MESH_IDLE_TIMEOUT_MS` (new env, default **600000** = 10 min), it logs WARN ("no bridge traffic for X ms — forcing reconnect") and destroys the socket — the EXISTING connect/retry loop (`MESH_RECONNECT_MS`) then re-establishes with a fresh sync. No changes to connect-error retry/backoff behavior; this only adds detection for established-but-silent connections.
+- TCP keepalive on the bridge socket: `socket.setKeepAlive(true, 30_000)` — cheap insurance against dead peers at the TCP level, complementing the application-level watchdog.
+- Tests: 165 → 169 — silence past an overridden timeout forces disconnect + reconnect (fake bridge), inbound traffic keeps resetting the idle clock so no false trigger, default timeout does not fire in a test window, and `setKeepAlive(true, 30_000)` is asserted on the socket.
+
+## v0.21.0 — 2026-09-25 19:59
+
+- `#rss get <name|#tag>` now replies with **3–5 SEPARATE mesh messages** instead of one small summary (owner request: the single-message summary was too small). Each item is its own packet, so no fragmentation — and each rides the trigger's channel threaded as a quote of the command packet.
+- New summarizer prompt asks for exactly 3-5 lines, one item per line, format `<short header>: <one or two short sentences>` with a ≤20-char header (e.g. `Culture: Museum opens new wing`), no intro/outro/numbering. maxTokens stays 2500 (reasoning-token headroom — see v0.20.1).
+- The LLM reply is parsed into items: split on newlines, trim, drop empty lines and lines without a `:` header separator, cap at 5. Fewer than 3 valid lines → send what we got (no failure, no retry — the model is non-deterministic); zero valid lines → no message sent.
+- Per-item backstop replaces the old whole-reply cut: any single line >185 chars is hard-cut at a word boundary near 180 (`fitOneLine`), so every item fits one packet even if the model ignores the prompt. `fitOnePacket()` (whole-reply ≤190) is gone — it no longer applies to joined text.
+- CommandService now sends array replies line by line: each element goes through the same routing as a single reply (`respond(id, line)` threaded to the trigger packet id; legacy sendText fallback per line when there is no packet id). A failing send stops the remaining lines (warn log), like any failed command.
+- LLM failure path unchanged: single `summary failed` reply via respond(). `#rss get #tag` gets the same multi-message treatment automatically (shared summary path — covered by tests). All other subcommands unchanged.
+- Tests: 158 → 165 — prompt shape + maxTokens asserted on the new call, 5-item cap, invalid-line filtering, fewer-than-3 fallback, per-line over-length cut through `handle()`, direct `parseSummaryItems`/`fitOneLine` specs, and CommandService array-reply routing (threaded respond ×N to one packet id; legacy sendText fallback).
+
+## v0.20.1 — 2026-09-25 19:20
+
+- `#rss get` summaries now fit ONE mesh packet (≤190 chars). Mesh fragments longer replies into fire-and-forget packets that recipients frequently never receive, and the old prompt ("a few short one-line highlights") produced ~326-334 char replies.
+- The summary prompt now asks for "at most 3 short bullet lines, each under 45 characters … bullets only - no intro, no other text" (verified against the live LLM: exactly 3 compliant bullets, ~110 chars). A `fitOnePacket()` backstop additionally cuts any over-length reply at complete-bullet boundaries so delivery is one packet even if the model ignores the prompt.
+- The summary `chat()` call now uses an explicit `maxTokens = 2500` (was 200). Empirically verified on this server: qwen3.8-27b emits `reasoning_content` and those tokens COUNT against max_tokens (cap 150 → completion_tokens 150, of which 105 were reasoning, finish_reason 'length'; a cap of 500 was fully consumed by reasoning with zero visible content). Thinking length for this task is unbounded and uncontrollable server-side (`/no_think`, `chat_template_kwargs.enable_thinking` and `thinking_budget` are all ignored) — observed 32..1776 tokens across runs. 2500 covers every observed run plus ~80 content tokens, and keeps the worst case (~42 s at ~60 tok/s) under the 60 s LLM timeout. The old cap of 200 guaranteed empty replies whenever reasoning exceeded it.
+- Tests: 154 → 158 — prompt shape + maxTokens asserted on the summary call, over-length reply cut through `handle()`, and direct `fitOnePacket` specs (pass-through at/under 190, bullet-boundary cut, hard-cut fallback for non-bulleted paragraphs).
+
+## v0.20.0 — 2026-09-25 18:40
+
+- New `#rss` command family on the command channel (ch2): `#rss help`, `#rss add <url> <name>` (validates URL + fetches with a 15 s timeout, requires ≥1 item with a non-empty title, rejects duplicate names case-insensitively; tags are generated by the LLM from up to 8 latest titles — on LLM failure the source is still added with empty tags and the reply says so), `#rss remove <name>`, `#rss tags` (all distinct tags), `#rss sources`, `#rss get <name>` and `#rss get #<tag>` (LLM headline summary, maxTokens 200; tag form collects items across ALL sources carrying the tag — one dead feed does not sink the summary). Bare `#rss` / unknown subcommand → help. All replies ride the existing respond() path like `#ping`.
+- Storage: new `rss_sources(name TEXT PRIMARY KEY, url, tags, created_at)` table in the EXISTING MESH_DB_PATH file (default ./data/mesh-bot.db) via a second node:sqlite connection opened by `RssModule`'s factory — no new DB file. Names are matched case-insensitively everywhere (`COLLATE NOCASE`).
+- Feed parsing: new dependency `fast-xml-parser` (the only one added for this feature) — RSS 2.0 (`<item><title>/<link>`) and Atom (`<entry><title>`, link as `href` attribute); CDATA titles supported; malformed input or no usable items → "not a valid feed".
+- LLM: `RssService` injects `LlmService` (plain DI, one-way — `RssModule` imports `LlmModule`) and uses `chat()` directly with explicit maxTokens (50 for tags, 200 for summaries) to keep mesh replies short. Tag output is sanitized (lowercase, no #, whitespace → '-', deduped).
+- Dispatch: `CommandService` gains prefix registration (`registerPrefix(name, fn)`) alongside exact matches — one handler owns the whole `#rss` family while `#ping` stays an untouched exact match; exact names win over prefixes, and a name merely starting with the prefix (e.g. `#rssfoo`) does not dispatch. Wired in `CommandModule`'s factory (`inject: [MeshService, RssService]`) — still no constructor-level cycle, no forwardRef.
+- Tests: 128 → 153 specs — store CRUD against a real temp SQLite file (incl. second-connection persistence), feed parser fixtures (RSS 2.0 / Atom / malformed / empty titles), handler behavior with mocked LLM + fetch (help, add success/LLM-fail/invalid-url/duplicate/non-2xx/unparseable, remove found/missing, tags/sources empty+populated, get by name/by tag across sources/dead-feed resilience/unknown name+tag), and `#rss` prefix dispatch through respond().
+
+## v0.19.0 — 2026-09-25 18:03
+
+- New LLM client module (`src/llm`): `LlmService` speaks the OpenAI-compatible chat-completions API of the local server at `LLM_API_BASE` (default `http://192.168.1.70:1111/v1`, no auth) using native fetch only — no new dependencies. Plain feature module (`LlmModule`), wired into `app.module.ts`; no Mesh/Schedule dependency.
+- Methods: `listModels()` (GET `/models` → `data[].id` strings), `chat(messages, opts?)` (POST `/chat/completions` with `{ model, messages, ...opts }` → `choices[0].message.content`; non-2xx throws an Error carrying the HTTP status and a short body snippet; malformed responses without content throw too), and `summarize(text)` — thin wrapper over `chat()` with system prompt "Summarize the following text concisely." (the stated primary use).
+- Env: `LLM_API_BASE` (default `http://192.168.1.70:1111/v1`), `LLM_MODEL` (default `qwen3.8-27b`), `LLM_TIMEOUT_MS` (default `60000` — the local 27B model can be slow; applied via `AbortSignal.timeout`).
+- Tests: +4 specs — listModels parses ids, chat passes model/messages/opts through and returns content, chat throws on non-2xx with status in the message, summarize sends system prompt + user text.
+
+## v0.18.1 — 2026-09-25 17:30
+
+- Command replies now ride `MeshService.respond(id, reply)` instead of direct `sendText` routing: when a handler returns a non-empty string and the trigger has a packet id, the reply is auto-routed (rx → DM back to the original sender unless the original was a broadcast; tx → its destination) on the **original message's channel** with `replyId = id`, so the recipient app renders it as a threaded quote of the triggering packet. `COMMAND_CHANNEL` is now only the trigger/listen gate — the reply channel comes from the record.
+- Defensive fallback: when the trigger has no packet id (never happens in production — `MeshService` always passes `pkt.id`), the legacy sendText routing on `COMMAND_CHANNEL` (directed DM or broadcast) still sends the reply out. Failure handling unchanged: a failing handler or respond only logs a warn, never crashes.
+- Tests: 121 → 124 specs — unit cases now mock `mesh.respond` (id present → `respond(id, reply)` with no sendText; id absent → legacy DM/broadcast fallback on the command channel), plus a failing-respond swallow case; e2e over the fake bridge asserts wire-level threading for both shapes: `#ping` broadcast on ch2 → `#pong!` broadcast on ch2 with `replyId` = ping packet id, and `#ping` DM → `#pong!` DM to the sender on ch2 with `replyId` set. All gate tests (case/whitespace/channel/env override) kept.
+- The wire-decode test helper `outboundPackets()` moved from `mesh.service.spec.ts` into `fake-bridge.ts` so both specs share it.
+- Docs: AGENTS.md "Other" bullet and MESHTASTIC.md describe the respond() auto-routing + threading; README env list unchanged (`COMMAND_CHANNEL` still exists, now meaning trigger channel only).
+
 ## v0.18.0 — 2026-09-25 17:08
 
 - New channel-index-2 auto-responder (`src/commands`): an event-driven `CommandService` reacts to decoded rx text on `COMMAND_CHANNEL` (env, default `2`) and dispatches exact `#command` matches (case-sensitive, surrounding whitespace trimmed) through a single-registration-point registry — handlers registered in the constructor via `register(name, fn)` receive `{ text, from?, id? }` and return a reply string or void (= no reply). First command: `#ping` → replies `#pong!`.

MESHTASTIC.md

@@ -22,7 +22,7 @@ Rules for how mesh-bot communicates over Meshtastic and how the agent should rea
 
 - All bot sends ride channel index 3 ("test") by design (`MESH_SEND_CHANNEL`, default "3") — never the primary channel.
 - Broadcasts show up in `/api/messages` as `failed` / `NO_RESPONSE` on this firmware — known quirk, not a real failure; the message was transmitted.
-- Channel index 2 carries the bot's auto-responder (`COMMAND_CHANNEL`, default 2): exact `#command` texts (case-sensitive) get an automatic reply on that channel — directed back to the sender when present, else broadcast. Currently only `#ping` → `#pong!`. This is a mechanical echo for testing the mesh path; it is not the agent and does not mean the owner has seen anything.
+- Channel index 2 carries the bot's auto-responder (`COMMAND_CHANNEL`, default 2): exact `#command` texts (case-sensitive) on that channel get an automatic reply routed through `MeshService.respond()` — DM back to the original sender, broadcast when the original was a broadcast — riding the original message's channel as a threaded quote (`replyId` = the trigger packet id). Currently only `#ping` → `#pong!`. This is a mechanical echo for testing the mesh path; it is not the agent and does not mean the owner has seen anything.
 
 ## Notifications (mesh → agent)
 

README.md

@@ -125,6 +125,9 @@ Config lives in `.env` (gitignored) and is passed via compose environment — cr
 - `MESH_DB_PATH` (default `./data/mesh-bot.db`) — SQLite file backing the message history (parent dir created if missing; in Docker, mounted at `/app/data` via a named volume so it survives container recreation)
 - `MESH_POLL_MS` (default `1000`) — how often the poller re-upserts the message history into SQLite and prunes rows beyond the newest 1000
 - `PORT` (default `3000`) — HTTP listen port
+- `LLM_API_BASE` (default `http://192.168.1.70:1111/v1`) — OpenAI-compatible LLM server base URL used by the in-process `LlmService` (`src/llm`; no auth)
+- `LLM_MODEL` (default `qwen3.8-27b`) — model id sent to `/chat/completions`
+- `LLM_TIMEOUT_MS` (default `60000`) — per-request timeout for LLM calls (the local 27B model can be slow)
 
 Note: the serial bridge accepts only ONE client at a time — if another app is
 connected to the radio, this bot will not get a connection.

docker-compose.yml

@@ -2,6 +2,7 @@ services:
   bot:
     build: .
     environment:
+      TZ: Europe/Warsaw
       MESH_HOST: 192.168.1.4
       MESH_PORT: '4403'
       MESH_DB_PATH: ./data/mesh-bot.db

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "mesh-bot",
-  "version": "0.11.3",
+  "version": "0.19.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "mesh-bot",
-      "version": "0.11.3",
+      "version": "0.19.0",
       "license": "UNLICENSED",
       "dependencies": {
         "@bufbuild/protobuf": "^2.15.0",
@@ -18,6 +18,7 @@
         "@nestjs/schedule": "^12.0.2",
         "@nestjs/swagger": "^12.0.2",
         "@scalar/nestjs-api-reference": "^1.2.21",
+        "fast-xml-parser": "^5.11.1",
         "reflect-metadata": "^0.2.2",
         "rxjs": "^7.8.1"
       },
@@ -1148,6 +1149,18 @@
         "url": "https://paulmillr.com/funding/"
       }
     },
+    "node_modules/@nodable/entities": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-3.0.0.tgz",
+      "integrity": "sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodable"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/@oxc-project/types": {
       "version": "0.151.0",
       "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.151.0.tgz",
@@ -2336,6 +2349,18 @@
         "node": ">=14"
       }
     },
+    "node_modules/anynum": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
+      "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/append-field": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
@@ -3279,6 +3304,45 @@
         "fast-string-width": "^3.0.2"
       }
     },
+    "node_modules/fast-xml-builder": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.3.1.tgz",
+      "integrity": "sha512-pIM/1n3ntFXKYrUZwW7QCK0gAW7XY+wzj1YMIV3tLDvPj/V+zTGJK5e3/4WJfwj0qWw2ElNXiTixda/R+3YSug==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "path-expression-matcher": "^1.6.2",
+        "xml-naming": "^0.3.0"
+      }
+    },
+    "node_modules/fast-xml-parser": {
+      "version": "5.11.1",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.11.1.tgz",
+      "integrity": "sha512-TBw6K/fxoQGGjCmZDw9w/ZwP3uDcnTM4YH/g+PFRWr8sbe5idXtxNN6vITh4+1ruCZaho6uBFurElsA7F0zzgw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@nodable/entities": "^3.0.0",
+        "fast-xml-builder": "^1.2.0",
+        "is-unsafe": "^2.0.0",
+        "path-expression-matcher": "^1.6.2",
+        "strnum": "^2.4.2",
+        "xml-naming": "^0.3.0"
+      },
+      "bin": {
+        "fxparser": "src/cli/cli.js"
+      }
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -3830,6 +3894,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/is-unsafe": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-2.0.2.tgz",
+      "integrity": "sha512-HgbIHPBH0KHHCcjLfGsCvhtPTVxjaAZlXjwdz7/GQC40SjSe4sfQsar8J5VFo8JOSbarkpV0OLG95bbaNd9aAQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -4848,6 +4924,21 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/path-expression-matcher": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.2.tgz",
+      "integrity": "sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/path-key": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -5503,6 +5594,21 @@
         "node": ">=4"
       }
     },
+    "node_modules/strnum": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.4.2.tgz",
+      "integrity": "sha512-rDG3Ah4TV0k1hWvLSzkZtMmLN9+eS+h3knq4MP6A42Y3Yh5qGNnOUs1jJkoSr8FG5dsL28c7KgkIBzSEykqtuw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "anynum": "^1.0.1"
+      }
+    },
     "node_modules/strtok3": {
       "version": "10.3.5",
       "resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.3.5.tgz",
@@ -6147,6 +6253,21 @@
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "license": "ISC"
     },
+    "node_modules/xml-naming": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.3.0.tgz",
+      "integrity": "sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/yoctocolors": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.2.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mesh-bot",
-  "version": "0.18.0",
+  "version": "0.21.10",
   "description": "",
   "author": "",
   "private": true,
@@ -30,6 +30,7 @@
     "@nestjs/schedule": "^12.0.2",
     "@nestjs/swagger": "^12.0.2",
     "@scalar/nestjs-api-reference": "^1.2.21",
+    "fast-xml-parser": "^5.11.1",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1"
   },

src/app.module.ts

@@ -1,10 +1,19 @@
 import { Module } from '@nestjs/common';
 import { BatteryAlertModule } from './battery/battery.module.js';
 import { CommandModule } from './commands/command.module.js';
+import { LlmModule } from './llm/llm.module.js';
 import { MeshModule } from './mesh/mesh.module.js';
+import { RssModule } from './rss/rss.module.js';
 import { WeatherModule } from './weather/weather.module.js';
 
 @Module({
-  imports: [MeshModule, WeatherModule, BatteryAlertModule, CommandModule],
+  imports: [
+    MeshModule,
+    WeatherModule,
+    BatteryAlertModule,
+    CommandModule,
+    LlmModule,
+    RssModule,
+  ],
 })
 export class AppModule {}

src/battery/battery.module.ts

@@ -1,10 +1,9 @@
 import { Module } from '@nestjs/common';
-import { ScheduleModule } from '@nestjs/schedule';
 import { MeshModule } from '../mesh/mesh.module.js';
 import { BatteryAlertService } from './battery.service.js';
 
 @Module({
-  imports: [ScheduleModule.forRoot(), MeshModule],
+  imports: [MeshModule],
   providers: [BatteryAlertService],
   exports: [BatteryAlertService],
 })

src/commands/command.module.ts

@@ -1,20 +1,22 @@
 import { Module } from '@nestjs/common';
 import { MeshModule } from '../mesh/mesh.module.js';
 import { MeshService } from '../mesh/mesh.service.js';
+import { RssModule } from '../rss/rss.module.js';
+import { RssService } from '../rss/rss.service.js';
 import { CommandService } from './command.service.js';
 
 @Module({
-  imports: [MeshModule], // one-way only — the reverse edge is wired in the factory below, not via DI
+  imports: [MeshModule, RssModule], // one-way only — the MeshService reverse edge is wired in the factory below, not via DI
   providers: [
     {
       provide: CommandService,
-      useFactory: (mesh: MeshService) => {
-        const commands = new CommandService(mesh);
+      useFactory: (mesh: MeshService, rss: RssService) => {
+        const commands = new CommandService(mesh, rss);
         // break the cycle: MeshService can't inject us (its own factory would deadlock on this edge), so attach ourselves once we exist — mesh is guaranteed created here because it's our injected dependency
         mesh.attachCommands(commands);
         return commands;
       },
-      inject: [MeshService],
+      inject: [MeshService, RssService],
     },
   ],
   exports: [CommandService],

src/commands/command.service.spec.ts

@@ -1,36 +1,71 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { BROADCAST_ADDR } from '../mesh/codec.js';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { LlmService } from '../llm/llm.service.js';
+import { RssService } from '../rss/rss.service.js';
 import {
   startBridge,
   textPacketFrame,
   waitFor,
+  outboundPackets,
   KAMIL_NUM,
 } from '../mesh/fake-bridge.js';
-import type { MeshService } from '../mesh/mesh.service.js';
+import { BROADCAST_ADDR } from '../mesh/codec.js';
+import type {
+  MessageRecord,
+  MeshService,
+  NodeSummary,
+} from '../mesh/mesh.service.js';
 import { MeshService as RealMeshService } from '../mesh/mesh.service.js';
 import { CommandService } from './command.service.js';
 
 function makeService(
   sendText?: ReturnType<typeof vi.fn>,
+  respond?: ReturnType<typeof vi.fn>,
 ): [CommandService, MeshService] {
-  const mesh = { sendText: sendText ?? vi.fn() } as unknown as MeshService;
+  const mesh = {
+    sendText: sendText ?? vi.fn(),
+    respond: respond ?? vi.fn().mockResolvedValue({ id: 1 }),
+  } as unknown as MeshService;
   return [new CommandService(mesh), mesh];
 }
 
 beforeEach(() => {
   delete process.env.COMMAND_CHANNEL; // default channel 2 under test
+  process.env.MESH_MULTI_SEND_DELAY_MS = '0'; // no spacing under test unless a test opts in — the real default (5000) would slow the suite down
 });
 
 describe('CommandService.onRx', () => {
-  it('answers #ping on the command channel with a directed DM back to the sender', async () => {
+  it('replies #ping via respond() — threaded quote of the trigger packet, no direct sendText', async () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#ping', 42, 7);
+    expect(mesh.respond).toHaveBeenCalledWith(7, '#pong!');
+    expect(mesh.sendText).not.toHaveBeenCalled();
+  });
+
+  it('replies #help with a short single-message list of all commands', async () => {
+    const [svc, mesh] = makeService();
+    await svc.onRx(2, '#help', 42, 7);
+    expect(mesh.respond).toHaveBeenCalledTimes(1); // one packet — not one per line
+    const text = mesh.respond.mock.calls[0][1];
+    expect(text).toContain('#ping');
+    expect(text).toContain('#loser');
+    expect(text).toContain('#rss');
+  });
+
+  it('falls back to a directed sendText on COMMAND_CHANNEL when the trigger has no packet id (DM)', async () => {
+    const [svc, mesh] = makeService();
+    await svc.onRx(2, '#ping', 42); // from present but no id — defensive path
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 2);
   });
 
-  it('broadcasts the reply when there is no sender', async () => {
+  it('falls back to a broadcast sendText on COMMAND_CHANNEL when the trigger has no packet id (no sender)', async () => {
     const [svc, mesh] = makeService();
-    await svc.onRx(2, '#ping');
+    await svc.onRx(2, '#ping'); // no from, no id — defensive path
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).toHaveBeenCalledWith(
       BROADCAST_ADDR,
       '#pong!',
@@ -43,6 +78,7 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(0, '#ping', 42);
     await svc.onRx(3, '#ping', 42);
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -50,6 +86,7 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, 'hello there', 42);
     await svc.onRx(2, 'ping', 42); // no leading # — not a command trigger
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -57,28 +94,31 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#Ping', 42);
     await svc.onRx(2, '#ping!', 42); // extra char — no partial matches
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
   it('trims surrounding whitespace before matching', async () => {
     const [svc, mesh] = makeService();
-    await svc.onRx(2, '  #ping  ', 42);
-    expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 2);
+    await svc.onRx(2, '  #ping  ', 42, 9);
+    expect(mesh.respond).toHaveBeenCalledWith(9, '#pong!');
   });
 
   it('honors the COMMAND_CHANNEL env override', async () => {
     process.env.COMMAND_CHANNEL = '5';
     const [svc, mesh] = makeService();
     await svc.onRx(2, '#ping', 42); // old default no longer triggers
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
-    await svc.onRx(5, '#ping', 42);
-    expect(mesh.sendText).toHaveBeenCalledWith(42, '#pong!', undefined, 5);
+    await svc.onRx(5, '#ping', 42, 8);
+    expect(mesh.respond).toHaveBeenCalledWith(8, '#pong!');
   });
 
   it('sends nothing when a handler returns void', async () => {
     const [svc, mesh] = makeService();
     svc.register('silent', () => undefined);
     await svc.onRx(2, '#silent', 42);
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
@@ -86,7 +126,62 @@ describe('CommandService.onRx', () => {
     const [svc, mesh] = makeService();
     svc.register('status', (ctx) => `up from ${ctx.from ?? 'broadcast'}`);
     await svc.onRx(2, '#status', 99, 5);
-    expect(mesh.sendText).toHaveBeenCalledWith(99, 'up from 99', undefined, 2);
+    expect(mesh.respond).toHaveBeenCalledWith(5, 'up from 99');
+  });
+
+  it('sends each line of an array reply as its own threaded respond() to the same packet id', async () => {
+    const [svc, mesh] = makeService();
+    svc.register('multi', () => ['one: first item', 'two: second item']);
+    await svc.onRx(2, '#multi', 42, 9);
+    expect(mesh.respond).toHaveBeenCalledTimes(2);
+    expect(mesh.respond.mock.calls[0]).toEqual([9, 'one: first item']);
+    expect(mesh.respond.mock.calls[1]).toEqual([9, 'two: second item']);
+    expect(mesh.sendText).not.toHaveBeenCalled();
+  });
+
+  it('spaces consecutive multi-line sends by MESH_MULTI_SEND_DELAY_MS — no delay before the first line', async () => {
+    process.env.MESH_MULTI_SEND_DELAY_MS = '50'; // short so the test stays fast
+    let sends = 0;
+    const respond = vi.fn(async () => {
+      sends++;
+      return { id: 1 };
+    });
+    vi.useFakeTimers();
+    try {
+      const [svc, mesh] = makeService(undefined, respond);
+      svc.register('multi3', () => ['a: one', 'b: two', 'c: three']);
+
+      const p = svc.onRx(2, '#multi3', 42, 9);
+      // flush microtasks without advancing time — the first line must already be out (no delay before it)
+      await vi.advanceTimersByTimeAsync(0);
+      expect(sends).toBe(1);
+
+      // each subsequent line waits exactly MESH_MULTI_SEND_DELAY_MS after the previous one landed
+      await vi.advanceTimersByTimeAsync(50);
+      expect(sends).toBe(2);
+      await vi.advanceTimersByTimeAsync(50);
+      expect(sends).toBe(3);
+
+      await p;
+      expect(mesh.respond).toHaveBeenCalledTimes(3);
+    } finally {
+      vi.useRealTimers();
+      delete process.env.MESH_MULTI_SEND_DELAY_MS;
+    }
+  });
+
+  it('sends each line of an array reply via the legacy sendText fallback when there is no packet id', async () => {
+    const [svc, mesh] = makeService();
+    svc.register('multi', () => ['one: first item', 'two: second item']);
+    await svc.onRx(2, '#multi', 42); // no id → legacy path on COMMAND_CHANNEL, DM back to the sender
+    expect(mesh.sendText).toHaveBeenCalledTimes(2);
+    expect(mesh.sendText.mock.calls[0]).toEqual([
+      42,
+      'one: first item',
+      undefined,
+      2,
+    ]);
+    expect(mesh.respond).not.toHaveBeenCalled();
   });
 
   it('swallows a failing handler (a bad command must not crash the app)', async () => {
@@ -95,19 +190,212 @@ describe('CommandService.onRx', () => {
       throw new Error('kaboom');
     });
     await expect(svc.onRx(2, '#boom', 42)).resolves.toBeUndefined();
+    expect(mesh.respond).not.toHaveBeenCalled();
     expect(mesh.sendText).not.toHaveBeenCalled();
   });
 
+  it('swallows a failing respond (unknown id / bridge down) without throwing', async () => {
+    const [svc] = makeService(
+      undefined,
+      vi.fn().mockRejectedValue(new Error('no message with id 7')),
+    );
+    await expect(svc.onRx(2, '#ping', 42, 7)).resolves.toBeUndefined();
+  });
+
   it('swallows a failing send (mesh down) without throwing', async () => {
     const [svc] = makeService(
       vi.fn().mockRejectedValue(new Error('no bridge')),
     );
-    await expect(svc.onRx(2, '#ping', 42)).resolves.toBeUndefined();
+    await expect(svc.onRx(2, '#ping', 42)).resolves.toBeUndefined(); // no id → legacy path
+  });
+});
+
+describe('#loser', () => {
+  const tx = (
+    id: number,
+    to: number,
+    status: MessageRecord['status'],
+  ): MessageRecord => ({
+    id,
+    dir: 'tx',
+    to,
+    text: 'hi',
+    channel: 3,
+    at: Date.now(),
+    status,
+  });
+
+  const makeLoserMesh = (
+    messages: MessageRecord[],
+    nodes: NodeSummary[],
+  ): [CommandService, MeshService] => {
+    const mesh = {
+      sendText: vi.fn(),
+      respond: vi.fn().mockResolvedValue({ id: 1 }),
+      messages: () => messages,
+      nodes: async () => nodes,
+    } as unknown as MeshService;
+    return [new CommandService(mesh), mesh];
+  };
+
+  it('reports the node with the most failures — named via longName, broadcasts and pending sends excluded', async () => {
+    const messages = [
+      tx(10, BROADCAST_ADDR, 'failed'), // firmware quirk: a broadcast NACK is never a real destination
+      tx(9, 222, 'failed'), // Alice: 3 failed / 0 delivered → loser
+      tx(8, 111, 'delivered'), // Bob: 1 failed / 2 delivered
+      tx(7, 222, 'failed'),
+      tx(6, 111, 'failed'),
+      tx(5, 333, 'pending'), // no final status yet — ignored
+      tx(4, 222, 'failed'),
+      {
+        id: 3,
+        dir: 'rx',
+        from: 999,
+        text: 'hello',
+        channel: 0,
+        at: Date.now(),
+      },
+    ];
+    const nodes = [
+      { num: 111, shortName: 'Bob', lastHeard: null },
+      { num: 222, longName: 'Alice', lastHeard: null },
+    ];
+    const [svc, mesh] = makeLoserMesh(messages, nodes);
+
+    await svc.onRx(2, '#loser', 42, 7);
+
+    expect(mesh.respond).toHaveBeenCalledWith(
+      7,
+      'worst delivery: Alice (@!000000de) - 3 failed / 0 delivered',
+    );
+    expect(mesh.sendText).not.toHaveBeenCalled();
+  });
+
+  it('says no failed sends when the directed history is all delivered', async () => {
+    const messages = [tx(2, 5, 'delivered'), tx(1, 6, 'delivered')];
+    const [svc, mesh] = makeLoserMesh(messages, []);
+
+    await svc.onRx(2, '#loser', 42, 7);
+
+    expect(mesh.respond).toHaveBeenCalledWith(
+      7,
+      'no failed sends yet - everyone delivers :)',
+    );
+  });
+
+  it('explains the directed-only rule when there is no final-status data at all', async () => {
+    const messages = [tx(2, BROADCAST_ADDR, 'pending'), tx(1, 5, 'pending')];
+    const [svc, mesh] = makeLoserMesh(messages, []);
+
+    await svc.onRx(2, '#loser', 42, 7);
+
+    expect(mesh.respond).toHaveBeenCalledWith(
+      7,
+      'not enough data yet - only directed sends count (broadcasts have no acks)',
+    );
+  });
+
+  it('falls back to the @!hex mention when the worst node has no known name', async () => {
+    const messages = [tx(1, 600, 'failed')];
+    const nodes = [{ num: 5, longName: 'Someone Else', lastHeard: null }];
+    const [svc, mesh] = makeLoserMesh(messages, nodes);
+
+    await svc.onRx(2, '#loser', 42, 7);
+
+    expect(mesh.respond).toHaveBeenCalledWith(
+      7,
+      'worst delivery: @!00000258 - 1 failed / 0 delivered',
+    );
+  });
+
+  it('tie-breaks equal failure counts by the worse failure ratio', async () => {
+    const messages = [
+      // node 7: 1 failed / 9 delivered (ratio 0.1) — not the loser
+      tx(16, 8, 'failed'), // node 8: 1 failed / 1 delivered (ratio 0.5) → loser
+      tx(15, 8, 'delivered'),
+      tx(14, 7, 'failed'),
+      ...Array.from({ length: 9 }, (_, i) =>
+        tx(i + 1, 7, 'delivered' as const),
+      ),
+    ];
+    const [svc, mesh] = makeLoserMesh(messages, []);
+
+    await svc.onRx(2, '#loser', 42, 7);
+
+    expect(mesh.respond).toHaveBeenCalledWith(
+      7,
+      'worst delivery: @!00000008 - 1 failed / 1 delivered',
+    );
+  });
+});
+
+describe('#rss prefix dispatch', () => {
+  let dir: string | undefined;
+
+  const makeRss = (): RssService => {
+    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-cmd-rss-'));
+    return new RssService(
+      { chat: vi.fn() } as unknown as LlmService,
+      new DatabaseSync(join(dir, 'test.db')),
+    );
+  };
+
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+    dir = undefined;
+  });
+
+  it('routes #rss subcommands through respond() like any command reply', async () => {
+    const mesh = {
+      sendText: vi.fn(),
+      respond: vi.fn().mockResolvedValue({ id: 1 }),
+    } as unknown as MeshService;
+    const svc = new CommandService(mesh, makeRss());
+
+    await svc.onRx(2, '#rss sources', 42, 9);
+
+    expect(mesh.respond).toHaveBeenCalledWith(9, 'no sources yet');
+    expect(mesh.sendText).not.toHaveBeenCalled();
+  });
+
+  it('routes bare #rss to the help text via respond()', async () => {
+    const mesh = {
+      sendText: vi.fn(),
+      respond: vi.fn().mockResolvedValue({ id: 1 }),
+    } as unknown as MeshService;
+    const svc = new CommandService(mesh, makeRss());
+
+    await svc.onRx(2, '#rss', 42, 9);
+
+    expect(mesh.respond).toHaveBeenCalledTimes(1);
+    expect(String(mesh.respond.mock.calls[0][1])).toContain(
+      '#rss add <url> <name>',
+    );
+  });
+
+  it('leaves exact commands untouched and does not partial-match prefix names', async () => {
+    const mesh = {
+      sendText: vi.fn(),
+      respond: vi.fn().mockResolvedValue({ id: 1 }),
+    } as unknown as MeshService;
+    const svc = new CommandService(mesh, makeRss());
+
+    await svc.onRx(2, '#ping', 42, 3);
+    expect(mesh.respond).toHaveBeenCalledWith(3, '#pong!');
+    await svc.onRx(2, '#rssfoo', 42, 4); // starts with 'rss' but is not the family — no partial prefix match
+    expect(mesh.respond).toHaveBeenCalledTimes(1);
+  });
+
+  it('does nothing for #rss when no RssService was wired (legacy construction)', async () => {
+    const [svc, mesh] = makeService(); // rss omitted
+    await svc.onRx(2, '#rss sources', 42, 9);
+    expect(mesh.respond).not.toHaveBeenCalled();
+    expect(mesh.sendText).not.toHaveBeenCalled();
   });
 });
 
 describe('MeshService wiring (event-driven trigger)', () => {
-  it('calls onRx for decoded rx text and answers #ping over the wire', async () => {
+  it('answers a #ping DM on ch2 with a directed #pong! back to the sender, same channel, threaded quote', async () => {
     const bridge = await startBridge();
     process.env.MESH_HOST = '127.0.0.1';
     process.env.MESH_PORT = String(bridge.port);
@@ -120,6 +408,10 @@ describe('MeshService wiring (event-driven trigger)', () => {
         () => bridge.sockets.length === 1 && svc.status().connected,
       );
 
+      const out: Uint8Array[] = [];
+      bridge.sockets[0].on('data', (c) => out.push(c));
+
+      // rx DM from KAMIL to node 42 on channel 2 (packet id 1)
       bridge.sockets[0].write(textPacketFrame(KAMIL_NUM, 42, '#ping', 2));
 
       // rx record + the directed #pong! reply on channel 2 (newest first — the reply is [0])
@@ -130,6 +422,60 @@ describe('MeshService wiring (event-driven trigger)', () => {
         text: '#pong!',
         channel: 2,
       });
+
+      // wire-level: DM back to the sender on ch2 with replyId = the ping packet id (threaded quote)
+      await waitFor(() => outboundPackets(out).length >= 1);
+      const pkt = outboundPackets(out)[0]!;
+      expect(pkt.to).toBe(KAMIL_NUM);
+      expect(pkt.channel).toBe(2);
+      const data =
+        pkt.payloadVariant?.case === 'decoded'
+          ? pkt.payloadVariant.value
+          : undefined;
+      expect(data?.replyId).toBe(1);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('answers a #ping broadcast on ch2 with a #pong! broadcast, same channel, threaded quote', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new RealMeshService();
+    try {
+      svc.attachCommands(new CommandService(svc));
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      const out: Uint8Array[] = [];
+      bridge.sockets[0].on('data', (c) => out.push(c));
+
+      // rx broadcast from KAMIL on channel 2 (packet id 1)
+      bridge.sockets[0].write(
+        textPacketFrame(KAMIL_NUM, BROADCAST_ADDR, '#ping', 2),
+      );
+
+      await waitFor(() => svc.messages().length === 2);
+      expect(svc.messages()[0]).toMatchObject({
+        dir: 'tx',
+        to: BROADCAST_ADDR, // broadcast original → broadcast reply
+        text: '#pong!',
+        channel: 2,
+      });
+
+      await waitFor(() => outboundPackets(out).length >= 1);
+      const pkt = outboundPackets(out)[0]!;
+      expect(pkt.to).toBe(BROADCAST_ADDR);
+      expect(pkt.channel).toBe(2);
+      const data =
+        pkt.payloadVariant?.case === 'decoded'
+          ? pkt.payloadVariant.value
+          : undefined;
+      expect(data?.replyId).toBe(1); // threaded quote of the ping packet (id 1)
     } finally {
       svc.onModuleDestroy();
       bridge.close();

src/commands/command.service.ts

@@ -1,7 +1,10 @@
 import { Injectable, Logger } from '@nestjs/common';
+// pure formatting helper (no cycle: battery → mesh only)
+import { mention } from '../battery/battery.service.js';
 import { BROADCAST_ADDR } from '../mesh/codec.js';
-// type-only: the instance comes from DI (command.module.ts factory) or direct construction in tests — no runtime import cycle with src/mesh
+// type-only: the instances come from DI (command.module.ts factory) or direct construction in tests — no runtime import cycles with src/mesh / src/rss
 import type { MeshService } from '../mesh/mesh.service.js';
+import type { RssService } from '../rss/rss.service.js';
 
 /** Context handed to a command handler: the trimmed text plus sender/packet id when present. */
 export interface CommandContext {
@@ -13,10 +16,10 @@ export interface CommandContext {
   id?: number;
 }
 
-/** A command handler: returns the reply text to send back, or void/undefined for no reply. */
+/** A command handler: returns the reply text(s) to send back — an array sends one message per line — or void/undefined for no reply. */
 export type CommandHandler = (
   ctx: CommandContext,
-) => string | undefined | Promise<string | undefined>;
+) => string | string[] | undefined | Promise<string | string[] | undefined>;
 
 @Injectable()
 export class CommandService {
@@ -26,12 +29,82 @@ export class CommandService {
     process.env.COMMAND_CHANNEL ?? '2',
     10,
   );
+  // spacing between consecutive multi-line reply messages — back-to-back packets get dropped in RF on a real mesh; each packet needs time to land. Read at construction like the other env config.
+  private readonly multiSendDelayMs = parseInt(
+    process.env.MESH_MULTI_SEND_DELAY_MS ?? '5000',
+    10,
+  );
   // single registration point: the constructor registers every built-in command — add the next one there (or via register())
   private readonly commands = new Map<string, CommandHandler>();
+  // prefix handlers own a whole family (`#rss`, `#rss add ...`) instead of one exact name
+  private readonly prefixes = new Map<string, CommandHandler>();
 
   /** mesh is optional so tests can construct without a bridge; production DI always passes one. */
-  constructor(private readonly mesh?: MeshService) {
+  constructor(
+    private readonly mesh?: MeshService,
+    rss?: RssService,
+  ) {
     this.register('ping', () => '#pong!');
+    this.register('loser', () => this.loserReply());
+    // single multi-line string = ONE packet — not an array, which would drip-feed one spaced packet per line
+    this.register('help', () =>
+      [
+        '#ping - alive check',
+        '#loser - worst delivery record',
+        '#rss help - rss subcommands',
+        '#rss add <url> <name> - add feed with AI tags',
+        '#rss remove <name> - drop feed',
+        '#rss get <name|#tag> - news summary',
+        '#rss sources / #rss tags - list feeds/tags',
+      ].join('\n'),
+    );
+    if (rss) this.registerPrefix('rss', (ctx) => rss.handle(ctx));
+  }
+
+  /**
+   * #loser — worst packet delivery record, over directed sends only. Meshtastic shares no mesh-wide
+   * loss stats, so the only real data is our own tx history: group by destination, count delivered vs
+   * failed per node; broadcasts are excluded (firmware strips want_ack pre-TX, they stay pending — and
+   * the broadcast addr is never a real destination even if a NACK ever lands on it). Loser = most
+   * failures, tie-break worse failure ratio. One reply line, ≤ ~180 chars.
+   */
+  private async loserReply(): Promise<string> {
+    const mesh = this.mesh;
+    if (!mesh)
+      return 'not enough data yet - only directed sends count (broadcasts have no acks)';
+    const stats = new Map<number, { failed: number; delivered: number }>();
+    for (const m of mesh.messages()) {
+      if (m.dir !== 'tx' || m.to === undefined || m.to === BROADCAST_ADDR)
+        continue; // directed sends only
+      if (m.status !== 'delivered' && m.status !== 'failed') continue; // pending = no final status yet
+      const s = stats.get(m.to) ?? { failed: 0, delivered: 0 };
+      if (m.status === 'failed') s.failed += 1;
+      else s.delivered += 1;
+      stats.set(m.to, s);
+    }
+    if (stats.size === 0)
+      return 'not enough data yet - only directed sends count (broadcasts have no acks)';
+    let worst: { num: number; failed: number; total: number } | undefined;
+    for (const [num, s] of stats) {
+      if (s.failed === 0) continue; // zero-failure nodes can't be the loser
+      const total = s.failed + s.delivered;
+      // most failures first, then worse failure ratio on a tie
+      if (
+        !worst ||
+        s.failed > worst.failed ||
+        (s.failed === worst.failed &&
+          s.failed / total > worst.failed / worst.total)
+      ) {
+        worst = { num, failed: s.failed, total };
+      }
+    }
+    if (!worst) return 'no failed sends yet - everyone delivers :)';
+    const names = new Map(
+      (await mesh.nodes()).map((n) => [n.num, n.longName ?? n.shortName]),
+    );
+    const name = names.get(worst.num);
+    const who = name ? `${name} (${mention(worst.num)})` : mention(worst.num);
+    return `worst delivery: ${who} - ${worst.failed} failed / ${worst.total - worst.failed} delivered`;
   }
 
   /** Register a command handler (names are case-sensitive; the leading `#` is stripped before lookup). */
@@ -39,11 +112,18 @@ export class CommandService {
     this.commands.set(name, fn);
   }
 
+  /** Register a prefix handler: owns bare `#<name>` and everything starting with `#<name> `. Exact matches win over prefixes. */
+  registerPrefix(name: string, fn: CommandHandler): void {
+    this.prefixes.set(name, fn);
+  }
+
   /**
    * Event-driven entry point called by MeshService for every decoded rx text.
-   * No-op unless on COMMAND_CHANNEL with an exact `#command` match (case-sensitive).
-   * Replies ride COMMAND_CHANNEL: directed DM back to the sender when present, else broadcast.
-   * Never throws — a failed command must not crash the app.
+   * No-op unless on COMMAND_CHANNEL with a case-sensitive `#command` match — exact name or registered prefix family (`#rss ...`).
+   * Replies go through MeshService.respond(id, reply): auto-routed to the original message's
+   * destination and channel as a threaded quote (replyId = id). Only when the trigger has no packet
+   * id does it fall back to legacy sendText routing on COMMAND_CHANNEL. Never throws — a failed
+   * command must not crash the app.
    */
   async onRx(
     channel: number,
@@ -54,17 +134,43 @@ export class CommandService {
     if (channel !== this.commandChannel) return;
     const trimmed = text.trim();
     if (!trimmed.startsWith('#')) return; // only `#command` texts trigger handlers
-    const handler = this.commands.get(trimmed.slice(1));
+    const name = trimmed.slice(1);
+    let handler = this.commands.get(name);
+    if (!handler) {
+      for (const [prefix, fn] of this.prefixes) {
+        // a prefix owns bare `#<prefix>` and everything starting with `#<prefix> ` — e.g. 'rss' → #rss / #rss add ...
+        if (name === prefix || name.startsWith(prefix + ' ')) {
+          handler = fn;
+          break;
+        }
+      }
+    }
     if (!handler) return; // exact, case-sensitive match — no partials
     try {
       const reply = await handler({ text: trimmed, from, id });
       if (reply === undefined || reply === null) return; // void = no reply
-      await this.mesh?.sendText(
-        from ?? BROADCAST_ADDR,
-        reply,
-        undefined,
-        this.commandChannel,
-      );
+      // an array reply sends one message per line, all threaded to the same trigger packet id — spaced so each packet has time to land in RF (no delay before the first line)
+      const lines = Array.isArray(reply) ? reply : [reply];
+      for (let i = 0; i < lines.length; i++) {
+        if (i > 0 && this.multiSendDelayMs > 0) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, this.multiSendDelayMs),
+          );
+        }
+        const line = lines[i];
+        if (id !== undefined && this.mesh) {
+          // respond() auto-routes each line: rides the original record's channel with replyId = id (threaded quote)
+          await this.mesh.respond(id, line);
+        } else {
+          // defensive fallback when the trigger has no packet id: legacy routing on COMMAND_CHANNEL
+          await this.mesh?.sendText(
+            from ?? BROADCAST_ADDR,
+            line,
+            undefined,
+            this.commandChannel,
+          );
+        }
+      }
     } catch (err) {
       this.logger.warn(
         `[commands] '${trimmed}' failed: ${(err as Error).message}`,

src/llm/llm.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { LlmService } from './llm.service.js';
+
+@Module({
+  providers: [LlmService],
+  exports: [LlmService],
+})
+export class LlmModule {}

src/llm/llm.service.spec.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ChatMessage } from './llm.service.js';
+import { LlmService } from './llm.service.js';
+
+const BASE = 'http://192.168.1.70:1111/v1';
+
+function json(body: unknown): Response {
+  return { ok: true, status: 200, json: async () => body } as Response;
+}
+
+/** Fresh service with a clean env (explicit base/model/timeout). */
+function makeService(): LlmService {
+  process.env.LLM_API_BASE = BASE;
+  process.env.LLM_MODEL = 'qwen3.8-27b';
+  process.env.LLM_TIMEOUT_MS = '60000';
+  return new LlmService();
+}
+
+describe('LlmService', () => {
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    for (const k of ['LLM_API_BASE', 'LLM_MODEL', 'LLM_TIMEOUT_MS'])
+      delete process.env[k];
+  });
+
+  it('listModels returns the data[].id strings from GET /models', async () => {
+    const svc = makeService();
+    fetchMock.mockResolvedValueOnce(
+      json({
+        data: [
+          { id: 'qwen3.8-27b' },
+          { id: 'text-embedding-nomic-embed-text-v1.5' },
+        ],
+      }),
+    );
+
+    await expect(svc.listModels()).resolves.toEqual([
+      'qwen3.8-27b',
+      'text-embedding-nomic-embed-text-v1.5',
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0][0]).toBe(`${BASE}/models`);
+  });
+
+  it('chat posts model+messages and returns choices[0].message.content', async () => {
+    const svc = makeService();
+    fetchMock.mockResolvedValueOnce(
+      json({ choices: [{ message: { content: 'hello back' } }] }),
+    );
+
+    const messages: ChatMessage[] = [
+      { role: 'system', content: 'be brief' },
+      { role: 'user', content: 'hi' },
+    ];
+    await expect(
+      svc.chat(messages, { maxTokens: 50, temperature: 0.2 }),
+    ).resolves.toBe('hello back');
+
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe(`${BASE}/chat/completions`);
+    expect(init.method).toBe('POST');
+    expect(JSON.parse(init.body)).toEqual({
+      model: 'qwen3.8-27b',
+      messages,
+      maxTokens: 50,
+      temperature: 0.2,
+    });
+  });
+
+  it('chat throws on non-2xx with the HTTP status in the message', async () => {
+    const svc = makeService();
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      text: async () => 'upstream down',
+    } as Response);
+
+    await expect(svc.chat([{ role: 'user', content: 'hi' }])).rejects.toThrow(
+      /HTTP 503.*upstream down/,
+    );
+  });
+
+  it('summarize calls chat with the system prompt plus the user text', async () => {
+    const svc = makeService();
+    fetchMock.mockResolvedValueOnce(
+      json({ choices: [{ message: { content: 'the summary' } }] }),
+    );
+
+    await expect(svc.summarize('a long text')).resolves.toBe('the summary');
+
+    const [, init] = fetchMock.mock.calls[0];
+    expect(JSON.parse(init.body).messages).toEqual([
+      { role: 'system', content: 'Summarize the following text concisely.' },
+      { role: 'user', content: 'a long text' },
+    ]);
+  });
+});

src/llm/llm.service.ts

@@ -0,0 +1,68 @@
+import { Injectable } from '@nestjs/common';
+
+/** A single chat message in OpenAI chat-completions shape. */
+export interface ChatMessage {
+  role: string;
+  content: string;
+}
+
+@Injectable()
+export class LlmService {
+  // read at construction, like other services' env config
+  private readonly apiBase =
+    process.env.LLM_API_BASE ?? 'http://192.168.1.70:1111/v1';
+  private readonly model = process.env.LLM_MODEL ?? 'qwen3.8-27b';
+  // local 27B model can be slow (uncontrollable reasoning tokens) — generous default: 3 min headroom for slow reasoning periods
+  private readonly timeoutMs = parseInt(
+    process.env.LLM_TIMEOUT_MS ?? '180000',
+    10,
+  );
+
+  /** GET {base}/models → the `data[].id` strings. */
+  async listModels(): Promise<string[]> {
+    const res = await fetch(`${this.apiBase}/models`, {
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+    if (!res.ok) {
+      throw new Error(
+        `listModels failed: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`,
+      );
+    }
+    const body = (await res.json()) as { data?: { id: string }[] };
+    return (body.data ?? []).map((m) => m.id);
+  }
+
+  /** POST {base}/chat/completions → `choices[0].message.content`. */
+  async chat(
+    messages: ChatMessage[],
+    opts?: { maxTokens?: number; temperature?: number },
+  ): Promise<string> {
+    const res = await fetch(`${this.apiBase}/chat/completions`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model: this.model, messages, ...opts }),
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+    if (!res.ok) {
+      throw new Error(
+        `chat failed: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`,
+      );
+    }
+    const body = (await res.json()) as {
+      choices?: { message?: { content?: string } }[];
+    };
+    const content = body.choices?.[0]?.message?.content;
+    if (typeof content !== 'string') {
+      throw new Error('chat failed: no choices[0].message.content in response');
+    }
+    return content;
+  }
+
+  /** Thin wrapper over chat(): the stated primary use of this service. */
+  async summarize(text: string): Promise<string> {
+    return this.chat([
+      { role: 'system', content: 'Summarize the following text concisely.' },
+      { role: 'user', content: text },
+    ]);
+  }
+}

src/mesh/fake-bridge.ts

@@ -1,8 +1,8 @@
-import { create, toBinary } from '@bufbuild/protobuf';
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
 import * as P from '@meshtastic/protobufs';
 import * as net from 'node:net';
 import type { AddressInfo } from 'node:net';
-import { frame } from './codec.js';
+import { extractFrames, frame } from './codec.js';
 
 /** In-process TCP stand-in for the meshtastic-serial-bridge; hands out accepted sockets. */
 export function startBridge(
@@ -10,6 +10,8 @@ export function startBridge(
 ): Promise<{ port: number; sockets: net.Socket[]; close: () => void }> {
   const sockets: net.Socket[] = [];
   const server = net.createServer((socket) => {
+    // Test-owned socket: the service destroys its end mid-test with unread data pending (overflow/garbage tests), which makes the kernel send RST and this side emit ECONNRESET. Expected teardown noise — without a handler Node throws it as an uncaught exception and vitest fails the whole run.
+    socket.on('error', () => {});
     onSocket?.(socket); // attached at accept time, before any data can arrive
     sockets.push(socket);
   });
@@ -176,6 +178,21 @@ export function textPacketFrame(
   );
 }
 
+/** Outbound text packets written to the bridge, in order (want_config frames skipped). */
+export function outboundPackets(out: Uint8Array[]): P.Mesh.MeshPacket[] {
+  const merged = new Uint8Array(out.reduce((n, c) => n + c.length, 0));
+  let off = 0;
+  for (const c of out) {
+    merged.set(c, off);
+    off += c.length;
+  }
+  return extractFrames(merged).packets.flatMap((p) => {
+    const tr = fromBinary(P.Mesh.ToRadioSchema, p);
+    if (tr.payloadVariant?.case === 'packet') return [tr.payloadVariant.value];
+    return [];
+  });
+}
+
 export const KAMIL_NUM = 123456789;
 
 export function kamilNodeInfo(): NodeInfoFields {

src/mesh/mesh.service.spec.ts

@@ -1,6 +1,7 @@
 import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
 import * as P from '@meshtastic/protobufs';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
+import * as net from 'node:net';
 import { DatabaseSync } from 'node:sqlite';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { BROADCAST_ADDR, extractFrames, frame } from './codec.js';
@@ -11,6 +12,7 @@ import {
   metadataFrame,
   moduleConfigSectionFrame,
   nodeInfoFrame,
+  outboundPackets,
   startBridge,
   telemetryPacketFrame,
   textPacketFrame,
@@ -248,6 +250,195 @@ describe('MeshService connect', () => {
   });
 });
 
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe('MeshService idle watchdog', () => {
+  it('forces a reconnect when an established connection goes silent past MESH_IDLE_TIMEOUT_MS', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
+    process.env.MESH_IDLE_TIMEOUT_MS = '100'; // override — the default (60000) would never fire in a test
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // zombie case: connected but no inbound traffic at all — wait past the timeout, then drive a watchdog tick
+      await sleep(250);
+      svc.checkIdle();
+
+      // socket torn down → existing connect/retry loop re-establishes with a fresh session
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      delete process.env.MESH_IDLE_TIMEOUT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('raw non-frame bytes do NOT keep the watchdog alive — a garbage-only stream forces a reconnect', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
+    process.env.MESH_IDLE_TIMEOUT_MS = '100'; // override — the default (60000) would never fire in a test
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // today's incident: the peer keeps dribbling small non-frame bytes (keepalive noise / desynced stream) — raw chunks must not reset the idle clock
+      const garbage = Buffer.from('zz-no-frames-here'); // pure ASCII — never forms a 0x94 0xc3 frame header
+      for (let i = 0; i < 6; i++) {
+        await sleep(50); // ~300 ms wall time, well past the timeout
+        bridge.sockets[0].write(garbage);
+      }
+
+      svc.checkIdle();
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      delete process.env.MESH_IDLE_TIMEOUT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('forces a reconnect when the undecoded frame buffer exceeds MESH_MAX_FRAME_BUFFER', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
+    process.env.MESH_MAX_FRAME_BUFFER = '100'; // tiny cap — Node delivers socket data in ~64 KB events, far below the 256_000 default
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // non-frame bytes (0x42 is not part of any frame header) — a desynced stream that never forms frames; the first ~64 KB data event alone exceeds the cap
+      bridge.sockets[0].write(Buffer.alloc(300_000, 0x42));
+
+      // overflow forced a reconnect — fresh session
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+
+      // the new socket starts with a clean buffer and decodes valid frames normally (the myInfo frame is well under the cap)
+      const fr = create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'myInfo', value: { myNodeNum: 777 } },
+      });
+      bridge.sockets[1].write(frame(toBinary(P.Mesh.FromRadioSchema, fr)));
+      await waitFor(() => svc.status().myNodeNum === 777);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      delete process.env.MESH_MAX_FRAME_BUFFER;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('inbound traffic keeps resetting the idle clock — no false trigger while packets arrive', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_IDLE_TIMEOUT_MS = '100';
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // steady drip of inbound frames for well over the timeout in wall time — each chunk resets lastPacketAt
+      for (let i = 0; i < 5; i++) {
+        await sleep(60);
+        bridge.sockets[0].write(nodeInfoFrame(42, kamilNodeInfo()));
+      }
+
+      svc.checkIdle(); // wall time is past the timeout, but traffic kept resetting it
+      await sleep(100); // enough for a destroy to surface as 'close' (connected would flip false)
+      expect(svc.status().connected).toBe(true);
+      expect(bridge.sockets.length).toBe(1);
+    } finally {
+      delete process.env.MESH_IDLE_TIMEOUT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('does not trigger under the default timeout (MESH_IDLE_TIMEOUT_MS unset)', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    delete process.env.MESH_IDLE_TIMEOUT_MS; // default 60000 — a test can't wait that long, so silence must NOT fire
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      await sleep(250); // silent, but far under the default budget
+      svc.checkIdle();
+
+      expect(svc.status().connected).toBe(true);
+      expect(bridge.sockets.length).toBe(1);
+    } finally {
+      delete process.env.MESH_IDLE_TIMEOUT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('enables TCP keepalive on the bridge socket', async () => {
+    const setKeepAlive = vi.spyOn(net.Socket.prototype, 'setKeepAlive');
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(() => svc.status().connected);
+      expect(setKeepAlive).toHaveBeenCalledWith(true, 30_000);
+    } finally {
+      setKeepAlive.mockRestore();
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
+
+describe('MeshService periodic autoreconnect', () => {
+  it('unconditionally reconnects when MESH_RECONNECT_INTERVAL_MS elapses', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
+    process.env.MESH_RECONNECT_INTERVAL_MS = '100'; // override — the default (300000) would never elapse in a test
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // interval fires → destroy → existing close/retry loop re-establishes with a fresh session
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      delete process.env.MESH_RECONNECT_INTERVAL_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
+
 describe('MeshService send', () => {
   it('sends on the test channel (index 3) by default, never primary', async () => {
     const bridge = await startBridge();
@@ -667,21 +858,6 @@ describe('MeshService message history', () => {
   });
 });
 
-// outbound text packets written to the bridge, in order (want_config frames skipped)
-function outboundPackets(out: Uint8Array[]): P.Mesh.MeshPacket[] {
-  const merged = new Uint8Array(out.reduce((n, c) => n + c.length, 0));
-  let off = 0;
-  for (const c of out) {
-    merged.set(c, off);
-    off += c.length;
-  }
-  return extractFrames(merged).packets.flatMap((p) => {
-    const tr = fromBinary(P.Mesh.ToRadioSchema, p);
-    if (tr.payloadVariant?.case === 'packet') return [tr.payloadVariant.value];
-    return [];
-  });
-}
-
 describe('MeshService respond', () => {
   it('replies to an rx DM as a directed send back to the sender on the original channel with replyId = messageId', async () => {
     const bridge = await startBridge();

src/mesh/mesh.service.ts

@@ -81,6 +81,8 @@ export interface TelemetryRecord {
 const HISTORY_LIMIT = 100;
 /** Rows kept in SQLite across restarts; older rows are pruned on every poller tick. */
 const DB_RETENTION = 1000;
+// how often the idle watchdog checks for a silent-but-connected bridge (ms)
+const IDLE_CHECK_MS = 30_000;
 
 // one row per MessageRecord, keyed by packet id (tx ids and injected ids are random uint32, rx uses the wire id)
 export const MESSAGES_DDL = `CREATE TABLE IF NOT EXISTS messages(
@@ -208,6 +210,21 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
   );
   // how often the poller re-upserts the history buffer into SQLite (ms)
   private readonly pollMs = parseInt(process.env.MESH_POLL_MS ?? '1000', 10);
+  // idle watchdog: force a reconnect when an ESTABLISHED connection stops decoding frames — the zombie-bridge case where outbound sends keep working but inbound frame flow is dead (raw non-frame bytes do NOT reset the clock). Read at construction like the other env config.
+  private readonly idleTimeoutMs = parseInt(
+    process.env.MESH_IDLE_TIMEOUT_MS ?? '60000',
+    10,
+  );
+  // lazy periodic autoreconnect: unconditionally destroy + re-establish every N ms so a fresh sync happens on schedule — the bridge/radio side tends to kill inbound RX within ~20 min of a fresh sync. Read at construction like the other env config.
+  private readonly reconnectIntervalMs = parseInt(
+    process.env.MESH_RECONNECT_INTERVAL_MS ?? '300000',
+    10,
+  );
+  // cap on undecoded frame buffer: a desynced stream that never forms frames would grow it without bound — force a reconnect instead. Env-overridable so tests can trigger it (Node caps socket 'data' events at ~64 KB).
+  private readonly maxFrameBuffer = parseInt(
+    process.env.MESH_MAX_FRAME_BUFFER ?? '256000',
+    10,
+  );
 
   /** SQLite database backing the message history; null = persistence disabled (tests construct without one). */
   private db: DatabaseSync | null = null;
@@ -255,6 +272,10 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
   // telemetry history (newest kept, capped at HISTORY_LIMIT)
   private telemetryHistory: TelemetryRecord[] = [];
   private reconnectTimer: NodeJS.Timeout | null = null;
+  /** epoch ms when the last valid frame was decoded from the bridge; reset on connect — idle watchdog baseline */
+  private lastPacketAt = Date.now();
+  private idleTimer: NodeJS.Timeout | null = null;
+  private periodicReconnectTimer: NodeJS.Timeout | null = null;
   private shuttingDown = false;
 
   onModuleInit(): void {
@@ -264,6 +285,15 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
       // ponytail: full re-upsert of the ≤100-row buffer every tick — trivial load, zero bookkeeping
       this.pollTimer = setInterval(() => this.flushHistory(), this.pollMs);
     }
+    // idle watchdog: catches established-but-silent connections (zombie bridge) that the connect/retry loop never sees
+    this.idleTimer = setInterval(() => this.checkIdle(), IDLE_CHECK_MS);
+    // lazy periodic autoreconnect: unconditional fresh sync on a fixed schedule; when not connected, destroy is a no-op and the retry loop owns recovery
+    this.periodicReconnectTimer = setInterval(() => {
+      this.logger.log(
+        'periodic reconnect — MESH_RECONNECT_INTERVAL_MS elapsed',
+      );
+      this.socket?.destroy();
+    }, this.reconnectIntervalMs);
     this.connect();
   }
 
@@ -271,6 +301,8 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
     this.shuttingDown = true;
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.idleTimer) clearInterval(this.idleTimer);
+    if (this.periodicReconnectTimer) clearInterval(this.periodicReconnectTimer);
     this.socket?.destroy();
     this.db?.close();
   }
@@ -641,11 +673,17 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
   private connect(): void {
     if (this.shuttingDown) return;
     const socket = net.createConnection({ host: this.host, port: this.port });
+    // TCP-level keepalive: cheap insurance against a dead peer that the idle watchdog (application level) complements
+    socket.setKeepAlive(true, 30_000);
     this.socket = socket;
     socket.on('connect', () => {
       this.connected = true;
+      // fresh connection — reset the idle clock so it can't self-trigger before any traffic arrives
+      this.lastPacketAt = Date.now();
       // fresh sync on every (re)connect — drop stale channels/nodes/device info/telemetry from the old session;
-      // message history is NOT reset: it's an append-only log backed by SQLite and survives reconnects
+      // message history is NOT reset: it's an append-only log backed by SQLite and survives reconnects.
+      // The undecoded frame buffer goes too: leftover desync garbage must not re-trigger the overflow backstop on a healthy new stream.
+      this.buffer = new Uint8Array(0);
       this.channelMap = new Map();
       this.nodeMap = new Map();
       this.metadata = null;
@@ -666,9 +704,19 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
       const merged = new Uint8Array(this.buffer.length + chunk.length);
       merged.set(this.buffer, 0);
       merged.set(chunk, this.buffer.length);
+      // buffer-overflow backstop: a desynced stream that never forms frames would grow the buffer without bound — cap it and self-heal via reconnect
+      if (merged.length > this.maxFrameBuffer) {
+        this.logger.error(
+          'frame buffer overflow — stream desync, forcing reconnect',
+        );
+        socket.destroy();
+        return;
+      }
       this.buffer = merged;
       const { packets, rest } = extractFrames(this.buffer);
       this.buffer = rest;
+      // the watchdog tracks DECODED FRAMES, not raw bytes: non-frame noise (keepalives, desynced streams) must not keep a dead connection alive
+      if (packets.length) this.lastPacketAt = Date.now();
       for (const p of packets) {
         decodeFromRadio(p)
           .then((fr) => this.handleFromRadio(fr))
@@ -694,6 +742,25 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
     this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectMs);
   }
 
+  /**
+   * Idle watchdog tick: force a reconnect when an ESTABLISHED connection has decoded no frames from
+   * the bridge for MESH_IDLE_TIMEOUT_MS — the zombie case where outbound sends keep working but inbound
+   * frame flow is dead (raw non-frame bytes arriving on the socket do not count). Destroying the socket
+   * routes through 'close' → onDown → scheduleReconnect, so the existing connect/retry loop re-establishes
+   * with a fresh sync; no new retry machinery here. Public so tests can drive a tick without waiting for
+   * the real interval (like flushHistory()).
+   */
+  checkIdle(): void {
+    if (!this.connected) return; // disconnected state is owned by the connect/retry loop
+    const idle = Date.now() - this.lastPacketAt;
+    if (idle > this.idleTimeoutMs) {
+      this.logger.warn(
+        `no decoded bridge frames for ${idle} ms — forcing reconnect`,
+      );
+      this.socket?.destroy();
+    }
+  }
+
   private async handleFromRadio(
     fr: import('@meshtastic/protobufs').Mesh.FromRadio,
   ): Promise<void> {

src/rss/rss.feed.spec.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { parseFeed } from './rss.feed.js';
+
+const RSS2 = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>Some Feed</title>
+    <item>
+      <title>First headline</title>
+      <link>https://example.com/first</link>
+    </item>
+    <item>
+      <title><![CDATA[Second: with CDATA]]></title>
+      <description>ignored</description>
+    </item>
+    <item>
+      <title></title>
+      <link>https://example.com/empty-title</link>
+    </item>
+  </channel>
+</rss>`;
+
+const ATOM = `<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>An Atom feed</title>
+  <entry>
+    <title>Only entry</title>
+    <link rel="alternate" href="https://example.com/atom"/>
+  </entry>
+</feed>`;
+
+describe('parseFeed', () => {
+  it('parses RSS 2.0 items in document order, keeping links where present and skipping empty titles', () => {
+    expect(parseFeed(RSS2)).toEqual([
+      { title: 'First headline', link: 'https://example.com/first' },
+      { title: 'Second: with CDATA' },
+    ]);
+  });
+
+  it('parses Atom entries (single entry object, link as href attribute)', () => {
+    expect(parseFeed(ATOM)).toEqual([
+      { title: 'Only entry', link: 'https://example.com/atom' },
+    ]);
+  });
+
+  it('returns [] for malformed XML', () => {
+    expect(parseFeed('this is not xml at all')).toEqual([]);
+    expect(parseFeed('<rss><channel><item><title>broken')).toEqual([]);
+  });
+
+  it('returns [] when there are no items or none with a usable title', () => {
+    expect(
+      parseFeed('<rss version="2.0"><channel><title>x</title></channel></rss>'),
+    ).toEqual([]);
+    expect(
+      parseFeed('<feed xmlns="http://www.w3.org/2005/Atom"></feed>'),
+    ).toEqual([]);
+    expect(
+      parseFeed(
+        '<rss version="2.0"><channel><item><title>   </title></item></channel></rss>',
+      ),
+    ).toEqual([]);
+  });
+});

src/rss/rss.feed.ts

@@ -0,0 +1,60 @@
+import { XMLParser } from 'fast-xml-parser';
+
+/** One feed item: title always present (non-empty), link where the feed provides one. */
+export interface FeedItem {
+  title: string;
+  link?: string;
+}
+
+const parser = new XMLParser({ ignoreAttributes: false });
+
+function asText(value: unknown): string | undefined {
+  if (typeof value === 'string') return value.trim() || undefined;
+  // element with attributes/CDATA parses to an object holding its text under #text
+  const t = (value as Record<string, unknown>)?.['#text'];
+  if (typeof t === 'string' && t.trim()) return t.trim();
+  return undefined;
+}
+
+function asLink(value: unknown): string | undefined {
+  const fromText = asText(value);
+  if (fromText) return fromText; // RSS 2.0 <link>url</link>
+  // Atom <link rel="alternate" href="..."/> — the URL is an attribute
+  const href = (value as Record<string, unknown>)?.['@_href'];
+  if (typeof href === 'string' && href.trim()) return href.trim();
+  return undefined;
+}
+
+function collect(value: unknown): Record<string, unknown>[] {
+  // a single item/entry parses to an object, several to an array
+  if (!value) return [];
+  const arr = Array.isArray(value) ? value : [value];
+  return arr.filter(
+    (v): v is Record<string, unknown> => !!v && typeof v === 'object',
+  );
+}
+
+/**
+ * Parse RSS 2.0 (`<item><title>/<link>`) or Atom (`<entry><title>`) XML into items with
+ * non-empty titles, in document order (feeds are newest-first). Returns [] for malformed
+ * input or feeds without usable items — that empty result IS the "not a valid feed" signal.
+ */
+export function parseFeed(xml: string): FeedItem[] {
+  let doc: unknown;
+  try {
+    doc = parser.parse(xml);
+  } catch {
+    return []; // fast-xml-parser is lenient, but a hard failure means no items either
+  }
+  const root = doc as Record<string, any>;
+  // coalesce the RAW values first — collect() always returns an array, so `collect(a) ?? collect(b)` could never fall through to b
+  const rawItems = collect(root?.rss?.channel?.item ?? root?.feed?.entry);
+  const items: FeedItem[] = [];
+  for (const item of rawItems) {
+    const title = asText(item?.title);
+    if (!title) continue; // skip entries without a usable title
+    const link = asLink(item.link);
+    items.push(link ? { title, link } : { title });
+  }
+  return items;
+}

src/rss/rss.module.ts

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { LlmModule } from '../llm/llm.module.js';
+import { LlmService } from '../llm/llm.service.js';
+import { RssService } from './rss.service.js';
+
+// The rss_sources table lives in the SAME file as the mesh message history (MESH_DB_PATH) — a second
+// connection is fine, SQLite serializes writes. The service initializes its own table on construction.
+function openRssDb(): DatabaseSync {
+  const path = process.env.MESH_DB_PATH ?? './data/mesh-bot.db';
+  mkdirSync(dirname(path), { recursive: true });
+  return new DatabaseSync(path);
+}
+
+@Module({
+  imports: [LlmModule], // one-way — LlmService has no dependencies of its own
+  providers: [
+    {
+      provide: RssService,
+      useFactory: (llm: LlmService) => new RssService(llm, openRssDb()),
+      inject: [LlmService],
+    },
+  ],
+  exports: [RssService],
+})
+export class RssModule {}

src/rss/rss.service.spec.ts

@@ -0,0 +1,317 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { LlmService } from '../llm/llm.service.js';
+import { RssStore } from './rss.store.js';
+import { fitOneLine, parseSummaryItems, RssService } from './rss.service.js';
+
+const FEED_A = `<rss version="2.0"><channel>
+  <item><title>Alpha headline</title></item>
+  <item><title>Beta headline</title></item>
+</channel></rss>`;
+const FEED_B = `<rss version="2.0"><channel>
+  <item><title>Gamma headline</title></item>
+</channel></rss>`;
+
+function feedResponse(xml: string): Response {
+  return { ok: true, status: 200, text: async () => xml } as Response;
+}
+
+describe('RssService.handle', () => {
+  let dir: string;
+  let dbFile: string;
+  let llm: { chat: ReturnType<typeof vi.fn> };
+  let svc: RssService;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-rss-svc-'));
+    dbFile = join(dir, 'test.db');
+    llm = { chat: vi.fn() };
+    svc = new RssService(
+      llm as unknown as LlmService,
+      new DatabaseSync(dbFile),
+    );
+    fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const ctx = (text: string) => ({ text });
+  // second connection — the same shape production uses for a separate table in one file
+  const stored = () => new RssStore(new DatabaseSync(dbFile));
+
+  it('replies with usage on bare #rss and on unknown subcommands', async () => {
+    const help = await svc.handle(ctx('#rss'));
+    expect(help).toContain('#rss add <url> <name>');
+    expect(help).toContain('#rss get <name|#tag>');
+    expect(await svc.handle(ctx('#rss frobnicate'))).toBe(help);
+  });
+
+  it('add: validates the feed, stores source with LLM tags, replies added (tags: ...)', async () => {
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    llm.chat.mockResolvedValueOnce('#AI, News');
+
+    const reply = await svc.handle(
+      ctx('#rss add https://a.example/rss my feed'),
+    );
+
+    expect(reply).toBe('added my feed (tags: ai, news)');
+    expect(stored().get('my feed')).toMatchObject({
+      url: 'https://a.example/rss',
+      tags: ['ai', 'news'],
+    });
+    const [messages, opts] = llm.chat.mock.calls[0];
+    expect(opts).toEqual({ maxTokens: 50 });
+    expect(messages[0].content).toContain('Alpha headline');
+  });
+
+  it('add: LLM failure still stores the source with empty tags and says so', async () => {
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    llm.chat.mockRejectedValueOnce(new Error('llm down'));
+
+    const reply = await svc.handle(
+      ctx('#rss add https://a.example/rss myfeed'),
+    );
+
+    expect(reply).toBe('added myfeed (tag generation failed - no tags)');
+    expect(stored().get('myfeed')?.tags).toEqual([]);
+  });
+
+  it('add: rejects invalid urls without fetching or storing', async () => {
+    expect(await svc.handle(ctx('#rss add not a url x'))).toBe('invalid url');
+    expect(await svc.handle(ctx('#rss add ftp://a.example/rss x'))).toBe(
+      'invalid url',
+    );
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(stored().list()).toEqual([]);
+  });
+
+  it('add: rejects duplicate names case-insensitively without fetching', async () => {
+    stored().add({ name: 'MyFeed', url: 'https://old.example/rss', tags: [] });
+
+    const reply = await svc.handle(
+      ctx('#rss add https://a.example/rss myfeed'),
+    );
+
+    expect(reply).toBe('myfeed already exists - remove it first');
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(stored().get('myfeed')?.url).toBe('https://old.example/rss'); // untouched
+  });
+
+  it('add: reports non-2xx and unparseable feeds, stores nothing', async () => {
+    fetchMock.mockResolvedValueOnce({ ok: false, status: 404 } as Response);
+    expect(await svc.handle(ctx('#rss add https://a.example/rss x'))).toBe(
+      'feed fetch failed (HTTP 404)',
+    );
+
+    fetchMock.mockResolvedValueOnce(feedResponse('this is not xml'));
+    expect(await svc.handle(ctx('#rss add https://b.example/rss y'))).toBe(
+      'not a valid feed (no items)',
+    );
+    expect(stored().list()).toEqual([]);
+  });
+
+  it('remove: deletes case-insensitively, reports missing names', async () => {
+    stored().add({ name: 'Gone', url: 'https://g.example/rss', tags: [] });
+    expect(await svc.handle(ctx('#rss remove gone'))).toBe('removed gone');
+    expect(stored().list()).toEqual([]);
+    expect(await svc.handle(ctx('#rss remove nope'))).toBe(
+      'no source named nope',
+    );
+  });
+
+  it('tags: no tags yet when empty, distinct sorted list otherwise', async () => {
+    expect(await svc.handle(ctx('#rss tags'))).toBe('no tags yet');
+    stored().add({
+      name: 'A',
+      url: 'https://a.example/rss',
+      tags: ['zeta', 'alpha'],
+    });
+    stored().add({
+      name: 'B',
+      url: 'https://b.example/rss',
+      tags: ['beta', 'alpha'],
+    });
+    expect(await svc.handle(ctx('#rss tags'))).toBe('alpha, beta, zeta');
+  });
+
+  it('sources: no sources yet when empty, names otherwise', async () => {
+    expect(await svc.handle(ctx('#rss sources'))).toBe('no sources yet');
+    stored().add({ name: 'Bee', url: 'https://b.example/rss', tags: [] });
+    stored().add({ name: 'Aye', url: 'https://a.example/rss', tags: [] });
+    expect(await svc.handle(ctx('#rss sources'))).toBe('Aye, Bee');
+  });
+
+  it('get <name>: summarizes via chat with a bounded maxTokens and replies with headered lines', async () => {
+    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    llm.chat.mockResolvedValueOnce(
+      'Chips: EU funds foundries.\nPark: Riverfront expansion approved.',
+    );
+
+    const reply = await svc.handle(ctx('#rss get myfeed'));
+
+    expect(reply).toEqual([
+      'Chips: EU funds foundries.',
+      'Park: Riverfront expansion approved.',
+    ]);
+    const [messages, opts] = llm.chat.mock.calls[0];
+    // headroom for the server's reasoning tokens (they count against max_tokens) — see rss.service.ts
+    expect(opts).toEqual({ maxTokens: 2500 });
+    const prompt = messages[0].content;
+    expect(prompt).toContain('exactly 3-5 lines');
+    expect(prompt).toContain('<short header>: <one or two short sentences>');
+    expect(prompt).toContain('at most 20 characters');
+    expect(prompt).toContain('No intro, no outro, no numbering');
+    expect(prompt).toContain('Alpha headline');
+    expect(prompt).toContain('Beta headline');
+  });
+
+  it('get <name>: caps items at 5', async () => {
+    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    const seven = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+      .map((c) => `${c}: item ${c}`)
+      .join('\n');
+    llm.chat.mockResolvedValueOnce(seven);
+
+    const reply = await svc.handle(ctx('#rss get myfeed'));
+
+    expect(reply).toEqual([
+      'a: item a',
+      'b: item b',
+      'c: item c',
+      'd: item d',
+      'e: item e',
+    ]);
+  });
+
+  it('get <name>: drops empty and separator-less lines, sends what remains when fewer than 3 are valid', async () => {
+    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    llm.chat.mockResolvedValueOnce(
+      'Chips: EU funds foundries.\n\nJust a sentence without a header\n   \nPark: expansion approved.',
+    );
+
+    const reply = await svc.handle(ctx('#rss get myfeed'));
+
+    expect(reply).toEqual([
+      'Chips: EU funds foundries.',
+      'Park: expansion approved.',
+    ]);
+  });
+
+  it('get <name>: hard-cuts an over-length line at a word boundary so each item fits one packet', async () => {
+    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
+    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
+    const longLine = `Chips: ${'word '.repeat(40)}`; // 207 chars — over the per-line cap
+    llm.chat.mockResolvedValueOnce(`${longLine}\nPark: short line.`);
+
+    const reply = await svc.handle(ctx('#rss get myfeed'));
+
+    expect(Array.isArray(reply)).toBe(true);
+    const [cut, ok] = reply as string[];
+    expect(cut.length).toBeLessThanOrEqual(180);
+    expect(longLine.startsWith(cut)).toBe(true); // prefix — cut at a word boundary, not mid-word
+    expect(cut.endsWith(' ')).toBe(false);
+    expect(ok).toBe('Park: short line.'); // other lines untouched
+  });
+
+  it('get #tag: collects items across all sources with the tag; one dead feed does not sink it', async () => {
+    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
+    stored().add({ name: 'B', url: 'https://b.example/rss', tags: ['tech'] });
+    stored().add({ name: 'C', url: 'https://c.example/rss', tags: ['other'] }); // not matched by #tech
+    fetchMock
+      .mockResolvedValueOnce(feedResponse(FEED_A)) // A answers (Alpha, Beta)
+      .mockRejectedValueOnce(new Error('down')); // B is dead
+
+    llm.chat.mockResolvedValueOnce('Chips: only alpha survived.');
+    const reply = await svc.handle(ctx('#rss get #tech'));
+
+    // B's fetch rejected, yet the summary still went out from A's titles alone
+    expect(reply).toEqual(['Chips: only alpha survived.']);
+    expect(llm.chat).toHaveBeenCalledTimes(1);
+    const content = llm.chat.mock.calls[0][0][0].content;
+    expect(content).toContain('Alpha headline');
+  });
+
+  it('get #tag: merges titles from every source carrying the tag', async () => {
+    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
+    stored().add({ name: 'B', url: 'https://b.example/rss', tags: ['tech'] });
+    fetchMock
+      .mockResolvedValueOnce(feedResponse(FEED_A)) // A → Alpha, Beta
+      .mockResolvedValueOnce(feedResponse(FEED_B)); // B → Gamma
+
+    llm.chat.mockResolvedValueOnce(
+      'Alpha: first headline.\nGamma: second headline.',
+    );
+    const reply = await svc.handle(ctx('#rss get #tech'));
+
+    expect(reply).toEqual([
+      'Alpha: first headline.',
+      'Gamma: second headline.',
+    ]);
+    const content = llm.chat.mock.calls[0][0][0].content;
+    expect(content).toContain('Alpha headline');
+    expect(content).toContain('Gamma headline'); // proves B's feed was collected too
+  });
+
+  it('get: unknown name and tag get distinct error replies', async () => {
+    expect(await svc.handle(ctx('#rss get nope'))).toBe('no source named nope');
+    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
+    expect(await svc.handle(ctx('#rss get #nothing'))).toBe(
+      'no sources with tag nothing',
+    );
+  });
+});
+
+describe('parseSummaryItems (per-line items for multi-message summaries)', () => {
+  it('keeps lines with a header separator, drops empty and separator-less ones', () => {
+    expect(
+      parseSummaryItems(
+        'Chips: EU funds foundries.\n\nNo header here\n   \nPark: expansion approved.',
+      ),
+    ).toEqual(['Chips: EU funds foundries.', 'Park: expansion approved.']);
+  });
+
+  it('caps at 5 items', () => {
+    const seven = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+      .map((c) => `${c}: item`)
+      .join('\n');
+    expect(parseSummaryItems(seven)).toHaveLength(5);
+    expect(parseSummaryItems(seven)[4]).toBe('e: item');
+  });
+
+  it('returns [] when nothing is valid', () => {
+    expect(parseSummaryItems('no headers at all\n')).toEqual([]);
+  });
+});
+
+describe('fitOneLine (one mesh packet per line)', () => {
+  it('passes through lines that already fit, including exactly 185 chars', () => {
+    const short = 'Chips: EU funds foundries.';
+    expect(fitOneLine(short)).toBe(short);
+    const exact = 'x'.repeat(185);
+    expect(fitOneLine(exact)).toBe(exact);
+  });
+
+  it('cuts over-long lines at a word boundary near 180', () => {
+    const long = `Chips: ${'word '.repeat(40)}`; // 207 chars
+    const cut = fitOneLine(long);
+    expect(cut.length).toBeLessThanOrEqual(180);
+    expect(long.startsWith(cut)).toBe(true); // prefix — not mid-word
+    expect(cut.endsWith(' ')).toBe(false);
+  });
+
+  it('hard-cuts at 180 when there is no word boundary in reach', () => {
+    const long = 'w'.repeat(250);
+    expect(fitOneLine(long)).toBe('w'.repeat(180));
+  });
+});

src/rss/rss.service.ts

@@ -0,0 +1,237 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DatabaseSync } from 'node:sqlite';
+// type-only both ways — no runtime import cycle between src/rss and src/commands
+import type { CommandContext } from '../commands/command.service.js';
+import { LlmService } from '../llm/llm.service.js';
+import { parseFeed } from './rss.feed.js';
+import { RssStore } from './rss.store.js';
+
+// ponytail: hardcoded tunables, promote to env if the owner wants them adjustable
+const FETCH_TIMEOUT_MS = 15000; // feed fetches — same budget as the opencode notifier's POSTs
+const MAX_TITLES = 8; // "up to 8 latest item titles" per the design
+const TAG_MAX_TOKENS = 50;
+// The LLM server (qwen3.8-27b) emits reasoning_content and those tokens COUNT against max_tokens
+// (verified: cap 150 → completion_tokens 150 of which 105 were reasoning, finish_reason 'length').
+// Thinking length for this task is unbounded and uncontrollable server-side (/no_think,
+// chat_template_kwargs.enable_thinking and thinking_budget are all ignored) — observed 32..1776
+// tokens across runs. So the cap must be headroom for reasoning + ~80 content tokens:
+// 2500 covers every observed run (worst case ≈42 s at ~60 tok/s, under LLM_TIMEOUT_MS=60 s).
+const SUMMARY_MAX_TOKENS = 2500;
+// Mesh fragments replies longer than ~190 chars into fire-and-forget packets that recipients
+// often never get — each summary line must fit ONE packet on its own. The prompt asks for short
+// headered lines; this is the hard backstop if the model ignores it (cut at a word boundary).
+const MAX_LINE_CHARS = 185; // per-line one-packet threshold
+const LINE_CUT_AT = 180; // where over-long lines get cut, snapped back to a word boundary
+const MAX_ITEMS = 5; // cap on summary items sent as separate messages
+
+/**
+ * The `#rss` command family: stored RSS sources (SQLite, shared MESH_DB_PATH file) with
+ * LLM-generated tags and on-demand headline summaries. Replies are short strings — or an array
+ * of lines for multi-message summaries, which CommandService sends one respond() per line.
+ */
+@Injectable()
+export class RssService {
+  private readonly logger = new Logger(RssService.name);
+  private readonly store: RssStore;
+
+  constructor(
+    private readonly llm: LlmService,
+    db: DatabaseSync,
+  ) {
+    this.store = new RssStore(db);
+  }
+
+  /** Entry point for the `#rss` prefix — always replies (errors included); `get` may reply with several lines. */
+  async handle(ctx: CommandContext): Promise<string | string[]> {
+    const words = ctx.text.trim().split(/\s+/);
+    switch (words[1]) {
+      case undefined: // bare `#rss`
+      case 'help':
+        return this.help();
+      case 'add':
+        return this.add(words.slice(2));
+      case 'remove':
+        return this.remove(words.slice(2).join(' '));
+      case 'tags':
+        return this.tags();
+      case 'sources':
+        return this.sources();
+      case 'get':
+        return this.get((words[2] ?? '').trim());
+      default:
+        return this.help(); // unknown subcommand → help
+    }
+  }
+
+  private help(): string {
+    return [
+      '#rss add <url> <name> - add source with AI tags',
+      '#rss remove <name> - delete a source',
+      '#rss get <name|#tag> - summarize latest items',
+      '#rss tags - all distinct tags',
+      '#rss sources - all source names',
+    ].join('\n');
+  }
+
+  /** `#rss add <url> <name>` — name may contain spaces (everything after the url). */
+  private async add(args: string[]): Promise<string> {
+    const url = args[0];
+    const name = args.slice(1).join(' ').trim();
+    if (!url || !name) return 'usage: #rss add <url> <name>';
+    let parsedUrl: URL;
+    try {
+      parsedUrl = new URL(url);
+    } catch {
+      return 'invalid url';
+    }
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')
+      return 'invalid url';
+    if (this.store.exists(name))
+      return `${name} already exists - remove it first`;
+
+    let titles: string[];
+    try {
+      titles = await this.fetchLatestTitles(url);
+    } catch (err) {
+      const msg = (err as Error).message;
+      // fetchLatestTitles throws `HTTP <status>` on non-2xx, other errors carry their own message
+      return msg.startsWith('HTTP')
+        ? `feed fetch failed (${msg})`
+        : 'not a valid feed';
+    }
+    if (!titles.length) return 'not a valid feed (no items)';
+
+    // AI tags — best effort: a source is still added when the LLM fails
+    let tags: string[] = [];
+    try {
+      const raw = await this.llm.chat(
+        [
+          {
+            role: 'user',
+            content: `Give 2-4 short lowercase tags for these RSS feed item titles. Reply with comma-separated tags only - no # symbols, no explanation:\n${titles.join('\n')}`,
+          },
+        ],
+        { maxTokens: TAG_MAX_TOKENS },
+      );
+      tags = sanitizeTags(raw);
+    } catch (err) {
+      this.logger.warn(
+        `[rss] tag generation failed for '${name}': ${(err as Error).message}`,
+      );
+    }
+
+    this.store.add({ name, url, tags });
+    return tags.length
+      ? `added ${name} (tags: ${tags.join(', ')})`
+      : 'added ' + name + ' (tag generation failed - no tags)';
+  }
+
+  private remove(name: string): string {
+    if (!name) return 'usage: #rss remove <name>';
+    return this.store.remove(name)
+      ? `removed ${name}`
+      : `no source named ${name}`;
+  }
+
+  private tags(): string {
+    const all = this.store.allTags();
+    return all.length ? all.join(', ') : 'no tags yet';
+  }
+
+  private sources(): string {
+    const names = this.store.list().map((s) => s.name);
+    return names.length ? names.join(', ') : 'no sources yet';
+  }
+
+  /** `#rss get <name>` or `#rss get #<tag>` — replies with 3-5 separate one-packet lines. */
+  private async get(target: string): Promise<string | string[]> {
+    if (!target) return 'usage: #rss get <name|#tag>';
+
+    let urls: string[];
+    if (target.startsWith('#')) {
+      const tag = target.slice(1).toLowerCase();
+      if (!tag) return 'usage: #rss get <name|#tag>';
+      const matching = this.store.list().filter((s) => s.tags.includes(tag));
+      if (!matching.length) return `no sources with tag ${tag}`;
+      urls = matching.map((s) => s.url);
+    } else {
+      const source = this.store.get(target);
+      if (!source) return `no source named ${target}`;
+      urls = [source.url];
+    }
+
+    // one dead feed must not sink the whole summary — collect what answers
+    const results = await Promise.allSettled(
+      urls.map((u) => this.fetchLatestTitles(u)),
+    );
+    const titles: string[] = [];
+    for (const r of results) {
+      if (r.status === 'fulfilled') titles.push(...r.value);
+      else
+        this.logger.warn(
+          `[rss] feed fetch failed: ${(r.reason as Error).message}`,
+        );
+    }
+    if (!titles.length) return 'no items found';
+
+    try {
+      const reply = await this.llm.chat(
+        [
+          {
+            role: 'user',
+            content: `Summarize these RSS headlines into exactly 3-5 lines, one item per line, each in the format "<short header>: <one or two short sentences>" where the header is at most 20 characters (e.g. "Culture: Museum opens new wing"). No intro, no outro, no numbering - items only:\n${titles.join('\n')}`,
+          },
+        ],
+        { maxTokens: SUMMARY_MAX_TOKENS },
+      );
+      // each item goes out as its own mesh message — CommandService sends the array line by line;
+      // fewer than 3 valid lines is fine (the model is non-deterministic), we send what we got
+      return parseSummaryItems(reply).map(fitOneLine);
+    } catch (err) {
+      this.logger.warn(`[rss] summary failed: ${(err as Error).message}`);
+      return 'summary failed';
+    }
+  }
+
+  /** Fetch a feed and return up to MAX_TITLES latest item titles; throws on non-2xx. */
+  private async fetchLatestTitles(url: string): Promise<string[]> {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return parseFeed(await res.text())
+      .slice(0, MAX_TITLES)
+      .map((i) => i.title);
+  }
+}
+
+/** Parse an LLM summary into per-line items: drop empty lines and lines without a `:` header separator, cap at MAX_ITEMS. */
+export function parseSummaryItems(reply: string): string[] {
+  return reply
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l && l.includes(':'))
+    .slice(0, MAX_ITEMS);
+}
+
+/** Hard-cut a single summary line at a word boundary near LINE_CUT_AT when it exceeds MAX_LINE_CHARS. */
+export function fitOneLine(line: string): string {
+  if (line.length <= MAX_LINE_CHARS) return line;
+  const slice = line.slice(0, LINE_CUT_AT);
+  const at = slice.lastIndexOf(' ');
+  return (at > 0 ? slice.slice(0, at) : slice).trimEnd();
+}
+
+/** Normalize LLM tag output: lowercase, no #, whitespace → '-', deduped. */
+export function sanitizeTags(raw: string): string[] {
+  const seen = new Set<string>();
+  for (const part of raw.split(',')) {
+    const tag = part
+      .trim()
+      .toLowerCase()
+      .replace(/^#+/, '')
+      .replace(/\s+/g, '-');
+    if (tag) seen.add(tag);
+  }
+  return [...seen];
+}

src/rss/rss.store.spec.ts

@@ -0,0 +1,80 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { RssStore } from './rss.store.js';
+
+describe('RssStore (real SQLite file)', () => {
+  let dir: string;
+  let store: RssStore;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-rss-'));
+    const db = new DatabaseSync(join(dir, 'test.db'));
+    store = new RssStore(db);
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('adds and lists sources with tags round-tripped through the comma string', () => {
+    store.add({
+      name: 'Hacker News',
+      url: 'https://news.ycombinator.com/rss',
+      tags: ['tech', 'news'],
+    });
+    store.add({ name: 'LWN', url: 'https://lwn.net/headlines.rss', tags: [] });
+
+    expect(store.list()).toEqual([
+      {
+        name: 'Hacker News',
+        url: 'https://news.ycombinator.com/rss',
+        tags: ['tech', 'news'],
+        createdAt: expect.any(Number),
+      },
+      {
+        name: 'LWN',
+        url: 'https://lwn.net/headlines.rss',
+        tags: [],
+        createdAt: expect.any(Number),
+      },
+    ]);
+  });
+
+  it('looks up and checks existence case-insensitively', () => {
+    store.add({ name: 'My Feed', url: 'https://example.com/rss', tags: ['a'] });
+    expect(store.get('my feed')?.url).toBe('https://example.com/rss');
+    expect(store.get('MY FEED')).toBeDefined();
+    expect(store.exists('mY fEeD')).toBe(true);
+    expect(store.exists('other')).toBe(false);
+  });
+
+  it('removes case-insensitively and reports whether a row went', () => {
+    store.add({ name: 'Gone', url: 'https://example.com/gone', tags: [] });
+    expect(store.remove('gone')).toBe(true);
+    expect(store.list()).toEqual([]);
+    expect(store.remove('gone')).toBe(false);
+  });
+
+  it('collects all distinct tags across sources, sorted', () => {
+    store.add({
+      name: 'A',
+      url: 'https://a.example/rss',
+      tags: ['zeta', 'alpha'],
+    });
+    store.add({
+      name: 'B',
+      url: 'https://b.example/rss',
+      tags: ['beta', 'alpha'],
+    });
+    expect(store.allTags()).toEqual(['alpha', 'beta', 'zeta']);
+  });
+
+  it('persists across a second connection to the same file (the production shape)', () => {
+    store.add({ name: 'Durable', url: 'https://d.example/rss', tags: ['x'] });
+    const db2 = new DatabaseSync(join(dir, 'test.db'));
+    expect(new RssStore(db2).get('durable')?.tags).toEqual(['x']);
+  });
+});

src/rss/rss.store.ts

@@ -0,0 +1,108 @@
+import { DatabaseSync } from 'node:sqlite';
+
+/** A stored RSS source; tags are a comma-separated string in the DB, split here. */
+export interface RssSource {
+  name: string;
+  url: string;
+  tags: string[];
+  createdAt: number;
+}
+
+/** Idempotent — safe to call on every open (the table lives in the shared MESH_DB_PATH file). */
+export function initRssTable(db: DatabaseSync): void {
+  db.exec(`CREATE TABLE IF NOT EXISTS rss_sources (
+    name TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    tags TEXT NOT NULL DEFAULT '',
+    created_at INTEGER
+  )`);
+}
+
+/** CRUD for the rss_sources table. Names are matched case-insensitively everywhere. */
+export class RssStore {
+  constructor(private readonly db: DatabaseSync) {
+    initRssTable(db);
+  }
+
+  list(): RssSource[] {
+    const rows = this.db
+      .prepare(
+        'SELECT name, url, tags, created_at FROM rss_sources ORDER BY name',
+      )
+      .all() as {
+      name: string;
+      url: string;
+      tags: string;
+      created_at: number;
+    }[];
+    return rows.map((r) => ({
+      name: r.name,
+      url: r.url,
+      tags: splitTags(r.tags),
+      createdAt: r.created_at,
+    }));
+  }
+
+  /** Case-insensitive lookup by name. */
+  get(name: string): RssSource | undefined {
+    const row = this.db
+      .prepare(
+        'SELECT name, url, tags, created_at FROM rss_sources WHERE name = ? COLLATE NOCASE',
+      )
+      .get(name) as
+      | { name: string; url: string; tags: string; created_at: number }
+      | undefined;
+    return (
+      row && {
+        name: row.name,
+        url: row.url,
+        tags: splitTags(row.tags),
+        createdAt: row.created_at,
+      }
+    );
+  }
+
+  /** Case-insensitive duplicate check. */
+  exists(name: string): boolean {
+    const row = this.db
+      .prepare('SELECT 1 FROM rss_sources WHERE name = ? COLLATE NOCASE')
+      .get(name);
+    return row !== undefined;
+  }
+
+  add(source: { name: string; url: string; tags: string[] }): void {
+    this.db
+      .prepare(
+        'INSERT INTO rss_sources (name, url, tags, created_at) VALUES (?, ?, ?, ?)',
+      )
+      .run(source.name, source.url, joinTags(source.tags), Date.now());
+  }
+
+  /** Case-insensitive delete; true when a row was removed. */
+  remove(name: string): boolean {
+    const result = this.db
+      .prepare('DELETE FROM rss_sources WHERE name = ? COLLATE NOCASE')
+      .run(name);
+    return Number(result.changes) > 0;
+  }
+
+  /** All distinct tags across sources, sorted. */
+  allTags(): string[] {
+    const set = new Set<string>();
+    for (const source of this.list()) {
+      for (const tag of source.tags) set.add(tag);
+    }
+    return [...set].sort();
+  }
+}
+
+export function splitTags(raw: string): string[] {
+  return raw
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+export function joinTags(tags: string[]): string {
+  return tags.join(',');
+}

src/schedule-singleton.spec.ts

@@ -0,0 +1,28 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const srcDir = fileURLToPath(new URL('.', import.meta.url));
+
+function moduleFiles(dir: string): string[] {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) =>
+    entry.isDirectory()
+      ? moduleFiles(join(dir, entry.name))
+      : entry.name.endsWith('.module.ts')
+        ? [join(dir, entry.name)]
+        : [],
+  );
+}
+
+describe('ScheduleModule.forRoot single registration', () => {
+  // Regression guard (v0.21.7): each forRoot() call creates its own ScheduleExplorer that scans all providers, so a second call made every @Cron/@Interval job fire twice.
+  it('appears exactly once across all src/**/*.module.ts', () => {
+    const hits = moduleFiles(srcDir).flatMap((file) =>
+      (
+        readFileSync(file, 'utf8').match(/ScheduleModule\.forRoot\(/g) ?? []
+      ).map(() => file.slice(srcDir.length)),
+    );
+    expect(hits).toHaveLength(1);
+  });
+});