igdb search + capped http reads: native fulltext, full-page fetch

search_games used `where name ~ "<q>"*`: prefix-only, diacritic- and
word-order-sensitive -- "MARVEL Tōkon" found nothing though IGDB has
it. Switch to IGDB's native `search` clause (relevance-ranked,
diacritic-insensitive).

fetch_url and image downloads read bodies with content.read(n), which
returns only the first buffered chunk (~7 KB): pages collapsed to
their <title>. httpread.read_capped collects chunks up to the byte
cap; image downloads read limit+1 so over-limit files are still
rejected instead of cached truncated (IMG-10).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

IGDB_SETUP.md

@@ -20,13 +20,6 @@ The bot now supports real-time video game information through IGDB (Internet Gam
    - **Category**: Select appropriate category
 3. Note down your **Client ID**
 4. Generate a **Client Secret**
-5. Get an access token using this curl command:
-   ```bash
-   curl -X POST 'https://id.twitch.tv/oauth2/token' \
-   -H 'Content-Type: application/x-www-form-urlencoded' \
-   -d 'client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&grant_type=client_credentials'
-   ```
-6. Save the `access_token` from the response
 
 ### 2. Configure the Bot
 
@@ -35,6 +28,25 @@ Update your `config.toml` file:
 ```toml
 # IGDB Configuration for game information
 igdb-client-id = "your_actual_client_id_here"
+igdb-client-secret = "your_actual_client_secret_here"
+enable-game-info = true
+```
+
+With the client secret configured, the bot fetches an app access token from
+Twitch itself and refreshes it automatically before it expires (Twitch app
+tokens live ~60 days) — no manual token handling needed.
+
+Alternatively, a static token still works (legacy setup — it expires after
+~60 days and then game lookups fail with 401 until you replace it):
+
+```bash
+curl -X POST 'https://id.twitch.tv/oauth2/token' \
+-H 'Content-Type: application/x-www-form-urlencoded' \
+-d 'client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&grant_type=client_credentials'
+```
+
+```toml
+igdb-client-id = "your_actual_client_id_here"
 igdb-access-token = "your_actual_access_token_here"
 enable-game-info = true
 ```
@@ -99,7 +111,8 @@ The integration provides two OpenAI functions:
    - Verify client ID and access token are set
 
 2. **Authentication errors**
-   - Regenerate access token (they expire)
+   - Prefer `igdb-client-secret` — the bot then refreshes tokens itself
+   - With a static `igdb-access-token`: regenerate it (they expire)
    - Verify client ID matches your Twitch app
 
 3. **No game results**

Makefile

@@ -83,3 +83,6 @@ ci: install-dev all-checks ## Full CI pipeline (install deps and run all checks)
 # Deploy targets (SPEC-007)
 deploy: ## Deploy a tag to a host: make deploy HOST=ggg TAG=v3.0.0
 	bash deploy/deploy.sh $(HOST) $(TAG)
+
+backup: ## Back up a local bot.db: make backup DB=history/bot.db DIR=backups
+	uv run python deploy/backup_db.py $(DB) $(DIR) $(or $(KEEP),14)

config.toml

@@ -14,7 +14,11 @@ system = "You are a smart AI assistant with access to real-time video game infor
 
 # IGDB Configuration for game information
 igdb-client-id = "YOUR_IGDB_CLIENT_ID"
-igdb-access-token = "YOUR_IGDB_ACCESS_TOKEN"
+# With the Twitch app client secret set, the bot fetches and refreshes the
+# access token itself (recommended). A static igdb-access-token still works
+# but expires after ~60 days.
+igdb-client-secret = "YOUR_IGDB_CLIENT_SECRET"
+# igdb-access-token = "YOUR_IGDB_ACCESS_TOKEN"
 enable-game-info = true
 
 # --- operator / safety (SPEC-003, SPEC-006) ---
@@ -73,3 +77,18 @@ enable-game-info = true
 # url-max-chars = 6000          # text handed to the model
 # url-max-images = 2            # page images into the vision cache
 # url-daily-per-user = 20
+# Ops (SPEC-012): consecutive OpenAI failures before a staff alert
+# api-error-alert-threshold = 5
+# Backups: cron runs deploy/backup_db.py daily -> ~/backups/<bot>/ (keep 14)
+
+# News digest (SPEC-013) — `python -m fjerkroa_bot.news --config X.toml` via cron;
+# writes the {news} file. Feeds are [url, label] pairs (RSS or Atom):
+# news = "news_feed.txt"
+# news-per-feed = 3
+# news-max-items = 15
+# news-feeds = [
+#   ["https://blog.playstation.com/feed/", "PS"],
+#   ["https://kotaku.com/rss", "Kotaku"],
+#   ["https://www.pushsquare.com/feeds/latest", "Push"],
+#   ["https://mein-mmo.de/feed/", "MeinMMO"],
+# ]

deploy/backup_db.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Consistent, rotated bot.db backups (SPEC-012 OPS-13).
+
+Run from cron on each host. Uses the sqlite3 online-backup API so the
+snapshot is consistent even while the bot writes (WAL-safe), gzips it,
+and keeps the newest N. Stdlib only.
+
+Usage: python3 backup_db.py <bot.db> <backup-dir> [keep]
+"""
+
+import gzip
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+DEFAULT_KEEP = 14
+BACKUP_GLOB = "bot-*.db.gz"
+
+
+def snapshot(src: Path, dest_gz: Path) -> None:
+    """Write a consistent gzipped snapshot of src to dest_gz (OPS-13)."""
+    fd, tmp_path = tempfile.mkstemp(suffix=".db", dir=str(dest_gz.parent))
+    os.close(fd)
+    tmp = Path(tmp_path)
+    try:
+        source = sqlite3.connect(str(src))
+        try:
+            target = sqlite3.connect(str(tmp))
+            try:
+                source.backup(target)  # atomic, WAL-safe online backup
+            finally:
+                target.close()
+        finally:
+            source.close()
+        with open(tmp, "rb") as raw, gzip.open(str(dest_gz), "wb") as gz:
+            shutil.copyfileobj(raw, gz)
+        os.chmod(dest_gz, 0o600)  # conversation data
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+def victims(existing: list, keep: int) -> list:
+    """Given backup paths (any order), return the ones to delete, oldest first (OPS-14)."""
+    ordered = sorted(existing)  # timestamped names sort chronologically
+    return ordered[: max(0, len(ordered) - keep)]
+
+
+def rotate(backup_dir: Path, keep: int) -> int:
+    removed = 0
+    for path in victims(list(backup_dir.glob(BACKUP_GLOB)), keep):
+        Path(path).unlink(missing_ok=True)
+        removed += 1
+    return removed
+
+
+def main() -> int:
+    if len(sys.argv) < 3:
+        print("usage: backup_db.py <bot.db> <backup-dir> [keep]", file=sys.stderr)
+        return 2
+    src = Path(sys.argv[1]).expanduser()
+    backup_dir = Path(sys.argv[2]).expanduser()
+    keep = int(sys.argv[3]) if len(sys.argv) > 3 else DEFAULT_KEEP
+    if not src.exists():
+        print(f"backup: source {src} missing", file=sys.stderr)
+        return 1
+    backup_dir.mkdir(parents=True, exist_ok=True)
+    stamp = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
+    dest = backup_dir / f"bot-{stamp}.db.gz"
+    snapshot(src, dest)
+    removed = rotate(backup_dir, keep)
+    print(f"backup: wrote {dest.name} ({dest.stat().st_size} bytes), rotated {removed} old")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fjerkroa_bot/discord_bot.py

@@ -89,6 +89,7 @@ class FjerkroaBot(commands.Bot):
         self.tasks_enabled = True
         self.quiet_until = 0.0
         self._staff_alert_times: deque = deque()
+        self._consecutive_api_errors = 0  # OPS-16
 
         self.init_observer()
         self.init_aichannels()
@@ -498,6 +499,14 @@ class FjerkroaBot(commands.Bot):
             return True, False
         return False, bool(verdict.get("factual", False))
 
+    async def _note_api_error(self, err: Exception) -> None:
+        """Count consecutive failures; alert staff once at threshold (OPS-16)."""
+        self._consecutive_api_errors += 1
+        logging.warning(f"responder call failed ({self._consecutive_api_errors} in a row): {repr(err)}")
+        threshold = int(self.config.get("api-error-alert-threshold", 5))
+        if self._consecutive_api_errors == threshold:
+            await self.send_staff_alert(f"⚠️ {threshold} consecutive API errors — the bot may be down. Last: {str(err)[:200]}")
+
     async def send_message_with_typing(self, airesponder, channel, message):
         """Send the user message to the AI responder with typing animation in discord"""
         async with channel.typing():
@@ -603,8 +612,15 @@ class FjerkroaBot(commands.Bot):
         # Get the AI responder based on the channel name
         airesponder = self.get_ai_responder(channel_name)
 
-        # Send the user message to the AI responder, with typing indicators
+        # Send the user message to the AI responder, with typing indicators.
-        response = await self.send_message_with_typing(airesponder, channel, message)
+        # A raised call = a broken API path (cf. the gpt-5.6 tools incident):
+        # count it, alert staff at threshold, never crash the handler (OPS-16).
+        try:
+            response = await self.send_message_with_typing(airesponder, channel, message)
+        except Exception as err:
+            await self._note_api_error(err)
+            return
+        self._consecutive_api_errors = 0
 
         # SAF/OPS gates between model proposal and delivery
         await self._apply_response_gates(message, response)

fjerkroa_bot/httpread.py

@@ -0,0 +1,18 @@
+"""Bounded HTTP body read (leaf module, no intra-package imports).
+
+`response.content.read(n)` returns whatever is buffered, not n bytes,
+so it silently truncates large or chunked bodies (and web feeds/pages
+parse to garbage). This accumulates decompressed chunks up to a hard
+cap instead.
+"""
+
+CHUNK = 65536
+
+
+async def read_capped(response, max_bytes: int) -> bytes:
+    buf = bytearray()
+    async for chunk in response.content.iter_chunked(CHUNK):
+        buf.extend(chunk)
+        if len(buf) > max_bytes:
+            break
+    return bytes(buf[:max_bytes])

fjerkroa_bot/igdblib.py

@@ -1,30 +1,67 @@
 import logging
+import time
 from functools import cache
 from typing import Any, Dict, List, Optional
 
 import requests
 
+TWITCH_OAUTH_URL = "https://id.twitch.tv/oauth2/token"
+# Refresh this long before Twitch expires the token (app tokens live ~60 days)
+TOKEN_REFRESH_MARGIN = 86400
+
 
 class IGDBQuery(object):
-    def __init__(self, client_id, igdb_api_key):
+    def __init__(self, client_id, igdb_api_key=None, client_secret=None):
         self.client_id = client_id
         self.igdb_api_key = igdb_api_key
+        self.client_secret = client_secret
+        # Unknown for statically configured tokens; set after each refresh
+        self._token_expires_at = None
+
+    def _refresh_token(self):
+        response = requests.post(
+            TWITCH_OAUTH_URL,
+            params={"client_id": self.client_id, "client_secret": self.client_secret, "grant_type": "client_credentials"},
+        )
+        response.raise_for_status()
+        data = response.json()
+        self.igdb_api_key = data["access_token"]
+        self._token_expires_at = time.time() + data.get("expires_in", 0) - TOKEN_REFRESH_MARGIN
+        logging.info("IGDB: refreshed Twitch app access token")
+
+    def _ensure_token(self):
+        if not self.client_secret:
+            return
+        if not self.igdb_api_key or (self._token_expires_at is not None and time.time() >= self._token_expires_at):
+            self._refresh_token()
 
     def send_igdb_request(self, endpoint, query_body):
         igdb_url = f"https://api.igdb.com/v4/{endpoint}"
-        headers = {"Client-ID": self.client_id, "Authorization": f"Bearer {self.igdb_api_key}"}
 
         try:
-            response = requests.post(igdb_url, headers=headers, data=query_body)
+            self._ensure_token()
+            response = self._post_igdb(igdb_url, query_body)
+            if self.client_secret and response.status_code == 401:
+                # Token expired server-side (e.g. statically configured) — refresh and retry once
+                self._refresh_token()
+                response = self._post_igdb(igdb_url, query_body)
             response.raise_for_status()
             return response.json()
         except requests.RequestException as e:
             print(f"Error during IGDB API request: {e}")
             return None
 
+    def _post_igdb(self, igdb_url, query_body):
+        headers = {"Client-ID": self.client_id, "Authorization": f"Bearer {self.igdb_api_key}"}
+        return requests.post(igdb_url, headers=headers, data=query_body)
+
     @staticmethod
-    def build_query(fields, filters=None, limit=10, offset=None):
+    def build_query(fields, filters=None, limit=10, offset=None, search_term=None):
-        query = f"fields {','.join(fields) if fields is not None and len(fields) > 0 else '*'}; limit {limit};"
+        query = ""
+        if search_term:
+            escaped = search_term.replace("\\", "\\\\").replace('"', '\\"')
+            query += f'search "{escaped}"; '
+        query += f"fields {','.join(fields) if fields is not None and len(fields) > 0 else '*'}; limit {limit};"
         if offset is not None:
             query += f" offset {offset};"
         if filters:
@@ -32,12 +69,12 @@ class IGDBQuery(object):
             query += " where " + " & ".join(filter_statements) + ";"
         return query
 
-    def generalized_igdb_query(self, params, endpoint, fields, additional_filters=None, limit=10, offset=None):
+    def generalized_igdb_query(self, params, endpoint, fields, additional_filters=None, limit=10, offset=None, search_term=None):
         all_filters = {key: f'~ "{value}"*' for key, value in params.items() if value}
         if additional_filters:
             all_filters.update(additional_filters)
 
-        query = self.build_query(fields, all_filters, limit, offset)
+        query = self.build_query(fields, all_filters, limit, offset, search_term)
         data = self.send_igdb_request(endpoint, query)
         print(f"{endpoint}: {query} -> {data}")
         return data
@@ -79,7 +116,7 @@ class IGDBQuery(object):
                 "id",
                 "name",
                 "alternative_names",
-                "category",
+                "game_type",
                 "release_dates",
                 "franchise",
                 "language_supports",
@@ -101,9 +138,10 @@ class IGDBQuery(object):
             return None
 
         try:
-            # Search for games with fuzzy matching
+            # IGDB native full-text search: diacritic- and word-order-insensitive,
+            # unlike a `name ~ "..."*` prefix filter
             games = self.generalized_igdb_query(
-                {"name": query.strip()},
+                {},
                 "games",
                 [
                     "id",
@@ -120,8 +158,9 @@ class IGDBQuery(object):
                     "themes.name",
                     "cover.url",
                 ],
-                additional_filters={"category": "= 0"},  # Main games only
+                additional_filters={"game_type": "= 0"},  # Main games only (IGDB renamed category -> game_type)
                 limit=limit,
+                search_term=query.strip(),
             )
 
             if not games:

fjerkroa_bot/images.py

@@ -14,6 +14,7 @@ from typing import Any, Callable, Dict, List, Optional
 
 import aiohttp
 
+from .httpread import read_capped
 from .persistence import PersistentStore
 
 DEFAULT_CACHE_MB = 500
@@ -79,7 +80,9 @@ class ImageCache:
         async with aiohttp.ClientSession(timeout=timeout) as session:
             async with session.get(url) as response:
                 response.raise_for_status()
-                return await response.content.read(limit + 1)
+                # limit + 1: an over-limit body must stay over-limit so
+                # ingest_bytes rejects it instead of caching it truncated
+                return await read_capped(response, limit + 1)
 
     def data_url(self, sha256: str, ext: str) -> Optional[str]:
         path = self._path(sha256, ext)

fjerkroa_bot/news.py

@@ -0,0 +1,153 @@
+"""News digest fetcher (SPEC-013, FDB-012 news rewrite).
+
+Replaces the broken pre-1.0-openai `news_feed.py`. Fetches configured
+RSS/Atom feeds (stdlib, no feedparser dep), builds a compact sanitized
+headline digest, and writes it to the `{news}` file the responder
+injects (AIResponder.message). Feeds are external input: titles are
+sanitized (SAF-03) and each feed URL is SSRF-guarded before fetching.
+
+CLI: python -m fjerkroa_bot.news --config kroa.toml
+"""
+
+import argparse
+import logging
+import sys
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import defusedxml.ElementTree as ElementTree  # hardened XML: feeds are untrusted (XXE/billion-laughs)
+
+from .ai_responder import sanitize_external_text
+
+DEFAULT_PER_FEED = 3
+DEFAULT_MAX_ITEMS = 15
+FETCH_TIMEOUT_S = 15
+_ATOM = "{http://www.w3.org/2005/Atom}"
+
+
+def parse_feed(data: bytes, source: str = "") -> List[Dict[str, str]]:
+    """Parse RSS or Atom bytes into [{title, link, source}] (tolerant)."""
+    try:
+        root = ElementTree.fromstring(data)
+    except Exception as err:
+        # malformed XML or a blocked entity/DTD attack — tolerate, never raise (NEWS-01)
+        logging.warning(f"news: unparseable/unsafe feed {source!r}: {err!r}")
+        return []
+    items: List[Dict[str, str]] = []
+    # RSS: <rss><channel><item><title/><link/>
+    for item in root.iter("item"):
+        title = (item.findtext("title") or "").strip()
+        link = (item.findtext("link") or "").strip()
+        if title:
+            items.append({"title": title, "link": link, "source": source})
+    # Atom: <feed><entry><title/><link href=/>
+    for entry in root.iter(f"{_ATOM}entry"):
+        title = (entry.findtext(f"{_ATOM}title") or "").strip()
+        link_el = entry.find(f"{_ATOM}link")
+        link = link_el.get("href", "") if link_el is not None else ""
+        if title:
+            items.append({"title": title, "link": link, "source": source})
+    return items
+
+
+def render_digest(items: List[Dict[str, str]], max_items: int = DEFAULT_MAX_ITEMS) -> str:
+    """Compact sanitized digest for the {news} prompt slot."""
+    lines = []
+    for item in items[:max_items]:
+        title = sanitize_external_text(item["title"], 200)
+        source = item.get("source", "")
+        link = item.get("link", "")
+        prefix = f"[{source}] " if source else ""
+        lines.append(f"- {prefix}{title}" + (f" ({link})" if link else ""))
+    return "\n".join(lines)
+
+
+class NewsFetcher:
+    def __init__(self, guard, fetch_bytes) -> None:
+        # injected so tests need no network; production wires aiohttp + guard_url
+        self._guard = guard
+        self._fetch_bytes = fetch_bytes
+
+    async def collect(self, feeds: List[Tuple[str, str]], per_feed: int) -> List[Dict[str, str]]:
+        """feeds = [(url, label)]; returns deduped items, order preserved."""
+        seen = set()
+        out: List[Dict[str, str]] = []
+        for url, label in feeds:
+            reason = self._guard(url)
+            if reason:
+                logging.warning(f"news: skipping feed {label} — {reason}")
+                continue
+            try:
+                data = await self._fetch_bytes(url)
+            except Exception as err:
+                logging.warning(f"news: fetch failed for {label}: {repr(err)}")
+                continue
+            for item in parse_feed(data, label)[:per_feed]:
+                key = item["title"]
+                if key not in seen:
+                    seen.add(key)
+                    out.append(item)
+        return out
+
+
+def _feeds_from_config(config: Dict[str, Any]) -> List[Tuple[str, str]]:
+    """news-feeds = [["url", "label"], ...] or ["url", ...]."""
+    feeds = []
+    for entry in config.get("news-feeds", []):
+        if isinstance(entry, (list, tuple)):
+            feeds.append((str(entry[0]), str(entry[1]) if len(entry) > 1 else ""))
+        else:
+            feeds.append((str(entry), ""))
+    return feeds
+
+
+async def _aiohttp_fetch(url: str) -> bytes:
+    import aiohttp
+
+    from .httpread import read_capped
+
+    timeout = aiohttp.ClientTimeout(total=FETCH_TIMEOUT_S)
+    async with aiohttp.ClientSession(timeout=timeout, headers={"User-Agent": "Mozilla/5.0 (compatible; FjerkroaBot-news/1.0)"}) as session:
+        async with session.get(url) as response:
+            response.raise_for_status()
+            return await read_capped(response, 4 * 1024 * 1024)
+
+
+async def run(config: Dict[str, Any]) -> Optional[str]:
+    from .url_reader import guard_url
+
+    out_path = config.get("news")
+    if not out_path:
+        logging.error("news: no `news` output path in config")
+        return None
+    feeds = _feeds_from_config(config)
+    if not feeds:
+        logging.error("news: no `news-feeds` configured")
+        return None
+    fetcher = NewsFetcher(guard_url, _aiohttp_fetch)
+    items = await fetcher.collect(feeds, int(config.get("news-per-feed", DEFAULT_PER_FEED)))
+    digest = render_digest(items, int(config.get("news-max-items", DEFAULT_MAX_ITEMS)))
+    header = f"News as of {time.strftime('%Y-%m-%d %H:%M UTC', time.gmtime())}:\n"
+    with open(out_path, "w", encoding="utf-8") as fd:
+        fd.write(header + digest + "\n")
+    logging.info(f"news: wrote {len(items)} items to {out_path}")
+    return out_path
+
+
+def main() -> int:
+    import asyncio
+
+    import tomlkit
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    parser = argparse.ArgumentParser(description="Fetch RSS/Atom feeds into the {news} digest file")
+    parser.add_argument("--config", required=True)
+    args = parser.parse_args()
+    with open(args.config, encoding="utf-8") as fd:
+        config = tomlkit.load(fd)
+    result = asyncio.run(run(config))
+    return 0 if result else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fjerkroa_bot/openai_responder.py

@@ -137,16 +137,20 @@ class OpenAIResponder(AIResponder, LeonardoAIDrawMixIn):
 
         # Initialize IGDB if enabled
         self.igdb = None
+        igdb_client_id = self.config.get("igdb-client-id")
+        igdb_client_secret = self.config.get("igdb-client-secret")
+        igdb_access_token = self.config.get("igdb-access-token")
         logging.info("IGDB Configuration Check:")
         logging.info(f"  enable-game-info: {self.config.get('enable-game-info', 'NOT SET')}")
-        logging.info(f"  igdb-client-id: {'SET' if self.config.get('igdb-client-id') else 'NOT SET'}")
+        logging.info(f"  igdb-client-id: {'SET' if igdb_client_id else 'NOT SET'}")
-        logging.info(f"  igdb-access-token: {'SET' if self.config.get('igdb-access-token') else 'NOT SET'}")
+        logging.info(f"  igdb-client-secret: {'SET' if igdb_client_secret else 'NOT SET'}")
+        logging.info(f"  igdb-access-token: {'SET' if igdb_access_token else 'NOT SET'}")
 
-        if self.config.get("enable-game-info", False) and self.config.get("igdb-client-id") and self.config.get("igdb-access-token"):
+        if self.config.get("enable-game-info", False) and igdb_client_id and (igdb_client_secret or igdb_access_token):
             try:
-                self.igdb = IGDBQuery(self.config["igdb-client-id"], self.config["igdb-access-token"])
+                self.igdb = IGDBQuery(igdb_client_id, igdb_access_token, client_secret=igdb_client_secret)
                 logging.info("✅ IGDB integration SUCCESSFULLY enabled for game information")
-                logging.info(f"   Client ID: {self.config['igdb-client-id'][:8]}...")
+                logging.info(f"   Client ID: {igdb_client_id[:8]}...")
                 logging.info(f"   Available functions: {len(self.igdb.get_openai_functions())}")
             except Exception as e:
                 logging.error(f"❌ Failed to initialize IGDB: {e}")

fjerkroa_bot/url_reader.py

@@ -18,6 +18,7 @@ from urllib.parse import urljoin, urlparse
 import aiohttp
 
 from .ai_responder import sanitize_external_text
+from .httpread import read_capped
 
 DEFAULT_MAX_BYTES = 2 * 1024 * 1024
 DEFAULT_MAX_CHARS = 6000
@@ -115,7 +116,7 @@ class URLReader:
                     current = urljoin(current, response.headers["Location"])
                     continue
                 response.raise_for_status()
-                return str(response.url), await response.content.read(max_bytes + 1)
+                return str(response.url), await read_capped(response, max_bytes)
         raise ValueError("too many redirects")
 
     async def fetch(self, url: str, channel: str, user: str) -> Dict[str, Any]:

manual-verification.md

@@ -12,3 +12,4 @@ with date + result.
 | DEP-04 | 2026-07-13 | Smoke gate exercised on ggg: RUNNING + fresh login line. |
 | DEP-05 | 2026-07-13 | Live-verified: kroa deploy attempt ~15h Oslo refused without DEPLOY_FORCE=1. |
 | DEP-06 | 2026-07-13 | Rollback documented (older tag + db backup restore); live drill pending — next release. |
+| OPS-15 | 2026-07-13 | Backup cron installed on both hosts (daily 03:17 UTC → ~/backups/<bot>/, keep 14); first snapshots written + verified 0600 (kroa 10965 B, luma 25871 B). |

pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "tomlkit>=0.13",
     "watchdog>=6",
     "requests>=2.32",
+    "defusedxml>=0.7",
 ]
 
 [project.scripts]

specs/SPEC-012-ops.md

@@ -0,0 +1,32 @@
+# SPEC-012 — Operations hardening
+
+Runtime + host operability (FDB-012). Backups and host wiring are
+`manual` coverage; the in-process alerting is `test`.
+
+### OPS-13 — Consistent DB backups (coverage: test)
+
+`deploy/backup_db.py` writes a gzipped snapshot of `bot.db` using the
+sqlite3 online-backup API — consistent even while the bot writes
+(WAL-safe) — with 0600 permissions. Restoring a snapshot yields a
+readable database with the same rows.
+
+### OPS-14 — Backups are rotated (coverage: test)
+
+The newest `backup-keep` (default 14) snapshots are kept; older ones
+are deleted. Timestamped names sort chronologically so rotation is a
+pure list operation.
+
+### OPS-15 — Backup cron on each host (coverage: manual)
+
+Each host runs `backup_db.py` daily via cron, writing to
+`~/backups/<bot>/` (outside `~/fjerkroa_bot`, so deploys and service
+restarts never touch it). Verified by presence of the cron line and a
+fresh snapshot.
+
+### OPS-16 — Repeated API errors alert staff (coverage: test)
+
+The responder counts consecutive OpenAI request failures; at
+`api-error-alert-threshold` (default 5) in a row it fires one staff
+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.

specs/SPEC-013-news.md

@@ -0,0 +1,25 @@
+# SPEC-013 — News digest
+
+Replaces the broken pre-1.0-openai `news_feed.py`. A CLI
+(`python -m fjerkroa_bot.news --config <cfg>`) fetches the
+`news-feeds` and writes a compact digest to the `news` file that
+`AIResponder.message` injects into the `{news}` slot. Feeds are
+external input and operator-configured.
+
+### NEWS-01 — RSS and Atom parse to items (coverage: test)
+
+`parse_feed(bytes, label)` extracts `{title, link, source}` from both
+RSS (`<item>`) and Atom (`<entry>`) documents, tolerates malformed
+XML (returns an empty list, logs), and never raises.
+
+### NEWS-02 — Digest is sanitized and bounded (coverage: test)
+
+`render_digest` caps at `news-max-items`, and every headline passes
+`sanitize_external_text` (SAF-03) — a feed cannot inject `@everyone`
+or control characters into the prompt via a headline.
+
+### NEWS-03 — Feeds are SSRF-guarded and deduped (coverage: test)
+
+`NewsFetcher.collect` skips any feed URL the SSRF guard rejects,
+skips feeds that fail to fetch (one bad feed never sinks the run),
+and drops duplicate headlines across feeds.

tests/test_igdb_integration.py

@@ -28,7 +28,7 @@ class TestIGDBIntegration(unittest.IsolatedAsyncioTestCase):
 
             responder = OpenAIResponder(self.config_with_igdb)
 
-            mock_igdb.assert_called_once_with("test_client", "test_token")
+            mock_igdb.assert_called_once_with("test_client", "test_token", client_secret=None)
             self.assertEqual(responder.igdb, mock_igdb_instance)
 
     def test_igdb_initialization_disabled(self):

tests/test_igdblib.py

@@ -160,7 +160,7 @@ class TestIGDBQuery(unittest.TestCase):
             "id",
             "name",
             "alternative_names",
-            "category",
+            "game_type",
             "release_dates",
             "franchise",
             "language_supports",
@@ -174,5 +174,104 @@ class TestIGDBQuery(unittest.TestCase):
         self.assertEqual(result, [{"id": 1, "name": "Super Mario Bros"}])
 
 
+class TestIGDBNativeSearch(unittest.TestCase):
+    def test_build_query_with_search_term(self):
+        """search_games uses IGDB full-text search, not a name prefix filter."""
+        query = IGDBQuery.build_query(["name"], {"game_type": "= 0"}, limit=5, search_term="Marvel Tōkon")
+        self.assertEqual(query, 'search "Marvel Tōkon"; fields name; limit 5; where game_type = 0;')
+
+    def test_search_term_escapes_quotes_and_backslashes(self):
+        query = IGDBQuery.build_query(["name"], search_term='say "hi" \\ bye')
+        self.assertIn('search "say \\"hi\\" \\\\ bye";', query)
+
+    @patch.object(IGDBQuery, "generalized_igdb_query")
+    def test_search_games_passes_search_term(self, mock_query):
+        mock_query.return_value = []
+        IGDBQuery("cid", "token").search_games("Elden Ring", limit=3)
+        _, kwargs = mock_query.call_args
+        self.assertEqual(kwargs["search_term"], "Elden Ring")
+        self.assertEqual(mock_query.call_args.args[0], {})
+
+
+class TestIGDBTokenRefresh(unittest.TestCase):
+    @staticmethod
+    def _oauth_response(token="fresh_token", expires_in=5_000_000):
+        response = Mock()
+        response.json.return_value = {"access_token": token, "expires_in": expires_in}
+        response.raise_for_status.return_value = None
+        return response
+
+    @staticmethod
+    def _api_response(payload, status_code=200):
+        response = Mock()
+        response.status_code = status_code
+        response.json.return_value = payload
+        response.raise_for_status.return_value = None
+        return response
+
+    @patch("fjerkroa_bot.igdblib.requests.post")
+    def test_fetches_token_when_only_secret_configured(self, mock_post):
+        """Without a static token, the first request fetches one via Twitch OAuth."""
+        mock_post.side_effect = [self._oauth_response(), self._api_response([{"id": 1}])]
+        igdb = IGDBQuery("cid", client_secret="secret")
+
+        result = igdb.send_igdb_request("games", "fields name; limit 1;")
+
+        self.assertEqual(result, [{"id": 1}])
+        oauth_call, api_call = mock_post.call_args_list
+        self.assertEqual(oauth_call.args[0], "https://id.twitch.tv/oauth2/token")
+        self.assertEqual(
+            oauth_call.kwargs["params"],
+            {"client_id": "cid", "client_secret": "secret", "grant_type": "client_credentials"},
+        )
+        self.assertEqual(api_call.kwargs["headers"]["Authorization"], "Bearer fresh_token")
+
+    @patch("fjerkroa_bot.igdblib.requests.post")
+    def test_refreshes_and_retries_on_401(self, mock_post):
+        """A 401 with a configured secret triggers one refresh and retry."""
+        mock_post.side_effect = [
+            self._api_response(None, status_code=401),
+            self._oauth_response(),
+            self._api_response([{"id": 2}]),
+        ]
+        igdb = IGDBQuery("cid", "expired_token", client_secret="secret")
+
+        result = igdb.send_igdb_request("games", "fields name; limit 1;")
+
+        self.assertEqual(result, [{"id": 2}])
+        self.assertEqual(igdb.igdb_api_key, "fresh_token")
+        self.assertEqual(mock_post.call_args_list[2].kwargs["headers"]["Authorization"], "Bearer fresh_token")
+
+    @patch("fjerkroa_bot.igdblib.time.time")
+    @patch("fjerkroa_bot.igdblib.requests.post")
+    def test_proactive_refresh_before_expiry(self, mock_post, mock_time):
+        """An expired self-fetched token is refreshed before the request."""
+        mock_time.return_value = 1_000_000.0
+        mock_post.side_effect = [self._oauth_response("token_a", expires_in=5_000_000), self._api_response([])]
+        igdb = IGDBQuery("cid", client_secret="secret")
+        igdb.send_igdb_request("games", "fields name;")
+
+        # jump past the token expiry -> next request refreshes first
+        mock_time.return_value = 1_000_000.0 + 5_000_000
+        mock_post.side_effect = [self._oauth_response("token_b"), self._api_response([])]
+        igdb.send_igdb_request("games", "fields name;")
+
+        self.assertEqual(igdb.igdb_api_key, "token_b")
+
+    @patch("fjerkroa_bot.igdblib.requests.post")
+    def test_no_refresh_without_secret(self, mock_post):
+        """Static-token setups keep the old behavior: no OAuth calls, error -> None."""
+        response = Mock()
+        response.status_code = 401
+        response.raise_for_status.side_effect = requests.RequestException("401 Client Error")
+        mock_post.return_value = response
+        igdb = IGDBQuery("cid", "expired_token")
+
+        result = igdb.send_igdb_request("games", "fields name; limit 1;")
+
+        self.assertIsNone(result)
+        mock_post.assert_called_once()
+
+
 if __name__ == "__main__":
     unittest.main()

tests/test_spec_imgcache.py

@@ -45,6 +45,45 @@ class TestIngest(unittest.TestCase):
             self.assertIsNone(cache.ingest_bytes(PNG, "chat", "alice", "1"))
 
 
+class TestOversizedDownloadRejected(unittest.IsolatedAsyncioTestCase):
+    async def test_download_stays_over_limit_and_is_rejected(self):
+        """IMG-10: an over-limit download must be rejected, not cached truncated."""
+        with tempfile.TemporaryDirectory() as tmp:
+            _, cache = make_cache(tmp, {"image-max-bytes": 32})
+
+            class FakeContent:
+                @staticmethod
+                async def iter_chunked(size):
+                    yield PNG  # 72 bytes > 32
+
+            class FakeResp:
+                content = FakeContent()
+
+                async def __aenter__(self):
+                    return self
+
+                async def __aexit__(self, *a):
+                    return False
+
+                def raise_for_status(self):
+                    pass
+
+            class FakeSession:
+                def get(self, url):
+                    return FakeResp()
+
+                async def __aenter__(self):
+                    return self
+
+                async def __aexit__(self, *a):
+                    return False
+
+            with patch("fjerkroa_bot.images.aiohttp.ClientSession", return_value=FakeSession()):
+                data = await cache._download("http://x.com/big.png")
+                self.assertEqual(len(data), 33)  # limit + 1, not silently capped to limit
+                self.assertIsNone(await cache.ingest_url("http://x.com/big.png", "chat", "alice", "1"))
+
+
 class TestVisionDataUrls(OpsBase):
     async def test_attachment_becomes_data_url(self):
         """IMG-11: the model sees a data: URL, never the CDN link."""

tests/test_spec_news.py

@@ -0,0 +1,75 @@
+"""Unit coverage for SPEC-013 news digest (NEWS-01..03)."""
+
+import unittest
+from unittest.mock import AsyncMock
+
+from fjerkroa_bot.news import NewsFetcher, parse_feed, render_digest
+
+RSS = b"""<?xml version="1.0"?><rss><channel>
+<item><title>Game X released</title><link>https://ex.com/x</link></item>
+<item><title>Patch Y notes</title><link>https://ex.com/y</link></item>
+</channel></rss>"""
+
+ATOM = b"""<?xml version="1.0"?><feed xmlns="http://www.w3.org/2005/Atom">
+<entry><title>Atom headline</title><link href="https://ex.com/a"/></entry>
+</feed>"""
+
+
+class TestParse(unittest.TestCase):
+    def test_rss(self):
+        """NEWS-01: RSS items parsed with title + link."""
+        items = parse_feed(RSS, "Src")
+        self.assertEqual([i["title"] for i in items], ["Game X released", "Patch Y notes"])
+        self.assertEqual(items[0]["link"], "https://ex.com/x")
+        self.assertEqual(items[0]["source"], "Src")
+
+    def test_atom(self):
+        """NEWS-01: Atom entries parsed with href link."""
+        items = parse_feed(ATOM, "A")
+        self.assertEqual(items[0]["title"], "Atom headline")
+        self.assertEqual(items[0]["link"], "https://ex.com/a")
+
+    def test_malformed_never_raises(self):
+        """NEWS-01: garbage XML returns [] without raising."""
+        self.assertEqual(parse_feed(b"<not xml", "bad"), [])
+        self.assertEqual(parse_feed(b"", "empty"), [])
+
+
+class TestDigest(unittest.TestCase):
+    def test_sanitized_and_capped(self):
+        """NEWS-02: headlines sanitized, item count capped."""
+        items = [{"title": "@everyone big news \x00", "link": "", "source": "S"} for _ in range(20)]
+        digest = render_digest(items, max_items=5)
+        self.assertEqual(digest.count("\n"), 4)  # 5 lines
+        self.assertNotIn("@everyone", digest)
+        self.assertNotIn("\x00", digest)
+
+
+class TestCollect(unittest.IsolatedAsyncioTestCase):
+    async def test_ssrf_skip_and_dedup(self):
+        """NEWS-03: guarded feed skipped, dup titles dropped, bad fetch survived."""
+
+        def guard(url):
+            return "refused" if "internal" in url else None
+
+        async def fetch(url):
+            if "boom" in url:
+                raise ValueError("boom")
+            return RSS  # same content from two feeds -> dedup
+
+        fetcher = NewsFetcher(guard, fetch)
+        feeds = [
+            ("https://a.com/feed", "A"),
+            ("https://internal/feed", "Internal"),  # SSRF-skipped
+            ("https://boom.com/feed", "Boom"),  # fetch fails
+            ("https://b.com/feed", "B"),  # same RSS -> dup titles dropped
+        ]
+        items = await fetcher.collect(feeds, per_feed=5)
+        titles = [i["title"] for i in items]
+        self.assertEqual(titles, ["Game X released", "Patch Y notes"])  # deduped, internal+boom skipped
+
+    async def test_per_feed_limit(self):
+        """NEWS-03: per-feed cap honored."""
+        fetcher = NewsFetcher(lambda u: None, AsyncMock(return_value=RSS))
+        items = await fetcher.collect([("https://a.com", "A")], per_feed=1)
+        self.assertEqual(len(items), 1)

tests/test_spec_ops_backup.py

@@ -0,0 +1,100 @@
+"""Unit coverage for SPEC-012 ops hardening (OPS-13/14/16)."""
+
+import gzip
+import sqlite3
+import stat
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock
+
+from fjerkroa_bot.persistence import PersistentStore
+
+from .test_spec_ops import OpsBase
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "deploy"))
+import backup_db  # noqa: E402
+
+
+class TestSnapshotConsistency(unittest.TestCase):
+    def test_snapshot_roundtrips(self):
+        """OPS-13: a gzipped snapshot restores to a readable DB with the same rows, 0600."""
+        with tempfile.TemporaryDirectory() as tmp:
+            db = Path(tmp) / "bot.db"
+            store = PersistentStore(db)
+            store.save_history("chat", [{"role": "user", "content": "hei"}])
+            store.add_user_fact("alice", "likes espresso", "self")
+
+            dest = Path(tmp) / "snap.db.gz"
+            backup_db.snapshot(db, dest)
+            self.assertEqual(stat.S_IMODE(dest.stat().st_mode), 0o600)
+
+            restored = Path(tmp) / "restored.db"
+            with gzip.open(dest, "rb") as gz, open(restored, "wb") as out:
+                out.write(gz.read())
+            conn = sqlite3.connect(restored)
+            try:
+                rows = conn.execute("SELECT content FROM history WHERE channel='chat'").fetchall()
+                facts = conn.execute("SELECT fact FROM user_facts").fetchall()
+            finally:
+                conn.close()
+            self.assertEqual(rows, [("hei",)])
+            self.assertEqual(facts, [("likes espresso",)])
+
+    def test_snapshot_during_writes(self):
+        """OPS-13: snapshot succeeds while another connection holds the DB open (WAL)."""
+        with tempfile.TemporaryDirectory() as tmp:
+            db = Path(tmp) / "bot.db"
+            store = PersistentStore(db)
+            store.save_history("chat", [{"role": "user", "content": "x"}])
+            live = sqlite3.connect(db)  # simulate the running bot's open handle
+            live.execute("PRAGMA journal_mode=WAL")
+            try:
+                dest = Path(tmp) / "snap.db.gz"
+                backup_db.snapshot(db, dest)  # must not raise
+                self.assertTrue(dest.exists())
+            finally:
+                live.close()
+
+
+class TestRotation(unittest.TestCase):
+    def test_victims_keeps_newest(self):
+        """OPS-14: only the oldest beyond `keep` are selected for deletion."""
+        names = [f"bot-2026070{d}-000000.db.gz" for d in range(1, 8)]  # 7 chronological
+        victims = backup_db.victims(list(reversed(names)), keep=3)
+        self.assertEqual(victims, names[:4])  # oldest 4 removed, newest 3 kept
+
+    def test_victims_under_keep_deletes_nothing(self):
+        """OPS-14: fewer than `keep` backups -> nothing deleted."""
+        self.assertEqual(backup_db.victims(["bot-20260701-000000.db.gz"], keep=14), [])
+
+    def test_rotate_on_disk(self):
+        """OPS-14: rotate removes the right files from a real dir."""
+        with tempfile.TemporaryDirectory() as tmp:
+            for d in range(1, 6):
+                (Path(tmp) / f"bot-2026070{d}-000000.db.gz").write_bytes(b"x")
+            removed = backup_db.rotate(Path(tmp), keep=2)
+            self.assertEqual(removed, 3)
+            self.assertEqual(len(list(Path(tmp).glob("bot-*.db.gz"))), 2)
+
+
+class TestApiErrorAlert(OpsBase):
+    async def test_threshold_alert_and_reset(self):
+        """OPS-16: N consecutive failures fire one staff alert; success resets."""
+        self.bot.config["api-error-alert-threshold"] = 3
+        self.bot.send_message_with_typing = AsyncMock(side_effect=RuntimeError("boom"))
+        origin = MagicMock()
+        from fjerkroa_bot.ai_responder import AIMessage
+
+        for _ in range(3):
+            await self.bot.respond(AIMessage("alice", "hei", "chat"), origin)
+        self.assertEqual(self.bot.staff_channel.send.await_count, 1)  # exactly one alert at threshold
+        self.assertEqual(self.bot._consecutive_api_errors, 3)
+
+        # a success resets the counter
+        from fjerkroa_bot.ai_responder import AIResponse
+
+        self.bot.send_message_with_typing = AsyncMock(return_value=AIResponse(None, False, "chat", None, None, False, False))
+        await self.bot.respond(AIMessage("alice", "hei", "chat"), origin)
+        self.assertEqual(self.bot._consecutive_api_errors, 0)

tests/test_spec_url.py

@@ -91,6 +91,46 @@ class TestTextExtraction(unittest.TestCase):
         self.assertNotIn("x{}", text)
 
 
+class TestBodyReadCollectsAllChunks(unittest.IsolatedAsyncioTestCase):
+    async def test_get_reads_past_first_chunk(self):
+        """URL-05 regression: body arrives in many chunks; all are collected up to the cap."""
+        reader = URLReader(lambda: {}, None)
+        chunks = [b"<title>t</title>", b"<p>middle</p>", b"<p>end</p>"]
+
+        class FakeContent:
+            @staticmethod
+            async def iter_chunked(size):
+                for chunk in chunks:
+                    yield chunk
+
+        class FakeResp:
+            status = 200
+            headers = {}
+            url = "http://safe.example.com"
+            content = FakeContent()
+
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *a):
+                return False
+
+            def raise_for_status(self):
+                pass
+
+        class FakeSession:
+            def get(self, url, allow_redirects=False):
+                return FakeResp()
+
+        with patch("fjerkroa_bot.url_reader.guard_url", return_value=None):
+            _, body = await reader._get(FakeSession(), "http://safe.example.com", 1000)
+        self.assertEqual(body, b"".join(chunks))
+
+        with patch("fjerkroa_bot.url_reader.guard_url", return_value=None):
+            _, body = await reader._get(FakeSession(), "http://safe.example.com", 20)
+        self.assertEqual(body, b"".join(chunks)[:20])
+
+
 class TestFetchSanitizes(unittest.IsolatedAsyncioTestCase):
     async def test_fetch_result_is_sanitized_and_capped(self):
         """URL-05: fetch output is length-capped and @everyone-neutralized."""

uv.lock

@@ -627,6 +627,7 @@ version = "3.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },
+    { name = "defusedxml" },
     { name = "discord-py" },
     { name = "openai" },
     { name = "requests" },
@@ -656,6 +657,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "aiohttp", specifier = ">=3.12" },
+    { name = "defusedxml", specifier = ">=0.7" },
     { name = "discord-py", specifier = ">=2.5,<3" },
     { name = "openai", specifier = ">=2.45" },
     { name = "requests", specifier = ">=2.32" },