@misterhuydo/sentinel 1.1.8 → 1.2.0

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-03-23T08:53:23.129Z
+2026-03-23T09:25:27.661Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-23T09:16:11.394Z",
-  "checkpoint_at": "2026-03-23T09:16:11.395Z",
+  "message": "Auto-checkpoint at 2026-03-23T09:22:14.601Z",
+  "checkpoint_at": "2026-03-23T09:22:14.603Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

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

package/python/sentinel/sentinel_boss.py

@@ -187,9 +187,9 @@ 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:
-- If a broad search (e.g. search_logs with no source filter) already returned results for a query, do NOT repeat the same search with a source filter to "refine" — use the results you already have.
-- If a tool call fails (wrong source name, config not found), do NOT retry the entire search from scratch. Continue with what succeeded, and note the failure in your reply.
+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:
@@ -201,12 +201,18 @@ Issue identification — before calling create_issue:
    - Attachments: summarise any files/screenshots the user shared.
    - Support URL: note any ticket/doc/link the user mentioned.
    - Identity: always captured automatically from the Slack session.
-3. Before calling the tool, confirm with the user in natural language:
+3. ALWAYS populate the `findings` field with evidence from this session:
+   - If you ran search_logs, tail_log, ask_codebase, or get_status before creating the issue,
+     include the relevant results (log excerpts, error counts, timestamps, stack traces, etc.).
+   - The fix engine reads only the issue file — it has no access to the conversation.
+     Everything it needs to understand and fix the problem must be in the file.
+   - A `description` with no evidence forces the fix engine to guess. Always attach what you found.
+4. Before calling the tool, confirm with the user in natural language:
    e.g. "I'll create an issue for project *1881* — here's what I have: [summary]. Look right?"
    Wait for their confirmation before proceeding.
    EXCEPTION: if the user's message already contains a clear project + unambiguous description,
    skip the confirmation and create immediately — don't ask when nothing is unclear.
-4. After creating, tell them the issue was queued and Sentinel will pick it up on the next poll.
+5. After creating, tell them the issue was queued and Sentinel will pick it up on the next poll.
 
 When the engineer's request is fully handled, end your LAST message with the token: [DONE]
 IMPORTANT: Always write your actual reply text FIRST, then append [DONE] at the end. Example: "Hello! I'm Sentinel. [DONE]". Never output [DONE] as your only content.
@@ -267,6 +273,16 @@ _TOOLS = [
                     "type": "string",
                     "description": "Summary of any files/screenshots the user attached",
                 },
+                "findings": {
+                    "type": "string",
+                    "description": (
+                        "Evidence gathered during this session: log excerpts, search results, "
+                        "stack traces, error counts, timestamps — anything from tool calls that "
+                        "is relevant to the issue. Include this whenever you ran search_logs, "
+                        "tail_log, ask_codebase, or get_status before creating the issue. "
+                        "The fix engine reads the issue file and needs this context to act."
+                    ),
+                },
             },
             "required": ["description"],
         },
@@ -949,6 +965,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
 
         support_url          = inputs.get("support_url", "").strip()
         attachments_summary  = inputs.get("attachments_summary", "").strip()
+        findings             = inputs.get("findings", "").strip()
 
         issues_dir = project_dir / "issues"
         issues_dir.mkdir(exist_ok=True)
@@ -966,6 +983,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         lines.append(f"SUBMITTED_AT: {datetime.now(timezone.utc).isoformat()}")
         lines.append("")
         lines.append(description)
+        if findings:
+            lines.append(f"\nEVIDENCE (gathered by Sentinel Boss):\n{findings}")
         if attachments_summary:
             lines.append(f"\nATTACHMENTS:\n{attachments_summary}")
         content = "\n".join(lines)

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