@misterhuydo/sentinel 1.2.4 → 1.2.6

package/python/sentinel/state_store.py

@@ -1,499 +1,542 @@
-"""
-state_store.py — SQLite-backed persistence for errors, fixes, and reports.
-"""
-
-import json
-import sqlite3
-import logging
-from contextlib import contextmanager
-from datetime import datetime, timezone
-
-logger = logging.getLogger(__name__)
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class StateStore:
-    def __init__(self, db_path: str = "./sentinel.db"):
-        self.db_path = db_path
-        self._init_db()
-
-    @contextmanager
-    def _conn(self):
-        conn = sqlite3.connect(self.db_path)
-        conn.row_factory = sqlite3.Row
-        try:
-            yield conn
-            conn.commit()
-        finally:
-            conn.close()
-
-    def _init_db(self):
-        with self._conn() as conn:
-            conn.executescript("""
-                CREATE TABLE IF NOT EXISTS errors (
-                    fingerprint   TEXT PRIMARY KEY,
-                    first_seen    TEXT NOT NULL,
-                    last_seen     TEXT NOT NULL,
-                    count         INTEGER NOT NULL DEFAULT 1,
-                    source        TEXT,
-                    message       TEXT
-                );
-
-                CREATE TABLE IF NOT EXISTS fixes (
-                    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-                    fingerprint     TEXT NOT NULL,
-                    status          TEXT NOT NULL,   -- pending|applied|failed|skipped
-                    patch_path      TEXT,
-                    commit_hash     TEXT,
-                    branch          TEXT,
-                    pr_url          TEXT,
-                    repo_name       TEXT,
-                    timestamp       TEXT NOT NULL,
-                    sentinel_marker TEXT,            -- SENTINEL:#<fingerprint> injected into fix
-                    marker_seen_at  TEXT,            -- when marker was first seen in production logs
-                    confirmed_at    TEXT,            -- set after quiet period with no recurrence
-                    fix_outcome     TEXT             -- confirmed | regressed
-                );
-
-                -- Migration: add columns if upgrading from older schema
-                CREATE TABLE IF NOT EXISTS _sentinel_migrations (name TEXT PRIMARY KEY);
-
-                CREATE TABLE IF NOT EXISTS reports (
-                    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-                    sent_at         TEXT NOT NULL,
-                    recipient_count INTEGER NOT NULL DEFAULT 0,
-                    summary_json    TEXT
-                );
-            """)
-        self._migrate()
-        logger.debug("StateStore initialised at %s", self.db_path)
-
-    def _migrate(self):
-        """Add new columns to existing DBs without breaking old installs."""
-        migrations = [
-            ("add_sentinel_marker",       "ALTER TABLE fixes ADD COLUMN sentinel_marker TEXT"),
-            ("add_confirmed_at",          "ALTER TABLE fixes ADD COLUMN confirmed_at TEXT"),
-            ("add_fix_outcome",           "ALTER TABLE fixes ADD COLUMN fix_outcome TEXT"),
-            ("add_marker_seen_at",        "ALTER TABLE fixes ADD COLUMN marker_seen_at TEXT"),
-            ("add_watched_bots_project",  "ALTER TABLE watched_bots ADD COLUMN project_name TEXT"),
-        ]
-        with self._conn() as conn:
-            done = {r[0] for r in conn.execute("SELECT name FROM _sentinel_migrations").fetchall()}
-            for name, sql in migrations:
-                if name not in done:
-                    try:
-                        conn.execute(sql)
-                        conn.execute("INSERT INTO _sentinel_migrations VALUES (?)", (name,))
-                        logger.debug("Migration applied: %s", name)
-                    except Exception:
-                        pass  # column may already exist
-
-    # ── Errors ────────────────────────────────────────────────────────────────
-
-    def seen(self, fingerprint: str) -> bool:
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT fingerprint FROM errors WHERE fingerprint = ?", (fingerprint,)
-            ).fetchone()
-            return row is not None
-
-    def record_error(self, fingerprint: str, source: str, message: str):
-        now = _now()
-        with self._conn() as conn:
-            existing = conn.execute(
-                "SELECT count FROM errors WHERE fingerprint = ?", (fingerprint,)
-            ).fetchone()
-            if existing:
-                conn.execute(
-                    "UPDATE errors SET last_seen=?, count=count+1 WHERE fingerprint=?",
-                    (now, fingerprint),
-                )
-            else:
-                conn.execute(
-                    "INSERT INTO errors (fingerprint, first_seen, last_seen, count, source, message) "
-                    "VALUES (?, ?, ?, 1, ?, ?)",
-                    (fingerprint, now, now, source, message),
-                )
-
-    def get_recent_errors(self, hours: int = 6) -> list[dict]:
-        with self._conn() as conn:
-            rows = conn.execute(
-                "SELECT * FROM errors WHERE last_seen >= datetime('now', ? || ' hours') "
-                "ORDER BY last_seen DESC",
-                (f"-{hours}",),
-            ).fetchall()
-            return [dict(r) for r in rows]
-
-    # ── Fixes ─────────────────────────────────────────────────────────────────
-
-    def record_fix(
-        self,
-        fingerprint: str,
-        status: str,
-        patch_path: str = "",
-        commit_hash: str = "",
-        branch: str = "",
-        pr_url: str = "",
-        repo_name: str = "",
-        sentinel_marker: str = "",
-    ):
-        with self._conn() as conn:
-            conn.execute(
-                "INSERT INTO fixes (fingerprint, status, patch_path, commit_hash, branch, "
-                "pr_url, repo_name, timestamp, sentinel_marker) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
-                (fingerprint, status, patch_path, commit_hash, branch,
-                 pr_url, repo_name, _now(), sentinel_marker or None),
-            )
-
-    def get_open_prs(self) -> list[dict]:
-        """Returns fixes pushed as PRs that have not yet been merged (no commit_hash on main)."""
-        with self._conn() as conn:
-            rows = conn.execute(
-                "SELECT * FROM fixes WHERE status='pending' AND pr_url != '' "
-                "ORDER BY timestamp DESC"
-            ).fetchall()
-            return [dict(r) for r in rows]
-
-    def get_recent_fixes(self, hours: int = 6) -> list[dict]:
-        with self._conn() as conn:
-            rows = conn.execute(
-                "SELECT * FROM fixes WHERE timestamp >= datetime('now', ? || ' hours') "
-                "ORDER BY timestamp DESC",
-                (f"-{hours}",),
-            ).fetchall()
-            return [dict(r) for r in rows]
-
-    def fix_attempted_recently(self, fingerprint: str, hours: int = 24) -> bool:
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT id FROM fixes WHERE fingerprint=? "
-                "AND timestamp >= datetime('now', ? || ' hours')",
-                (fingerprint, f"-{hours}"),
-            ).fetchone()
-            return row is not None
-
-    def mark_marker_seen(self, marker: str) -> dict | None:
-        """Record that a SENTINEL marker appeared in production logs."""
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT * FROM fixes WHERE sentinel_marker=? AND marker_seen_at IS NULL",
-                (marker,),
-            ).fetchone()
-            if not row:
-                return None
-            conn.execute(
-                "UPDATE fixes SET marker_seen_at=? WHERE sentinel_marker=?",
-                (_now(), marker),
-            )
-            return dict(row)
-
-    def get_fixes_pending_confirmation(self, quiet_hours: int = 24) -> list[dict]:
-        """Return fixes whose marker was seen >= quiet_hours ago and are not yet confirmed/regressed."""
-        with self._conn() as conn:
-            rows = conn.execute(
-                "SELECT * FROM fixes WHERE marker_seen_at IS NOT NULL "
-                "AND confirmed_at IS NULL AND fix_outcome IS NULL "
-                "AND marker_seen_at <= datetime('now', ? || ' hours')",
-                (f"-{quiet_hours}",),
-            ).fetchall()
-            return [dict(r) for r in rows]
-
-    def confirm_fix(self, fingerprint: str) -> dict | None:
-        """Confirm a fix after quiet period — no recurrence observed."""
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT * FROM fixes WHERE fingerprint=? AND marker_seen_at IS NOT NULL "
-                "AND confirmed_at IS NULL AND fix_outcome IS NULL",
-                (fingerprint,),
-            ).fetchone()
-            if not row:
-                return None
-            conn.execute(
-                "UPDATE fixes SET confirmed_at=?, fix_outcome='confirmed' WHERE fingerprint=?",
-                (_now(), fingerprint),
-            )
-            return dict(row)
-
-    def mark_regressed(self, fingerprint: str):
-        """Mark fix as regressed — error recurred after marker was seen."""
-        with self._conn() as conn:
-            conn.execute(
-                "UPDATE fixes SET fix_outcome='regressed' "
-                "WHERE fingerprint=? AND fix_outcome IS NULL AND marker_seen_at IS NOT NULL",
-                (fingerprint,),
-            )
-
-    def get_confirmed_fix(self, fingerprint: str) -> dict | None:
-        """Return a confirmed (not yet regressed) fix for this fingerprint."""
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT * FROM fixes WHERE fingerprint=? AND fix_outcome='confirmed'",
-                (fingerprint,),
-            ).fetchone()
-            return dict(row) if row else None
-
-    def get_marker_seen_fix(self, fingerprint: str) -> dict | None:
-        """Return a fix for this fingerprint where marker was seen but not yet confirmed."""
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT * FROM fixes WHERE fingerprint=? "
-                "AND marker_seen_at IS NOT NULL AND fix_outcome IS NULL",
-                (fingerprint,),
-            ).fetchone()
-            return dict(row) if row else None
-
-    def get_stale_markers(self, repo_name: str) -> list[str]:
-        """Return markers for confirmed/regressed fixes in a repo — safe to remove from code."""
-        with self._conn() as conn:
-            rows = conn.execute(
-                "SELECT sentinel_marker FROM fixes "
-                "WHERE repo_name=? AND fix_outcome IN ('confirmed', 'regressed') "
-                "AND sentinel_marker IS NOT NULL",
-                (repo_name,),
-            ).fetchall()
-            return [r[0] for r in rows]
-
-        # ── Reports ───────────────────────────────────────────────────────────────
-
-    def record_report(self, recipient_count: int, summary: dict):
-        with self._conn() as conn:
-            conn.execute(
-                "INSERT INTO reports (sent_at, recipient_count, summary_json) VALUES (?, ?, ?)",
-                (_now(), recipient_count, json.dumps(summary)),
-            )
-
-    def last_report_time(self) -> datetime | None:
-        with self._conn() as conn:
-            row = conn.execute(
-                "SELECT sent_at FROM reports ORDER BY sent_at DESC LIMIT 1"
-            ).fetchone()
-            if row:
-                return datetime.fromisoformat(row["sent_at"])
-            return None
-
-    # ── Dedup store (used by Slack bot watcher) ───────────────────────────────
-
-    def is_seen_dedup(self, key: str) -> bool:
-        """Return True if this dedup key has already been processed."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS dedup "
-                "(key TEXT PRIMARY KEY, seen_at TEXT)"
-            )
-            row = conn.execute(
-                "SELECT key FROM dedup WHERE key = ?", (key,)
-            ).fetchone()
-            return row is not None
-
-    def mark_seen_dedup(self, key: str):
-        """Record a dedup key so it won't be processed again."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS dedup "
-                "(key TEXT PRIMARY KEY, seen_at TEXT)"
-            )
-            conn.execute(
-                "INSERT OR IGNORE INTO dedup (key, seen_at) VALUES (?, ?)",
-                (key, _now()),
-            )
-
-    # ── Watched bots (Slack passive monitor) ─────────────────────────────────
-
-    def _ensure_watched_bots_table(self, conn):
-        conn.execute(
-            "CREATE TABLE IF NOT EXISTS watched_bots "
-            "(bot_id TEXT PRIMARY KEY, bot_name TEXT, added_by TEXT, added_at TEXT)"
-        )
-
-    def add_watched_bot(self, bot_id: str, bot_name: str, added_by: str = "config", project_name: str = ""):
-        with self._conn() as conn:
-            self._ensure_watched_bots_table(conn)
-            conn.execute(
-                "INSERT OR REPLACE INTO watched_bots (bot_id, bot_name, added_by, added_at, project_name) "
-                "VALUES (?, ?, ?, ?, ?)",
-                (bot_id, bot_name, added_by, _now(), project_name or None),
-            )
-
-    def remove_watched_bot(self, bot_id: str) -> bool:
-        """Returns True if a row was deleted."""
-        with self._conn() as conn:
-            self._ensure_watched_bots_table(conn)
-            cur = conn.execute("DELETE FROM watched_bots WHERE bot_id = ?", (bot_id,))
-            return cur.rowcount > 0
-
-    def is_watched_bot(self, bot_id: str) -> bool:
-        with self._conn() as conn:
-            self._ensure_watched_bots_table(conn)
-            return conn.execute(
-                "SELECT 1 FROM watched_bots WHERE bot_id = ?", (bot_id,)
-            ).fetchone() is not None
-
-    def get_watched_bots(self) -> list[dict]:
-        with self._conn() as conn:
-            self._ensure_watched_bots_table(conn)
-            rows = conn.execute(
-                "SELECT * FROM watched_bots ORDER BY added_at"
-            ).fetchall()
-            return [dict(r) for r in rows]
-
-    # ── Conversation history persistence (per Slack user) ────────────────────
-
-    _MAX_HISTORY_MESSAGES = 40  # keep last 20 turns (user+assistant pairs)
-
-    # ── User-submitted issues (create_issue via Sentinel Boss) ─────────────────
-
-    def record_submitted_issue(
-        self,
-        user_id: str,
-        user_name: str,
-        project: str,
-        fname: str,
-        description: str,
-    ):
-        """Record that a user submitted an issue via Sentinel Boss."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS submitted_issues "
-                "(id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, user_name TEXT, "
-                " project TEXT, fname TEXT, description TEXT, submitted_at TEXT)"
-            )
-            conn.execute(
-                "INSERT INTO submitted_issues "
-                "(user_id, user_name, project, fname, description, submitted_at) "
-                "VALUES (?, ?, ?, ?, ?, ?)",
-                (user_id, user_name, project, fname, description[:300], _now()),
-            )
-
-    def get_submitted_issues(self, user_id: str, hours: int = 0) -> list[dict]:
-        """Return issues submitted by a specific user. hours=0 means all time."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS submitted_issues "
-                "(id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, user_name TEXT, "
-                " project TEXT, fname TEXT, description TEXT, submitted_at TEXT)"
-            )
-            if hours:
-                rows = conn.execute(
-                    "SELECT * FROM submitted_issues WHERE user_id=? "
-                    "AND submitted_at >= datetime('now', ? || ' hours') "
-                    "ORDER BY submitted_at DESC",
-                    (user_id, f"-{hours}"),
-                ).fetchall()
-            else:
-                rows = conn.execute(
-                    "SELECT * FROM submitted_issues WHERE user_id=? "
-                    "ORDER BY submitted_at DESC",
-                    (user_id,),
-                ).fetchall()
-            return [dict(r) for r in rows]
-
-    def upsert_user(self, user_id: str, display_name: str) -> None:
-        """Store or update the display name for a Slack user ID."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS slack_users "
-                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO slack_users (user_id, display_name, updated_at) "
-                "VALUES (?, ?, ?)",
-                (user_id, display_name, _now()),
-            )
-
-    def get_user_name(self, user_id: str) -> str:
-        """Return the stored display name for a user ID, or the ID itself if unknown."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS slack_users "
-                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
-            )
-            row = conn.execute(
-                "SELECT display_name FROM slack_users WHERE user_id = ?", (user_id,)
-            ).fetchone()
-        return row[0] if row else user_id
-
-    def get_all_users(self) -> dict[str, str]:
-        """Return all known {user_id: display_name} mappings."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS slack_users "
-                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
-            )
-            rows = conn.execute(
-                "SELECT user_id, display_name FROM slack_users ORDER BY display_name"
-            ).fetchall()
-        return {r[0]: r[1] for r in rows}
-
-    def save_conversation(self, user_id: str, history: list):
-        """Persist the last N messages of a user conversation to SQLite."""
-        trimmed = history[-self._MAX_HISTORY_MESSAGES:]
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS conversations "
-                "(user_id TEXT PRIMARY KEY, history_json TEXT, updated_at TEXT)"
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO conversations (user_id, history_json, updated_at) "
-                "VALUES (?, ?, ?)",
-                (user_id, json.dumps(trimmed, default=str), _now()),
-            )
-
-    def load_conversation(self, user_id: str) -> list:
-        """Load persisted conversation history for a user (empty list if none)."""
-        with self._conn() as conn:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS conversations "
-                "(user_id TEXT PRIMARY KEY, history_json TEXT, updated_at TEXT)"
-            )
-            row = conn.execute(
-                "SELECT history_json FROM conversations WHERE user_id = ?", (user_id,)
-            ).fetchone()
-        if row:
-            try:
-                return json.loads(row[0])
-            except Exception:
-                return []
-        return []
-
-    # ── Admin operations ──────────────────────────────────────────────────────
-
-    def get_all_user_stats(self) -> list[dict]:
-        """Return activity summary for every known Slack user."""
-        users = self.get_all_users()  # {user_id: display_name}
-        result = []
-        for uid, name in users.items():
-            issues = self.get_submitted_issues(uid)
-            conv   = self.load_conversation(uid)
-            result.append({
-                "user_id":      uid,
-                "display_name": name,
-                "issues_submitted": len(issues),
-                "conversation_messages": len(conv),
-            })
-        return result
-
-    def reset_fingerprint(self, fingerprint: str) -> bool:
-        """Remove a fix record so Sentinel will retry the error on the next poll."""
-        with self._conn() as conn:
-            cur = conn.execute("DELETE FROM fixes WHERE fingerprint = ?", (fingerprint,))
-            conn.execute("UPDATE errors SET last_seen = NULL WHERE fingerprint = ?", (fingerprint,))
-        return cur.rowcount > 0
-
-    def get_all_errors(self, hours: int = 0) -> list[dict]:
-        """Return full unfiltered error list, optionally within a time window."""
-        with self._conn() as conn:
-            if hours:
-                rows = conn.execute(
-                    "SELECT * FROM errors WHERE last_seen >= datetime('now', ? || ' hours') "
-                    "ORDER BY last_seen DESC",
-                    (f"-{hours}",),
-                ).fetchall()
-            else:
-                rows = conn.execute(
-                    "SELECT * FROM errors ORDER BY last_seen DESC"
-                ).fetchall()
-        return [dict(r) for r in rows]
+"""
+state_store.py — SQLite-backed persistence for errors, fixes, and reports.
+"""
+
+import json
+import sqlite3
+import logging
+from contextlib import contextmanager
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class StateStore:
+    def __init__(self, db_path: str = "./sentinel.db"):
+        self.db_path = db_path
+        self._init_db()
+
+    @contextmanager
+    def _conn(self):
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+            conn.commit()
+        finally:
+            conn.close()
+
+    def _init_db(self):
+        with self._conn() as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS errors (
+                    fingerprint   TEXT PRIMARY KEY,
+                    first_seen    TEXT NOT NULL,
+                    last_seen     TEXT NOT NULL,
+                    count         INTEGER NOT NULL DEFAULT 1,
+                    source        TEXT,
+                    message       TEXT
+                );
+
+                CREATE TABLE IF NOT EXISTS fixes (
+                    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                    fingerprint     TEXT NOT NULL,
+                    status          TEXT NOT NULL,   -- pending|applied|failed|skipped
+                    patch_path      TEXT,
+                    commit_hash     TEXT,
+                    branch          TEXT,
+                    pr_url          TEXT,
+                    repo_name       TEXT,
+                    timestamp       TEXT NOT NULL,
+                    sentinel_marker TEXT,            -- SENTINEL:#<fingerprint> injected into fix
+                    marker_seen_at  TEXT,            -- when marker was first seen in production logs
+                    confirmed_at    TEXT,            -- set after quiet period with no recurrence
+                    fix_outcome     TEXT             -- confirmed | regressed
+                );
+
+                -- Migration: add columns if upgrading from older schema
+                CREATE TABLE IF NOT EXISTS _sentinel_migrations (name TEXT PRIMARY KEY);
+
+                CREATE TABLE IF NOT EXISTS reports (
+                    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                    sent_at         TEXT NOT NULL,
+                    recipient_count INTEGER NOT NULL DEFAULT 0,
+                    summary_json    TEXT
+                );
+            """)
+        self._migrate()
+        logger.debug("StateStore initialised at %s", self.db_path)
+
+    def _migrate(self):
+        """Add new columns to existing DBs without breaking old installs."""
+        migrations = [
+            ("add_sentinel_marker",       "ALTER TABLE fixes ADD COLUMN sentinel_marker TEXT"),
+            ("add_confirmed_at",          "ALTER TABLE fixes ADD COLUMN confirmed_at TEXT"),
+            ("add_fix_outcome",           "ALTER TABLE fixes ADD COLUMN fix_outcome TEXT"),
+            ("add_marker_seen_at",        "ALTER TABLE fixes ADD COLUMN marker_seen_at TEXT"),
+            ("add_watched_bots_project",  "ALTER TABLE watched_bots ADD COLUMN project_name TEXT"),
+        ]
+        with self._conn() as conn:
+            done = {r[0] for r in conn.execute("SELECT name FROM _sentinel_migrations").fetchall()}
+            for name, sql in migrations:
+                if name not in done:
+                    try:
+                        conn.execute(sql)
+                        conn.execute("INSERT INTO _sentinel_migrations VALUES (?)", (name,))
+                        logger.debug("Migration applied: %s", name)
+                    except Exception:
+                        pass  # column may already exist
+
+    # ── Errors ────────────────────────────────────────────────────────────────
+
+    def seen(self, fingerprint: str) -> bool:
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT fingerprint FROM errors WHERE fingerprint = ?", (fingerprint,)
+            ).fetchone()
+            return row is not None
+
+    def record_error(self, fingerprint: str, source: str, message: str):
+        now = _now()
+        with self._conn() as conn:
+            existing = conn.execute(
+                "SELECT count FROM errors WHERE fingerprint = ?", (fingerprint,)
+            ).fetchone()
+            if existing:
+                conn.execute(
+                    "UPDATE errors SET last_seen=?, count=count+1 WHERE fingerprint=?",
+                    (now, fingerprint),
+                )
+            else:
+                conn.execute(
+                    "INSERT INTO errors (fingerprint, first_seen, last_seen, count, source, message) "
+                    "VALUES (?, ?, ?, 1, ?, ?)",
+                    (fingerprint, now, now, source, message),
+                )
+
+    def get_recent_errors(self, hours: int = 6) -> list[dict]:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM errors WHERE last_seen >= datetime('now', ? || ' hours') "
+                "ORDER BY last_seen DESC",
+                (f"-{hours}",),
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    # ── Fixes ─────────────────────────────────────────────────────────────────
+
+    def record_fix(
+        self,
+        fingerprint: str,
+        status: str,
+        patch_path: str = "",
+        commit_hash: str = "",
+        branch: str = "",
+        pr_url: str = "",
+        repo_name: str = "",
+        sentinel_marker: str = "",
+    ):
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO fixes (fingerprint, status, patch_path, commit_hash, branch, "
+                "pr_url, repo_name, timestamp, sentinel_marker) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (fingerprint, status, patch_path, commit_hash, branch,
+                 pr_url, repo_name, _now(), sentinel_marker or None),
+            )
+
+    def get_open_prs(self) -> list[dict]:
+        """Returns fixes pushed as PRs that have not yet been merged (no commit_hash on main)."""
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM fixes WHERE status='pending' AND pr_url != '' "
+                "ORDER BY timestamp DESC"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def get_recent_fixes(self, hours: int = 6) -> list[dict]:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM fixes WHERE timestamp >= datetime('now', ? || ' hours') "
+                "ORDER BY timestamp DESC",
+                (f"-{hours}",),
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def fix_attempted_recently(self, fingerprint: str, hours: int = 24) -> bool:
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT id FROM fixes WHERE fingerprint=? "
+                "AND timestamp >= datetime('now', ? || ' hours')",
+                (fingerprint, f"-{hours}"),
+            ).fetchone()
+            return row is not None
+
+    def mark_marker_seen(self, marker: str) -> dict | None:
+        """Record that a SENTINEL marker appeared in production logs."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM fixes WHERE sentinel_marker=? AND marker_seen_at IS NULL",
+                (marker,),
+            ).fetchone()
+            if not row:
+                return None
+            conn.execute(
+                "UPDATE fixes SET marker_seen_at=? WHERE sentinel_marker=?",
+                (_now(), marker),
+            )
+            return dict(row)
+
+    def get_fixes_pending_confirmation(self, quiet_hours: int = 24) -> list[dict]:
+        """Return fixes whose marker was seen >= quiet_hours ago and are not yet confirmed/regressed."""
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM fixes WHERE marker_seen_at IS NOT NULL "
+                "AND confirmed_at IS NULL AND fix_outcome IS NULL "
+                "AND marker_seen_at <= datetime('now', ? || ' hours')",
+                (f"-{quiet_hours}",),
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def confirm_fix(self, fingerprint: str) -> dict | None:
+        """Confirm a fix after quiet period — no recurrence observed."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM fixes WHERE fingerprint=? AND marker_seen_at IS NOT NULL "
+                "AND confirmed_at IS NULL AND fix_outcome IS NULL",
+                (fingerprint,),
+            ).fetchone()
+            if not row:
+                return None
+            conn.execute(
+                "UPDATE fixes SET confirmed_at=?, fix_outcome='confirmed' WHERE fingerprint=?",
+                (_now(), fingerprint),
+            )
+            return dict(row)
+
+    def mark_regressed(self, fingerprint: str):
+        """Mark fix as regressed — error recurred after marker was seen."""
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE fixes SET fix_outcome='regressed' "
+                "WHERE fingerprint=? AND fix_outcome IS NULL AND marker_seen_at IS NOT NULL",
+                (fingerprint,),
+            )
+
+    def get_confirmed_fix(self, fingerprint: str) -> dict | None:
+        """Return a confirmed (not yet regressed) fix for this fingerprint."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM fixes WHERE fingerprint=? AND fix_outcome='confirmed'",
+                (fingerprint,),
+            ).fetchone()
+            return dict(row) if row else None
+
+    def get_marker_seen_fix(self, fingerprint: str) -> dict | None:
+        """Return a fix for this fingerprint where marker was seen but not yet confirmed."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM fixes WHERE fingerprint=? "
+                "AND marker_seen_at IS NOT NULL AND fix_outcome IS NULL",
+                (fingerprint,),
+            ).fetchone()
+            return dict(row) if row else None
+
+    def get_stale_markers(self, repo_name: str) -> list[str]:
+        """Return markers for confirmed/regressed fixes in a repo — safe to remove from code."""
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT sentinel_marker FROM fixes "
+                "WHERE repo_name=? AND fix_outcome IN ('confirmed', 'regressed') "
+                "AND sentinel_marker IS NOT NULL",
+                (repo_name,),
+            ).fetchall()
+            return [r[0] for r in rows]
+
+        # ── Reports ───────────────────────────────────────────────────────────────
+
+    def record_report(self, recipient_count: int, summary: dict):
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO reports (sent_at, recipient_count, summary_json) VALUES (?, ?, ?)",
+                (_now(), recipient_count, json.dumps(summary)),
+            )
+
+    def last_report_time(self) -> datetime | None:
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT sent_at FROM reports ORDER BY sent_at DESC LIMIT 1"
+            ).fetchone()
+            if row:
+                return datetime.fromisoformat(row["sent_at"])
+            return None
+
+    # ── Dedup store (used by Slack bot watcher) ───────────────────────────────
+
+    def is_seen_dedup(self, key: str) -> bool:
+        """Return True if this dedup key has already been processed."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS dedup "
+                "(key TEXT PRIMARY KEY, seen_at TEXT)"
+            )
+            row = conn.execute(
+                "SELECT key FROM dedup WHERE key = ?", (key,)
+            ).fetchone()
+            return row is not None
+
+    def mark_seen_dedup(self, key: str):
+        """Record a dedup key so it won't be processed again."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS dedup "
+                "(key TEXT PRIMARY KEY, seen_at TEXT)"
+            )
+            conn.execute(
+                "INSERT OR IGNORE INTO dedup (key, seen_at) VALUES (?, ?)",
+                (key, _now()),
+            )
+
+    # ── Watched bots (Slack passive monitor) ─────────────────────────────────
+
+    def _ensure_watched_bots_table(self, conn):
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS watched_bots "
+            "(bot_id TEXT PRIMARY KEY, bot_name TEXT, added_by TEXT, added_at TEXT)"
+        )
+
+    def add_watched_bot(self, bot_id: str, bot_name: str, added_by: str = "config", project_name: str = ""):
+        with self._conn() as conn:
+            self._ensure_watched_bots_table(conn)
+            conn.execute(
+                "INSERT OR REPLACE INTO watched_bots (bot_id, bot_name, added_by, added_at, project_name) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (bot_id, bot_name, added_by, _now(), project_name or None),
+            )
+
+    def remove_watched_bot(self, bot_id: str) -> bool:
+        """Returns True if a row was deleted."""
+        with self._conn() as conn:
+            self._ensure_watched_bots_table(conn)
+            cur = conn.execute("DELETE FROM watched_bots WHERE bot_id = ?", (bot_id,))
+            return cur.rowcount > 0
+
+    def is_watched_bot(self, bot_id: str) -> bool:
+        with self._conn() as conn:
+            self._ensure_watched_bots_table(conn)
+            return conn.execute(
+                "SELECT 1 FROM watched_bots WHERE bot_id = ?", (bot_id,)
+            ).fetchone() is not None
+
+    def get_watched_bots(self) -> list[dict]:
+        with self._conn() as conn:
+            self._ensure_watched_bots_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM watched_bots ORDER BY added_at"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    # ── Conversation history persistence (per Slack user) ────────────────────
+
+    _MAX_HISTORY_MESSAGES = 40  # keep last 20 turns (user+assistant pairs)
+
+    # ── User-submitted issues (create_issue via Sentinel Boss) ─────────────────
+
+    def record_submitted_issue(
+        self,
+        user_id: str,
+        user_name: str,
+        project: str,
+        fname: str,
+        description: str,
+    ):
+        """Record that a user submitted an issue via Sentinel Boss."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS submitted_issues "
+                "(id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, user_name TEXT, "
+                " project TEXT, fname TEXT, description TEXT, submitted_at TEXT)"
+            )
+            conn.execute(
+                "INSERT INTO submitted_issues "
+                "(user_id, user_name, project, fname, description, submitted_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (user_id, user_name, project, fname, description[:300], _now()),
+            )
+
+    def get_submitted_issues(self, user_id: str, hours: int = 0) -> list[dict]:
+        """Return issues submitted by a specific user. hours=0 means all time."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS submitted_issues "
+                "(id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, user_name TEXT, "
+                " project TEXT, fname TEXT, description TEXT, submitted_at TEXT)"
+            )
+            if hours:
+                rows = conn.execute(
+                    "SELECT * FROM submitted_issues WHERE user_id=? "
+                    "AND submitted_at >= datetime('now', ? || ' hours') "
+                    "ORDER BY submitted_at DESC",
+                    (user_id, f"-{hours}"),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT * FROM submitted_issues WHERE user_id=? "
+                    "ORDER BY submitted_at DESC",
+                    (user_id,),
+                ).fetchall()
+            return [dict(r) for r in rows]
+
+    def upsert_user(self, user_id: str, display_name: str) -> None:
+        """Store or update the display name for a Slack user ID."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS slack_users "
+                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
+            )
+            conn.execute(
+                "INSERT OR REPLACE INTO slack_users (user_id, display_name, updated_at) "
+                "VALUES (?, ?, ?)",
+                (user_id, display_name, _now()),
+            )
+
+    def get_user_name(self, user_id: str) -> str:
+        """Return the stored display name for a user ID, or the ID itself if unknown."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS slack_users "
+                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
+            )
+            row = conn.execute(
+                "SELECT display_name FROM slack_users WHERE user_id = ?", (user_id,)
+            ).fetchone()
+        return row[0] if row else user_id
+
+    def get_all_users(self) -> dict[str, str]:
+        """Return all known {user_id: display_name} mappings."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS slack_users "
+                "(user_id TEXT PRIMARY KEY, display_name TEXT, updated_at TEXT)"
+            )
+            rows = conn.execute(
+                "SELECT user_id, display_name FROM slack_users ORDER BY display_name"
+            ).fetchall()
+        return {r[0]: r[1] for r in rows}
+
+    def save_conversation(self, user_id: str, history: list):
+        """Persist the last N messages of a user conversation to SQLite."""
+        trimmed = history[-self._MAX_HISTORY_MESSAGES:]
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS conversations "
+                "(user_id TEXT PRIMARY KEY, history_json TEXT, updated_at TEXT)"
+            )
+            conn.execute(
+                "INSERT OR REPLACE INTO conversations (user_id, history_json, updated_at) "
+                "VALUES (?, ?, ?)",
+                (user_id, json.dumps(trimmed, default=str), _now()),
+            )
+
+    def load_conversation(self, user_id: str) -> list:
+        """Load persisted conversation history for a user (empty list if none)."""
+        with self._conn() as conn:
+            conn.execute(
+                "CREATE TABLE IF NOT EXISTS conversations "
+                "(user_id TEXT PRIMARY KEY, history_json TEXT, updated_at TEXT)"
+            )
+            row = conn.execute(
+                "SELECT history_json FROM conversations WHERE user_id = ?", (user_id,)
+            ).fetchone()
+        if row:
+            try:
+                return json.loads(row[0])
+            except Exception:
+                return []
+        return []
+
+    # ── Admin operations ──────────────────────────────────────────────────────
+
+    # -- Health state (deliberate stop tracking) -----------------------------------
+
+    def _ensure_health_states_table(self, conn):
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS health_states "
+            "(repo_name TEXT PRIMARY KEY, status TEXT NOT NULL, "
+            " note TEXT, since TEXT NOT NULL)"
+        )
+
+    def get_health_state(self, repo_name: str) -> dict | None:
+        """Return the current health state for a repo, or None if normal."""
+        with self._conn() as conn:
+            self._ensure_health_states_table(conn)
+            row = conn.execute(
+                "SELECT * FROM health_states WHERE repo_name = ?", (repo_name,)
+            ).fetchone()
+            return dict(row) if row else None
+
+    def set_health_state(self, repo_name: str, status: str, note: str = "") -> None:
+        """Set health state for a repo. status: 'pending' | 'confirmed'."""
+        with self._conn() as conn:
+            self._ensure_health_states_table(conn)
+            conn.execute(
+                "INSERT OR REPLACE INTO health_states (repo_name, status, note, since) "
+                "VALUES (?, ?, ?, ?)",
+                (repo_name, status, note, _now()),
+            )
+
+    def clear_health_state(self, repo_name: str) -> None:
+        """Remove health state record — app is healthy again."""
+        with self._conn() as conn:
+            self._ensure_health_states_table(conn)
+            conn.execute("DELETE FROM health_states WHERE repo_name = ?", (repo_name,))
+
+    def get_all_maintenance(self) -> list[dict]:
+        """Return all repos currently in a maintenance/pending state."""
+        with self._conn() as conn:
+            self._ensure_health_states_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM health_states ORDER BY since DESC"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def get_all_user_stats(self) -> list[dict]:
+        """Return activity summary for every known Slack user."""
+        users = self.get_all_users()  # {user_id: display_name}
+        result = []
+        for uid, name in users.items():
+            issues = self.get_submitted_issues(uid)
+            conv   = self.load_conversation(uid)
+            result.append({
+                "user_id":      uid,
+                "display_name": name,
+                "issues_submitted": len(issues),
+                "conversation_messages": len(conv),
+            })
+        return result
+
+    def reset_fingerprint(self, fingerprint: str) -> bool:
+        """Remove a fix record so Sentinel will retry the error on the next poll."""
+        with self._conn() as conn:
+            cur = conn.execute("DELETE FROM fixes WHERE fingerprint = ?", (fingerprint,))
+            conn.execute("UPDATE errors SET last_seen = NULL WHERE fingerprint = ?", (fingerprint,))
+        return cur.rowcount > 0
+
+    def get_all_errors(self, hours: int = 0) -> list[dict]:
+        """Return full unfiltered error list, optionally within a time window."""
+        with self._conn() as conn:
+            if hours:
+                rows = conn.execute(
+                    "SELECT * FROM errors WHERE last_seen >= datetime('now', ? || ' hours') "
+                    "ORDER BY last_seen DESC",
+                    (f"-{hours}",),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT * FROM errors ORDER BY last_seen DESC"
+                ).fetchall()
+        return [dict(r) for r in rows]