@misterhuydo/sentinel 1.1.7 → 1.1.9

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-23T09:08:47.973Z",
-  "checkpoint_at": "2026-03-23T09:08:47.974Z",
+  "message": "Auto-checkpoint at 2026-03-23T09:20:28.044Z",
+  "checkpoint_at": "2026-03-23T09:20:28.045Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

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

package/python/sentinel/sentinel_boss.py

@@ -187,6 +187,11 @@ Session context — critical rules:
 - When handling a new request, call the tools fresh. Do not assume any prior tool result is still current or that any prior step "counts" toward the current task.
 - The only exception: if the user explicitly asks about something from the history ("what did you find earlier?"), you may reference it — but note it is from a prior session.
 
+Avoid redundant tool calls (within a single response only — always run tools fresh for new requests):
+- If a broad search (e.g. search_logs with no source filter) already returned results in THIS response, do NOT repeat the same search with a source filter to "refine" — use what you already fetched.
+- If a tool call fails in THIS response, do NOT retry the entire search from scratch. Continue with what succeeded and note the failure.
+- One pass per task: gather all needed data in a single round of tool calls, then produce the final answer.
+
 Issue identification — before calling create_issue:
 1. Determine if the message is a REAL issue/task (bug report, feature request, investigation ask)
    vs. a status question, tool query, or casual chat. If not an issue, just answer normally.
@@ -779,6 +784,48 @@ def _git_pull(path: Path) -> dict:
         return {"status": "error", "detail": str(e)}
 
 
+# ── Log-source name resolver ──────────────────────────────────────────────────
+
+def _filter_log_sources(props_files: list, source_hint: str) -> list:
+    """
+    Return the subset of props_files whose log source matches source_hint.
+
+    Matching is tried in order (first match wins per file):
+      1. Substring of the filename stem   (e.g. "sts"   → STS.properties)
+      2. Substring of REMOTE_SERVICE_USER (e.g. "ssolwa" → ...SSOLoginWebApp...)
+      3. Substring of HOSTS               (e.g. hostname fragment)
+
+    Case-insensitive throughout. An empty source_hint returns all files unchanged.
+    """
+    if not source_hint:
+        return props_files
+    hint = source_hint.lower()
+
+    def _props_contains(path: Path, key: str, hint: str) -> bool:
+        try:
+            for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+                stripped = line.strip()
+                if stripped.startswith("#"):
+                    continue
+                if stripped.upper().startswith(key + "="):
+                    val = stripped.split("=", 1)[1].partition("#")[0].strip().lower()
+                    if hint in val:
+                        return True
+        except OSError:
+            pass
+        return False
+
+    matched = []
+    for p in props_files:
+        if hint in p.stem.lower():
+            matched.append(p)
+        elif _props_contains(p, "REMOTE_SERVICE_USER", hint):
+            matched.append(p)
+        elif _props_contains(p, "HOSTS", hint):
+            matched.append(p)
+    return matched
+
+
 # ── 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:
@@ -1016,9 +1063,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         script = Path(__file__).resolve().parent.parent / "scripts" / "fetch_log.sh"
         log_cfg_dir = Path("config") / "log-configs"
         if script.exists() and log_cfg_dir.exists():
-            props_files = sorted(log_cfg_dir.glob("*.properties"))
-            if source:
-                props_files = [p for p in props_files if source in p.stem.lower()]
+            props_files = _filter_log_sources(sorted(log_cfg_dir.glob("*.properties")), source)
             if props_files:
                 live_results = []
                 for props in props_files:
@@ -1165,9 +1210,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         if not log_cfg_dir.exists():
             return json.dumps({"error": "config/log-configs/ not found"})
 
-        props_files = sorted(log_cfg_dir.glob("*.properties"))
-        if source_filter:
-            props_files = [p for p in props_files if source_filter in p.stem.lower()]
+        props_files = _filter_log_sources(sorted(log_cfg_dir.glob("*.properties")), source_filter)
         if not props_files:
             return json.dumps({"error": f"No log-config found matching '{source_filter}'"})
 

package/python/sentinel/slack_bot.py

@@ -367,31 +367,61 @@ async def _dispatch(event: dict, client, cfg_loader, store) -> None:
 
 _MAX_HISTORY_TURNS = 20   # keep last 20 exchanges (~40 messages) to stay well within context limits
 
+
+def _strip_tool_turns(history: list) -> list:
+    """
+    Remove any message that consists entirely of tool_use or tool_result blocks.
+    Keeps only plain text exchanges so loaded prior history doesn't contain stale
+    search results that the model might treat as already-done work.
+    """
+    result = []
+    for msg in history:
+        content = msg.get("content", "")
+        # Plain string content — always keep
+        if isinstance(content, str):
+            result.append(msg)
+            continue
+        # List content — keep only if it has at least one text block
+        if isinstance(content, list):
+            has_text = any(
+                isinstance(b, dict) and b.get("type") == "text" and b.get("text", "").strip()
+                for b in content
+            )
+            if has_text:
+                # Keep only the text blocks, drop tool_use/tool_result
+                text_blocks = [b for b in content if isinstance(b, dict) and b.get("type") == "text"]
+                result.append({**msg, "content": text_blocks})
+    return result
+
 async def _run_turn(session: _Session, message: str, client, cfg_loader, store, attachments: list | None = None, is_admin: bool = False) -> None:
     channel = session.channel
 
     # Load persisted history from DB on the first turn of a new session.
-    # - _clean_history strips orphaned tool_use turns from a previous crashed session.
-    # - Trim to last 6 exchanges (12 messages) to prevent stale tool results from bleeding
-    #   into the current session and causing the model to treat old work as already done.
-    # - Inject a session boundary marker so the model clearly sees where prior context ends.
+    # - _clean_history strips orphaned tool_use turns from previous crashed sessions.
+    # - Strip all tool_use / tool_result blocks from prior history — only keep conversational
+    #   text. Stale search results in prior history cause the model to skip re-running tools
+    #   for new requests ("I already searched that"), which produces wrong/empty answers.
+    # - Trim to last 6 text exchanges (12 messages) to limit context bleed.
+    # - Inject a session boundary marker so the model clearly separates old from new.
     if not session.history_loaded:
         loaded = _clean_history(store.load_conversation(session.user_id))
         if loaded:
-            # Keep only the most recent 6 exchanges from prior session
+            text_only = _strip_tool_turns(loaded)
             _PRIOR_TURNS = 6
-            trimmed = loaded[-(_PRIOR_TURNS * 2):]
-            # Prepend a boundary pair so the model treats everything before it as old context
-            session.history = [
-                {
-                    "role": "user",
-                    "content": "[system: new session started — the following is prior conversation context only]",
-                },
-                {
-                    "role": "assistant",
-                    "content": [{"type": "text", "text": "Understood. I'll treat the prior context as reference only and handle your new request fresh."}],
-                },
-            ] + trimmed
+            trimmed = text_only[-(_PRIOR_TURNS * 2):]
+            if trimmed:
+                session.history = [
+                    {
+                        "role": "user",
+                        "content": "[system: new session started — the following is prior conversation context only, no tool calls needed]",
+                    },
+                    {
+                        "role": "assistant",
+                        "content": [{"type": "text", "text": "Understood. Starting fresh — prior context is for reference only."}],
+                    },
+                ] + trimmed
+            else:
+                session.history = []
         else:
             session.history = []
         session.history_loaded = True