@misterhuydo/sentinel 1.5.53 → 1.5.54

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-04-21T05:28:47.362Z
+2026-04-21T05:59:33.396Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-04-21T05:29:15.578Z",
-  "checkpoint_at": "2026-04-21T05:29:15.579Z",
+  "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.53",
+  "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.53"
+__version__ = "1.5.54"

package/python/sentinel/main.py

@@ -1730,25 +1730,71 @@ 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 combined output to Slack."""
+    """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)
+    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
 
-    # Build a minimal Slack client for posting
     slack_client = None
     if cfg.slack_bot_token and channel:
         try:
@@ -1757,22 +1803,24 @@ async def _execute_monitor(monitor: dict, cfg_loader: ConfigLoader, store: State
         except Exception:
             pass
 
-    # Run each step
-    outputs: list[str] = []
+    # Run each step and collect formatted output
+    formatted_parts: list[str] = []
     for step in steps:
         tool   = step.get("tool", "")
         inputs = step.get("inputs", {})
         try:
-            result = await asyncio.wait_for(
+            raw = await asyncio.wait_for(
                 _run_tool(tool, inputs, cfg_loader, store,
                           slack_client=slack_client, user_id=user_id, channel=channel),
                 timeout=300,
             )
-            outputs.append(result)
+            part = _format_monitor_step_output(tool, raw)
+            if part:
+                formatted_parts.append(part)
         except asyncio.TimeoutError:
-            outputs.append(f"_Step `{tool}` timed out after 5 minutes._")
+            formatted_parts.append(f":warning: `{tool}` timed out after 5 minutes.")
         except Exception as e:
-            outputs.append(f"_Step `{tool}` error: {e}_")
+            formatted_parts.append(f":warning: `{tool}` error: {e}")
 
     runs_after = runs_so_far + 1
     now        = datetime.now(timezone.utc)
@@ -1784,8 +1832,7 @@ async def _execute_monitor(monitor: dict, cfg_loader: ConfigLoader, store: State
     if stop_at:
         try:
             stop_dt = datetime.fromisoformat(stop_at.replace("Z", "+00:00"))
-            next_dt = now + timedelta(seconds=interval_s)
-            if next_dt >= stop_dt:
+            if now + timedelta(seconds=interval_s) >= stop_dt:
                 done = True
         except Exception:
             pass
@@ -1796,26 +1843,28 @@ async def _execute_monitor(monitor: dict, cfg_loader: ConfigLoader, store: State
     if not slack_client or not channel:
         return
 
-    combined = "\n\n".join(o for o in outputs if o.strip())
-    MAX_LEN  = 3000
-    if len(combined) > MAX_LEN:
-        combined = combined[:MAX_LEN] + f"\n_(output truncated — {len(combined)} chars total)_"
+    # 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)
 
-    header = f":repeat: *Monitor `{mon_id}`* ({mon_name}) — run #{runs_after}"
     if done:
-        header += " _(final run)_"
-
-    text = f"{header}\n{combined}" if combined.strip() else f"{header}\n_no output_"
-
-    try:
-        await slack_client.chat_postMessage(channel=channel, text=text)
-        if done:
+        try:
             await slack_client.chat_postMessage(
                 channel=channel,
-                text=f":checkered_flag: Monitor `{mon_id}` finished after {runs_after} run(s).",
+                text=f":checkered_flag: Monitor `{mon_id}` ({mon_name}) finished after {runs_after} run(s).",
             )
-    except Exception as e:
-        logger.warning("Monitor %s: failed to post result to Slack: %s", mon_id, e)
+        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:

package/python/sentinel/sentinel_boss.py

@@ -378,7 +378,7 @@ reply with a grouped summary like this:
   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 and recent monitors with their status and next-run time
+• `list_monitors` — show all active monitors
 
 *File sharing*
 • `post_file` — upload any output as a Slack file (logs, diffs, reports)
@@ -537,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.
@@ -1399,7 +1408,7 @@ _TOOLS = [
     {
         "name": "list_monitors",
         "description": (
-            "List active and recently completed scheduled monitors. "
+            "List all active scheduled monitors. "
             "Use for: 'what monitors are running?', 'show scheduled tasks', 'list active monitors'."
         ),
         "input_schema": {"type": "object", "properties": {}},
@@ -2134,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.
@@ -2856,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")
 
@@ -3007,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
@@ -3227,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", "")
@@ -3548,9 +3592,9 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         return json.dumps({"error": f"Monitor '{mon_id}' not found or already stopped."})
 
     if name == "list_monitors":
-        monitors = store.list_all_monitors()
+        monitors = store.list_active_monitors()
         if not monitors:
-            return json.dumps({"monitors": [], "message": "No monitors found."})
+            return json.dumps({"monitors": [], "message": "No active monitors."})
         result = []
         for _m in monitors:
             _runs_left = None

package/python/sentinel/state_store.py

@@ -502,21 +502,22 @@ class StateStore:
             return [dict(r) for r in rows]
 
     def mark_monitor_ran(self, id: str, next_run_at: str, done: bool = False) -> None:
-        status = "done" if done else "active"
         with self._conn() as conn:
             self._ensure_monitors_table(conn)
-            conn.execute(
-                "UPDATE monitors SET runs_so_far = runs_so_far + 1, last_run_at = ?, "
-                "next_run_at = ?, status = ? WHERE id = ?",
-                (_now(), next_run_at, status, id),
-            )
+            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(
-                "UPDATE monitors SET status = 'cancelled' WHERE id = ? AND status = 'active'",
-                (id,),
+                "DELETE FROM monitors WHERE id = ? AND status = 'active'", (id,)
             )
             return cur.rowcount > 0
 
@@ -525,14 +526,11 @@ class StateStore:
             self._ensure_monitors_table(conn)
             if channel:
                 cur = conn.execute(
-                    "UPDATE monitors SET status = 'cancelled' "
-                    "WHERE status = 'active' AND channel = ?",
+                    "DELETE FROM monitors WHERE status = 'active' AND channel = ?",
                     (channel,),
                 )
             else:
-                cur = conn.execute(
-                    "UPDATE monitors SET status = 'cancelled' WHERE status = 'active'"
-                )
+                cur = conn.execute("DELETE FROM monitors WHERE status = 'active'")
             return cur.rowcount
 
     # ── Pending bot-message routing questions ─────────────────────────────────