news: get_news degrades softly on topic miss (news-13) — any-term ranked fallback, recent+note, language hint in schema; idle-impulse default varies form

DECISIONS.md

@@ -60,6 +60,16 @@ Decisions inside the set architecture. D-NNN, never renumbered.
   broken classifier must never mute the bot; the budget gate already
   bounds spend. Its verdict gates BEFORE the main call, the
   envelope's answer_needed still gates after — two independent nets.
+- **D-021** — Health monitoring (FDB-012, SPEC-012 OPS-18/19): a
+  separate `monitor_loop` (own cadence, default 300 s) rather than
+  folding checks into the 60 s task loop — monitoring is coarse and
+  should not run every minute. Checks are edge-triggered (alert on the
+  rising edge, re-arm on recovery) so a standing condition never spams;
+  they reuse the existing rate-limited staff-alert path. Metrics are
+  the cheap, high-signal ones (spend vs budget, free disk, task-queue
+  depth); each is independently skippable when it has no data, so a
+  deployment without a budget or store still runs the others. Opt-in
+  (`enable-monitoring`) like every other operational rollout.
 - **D-020** — Web search via Exa (FDB-022, SPEC-015): a `web_search`
   tool alongside fetch_url/IGDB/codex/get_news, filling the "look it up
   on the open web" gap. Exa (not a raw search-engine scrape) because it

Makefile

@@ -1,6 +1,6 @@
 # Fjerkroa Bot Development Makefile (uv-managed)
 
-.PHONY: help install install-dev clean test test-cov test-fast lint format format-check type-check security-check audit trace check all-checks pre-commit run run-dev build ci
+.PHONY: deploy backup help install install-dev clean test test-cov test-fast lint format format-check type-check security-check audit trace check all-checks pre-commit run run-dev build ci
 
 # Default target
 help: ## Show this help message

fjerkroa_bot/discord_bot.py

@@ -1,11 +1,14 @@
 import argparse
 import asyncio
+import fnmatch
 import logging
 import random
 import re
+import shutil
 import sys
 import time
 from collections import deque
+from pathlib import Path
 from typing import Optional, Union
 
 import discord
@@ -16,6 +19,7 @@ from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
 from .ai_responder import AIMessage
+from .monitor import HealthMonitor
 from .openai_responder import OpenAIResponder
 from .tasks import TaskEngine
 
@@ -65,11 +69,41 @@ def split_answer(text: str, threshold: int, max_parts: int) -> list:
 
 
 class ConfigFileHandler(FileSystemEventHandler):
-    def __init__(self, on_modified):
+    """Rename-safe config watch (CFG-05).
-        self._on_modified = on_modified
 
+    Editors and tools save atomically — write a temp file, then rename it
+    over the target — which fires a *moved*/*created* event (not
+    *modified*) and swaps the inode, so watching the file directly goes
+    deaf after the first save. We watch the config's *directory* and react
+    to any event whose src or dest path is the config file.
+    """
+
+    def __init__(self, config_path: str, on_change):
+        self._config_path = str(Path(config_path).resolve())
+        self._on_change = on_change
+
+    def _hits_config(self, event) -> bool:
+        for attr in ("src_path", "dest_path"):
+            path = getattr(event, attr, "")
+            if path and str(Path(path).resolve()) == self._config_path:
+                return True
+        return False
+
+    def _dispatch(self, event):
+        if not event.is_directory and self._hits_config(event):
+            self._on_change()
+
+    # Only write/rename events — NOT on_opened/on_closed, whose read-opens
+    # (our own load_config re-reads the file) would otherwise feed back into
+    # a reload loop (CFG-05).
     def on_modified(self, event):
-        self._on_modified(event)
+        self._dispatch(event)
+
+    def on_created(self, event):
+        self._dispatch(event)
+
+    def on_moved(self, event):
+        self._dispatch(event)
 
 
 class FjerkroaBot(commands.Bot):
@@ -99,8 +133,10 @@ class FjerkroaBot(commands.Bot):
 
     def init_observer(self):
         self.observer = Observer()
-        self.file_handler = ConfigFileHandler(self.on_config_file_modified)
+        config_path = Path(self.config_file).resolve()
-        self.observer.schedule(self.file_handler, path=self.config_file, recursive=False)
+        self.file_handler = ConfigFileHandler(str(config_path), self.on_config_file_changed)
+        # Watch the directory, not the file — atomic saves replace the inode (CFG-05)
+        self.observer.schedule(self.file_handler, path=str(config_path.parent), recursive=False)
         self.observer.start()
 
     def init_aichannels(self):
@@ -130,6 +166,15 @@ class FjerkroaBot(commands.Bot):
             observe=self.airesponder.observe_event,
         )
         self.loop.create_task(self.task_loop())
+        # Proactive health monitoring -> staff alerts (OPS-18/19)
+        self.health_monitor = HealthMonitor(
+            config_getter=lambda: self.config,
+            ledger=self.airesponder.ledger,
+            store=self.airesponder.store,
+            disk_free_mb=self._disk_free_mb,
+            alert=self.send_staff_alert,
+        )
+        self.loop.create_task(self.monitor_loop())
         logging.info("Task engine initialised.")
 
     async def task_loop(self):
@@ -140,6 +185,20 @@ class FjerkroaBot(commands.Bot):
             except Exception as err:
                 logging.warning(f"task tick failed: {repr(err)}")
 
+    def _disk_free_mb(self) -> float:
+        directory = Path(self.config.get("history-directory", ".")).expanduser()
+        target = directory if directory.exists() else Path.home()
+        return shutil.disk_usage(target).free / (1024 * 1024)
+
+    async def monitor_loop(self):
+        while True:
+            await asyncio.sleep(int(self.config.get("monitor-interval", 300)))
+            if self.health_monitor.enabled():
+                try:
+                    await self.health_monitor.tick()
+                except Exception as err:
+                    logging.warning(f"monitor tick failed: {repr(err)}")
+
     async def _execute_task(self, channel_name: str, prompt: str) -> None:
         """Run a due task through the normal responder path (TSK-02)."""
         channel = self.channel_by_name(channel_name, getattr(self, "chat_channel", None), no_ignore=True)
@@ -389,12 +448,10 @@ class FjerkroaBot(commands.Bot):
             airesponder.image_cache.purge_message(str(message.id))  # IMG-14
         await airesponder.observe_event(message.author.name, "delete", f"deleted: {message.content}")
 
-    def on_config_file_modified(self, event):
+    def on_config_file_changed(self):
         # Runs on the watchdog observer thread — the swap itself is
         # scheduled onto the event loop so no request reads a
         # half-swapped config (CFG-04 / D9)
-        if event.src_path != self.config_file:
-            return
         new_config = self.load_config(self.config_file)
         if repr(new_config) == repr(self.config):
             return
@@ -425,7 +482,7 @@ class FjerkroaBot(commands.Bot):
             return fallback_channel
         if channel_name.startswith("#"):
             channel_name = channel_name[1:]
-        if not no_ignore and channel_name in self.config.get("ignore-channels", []):
+        if not no_ignore and self.channel_ignored(channel_name):
             return fallback_channel
         for guild in self.guilds:
             channel = discord.utils.get(guild.channels, name=channel_name)
@@ -438,8 +495,12 @@ class FjerkroaBot(commands.Bot):
             return str(channel.recipient.name)
         return str(channel.id) if isinstance(channel, DMChannel) else str(channel.name)
 
+    def channel_ignored(self, channel_name) -> bool:
+        """fnmatch patterns; plain names match exactly as before (BEH-09)."""
+        return any(fnmatch.fnmatchcase(str(channel_name), pattern) for pattern in self.config.get("ignore-channels", []))
+
     def ignore_message(self, channel_name, message):
-        return channel_name in self.config.get("ignore-channels", []) and not message.direct
+        return self.channel_ignored(channel_name) and not message.direct
 
     def log_message_action(self, action, message, channel_name):
         logging.info(f"{action} message {repr(message)} for channel {channel_name}")
@@ -465,6 +526,11 @@ class FjerkroaBot(commands.Bot):
 
     async def handle_message_through_responder(self, message):
         """Handle a message through the AI responder"""
+        # Ignored channels are fully silent — before the classifier gate,
+        # so no emoji reaction leaks either (BEH-09). DMs are never ignored.
+        if not isinstance(message.channel, DMChannel) and self.channel_ignored(self.get_channel_name(message.channel)):
+            self.log_message_action("ignore", message, self.get_channel_name(message.channel))
+            return
         message_content = str(message.content).strip()
         if message.reference and message.reference.resolved and isinstance(message.reference.resolved.content, str):
             reference_content = str(message.reference.resolved.content).replace("\n", "> \n")

fjerkroa_bot/monitor.py

@@ -0,0 +1,82 @@
+"""Proactive health monitoring -> staff alerts (SPEC-012, FDB-012).
+
+A periodic check that watches daily spend against the budget, free disk,
+and task-queue depth, and posts a staff alert when a threshold is crossed
+— once per crossing, re-arming when the metric recovers, so a persistent
+condition never spams. Opt-in per deployment (`enable-monitoring`); it
+reuses the rate-limited staff-alert channel (OPS-07).
+"""
+
+import logging
+from typing import Any, Callable, Dict, Optional, Tuple
+
+# A check returns (metric-name, is-over-threshold, alert-message) or None when not applicable.
+Check = Optional[Tuple[str, bool, str]]
+
+
+class HealthMonitor:
+    def __init__(
+        self,
+        config_getter: Callable[[], Dict[str, Any]],
+        ledger: Any,
+        store: Any,
+        disk_free_mb: Callable[[], float],
+        alert: Callable[[str], Any],
+    ) -> None:
+        self._config = config_getter
+        self._ledger = ledger
+        self._store = store
+        self._disk_free_mb = disk_free_mb
+        self._alert = alert
+        self._armed: Dict[str, bool] = {}
+
+    def enabled(self) -> bool:
+        return bool(self._config().get("enable-monitoring", False))
+
+    def _check_spend(self) -> Check:
+        config = self._config()
+        if "daily-budget-usd" not in config:
+            return None
+        budget = float(config["daily-budget-usd"])
+        if budget <= 0:
+            return None
+        spent = float(self._ledger.spent_usd())
+        frac = spent / budget
+        threshold = float(config.get("monitor-spend-alert-frac", 0.8))
+        return ("spend", frac >= threshold, f"💸 Spend at ${spent:.2f} of ${budget:.2f} today ({frac:.0%}, alert ≥ {threshold:.0%}).")
+
+    def _check_disk(self) -> Check:
+        try:
+            free = float(self._disk_free_mb())
+        except Exception as err:
+            logging.debug(f"monitor: disk check failed: {err!r}")
+            return None
+        min_mb = float(self._config().get("monitor-disk-min-mb", 500))
+        return ("disk", free < min_mb, f"💾 Low disk: {free:.0f} MB free (alert < {min_mb:.0f} MB).")
+
+    def _check_queue(self) -> Check:
+        if self._store is None:
+            return None
+        try:
+            depth = len(self._store.tasks_open())
+        except Exception as err:
+            logging.debug(f"monitor: queue check failed: {err!r}")
+            return None
+        limit = int(self._config().get("monitor-taskqueue-max", 20))
+        return ("task-queue", depth >= limit, f"🗒️ Task queue deep: {depth} open (alert ≥ {limit}).")
+
+    async def tick(self) -> None:
+        """Evaluate every check; alert on a rising edge only (OPS-18/19)."""
+        for check in (self._check_spend(), self._check_disk(), self._check_queue()):
+            if check is None:
+                continue
+            metric, over, message = check
+            await self._fire(metric, over, message)
+
+    async def _fire(self, metric: str, over: bool, message: str) -> None:
+        was_over = self._armed.get(metric, False)
+        if over and not was_over:
+            self._armed[metric] = True
+            await self._alert(message)
+        elif not over and was_over:
+            self._armed[metric] = False  # recovered — re-arm silently for the next crossing

fjerkroa_bot/news.py

@@ -198,7 +198,12 @@ GET_NEWS_TOOL = {
     "parameters": {
         "type": "object",
         "properties": {
-            "topic": {"type": "string", "description": "Optional keywords to filter by, e.g. 'Nordland', 'football', 'weather'."},
+            "topic": {
+                "type": "string",
+                "description": "Optional filter: one or two keywords, in the language the feeds are written in "
+                "(e.g. Norwegian for Norwegian news: 'Nordland', 'fotball', 'trafikkulykke'). If nothing matches "
+                "exactly, related or recent items come back with a `note` saying so.",
+            },
             "source": {"type": "string", "description": "Optional source label, e.g. 'NRK', 'Aftenposten', 'Verden', 'Sport'."},
             "limit": {"type": "integer", "description": "How many items to return (default 10, max 30)."},
         },
@@ -220,8 +225,15 @@ def query_news(
     limit = max(1, min(int(limit or 10), 30))
     src = (str(source).strip() or None) if source else None
     terms = _news_terms(topic)
+    note = None
     try:
         rows = store.search_news(terms, limit, src) if terms else store.recent_news(limit, src)
+        if terms and not rows:  # NEWS-13: soft degradation, never empty-handed
+            rows = store.search_news(terms, limit, src, match_any=True)
+            note = "no item matches all keywords; showing items matching some of them"
+        if terms and not rows:
+            rows = store.recent_news(limit, src)
+            note = "nothing matches the topic; showing the newest stored items instead"
     except Exception as err:
         logging.warning(f"news: query failed: {err!r}")
         return {"error": "news lookup failed"}
@@ -234,7 +246,10 @@ def query_news(
         }
         for row in rows
     ]
-    return {"topic": topic or "", "source": src or "", "results": results}
+    payload = {"topic": topic or "", "source": src or "", "results": results}
+    if note:
+        payload["note"] = note
+    return payload
 
 
 def _open_store(config: Dict[str, Any]) -> Any:

fjerkroa_bot/persistence.py

@@ -152,20 +152,33 @@ class PersistentStore:
             rows = conn.execute(sql, params).fetchall()
         return [{"source": r[0], "title": r[1], "link": r[2], "summary": r[3]} for r in rows]
 
-    def search_news(self, terms: List[str], limit: int = 20, source: Optional[str] = None) -> List[Dict[str, Any]]:
+    def search_news(self, terms: List[str], limit: int = 20, source: Optional[str] = None, match_any: bool = False) -> List[Dict[str, Any]]:
-        """Rows where every term appears in title or summary; optional source filter (NEWS-11)."""
+        """Rows where every term appears in title/summary/source; match_any ranks by how many terms hit (NEWS-11/13)."""
         params: List[Any] = []
         clauses = []
         for term in terms:
             clauses.append("(title LIKE ? OR summary LIKE ? OR source LIKE ?)")
             like = f"%{term}%"
             params += [like, like, like]
-        where = " AND ".join(clauses) if clauses else "1=1"
+        if match_any and clauses:
-        if source:
+            hits = " + ".join(clauses)
-            where = f"({where}) AND source = ?"
+            where = "hits > 0"
-            params.append(source)
+            if source:
-        params.append(int(limit))
+                where += " AND source = ?"
-        sql = f"SELECT source, title, link, summary FROM news WHERE {where} ORDER BY id DESC LIMIT ?"  # nosec B608 - fixed templates; values parameterised
+                params.append(source)
+            params.append(int(limit))
+            sql = (
+                f"SELECT source, title, link, summary FROM "  # nosec B608 - fixed templates; values parameterised
+                f"(SELECT id, source, title, link, summary, {hits} AS hits FROM news) "
+                f"WHERE {where} ORDER BY hits DESC, id DESC LIMIT ?"
+            )
+        else:
+            where = " AND ".join(clauses) if clauses else "1=1"
+            if source:
+                where = f"({where}) AND source = ?"
+                params.append(source)
+            params.append(int(limit))
+            sql = f"SELECT source, title, link, summary FROM news WHERE {where} ORDER BY id DESC LIMIT ?"  # nosec B608 - fixed templates; values parameterised
         with closing(self._connect()) as conn:
             rows = conn.execute(sql, params).fetchall()
         return [{"source": r[0], "title": r[1], "link": r[2], "summary": r[3]} for r in rows]

fjerkroa_bot/tasks.py

@@ -17,7 +17,13 @@ from .quota import QuotaLedger
 DEFAULT_MAX_PER_CHANNEL_PER_DAY = 2
 DEFAULT_IDLE_IMPULSE_HOURS = 12.0
 DEFAULT_TASKGEN_INTERVAL_HOURS = 6.0
-DEFAULT_BORENESS_PROMPT = "Pretend that you just now thought of something, be creative."
+DEFAULT_BORENESS_PROMPT = (
+    "A thought just occurred to you. Anchor it to something real you know — recent news (use get_news), a game "
+    "releasing soon, the weather, or a regular you remember — not a generic musing. Share it briefly, in your own "
+    "voice, as an observation, a gentle question, or a joke; never an advertisement. Read the room and stay in character. "
+    "Check your own recent posts in the history first: pick a subject you have not touched lately and a different form "
+    "than last time, and never open with a fixed label or heading — just start mid-thought."
+)
 
 ExecuteCallback = Callable[[str, str], Awaitable[None]]
 ProposeCallback = Callable[[], Awaitable[Optional[Dict[str, Any]]]]

specs/SPEC-008-config.md

@@ -31,3 +31,16 @@ and all responder `.config` references is scheduled onto the event
 loop (`call_soon_threadsafe`), so no request ever reads a
 half-swapped config (D9). Before the loop runs (startup), the swap
 applies directly — there are no concurrent readers yet.
+
+### CFG-05 — Hot-reload is rename-safe (coverage: test)
+
+The watcher observes the config file's **directory**, not the file, and
+reacts to a **modified, created, or moved** event whose source or
+destination path is the config file. This catches atomic saves — write
+a temp file, then rename it over the target — which replace the inode
+and fire a move/create rather than a modify; watching the file directly
+would go deaf after the first such save. Open/close events are
+deliberately not handled: reloading re-opens the file to read it, so
+reacting to opens would feed back into an endless reload loop. Events
+for other files in the directory, and directory events themselves, are
+ignored.

specs/SPEC-010-behavior.md

@@ -61,3 +61,15 @@ Within `quiet-hours = "HH:MM-HH:MM"` (host-local, may wrap midnight)
 `bot_initiated_allowed()` is false: no boreness, later no scheduler
 posts. Replies to users stay unaffected — a guest asking at 23:30
 still gets an answer.
+
+### BEH-09 — Ignored channels are fully silent (coverage: test)
+
+Channels matching `ignore-channels` get neither replies nor
+classifier emoji reactions: the message handler returns before the
+classifier gate, so no model call, no reaction, no history entry.
+Entries are fnmatch patterns (`todo*` matches `todo`, `todo-lists`);
+plain names keep matching exactly as before. DMs are never ignored.
+`channel_by_name` resolution honors the same patterns. (Previously
+the ignore check sat only in `respond()`, after the classifier —
+emoji reactions leaked into ignored channels, and matching was
+exact-name only.)

specs/SPEC-012-ops.md

@@ -30,3 +30,23 @@ The responder counts consecutive OpenAI request failures; at
 alert (rate-limited like all staff alerts) so a silently-broken bot
 (cf. the gpt-5.6 tools/reasoning incident) surfaces within minutes
 instead of hours. A success resets the counter.
+
+### OPS-18 — Health monitor watches spend, disk, task-queue (coverage: test)
+
+When `enable-monitoring` is true, a loop wakes every `monitor-interval`
+(default 300 s) and checks three thresholds, alerting the staff channel
+when one is crossed: daily spend at or above `monitor-spend-alert-frac`
+(default 0.8) of `daily-budget-usd`; free disk below `monitor-disk-min-mb`
+(default 500 MB); open task-queue depth at or above `monitor-taskqueue-max`
+(default 20). A check with no data to evaluate (no budget set, no store,
+a failed disk read) is skipped, never fatal. With the flag off the loop
+does nothing.
+
+### OPS-19 — Alerts fire once per crossing and re-arm on recovery (coverage: test)
+
+Each metric alerts only on the rising edge — the first tick that finds
+it over its threshold — and stays silent while it remains over, so a
+persistent condition does not repeat every interval. When the metric
+falls back below the threshold the alert re-arms silently, ready to fire
+again on the next crossing. All alerts still pass through the
+rate-limited staff-alert path (OPS-07).

specs/SPEC-013-news.md

@@ -98,3 +98,14 @@ Each `get_news` call increments a per-user daily counter; over
 `news-daily-per-user` (default 30) the tool refuses with an error
 result without touching the store. The budget gate (SAF-04) still
 applies to the surrounding model calls.
+
+### NEWS-13 — Topic misses degrade softly, never empty-handed (coverage: test)
+
+A `topic` whose AND-match (NEWS-11) finds nothing falls back to an
+any-term match, ranked by how many keywords hit (ties: newest first);
+if that too is empty, the newest stored items are returned instead.
+Both fallbacks set a `note` field naming the degradation so the model
+can answer honestly ("nothing on that exactly, but…"). A model
+passing a multi-word or wrong-language topic (the live
+`"Nordland road accident"` → `[]` case) thus still gets usable
+context. Exact matches return no `note`.

tests/test_spec_beh.py

@@ -65,6 +65,55 @@ class TestClassifierGate(ClassifierGateBase):
         self.bot.respond.assert_not_awaited()
 
 
+class TestIgnoredChannels(ClassifierGateBase):
+    def ignored_msg(self, channel_name):
+        message = self.public_msg("hello there")
+        message.channel.name = channel_name
+        message.add_reaction = AsyncMock()
+        return message
+
+    async def test_pattern_match_suppresses_reaction_and_reply(self):
+        """BEH-09: fnmatch pattern hit -> no classifier call, no emoji, no reply."""
+        self.gate_setup({"reply": False, "factual": False, "emoji": "👍"})
+        self.bot.config["ignore-channels"] = ["todo*"]
+        message = self.ignored_msg("todo-lists")
+        await self.bot.on_message(message)
+        self.bot.airesponder.classify.assert_not_awaited()
+        message.add_reaction.assert_not_awaited()
+        self.bot.respond.assert_not_awaited()
+
+    async def test_exact_name_still_matches(self):
+        """BEH-09: plain names keep working as exact matches."""
+        self.gate_setup({"reply": True, "factual": False, "emoji": None})
+        self.bot.config["ignore-channels"] = ["blengon"]
+        await self.bot.on_message(self.ignored_msg("blengon"))
+        self.bot.respond.assert_not_awaited()
+
+    async def test_non_matching_channel_passes(self):
+        """BEH-09: unmatched channels reach the responder as before."""
+        self.gate_setup({"reply": True, "factual": False, "emoji": None})
+        self.bot.config["ignore-channels"] = ["todo*"]
+        await self.bot.on_message(self.ignored_msg("chat"))
+        self.bot.respond.assert_awaited_once()
+
+    async def test_dm_never_ignored(self):
+        """BEH-09: a DM whose recipient name matches a pattern is still answered."""
+        self.gate_setup({"reply": True, "factual": False, "emoji": None})
+        self.bot.config["ignore-channels"] = ["todo*"]
+        message = self.public_msg("hei bot")
+        message.channel = MagicMock(spec=DMChannel)
+        message.channel.recipient = MagicMock()
+        message.channel.recipient.name = "todo-fan"
+        await self.bot.on_message(message)
+        self.bot.respond.assert_awaited_once()
+
+    def test_channel_by_name_honors_patterns(self):
+        """BEH-09: channel_by_name resolution skips pattern-ignored channels."""
+        self.bot.config["ignore-channels"] = ["todo*"]
+        fallback = MagicMock(spec=TextChannel)
+        self.assertIs(self.bot.channel_by_name("todo-lists", fallback), fallback)
+
+
 class TestTypingPacing(OpsBase):
     async def send_with(self, answer, factual, cps=30):
         if cps is not None:

tests/test_spec_monitor.py

@@ -0,0 +1,106 @@
+"""Unit coverage for SPEC-012 health monitoring (OPS-18/19)."""
+
+import unittest
+from unittest.mock import AsyncMock
+
+from fjerkroa_bot.monitor import HealthMonitor
+
+
+class FakeLedger:
+    def __init__(self, spent=0.0):
+        self._spent = spent
+
+    def spent_usd(self):
+        return self._spent
+
+
+class FakeStore:
+    def __init__(self, open_tasks=0):
+        self._n = open_tasks
+
+    def tasks_open(self):
+        return list(range(self._n))
+
+
+def _monitor(cfg, ledger=None, store=None, disk=1000.0):
+    alert = AsyncMock()
+    monitor = HealthMonitor(lambda: cfg, ledger or FakeLedger(), store, lambda: disk, alert)
+    return monitor, alert
+
+
+class TestEnabled(unittest.TestCase):
+    def test_opt_in(self):
+        """OPS-18: monitoring is opt-in via enable-monitoring."""
+        self.assertFalse(_monitor({})[0].enabled())
+        self.assertTrue(_monitor({"enable-monitoring": True})[0].enabled())
+
+
+class TestChecks(unittest.IsolatedAsyncioTestCase):
+    async def test_spend_over_threshold_alerts(self):
+        """OPS-18: spend at/above frac*budget alerts."""
+        monitor, alert = _monitor({"daily-budget-usd": 2.0, "monitor-spend-alert-frac": 0.8}, ledger=FakeLedger(1.8))
+        await monitor.tick()
+        alert.assert_awaited_once()
+        self.assertIn("Spend", alert.await_args.args[0])
+
+    async def test_spend_under_threshold_silent(self):
+        """OPS-18: spend below threshold stays silent."""
+        monitor, alert = _monitor({"daily-budget-usd": 2.0}, ledger=FakeLedger(0.5))
+        await monitor.tick()
+        alert.assert_not_awaited()
+
+    async def test_no_budget_skips_spend(self):
+        """OPS-18: no budget configured -> spend check skipped, never fatal."""
+        monitor, alert = _monitor({"enable-monitoring": True}, ledger=FakeLedger(99))
+        await monitor.tick()
+        alert.assert_not_awaited()
+
+    async def test_low_disk_alerts(self):
+        """OPS-18: free disk below the floor alerts."""
+        monitor, alert = _monitor({"monitor-disk-min-mb": 500}, disk=100.0)
+        await monitor.tick()
+        self.assertTrue(any("Low disk" in call.args[0] for call in alert.await_args_list))
+
+    async def test_disk_read_failure_skipped(self):
+        """OPS-18: a failing disk read is skipped, not fatal."""
+
+        def boom():
+            raise OSError("nope")
+
+        alert = AsyncMock()
+        monitor = HealthMonitor(lambda: {}, FakeLedger(), None, boom, alert)
+        await monitor.tick()
+        alert.assert_not_awaited()
+
+    async def test_deep_queue_alerts(self):
+        """OPS-18: task-queue depth at/above max alerts."""
+        monitor, alert = _monitor({"monitor-taskqueue-max": 3}, store=FakeStore(5), disk=9999.0)
+        await monitor.tick()
+        self.assertTrue(any("Task queue" in call.args[0] for call in alert.await_args_list))
+
+    async def test_no_store_skips_queue(self):
+        """OPS-18: no store -> queue check skipped."""
+        monitor, alert = _monitor({"monitor-taskqueue-max": 1}, store=None, disk=9999.0)
+        await monitor.tick()
+        alert.assert_not_awaited()
+
+
+class TestEdgeArming(unittest.IsolatedAsyncioTestCase):
+    async def test_fires_once_per_crossing(self):
+        """OPS-19: a persistent over-threshold condition alerts once, not every tick."""
+        monitor, alert = _monitor({"daily-budget-usd": 2.0}, ledger=FakeLedger(1.9))
+        await monitor.tick()
+        await monitor.tick()
+        await monitor.tick()
+        self.assertEqual(alert.await_count, 1)
+
+    async def test_rearms_on_recovery(self):
+        """OPS-19: recovery re-arms silently; the next crossing alerts again."""
+        ledger = FakeLedger(1.9)
+        monitor, alert = _monitor({"daily-budget-usd": 2.0}, ledger=ledger, disk=9999.0)
+        await monitor.tick()  # over -> alert (1)
+        ledger._spent = 0.5
+        await monitor.tick()  # recovered -> silent, re-arm
+        ledger._spent = 1.95
+        await monitor.tick()  # over again -> alert (2)
+        self.assertEqual(alert.await_count, 2)

tests/test_spec_news.py

@@ -303,6 +303,26 @@ class TestQueryNews(NewsStoreBase):
         self.assertGreaterEqual(len(query_news(self.store, limit=0)["results"]), 1)
         self.assertIn("error", query_news(None))
 
+    def test_exact_match_has_no_note(self):
+        """NEWS-13: a direct AND-match returns without a note field."""
+        self.seed()
+        self.assertNotIn("note", query_news(self.store, topic="storm"))
+
+    def test_partial_match_falls_back_ranked(self):
+        """NEWS-13: AND-miss -> any-term match, most keyword hits first, with a note."""
+        self.seed()
+        res = query_news(self.store, topic="Nordland road accident")
+        self.assertEqual(res["results"][0]["title"], "Nordland storm")
+        self.assertIn("note", res)
+
+    def test_no_match_falls_back_to_recent(self):
+        """NEWS-13: nothing matches any term -> newest items + note, never empty-handed."""
+        self.seed()
+        res = query_news(self.store, topic="quantum blockchain")
+        self.assertTrue(res["results"])
+        self.assertEqual(res["results"][0]["title"], "Sport result")  # newest first
+        self.assertIn("note", res)
+
 
 class TestNewsTool(unittest.IsolatedAsyncioTestCase):
     def setUp(self):

tests/test_spec_per.py

@@ -120,9 +120,7 @@ class TestConfigReloadRace(TestBotBase):
         new_config["history-limit"] = 99
         self.bot.load_config = lambda path: new_config
         self.bot.loop = MagicMock()
-        event = MagicMock()
+        self.bot.on_config_file_changed()
-        event.src_path = self.bot.config_file
-        self.bot.on_config_file_modified(event)
         self.bot.loop.call_soon_threadsafe.assert_called_once()
         apply_fn = self.bot.loop.call_soon_threadsafe.call_args.args[0]
         apply_fn()
@@ -137,7 +135,37 @@ class TestConfigReloadRace(TestBotBase):
         loop = MagicMock()
         loop.call_soon_threadsafe.side_effect = RuntimeError("no running loop")
         self.bot.loop = loop
-        event = MagicMock()
+        self.bot.on_config_file_changed()
-        event.src_path = self.bot.config_file
-        self.bot.on_config_file_modified(event)
         self.assertEqual(self.bot.config["history-limit"], 42)
+
+
+class TestConfigReloadRenameSafe(unittest.TestCase):
+    def test_atomic_rename_and_modify_trigger_reload(self):
+        """CFG-05: a modified OR a renamed-into-place config fires the reload; unrelated files do not."""
+        from fjerkroa_bot.discord_bot import ConfigFileHandler
+
+        with tempfile.TemporaryDirectory() as tmp:
+            config = Path(tmp) / "kroa.toml"
+            config.write_text("x = 1\n")
+            hits = []
+            handler = ConfigFileHandler(str(config), lambda: hits.append(1))
+
+            def evt(is_dir=False, src=None, dest=None):
+                event = MagicMock()
+                event.is_directory = is_dir
+                event.src_path = src if src is not None else ""
+                event.dest_path = dest if dest is not None else ""
+                return event
+
+            handler.on_modified(evt(src=str(config)))  # in-place modify
+            handler.on_moved(evt(src=str(Path(tmp) / "kroa.toml.tmp"), dest=str(config)))  # atomic rename over
+            handler.on_created(evt(src=str(config)))  # write-new
+            self.assertEqual(len(hits), 3)
+
+            handler.on_modified(evt(src=str(Path(tmp) / "other.txt")))  # unrelated file
+            handler.on_modified(evt(is_dir=True, src=str(config)))  # directory event
+            self.assertEqual(len(hits), 3)  # neither fired
+
+            # open/close of the config (our own load_config re-reads) must NOT be handled — else a reload loop.
+            self.assertNotIn("on_opened", vars(ConfigFileHandler))
+            self.assertNotIn("on_closed", vars(ConfigFileHandler))