Expose delivery failures and prepare continuous hosting

Production logs show Medialogia ingestion and DeepSeek classification succeeding while every Telegram delivery times out. This proposal makes delivery health observable, starts AI and Telegram workers independently, retains valid webhooks during incomplete downstream configuration, waits for in-flight workers on shutdown, and provides a Render deployment with a persistent SQLite disk. Eight local regression checks passed. It does not resolve or bypass the Space network timeout; actual Telegram delivery must be verified on the target host. Kept as a proposal to avoid restarting the existing Space and losing its temporary pending queue. Existing secrets are not readable through the Hugging Face API and must be supplied on the new host.

.dockerignore

@@ -0,0 +1,8 @@
+.cache
+.git
+__pycache__
+*.pyc
+.env
+.env.*
+*.sqlite3
+*.sqlite3-*

.gitignore

@@ -0,0 +1,7 @@
+.cache/
+__pycache__/
+*.pyc
+.env
+.env.*
+*.sqlite3
+*.sqlite3-*

Dockerfile

@@ -1,6 +1,7 @@
 FROM python:3.12-slim
 RUN useradd --create-home --uid 1000 appuser
 WORKDIR /app
+RUN mkdir -p /app/data && chown appuser:appuser /app/data
 COPY requirements-monitor.txt /app/requirements-monitor.txt
 RUN pip install --no-cache-dir -r /app/requirements-monitor.txt
 COPY --chown=appuser:appuser receiver.py /app/receiver.py

README.md

@@ -14,8 +14,9 @@ independent DeepSeek classifier for potential topic alerts. Text only; no image,
 OCR, subtitle, or original-page fetching. The default model is deepseek-flash
 with thinking disabled. A positive result is a signal for a person to assess.
 
-Set these Space Secrets: WEBHOOK_SECRET, TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID,
-DEEPSEEK_API_KEY and ALERT_MENTIONS. CLASSIFIER_PROMPT overrides the generic
+Set these Space Secrets: WEBHOOK_SECRET, TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID
+and DEEPSEEK_API_KEY. ALERT_MENTIONS optionally adds user mentions to alerts.
+CLASSIFIER_PROMPT overrides the generic
 default instructions and belongs in a Secret when it contains internal context.
 Never commit credentials or confidential classifier instructions to this repo.
 
@@ -37,3 +38,43 @@ or an alert. AI failures remain pending and are retried, never recorded as NO.
 Normal posts are sent silently; alerts request a notification, which still
 depends on recipients' Telegram settings. Mentions are explicit @usernames.
 Post text is split across messages when necessary; its complete text is checked.
+
+## Delivery health and independent workers
+
+`/health` now distinguishes successful delivery, an untested Telegram connection,
+delivery errors, missing configuration, and stopped workers. The public response
+contains fixed error categories, never tokens, chat identifiers or post content.
+It is not an end-to-end delivery guarantee. `/live` is a separate process liveness
+check, so a Telegram outage does not restart the process and discard its queue.
+
+Telegram forwarding runs whenever its token and chat ID are configured, even if
+DeepSeek is not configured yet. AI processing starts independently when its key
+is available. `ALERT_MENTIONS` is optional. Valid authenticated webhooks are stored
+even while downstream configuration is incomplete, and workers resume delivery
+after configuration is corrected and the service restarted with the same database.
+
+## Continuous hosting on Render
+
+The included `render.yaml` describes one paid Docker web service with a 1 GB
+persistent disk at `/app/data`. Check the actual compute and disk prices before
+creating the service. Free services are unsuitable for continuous monitoring.
+Keep exactly one instance. The existing Dockerfile runs as an unprivileged user.
+
+Deploy this directory as the repository root. Enter the existing values for
+`WEBHOOK_SECRET`, `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID` and `DEEPSEEK_API_KEY`
+as secret environment variables. Hugging Face does not return stored secret
+values through its API; copy them from your original secure source. Preserve
+`DEEPSEEK_MODEL`, `CLASSIFIER_PROMPT`, `ALERT_MENTIONS` and `TELEGRAM_THREAD_ID`
+if customized. Do not put secrets in source control or Blueprint YAML.
+
+Before switching Medialogia, run the authenticated `/diagnostics/WEBHOOK_SECRET`
+checks on the new service and confirm bot membership and chat permissions. Then
+send a test publication through Medialogia and verify its arrival in Telegram.
+The diagnostic itself sends no messages. Update Medialogia to the new HTTPS
+`/medialogia/WEBHOOK_SECRET` URL only when ready to switch. Do not run two active
+webhook destinations for the same monitoring feed unless duplicates are desired.
+
+The old Hugging Face queue is in temporary storage and is not automatically
+migrated. Do not rebuild or delete that Space until any required pending
+publications have been recovered or replayed from Medialogia. A persistent disk
+retains the new service's queue across deploys; maintain separate backups.

receiver.py

@@ -28,7 +28,7 @@ from urllib.parse import urlsplit
 from zoneinfo import ZoneInfo
 
 LOG = logging.getLogger("monitor")
-VERSION = "1.1-diagnostics"
+VERSION = "1.2-delivery-health"
 MAX_BYTES = 1024 * 1024
 AI_CHUNK = 12000
 DEFAULT_PROMPT = """Ты классификатор публикаций для мониторинга нового внешнего вида
@@ -189,8 +189,7 @@ class Config:
 
     def missing(self):
         return [name for name, value in (("TELEGRAM_BOT_TOKEN", self.telegram_token),
-                ("TELEGRAM_CHAT_ID", self.chat_id), ("DEEPSEEK_API_KEY", self.deepseek_key),
-                ("ALERT_MENTIONS", self.mentions)) if not value]
+                ("TELEGRAM_CHAT_ID", self.chat_id), ("DEEPSEEK_API_KEY", self.deepseek_key)) if not value]
 
 
 class Store:
@@ -353,6 +352,7 @@ class Clients:
     def __init__(self, config):
         self.config, self.last_tg = config, 0.0
         self.diagnostics_lock = threading.Lock()
+        self.telegram_health = {"status": "not_checked"}
 
     def diagnose_telegram(self):
         """Read-only Bot API checks; no publication, queue changes or AI calls."""
@@ -423,10 +423,15 @@ class Clients:
         data = {"chat_id": self.config.chat_id, **payload}
         if method == "sendMessage" and self.config.thread_id:
             data["message_thread_id"] = int(self.config.thread_id)
-        result = request_json("https://api.telegram.org/bot" + self.config.telegram_token + "/" + method,
-                              data, service="telegram", timeout=35)
-        if not isinstance(result, dict) or not result.get("ok"):
-            raise ServiceError("telegram_invalid_response")
+        try:
+            result = request_json("https://api.telegram.org/bot" + self.config.telegram_token + "/" + method,
+                                  data, service="telegram", timeout=35)
+            if not isinstance(result, dict) or not result.get("ok"):
+                raise ServiceError("telegram_invalid_response")
+        except ServiceError as exc:
+            self.telegram_health = {"status": "error", "error": exc.code}
+            raise
+        self.telegram_health = {"status": "ok"}
         return result.get("result")
 
 
@@ -509,15 +514,40 @@ class Monitor:
             self.stop.wait(0.25 if row else 1)
 
     def start(self):
-        if not self.config.missing():
-            for lane in ("ai", "tg"):
+        for lane, enabled in (("ai", bool(self.config.deepseek_key)),
+                              ("tg", bool(self.config.telegram_token and self.config.chat_id))):
+            if enabled:
                 thread = threading.Thread(target=self.worker, args=(lane,), daemon=True, name=lane)
                 self.threads.append(thread)
                 thread.start()
 
+    def health(self):
+        missing = self.config.missing()
+        telegram = dict(self.clients.telegram_health)
+        try:
+            queue = self.store.stats()
+        except Exception:
+            return {"status": "storage_unavailable", "version": VERSION}
+        workers = {thread.name: thread.is_alive() for thread in self.threads}
+        expected = {lane for lane, enabled in (("ai", bool(self.config.deepseek_key)),
+                    ("tg", bool(self.config.telegram_token and self.config.chat_id))) if enabled}
+        if missing:
+            state = "configuration_required"
+        elif not all(workers.get(lane, False) for lane in expected):
+            state = "worker_unavailable"
+        elif queue["telegram_errors"] or queue["ai_errors"] or telegram["status"] == "error":
+            state = "monitor_degraded"
+        elif telegram["status"] == "not_checked":
+            state = "monitor_waiting_for_delivery"
+        else:
+            state = "monitor_ready"
+        return {"status": state, "version": VERSION, "missing": missing,
+                "storage": "postgresql" if self.config.database_url else "sqlite",
+                "telegram": telegram, "workers": workers}
+
     def status(self):
         return {"mode": "monitor", "version": VERSION, "missing": self.config.missing(), "model": self.config.model,
-                "storage": "postgresql" if self.config.database_url else "temporary_sqlite",
+                "storage": "postgresql" if self.config.database_url else "sqlite",
                 "queue": self.store.stats(), "workers": {t.name: t.is_alive() for t in self.threads}}
 
 
@@ -547,10 +577,11 @@ def make_server(monitor, host="0.0.0.0", port=7860):
             return secrets.compare_digest(urlsplit(self.path).path.encode(), (prefix + monitor.config.secret).encode())
 
         def do_GET(self):
+            if urlsplit(self.path).path == "/live":
+                return self.reply(200, {"status": "alive", "version": VERSION})
             if urlsplit(self.path).path in ("/", "/health"):
-                missing = monitor.config.missing()
-                return self.reply(200, {"status": "configuration_required" if missing else "monitor_ready",
-                    "version": VERSION, "missing": missing, "storage": "postgresql" if monitor.config.database_url else "temporary_sqlite"})
+                health = monitor.health()
+                return self.reply(503 if health["status"] in ("storage_unavailable", "worker_unavailable") else 200, health)
             if self.authorized("/diagnostics/"):
                 return self.reply(200, monitor.clients.diagnose_telegram())
             if self.authorized("/status/") or self.authorized("/samples/"):
@@ -563,8 +594,6 @@ def make_server(monitor, host="0.0.0.0", port=7860):
         def do_POST(self):
             if not self.authorized("/medialogia/"):
                 return self.reply(404, {"error": "not_found"})
-            if monitor.config.missing():
-                return self.reply(503, {"error": "configuration_required"})
             try:
                 size = int(self.headers["Content-Length"])
             except (ValueError, TypeError):
@@ -598,7 +627,7 @@ if __name__ == "__main__":
     app = Monitor(Config.from_env())
     server = make_server(app, port=int(os.getenv("PORT", "7860")))
     app.start()
-    LOG.info("Monitor started; storage=%s; missing=%s", "postgresql" if app.config.database_url else "temporary_sqlite", app.config.missing())
+    LOG.info("Monitor started; storage=%s; missing=%s", "postgresql" if app.config.database_url else "sqlite", app.config.missing())
 
     def shutdown(*_args):
         app.stop.set()
@@ -610,5 +639,8 @@ if __name__ == "__main__":
         server.serve_forever()
     finally:
         app.stop.set()
+        deadline = time.monotonic() + 75
+        for thread in app.threads:
+            thread.join(timeout=max(0, deadline - time.monotonic()))
         server.server_close()
 

render.yaml

@@ -0,0 +1,25 @@
+services:
+  - type: web
+    name: medialogia-monitor
+    runtime: docker
+    plan: starter
+    numInstances: 1
+    healthCheckPath: /live
+    maxShutdownDelaySeconds: 90
+    disk:
+      name: monitor-queue
+      mountPath: /app/data
+      sizeGB: 1
+    envVars:
+      - key: MONITOR_DB_PATH
+        value: /app/data/queue.sqlite3
+      - key: WEBHOOK_SECRET
+        sync: false
+      - key: TELEGRAM_BOT_TOKEN
+        sync: false
+      - key: TELEGRAM_CHAT_ID
+        sync: false
+      - key: DEEPSEEK_API_KEY
+        sync: false
+      - key: DEEPSEEK_MODEL
+        value: deepseek-flash