@misterhuydo/sentinel 1.5.52 → 1.5.54

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-04-20T17:18:46.660Z
+2026-04-21T05:59:33.396Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-04-20T17:16:42.377Z",
-  "checkpoint_at": "2026-04-20T17:16:42.404Z",
+  "message": "Auto-checkpoint at 2026-04-21T06:02:37.029Z",
+  "checkpoint_at": "2026-04-21T06:02:37.031Z",
   "active_files": [
     "J:\\Projects\\Sentinel\\cli\\bin\\sentinel.js",
     "J:\\Projects\\Sentinel\\cli\\lib\\test.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/sentinel",
-  "version": "1.5.52",
+  "version": "1.5.54",
   "description": "Sentinel — Autonomous DevOps Agent installer and manager",
   "bin": {
     "sentinel": "./bin/sentinel.js"

package/python/sentinel/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.52"
+__version__ = "1.5.54"

package/python/sentinel/main.py

@@ -1730,6 +1730,156 @@ async def _patch_soak_monitor(cfg_loader: ConfigLoader) -> None:
     logger.info("Patch soak complete — hash=%s clean=True auto_publish=%s", patch_hash[:8], auto_publish)
 
 
+def _format_monitor_step_output(tool: str, raw: str) -> str | None:
+    """
+    Convert a _run_tool JSON result into a human-readable Slack string.
+    Returns None if there are no meaningful results to post (e.g. empty filter match).
+    """
+    import json as _json
+    try:
+        data = _json.loads(raw)
+    except Exception:
+        return raw.strip() or None
+
+    # ── fetch_logs ────────────────────────────────────────────────────────────
+    if tool == "fetch_logs":
+        results = data.get("results", [])
+        all_lines: list[str] = []
+        for r in results:
+            for line in (r.get("lines") or []):
+                all_lines.append(line.strip())
+        if not all_lines:
+            return None  # no matches — skip posting this cycle
+        lines_text = "\n".join(all_lines[:200])
+        if len(all_lines) > 200:
+            lines_text += f"\n_…and {len(all_lines) - 200} more lines_"
+        return f"```\n{lines_text}\n```"
+
+    # ── filter_logs ───────────────────────────────────────────────────────────
+    if tool == "filter_logs":
+        matches = data.get("matches") or data.get("results") or []
+        if not matches:
+            return None
+        lines = [
+            f"[{m.get('source','?')}:{m.get('file','?')}] {m.get('line', m)}"
+            if isinstance(m, dict) else str(m)
+            for m in matches[:200]
+        ]
+        text = "\n".join(lines)
+        if len(matches) > 200:
+            text += f"\n_…and {len(matches) - 200} more_"
+        return f"```\n{text}\n```"
+
+    # ── get_status / check_health / others — always show ─────────────────────
+    if "error" in data:
+        return f":warning: `{tool}` error: {data['error']}"
+    # Generic: strip JSON, show as compact text
+    return raw.strip()
+
+
+async def _execute_monitor(monitor: dict, cfg_loader: ConfigLoader, store: StateStore) -> None:
+    """Execute one monitor run: call all steps, post formatted output to Slack."""
+    import json as _json
+    from datetime import datetime, timezone, timedelta
+    from .sentinel_boss import _run_tool, _format_duration
+
+    mon_id      = monitor["id"]
+    channel     = monitor.get("channel", "")
+    user_id     = monitor.get("user_id", "")
+    steps       = _json.loads(monitor.get("steps_json") or "[]")
+    interval_s  = int(monitor.get("interval_seconds", 300))
+    stop_at     = monitor.get("stop_at")
+    max_runs    = monitor.get("max_runs")
+    runs_so_far = int(monitor.get("runs_so_far") or 0)
+    mon_name    = monitor.get("name") or " → ".join(s.get("tool", "") for s in steps)
+
+    cfg = cfg_loader.sentinel
+
+    slack_client = None
+    if cfg.slack_bot_token and channel:
+        try:
+            from slack_sdk.web.async_client import AsyncWebClient as _AsyncWebClient
+            slack_client = _AsyncWebClient(token=cfg.slack_bot_token)
+        except Exception:
+            pass
+
+    # Run each step and collect formatted output
+    formatted_parts: list[str] = []
+    for step in steps:
+        tool   = step.get("tool", "")
+        inputs = step.get("inputs", {})
+        try:
+            raw = await asyncio.wait_for(
+                _run_tool(tool, inputs, cfg_loader, store,
+                          slack_client=slack_client, user_id=user_id, channel=channel),
+                timeout=300,
+            )
+            part = _format_monitor_step_output(tool, raw)
+            if part:
+                formatted_parts.append(part)
+        except asyncio.TimeoutError:
+            formatted_parts.append(f":warning: `{tool}` timed out after 5 minutes.")
+        except Exception as e:
+            formatted_parts.append(f":warning: `{tool}` error: {e}")
+
+    runs_after = runs_so_far + 1
+    now        = datetime.now(timezone.utc)
+
+    # Determine if this was the final run
+    done = False
+    if max_runs and runs_after >= int(max_runs):
+        done = True
+    if stop_at:
+        try:
+            stop_dt = datetime.fromisoformat(stop_at.replace("Z", "+00:00"))
+            if now + timedelta(seconds=interval_s) >= stop_dt:
+                done = True
+        except Exception:
+            pass
+
+    next_run_at = (now + timedelta(seconds=interval_s)).isoformat()
+    store.mark_monitor_ran(mon_id, next_run_at, done=done)
+
+    if not slack_client or not channel:
+        return
+
+    # Only post if there is something to show
+    if formatted_parts:
+        combined = "\n".join(formatted_parts)
+        MAX_LEN  = 3800
+        if len(combined) > MAX_LEN:
+            combined = combined[:MAX_LEN] + f"\n_…truncated ({len(combined)} chars total)_"
+        header = f":repeat: *Monitor `{mon_id}`* ({mon_name}) — run #{runs_after}"
+        if done:
+            header += " _(final)_"
+        try:
+            await slack_client.chat_postMessage(channel=channel, text=f"{header}\n{combined}")
+        except Exception as e:
+            logger.warning("Monitor %s: Slack post failed: %s", mon_id, e)
+
+    if done:
+        try:
+            await slack_client.chat_postMessage(
+                channel=channel,
+                text=f":checkered_flag: Monitor `{mon_id}` ({mon_name}) finished after {runs_after} run(s).",
+            )
+        except Exception as e:
+            logger.warning("Monitor %s: Slack done-post failed: %s", mon_id, e)
+
+
+async def _monitor_runner_loop(cfg_loader: ConfigLoader, store: StateStore) -> None:
+    """Check every 30 s for due monitors and dispatch them."""
+    await asyncio.sleep(15)   # brief startup delay
+    while True:
+        try:
+            due = store.get_due_monitors()
+            for monitor in due:
+                asyncio.ensure_future(_execute_monitor(monitor, cfg_loader, store))
+        except Exception as e:
+            logger.warning("Monitor runner: error checking due monitors: %s", e)
+        await asyncio.sleep(30)
+
+
 async def run_loop(cfg_loader: ConfigLoader, store: StateStore):
     interval = cfg_loader.sentinel.poll_interval_seconds
     logger.info("Sentinel starting — poll interval: %ds, repos: %s",
@@ -1774,6 +1924,7 @@ async def run_loop(cfg_loader: ConfigLoader, store: StateStore):
         asyncio.ensure_future(_dev_poll_loop(cfg_loader, store))
         asyncio.ensure_future(_patch_soak_monitor(cfg_loader))
     asyncio.ensure_future(_repo_task_poll_loop(cfg_loader, store))
+    asyncio.ensure_future(_monitor_runner_loop(cfg_loader, store))
 
     while True:
         try:

package/python/sentinel/sentinel_boss.py

@@ -367,6 +367,19 @@ reply with a grouped summary like this:
     – The user explicitly says "STS is Whydah-SecurityTokenService" or "route STS to ..."
   After saving, Sentinel automatically reprocesses any pending routing for that service.
 
+*Scheduled monitors*
+• `start_monitor` — run a tool repeatedly at an interval, posting results to this channel.
+  Supported patterns:
+    – "every X min/hours/days until I say stop"
+    – "every X min for Y hours/days" → calculate stop_at = now + duration
+    – "every X min for N times" → set max_runs=N
+    – "every X min until <datetime>" → set stop_at
+  Minimum interval: 60 seconds. Allowed tools: fetch_logs, filter_logs, get_status,
+  ask_logs, list_recent_commits, check_health.
+  Always confirm to the user with the monitor ID and stop condition before creating.
+• `stop_monitor` — cancel a monitor by ID, or pass "all" to cancel all in this channel
+• `list_monitors` — show all active monitors
+
 *File sharing*
 • `post_file` — upload any output as a Slack file (logs, diffs, reports)
 
@@ -524,6 +537,15 @@ Response length:
 - Status/health data: one line. Don't re-list every field from the JSON.
 - Actions (fix, merge, release): brief confirmation of what happened.
 
+Formatting — always use Slack code blocks (triple backticks) for:
+- Log lines / log output
+- JSON or structured data
+- Stack traces
+- Code snippets
+- File diffs
+- Any multi-line technical content
+Never paste raw JSON or log text as plain prose.
+
 When to act vs. when to ask:
 - Any read/investigate tool → call immediately without asking permission.
   Never say "Want me to check?" — just check and report results.
@@ -1318,6 +1340,79 @@ _TOOLS = [
             "required": ["service_name", "repo_name"],
         },
     },
+    {
+        "name": "start_monitor",
+        "description": (
+            "Create a recurring scheduled task that runs a tool at a regular interval and posts "
+            "results to this Slack channel. Supports: run indefinitely (until stopped), run for "
+            "a fixed duration (stop_at), or run N times (max_runs). "
+            "steps is a list of {tool, inputs} objects — most monitors are a single step. "
+            "Allowed tools: fetch_logs, filter_logs, get_status, ask_logs, list_recent_commits, check_health. "
+            "Boss calculates stop_at from phrases like 'within 2 hours' / 'for 30 minutes' using "
+            "the current UTC time in the system prompt. "
+            "Examples: 'fetch SSOLWA logs filtered by provision/phone every 5 min for 2 hours', "
+            "'check STS health every 10 min until I say stop', 'get status every hour for 3 times'."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Short label for this monitor (e.g. 'SSOLWA provision/phone')",
+                },
+                "steps": {
+                    "type": "array",
+                    "description": "Ordered list of tool calls to execute each interval",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "tool":   {"type": "string"},
+                            "inputs": {"type": "object"},
+                        },
+                        "required": ["tool", "inputs"],
+                    },
+                },
+                "interval_seconds": {
+                    "type": "integer",
+                    "description": "How often to run in seconds (minimum 60)",
+                },
+                "stop_at": {
+                    "type": "string",
+                    "description": "ISO datetime (UTC) to stop, or null to run indefinitely",
+                },
+                "max_runs": {
+                    "type": "integer",
+                    "description": "Maximum number of runs, or null for unlimited",
+                },
+            },
+            "required": ["steps", "interval_seconds"],
+        },
+    },
+    {
+        "name": "stop_monitor",
+        "description": (
+            "Cancel a running monitor by ID. Pass 'all' to cancel every active monitor in this channel. "
+            "Use for: 'stop monitor m-abc123', 'stop all monitors', 'cancel the log watch'."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "monitor_id": {
+                    "type": "string",
+                    "description": "Monitor ID (e.g. 'm-abc123') or 'all'",
+                },
+            },
+            "required": ["monitor_id"],
+        },
+    },
+    {
+        "name": "list_monitors",
+        "description": (
+            "List all active scheduled monitors. "
+            "Use for: 'what monitors are running?', 'show scheduled tasks', 'list active monitors'."
+        ),
+        "input_schema": {"type": "object", "properties": {}},
+    },
     {
         "name": "upgrade_sentinel",
         "description": (
@@ -2048,6 +2143,41 @@ def _git_pull(path: Path) -> dict:
 
 # ── Log-source name resolver ──────────────────────────────────────────────────
 
+def _resolve_source_hint(hint: str, cfg_loader, store=None) -> str:
+    """
+    Translate a short alias (e.g. 'SSOLWA') to the canonical log-source / repo name
+    so that _filter_log_sources and _auto_health_check can match it.
+
+    Resolution order:
+      1. Already matches a log-source name → return as-is
+      2. Matches a repo's SERVICE_ALIASES  → return the repo name
+      3. DB aliases                         → return the stored repo name
+      4. Fallback                           → return hint unchanged
+    """
+    if not hint:
+        return hint
+    hint_lower = hint.lower()
+
+    # 1. Direct log-source match — no translation needed
+    for src_name in cfg_loader.log_sources:
+        if hint_lower in src_name.lower():
+            return hint
+
+    # 2. Config-declared SERVICE_ALIASES
+    for repo_name, repo in cfg_loader.repos.items():
+        declared = getattr(repo, "service_aliases", [])
+        if any(hint_lower == a.lower() for a in declared):
+            return repo_name
+
+    # 3. DB aliases
+    if store:
+        alias = store.get_service_alias(hint)
+        if alias:
+            return alias
+
+    return hint
+
+
 def _filter_log_sources(props_files: list, source_hint: str) -> list:
     """
     Return the subset of props_files whose log source matches source_hint.
@@ -2118,6 +2248,20 @@ def _auto_health_check(source_hint: str, cfg_loader) -> dict | None:
         return None
 
 
+def _format_duration(seconds: int) -> str:
+    """Convert seconds to a human-readable duration string."""
+    if seconds < 60:
+        return f"{seconds}s"
+    if seconds < 3600:
+        m = seconds // 60
+        return f"{m} min" + ("s" if m != 1 else "")
+    if seconds < 86400:
+        h = seconds // 3600
+        return f"{h} hour" + ("s" if h != 1 else "")
+    d = seconds // 86400
+    return f"{d} day" + ("s" if d != 1 else "")
+
+
 # ── Tool execution ────────────────────────────────────────────────────────────
 
 async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=None, user_id: str = "", channel: str = "", is_admin: bool = False) -> str:
@@ -2756,7 +2900,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
 
     if name == "search_logs":
         query       = inputs.get("query", "")
-        source      = inputs.get("source", "").lower()
+        source      = _resolve_source_hint(inputs.get("source", "").lower(), cfg_loader, store)
         max_matches = int(inputs.get("max_matches", 30))
         tail_override = inputs.get("tail")
 
@@ -2907,7 +3051,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             return line.strip()[:40]
 
         query_f      = inputs.get("query", "")
-        source_f     = inputs.get("source", "").lower()
+        source_f     = _resolve_source_hint(inputs.get("source", "").lower(), cfg_loader, store)
         since_hours  = inputs.get("since_hours")
         max_matches  = int(inputs.get("max_matches", 300))
         case_flag    = 0 if inputs.get("case_sensitive") else _re.IGNORECASE
@@ -3127,7 +3271,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         return json.dumps({"results": results})
 
     if name == "fetch_logs":
-        source_filter = inputs.get("source", "").lower()
+        source_filter = _resolve_source_hint(inputs.get("source", "").lower(), cfg_loader, store)
         debug         = bool(inputs.get("debug", False))
         tail_override = inputs.get("tail")
         grep_override = inputs.get("grep_filter", "")
@@ -3367,6 +3511,108 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             ),
         })
 
+    if name == "start_monitor":
+        steps       = inputs.get("steps") or []
+        interval_s  = int(inputs.get("interval_seconds", 0))
+        stop_at     = inputs.get("stop_at") or None
+        max_runs    = inputs.get("max_runs") or None
+        mon_name    = (inputs.get("name") or "").strip()
+
+        if not steps:
+            return json.dumps({"error": "steps is required — list at least one {tool, inputs} step"})
+        if interval_s < 60:
+            return json.dumps({"error": f"interval_seconds must be >= 60 (minimum 1 minute), got {interval_s}"})
+
+        _MONITOR_ALLOWED = {"fetch_logs", "filter_logs", "get_status", "ask_logs",
+                            "list_recent_commits", "check_health"}
+        for _step in steps:
+            _t = _step.get("tool", "")
+            if _t not in _MONITOR_ALLOWED:
+                return json.dumps({
+                    "error": f"Tool '{_t}' is not allowed in monitors.",
+                    "allowed": sorted(_MONITOR_ALLOWED),
+                })
+
+        if stop_at:
+            try:
+                datetime.fromisoformat(stop_at.replace("Z", "+00:00"))
+            except ValueError:
+                return json.dumps({"error": f"Invalid stop_at datetime: '{stop_at}'. Use ISO 8601 format."})
+
+        if max_runs is not None:
+            max_runs = int(max_runs)
+            if max_runs < 1:
+                return json.dumps({"error": "max_runs must be >= 1"})
+
+        mon_id     = "m-" + uuid.uuid4().hex[:6]
+        steps_json = json.dumps(steps)
+
+        store.create_monitor(
+            id=mon_id, name=mon_name, steps_json=steps_json,
+            interval_seconds=interval_s, stop_at=stop_at, max_runs=max_runs,
+            channel=channel, user_id=user_id or "",
+        )
+
+        interval_str = _format_duration(interval_s)
+        if stop_at:
+            _stop_dt = datetime.fromisoformat(stop_at.replace("Z", "+00:00"))
+            stop_desc = f"until {_stop_dt.strftime('%Y-%m-%d %H:%M UTC')}"
+            if max_runs:
+                stop_desc += f" or {max_runs} run(s) — whichever comes first"
+        elif max_runs:
+            stop_desc = f"for {max_runs} run{'s' if max_runs > 1 else ''}"
+        else:
+            stop_desc = "until you say stop"
+
+        steps_desc = " → ".join(s["tool"] for s in steps)
+        label = mon_name or steps_desc
+        return json.dumps({
+            "monitor_id":   mon_id,
+            "label":        label,
+            "interval":     interval_str,
+            "stop":         stop_desc,
+            "first_run_in": interval_str,
+            "status":       "active",
+            "message": (
+                f"Monitor `{mon_id}` created — running `{label}` every {interval_str} {stop_desc}. "
+                f"First run in {interval_str}. Say `stop monitor {mon_id}` to cancel."
+            ),
+        })
+
+    if name == "stop_monitor":
+        mon_id = (inputs.get("monitor_id") or "").strip()
+        if not mon_id:
+            return json.dumps({"error": "monitor_id is required"})
+        if mon_id.lower() == "all":
+            count = store.cancel_all_monitors(channel=channel)
+            return json.dumps({"cancelled": count, "message": f"Cancelled {count} active monitor(s)."})
+        ok = store.cancel_monitor(mon_id)
+        if ok:
+            return json.dumps({"status": "cancelled", "monitor_id": mon_id})
+        return json.dumps({"error": f"Monitor '{mon_id}' not found or already stopped."})
+
+    if name == "list_monitors":
+        monitors = store.list_active_monitors()
+        if not monitors:
+            return json.dumps({"monitors": [], "message": "No active monitors."})
+        result = []
+        for _m in monitors:
+            _runs_left = None
+            if _m.get("max_runs"):
+                _runs_left = _m["max_runs"] - _m["runs_so_far"]
+            result.append({
+                "id":          _m["id"],
+                "name":        _m.get("name") or "",
+                "status":      _m["status"],
+                "interval":    _format_duration(_m["interval_seconds"]),
+                "runs_so_far": _m["runs_so_far"],
+                "runs_left":   _runs_left,
+                "next_run_at": _m.get("next_run_at") or "",
+                "stop_at":     _m.get("stop_at") or "",
+                "steps":       json.loads(_m.get("steps_json") or "[]"),
+            })
+        return json.dumps({"monitors": result})
+
     if name == "upgrade_sentinel":
         if not is_admin:
             return json.dumps({"error": "upgrade is admin-only. Ask a Sentinel admin to perform the upgrade."})

package/python/sentinel/state_store.py

@@ -433,6 +433,106 @@ class StateStore:
             rows = conn.execute("SELECT * FROM service_aliases ORDER BY service_name").fetchall()
             return [dict(r) for r in rows]
 
+    # ── Scheduled monitors ────────────────────────────────────────────────────
+
+    def _ensure_monitors_table(self, conn):
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS monitors ("
+            "id TEXT PRIMARY KEY, "
+            "name TEXT, "
+            "steps_json TEXT, "
+            "interval_seconds INTEGER, "
+            "stop_at TEXT, "
+            "max_runs INTEGER, "
+            "runs_so_far INTEGER DEFAULT 0, "
+            "last_run_at TEXT, "
+            "next_run_at TEXT, "
+            "channel TEXT, "
+            "user_id TEXT, "
+            "status TEXT DEFAULT 'active', "
+            "created_at TEXT)"
+        )
+
+    def create_monitor(self, id: str, name: str, steps_json: str,
+                       interval_seconds: int, stop_at, max_runs,
+                       channel: str, user_id: str) -> None:
+        from datetime import datetime, timezone, timedelta
+        next_run = (datetime.now(timezone.utc) + timedelta(seconds=interval_seconds)).isoformat()
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            conn.execute(
+                "INSERT INTO monitors (id, name, steps_json, interval_seconds, stop_at, "
+                "max_runs, runs_so_far, last_run_at, next_run_at, channel, user_id, status, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, 0, NULL, ?, ?, ?, 'active', ?)",
+                (id, name, steps_json, interval_seconds, stop_at, max_runs,
+                 next_run, channel, user_id, _now()),
+            )
+
+    def get_due_monitors(self) -> list[dict]:
+        from datetime import datetime, timezone
+        now = datetime.now(timezone.utc).isoformat()
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM monitors WHERE status = 'active' AND next_run_at <= ?",
+                (now,),
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def get_monitor(self, id: str) -> dict | None:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            row = conn.execute("SELECT * FROM monitors WHERE id = ?", (id,)).fetchone()
+            return dict(row) if row else None
+
+    def list_active_monitors(self) -> list[dict]:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM monitors WHERE status = 'active' ORDER BY created_at DESC"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def list_all_monitors(self) -> list[dict]:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM monitors ORDER BY created_at DESC LIMIT 50"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def mark_monitor_ran(self, id: str, next_run_at: str, done: bool = False) -> None:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            if done:
+                conn.execute("DELETE FROM monitors WHERE id = ?", (id,))
+            else:
+                conn.execute(
+                    "UPDATE monitors SET runs_so_far = runs_so_far + 1, last_run_at = ?, "
+                    "next_run_at = ? WHERE id = ?",
+                    (_now(), next_run_at, id),
+                )
+
+    def cancel_monitor(self, id: str) -> bool:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            cur = conn.execute(
+                "DELETE FROM monitors WHERE id = ? AND status = 'active'", (id,)
+            )
+            return cur.rowcount > 0
+
+    def cancel_all_monitors(self, channel: str = "") -> int:
+        with self._conn() as conn:
+            self._ensure_monitors_table(conn)
+            if channel:
+                cur = conn.execute(
+                    "DELETE FROM monitors WHERE status = 'active' AND channel = ?",
+                    (channel,),
+                )
+            else:
+                cur = conn.execute("DELETE FROM monitors WHERE status = 'active'")
+            return cur.rowcount
+
     # ── Pending bot-message routing questions ─────────────────────────────────
 
     def _ensure_pending_routings_table(self, conn):