@misterhuydo/sentinel 1.4.68 → 1.4.70

package/python/scripts/fix_knowledge_cache.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Add a knowledge_cache table + methods to state_store.py and a cache layer
+to ask_codebase in sentinel_boss.py.
+
+Concept:
+- When ask_codebase answers a question, save the answer to knowledge_cache
+  keyed by (repo_name, normalised_question), TTL 24h
+- On the next identical/similar question, answer from cache instantly
+- Cache is auto-invalidated when a Sentinel fix is applied to that repo
+- New Boss tool: refresh_knowledge — clear cached answers for a repo or all
+- System prompt updated to describe the knowledge cache
+"""
+import ast, hashlib, sys
+
+STORE = '/home/sentinel/sentinel/code/sentinel/state_store.py'
+BOSS  = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+# ── 1. Add knowledge_cache to state_store ────────────────────────────────────
+
+with open(STORE, 'r', encoding='utf-8') as f:
+    store_src = f.read()
+
+OLD_MIGRATE_LIST = '''            ("create_pull_requests",'''
+
+if OLD_MIGRATE_LIST not in store_src:
+    print("ERROR: migrations anchor not found in state_store")
+    sys.exit(1)
+
+KNOWLEDGE_MIGRATION = '''            ("create_knowledge_cache",
+             """CREATE TABLE IF NOT EXISTS knowledge_cache (
+                    cache_key    TEXT    PRIMARY KEY,
+                    repo_name    TEXT    NOT NULL,
+                    question     TEXT    NOT NULL,
+                    answer       TEXT    NOT NULL,
+                    source_tool  TEXT    DEFAULT 'ask_codebase',
+                    cached_at    TEXT    NOT NULL,
+                    expires_at   TEXT    NOT NULL,
+                    hit_count    INTEGER DEFAULT 0
+                )"""),
+            ("create_pull_requests",'''
+
+store_src = store_src.replace(OLD_MIGRATE_LIST, KNOWLEDGE_MIGRATION, 1)
+print("Step 1a OK: knowledge_cache migration entry added")
+
+# Insert methods before get_all_errors
+KNOWLEDGE_METHODS = '''    # ── Knowledge cache (stable project Q&A) ────────────────────────────────
+
+    @staticmethod
+    def _knowledge_key(repo_name: str, question: str) -> str:
+        """Stable hash key for a (repo, question) pair."""
+        import re as _re
+        normalised = _re.sub(r"[^a-z0-9 ]", " ", question.lower().strip())
+        normalised = " ".join(normalised.split())[:200]
+        raw = f"{repo_name.lower()}::{normalised}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:32]
+
+    def get_knowledge(self, repo_name: str, question: str) -> str | None:
+        """Return a cached answer if it exists and has not expired."""
+        key = self._knowledge_key(repo_name, question)
+        now = _now()
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT answer, expires_at, hit_count FROM knowledge_cache "
+                "WHERE cache_key=? AND expires_at > ?",
+                (key, now),
+            ).fetchone()
+            if row:
+                conn.execute(
+                    "UPDATE knowledge_cache SET hit_count=? WHERE cache_key=?",
+                    (row["hit_count"] + 1, key),
+                )
+                return row["answer"]
+        return None
+
+    def save_knowledge(self, repo_name: str, question: str, answer: str,
+                       ttl_hours: int = 24, source_tool: str = "ask_codebase") -> None:
+        """Cache an answer. Overwrites any existing entry for this key."""
+        from datetime import timedelta
+        key       = self._knowledge_key(repo_name, question)
+        now       = _now()
+        expires   = (datetime.now(timezone.utc) + timedelta(hours=ttl_hours)).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO knowledge_cache "
+                "(cache_key, repo_name, question, answer, source_tool, cached_at, expires_at, hit_count) "
+                "VALUES (?,?,?,?,?,?,?,0)",
+                (key, repo_name, question, answer, source_tool, now, expires),
+            )
+
+    def invalidate_knowledge(self, repo_name: str = "") -> int:
+        """Invalidate cached knowledge. Pass repo_name to clear one repo, or '' to clear all."""
+        with self._conn() as conn:
+            if repo_name:
+                cur = conn.execute(
+                    "DELETE FROM knowledge_cache WHERE repo_name LIKE ?",
+                    (f"%{repo_name}%",),
+                )
+            else:
+                cur = conn.execute("DELETE FROM knowledge_cache")
+        return cur.rowcount
+
+    def list_knowledge(self, repo_name: str = "") -> list[dict]:
+        """List cached knowledge entries (for admin inspection)."""
+        with self._conn() as conn:
+            if repo_name:
+                rows = conn.execute(
+                    "SELECT repo_name, question, cached_at, expires_at, hit_count, source_tool "
+                    "FROM knowledge_cache WHERE repo_name LIKE ? ORDER BY hit_count DESC",
+                    (f"%{repo_name}%",),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT repo_name, question, cached_at, expires_at, hit_count, source_tool "
+                    "FROM knowledge_cache ORDER BY hit_count DESC LIMIT 100"
+                ).fetchall()
+        return [dict(r) for r in rows]
+
+'''
+
+STORE_ANCHOR = '''    def get_all_errors(self, hours: int = 0) -> list[dict]:'''
+if STORE_ANCHOR not in store_src:
+    print("ERROR: get_all_errors anchor not found in state_store")
+    sys.exit(1)
+
+# Also need to import hashlib at the top of state_store.py
+if 'import hashlib' not in store_src:
+    store_src = store_src.replace(
+        'import sqlite3\n',
+        'import hashlib\nimport sqlite3\n',
+        1
+    )
+    print("Step 1b OK: hashlib import added")
+
+store_src = store_src.replace(STORE_ANCHOR, KNOWLEDGE_METHODS + STORE_ANCHOR, 1)
+print("Step 1c OK: knowledge_cache methods added to state_store")
+
+with open(STORE, 'w', encoding='utf-8') as f:
+    f.write(store_src)
+
+try:
+    ast.parse(store_src)
+    print("state_store.py Syntax OK")
+except SyntaxError as e:
+    lines = store_src.splitlines()
+    print(f"SyntaxError at line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-4), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)
+
+# ── 2. Update ask_codebase handler in sentinel_boss.py ───────────────────────
+
+with open(BOSS, 'r', encoding='utf-8') as f:
+    boss = f.read()
+
+# Wrap _ask_one call with cache check/store
+OLD_ASK_ONE_CALL = '''        if len(matched) == 1:
+            result = _ask_one(*matched[0])
+            # Unwrap single-repo result for cleaner response
+            return json.dumps(result)
+
+        # Multiple repos — query each and combine
+        results = [_ask_one(rn, r) for rn, r in matched]
+        return json.dumps({"project": target, "repos_queried": len(results), "results": results})'''
+
+NEW_ASK_ONE_CALL = '''        def _ask_cached(repo_name, repo_cfg) -> dict:
+            # Check knowledge cache first (skip for issues mode — always fresh)
+            if mode != "issues":
+                cached = store.get_knowledge(repo_name, question)
+                if cached:
+                    logger.info("Boss ask_codebase %s: cache hit", repo_name)
+                    return {"repo": repo_name, "answer": cached, "cached": True}
+            result = _ask_one(repo_name, repo_cfg)
+            # Save to cache if we got a useful answer
+            if result.get("answer") and len(result["answer"]) > 50 and mode != "issues":
+                store.save_knowledge(repo_name, question, result["answer"], ttl_hours=24)
+            return result
+
+        if len(matched) == 1:
+            result = _ask_cached(*matched[0])
+            return json.dumps(result)
+
+        # Multiple repos — query each and combine
+        results = [_ask_cached(rn, r) for rn, r in matched]
+        return json.dumps({"project": target, "repos_queried": len(results), "results": results})'''
+
+if OLD_ASK_ONE_CALL not in boss:
+    print("ERROR: ask_codebase call block not found in boss")
+    sys.exit(1)
+boss = boss.replace(OLD_ASK_ONE_CALL, NEW_ASK_ONE_CALL, 1)
+print("Step 2 OK: ask_codebase now uses knowledge cache")
+
+# ── 3. Invalidate knowledge cache when a fix is applied ──────────────────────
+# Find where record_fix is called after a successful fix application
+
+OLD_RECORD_FIX = '''            if merge_resp.status_code == 200:
+                # Success
+                sha = merge_resp.json().get("sha", "")[:8]
+                store.record_fix(fp, "applied", branch=branch, pr_url=pr_url,
+                                 repo_name=repo_name, commit_hash=sha)
+                try:
+                    store.record_pr_decision(repo_name, int(pr_number), "merged", user_id)
+                except Exception:
+                    pass  # PR may not be in tracking table yet — non-fatal'''
+
+NEW_RECORD_FIX = '''            if merge_resp.status_code == 200:
+                # Success
+                sha = merge_resp.json().get("sha", "")[:8]
+                store.record_fix(fp, "applied", branch=branch, pr_url=pr_url,
+                                 repo_name=repo_name, commit_hash=sha)
+                try:
+                    store.record_pr_decision(repo_name, int(pr_number), "merged", user_id)
+                except Exception:
+                    pass  # PR may not be in tracking table yet — non-fatal
+                # Invalidate knowledge cache so next ask_codebase reflects the fix
+                try:
+                    store.invalidate_knowledge(repo_name)
+                except Exception:
+                    pass'''
+
+if OLD_RECORD_FIX not in boss:
+    print("WARNING: merge_pr Path B success block not found — cache invalidation on merge skipped")
+else:
+    boss = boss.replace(OLD_RECORD_FIX, NEW_RECORD_FIX, 1)
+    print("Step 3 OK: knowledge cache invalidated on merge")
+
+# ── 4. Add refresh_knowledge tool definition ──────────────────────────────────
+
+OLD_BEFORE_MERGE_DEF_2 = '''    {
+        "name": "list_prs",'''
+
+NEW_BEFORE_MERGE_DEF_2 = '''    {
+        "name": "refresh_knowledge",
+        "description": (
+            "Clear the knowledge cache so the next ask_codebase question fetches a fresh answer "
+            "instead of using the cached one. Use when the codebase has changed and you want "
+            "up-to-date answers. "
+            "e.g. 'refresh knowledge for TypeLib', 'clear codebase cache', "
+            "'force fresh answer for Java-SDK', 'list what is cached'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "repo": {
+                    "type": "string",
+                    "description": "Repo or project name to clear cache for. Omit to clear all cached knowledge.",
+                },
+                "list_only": {
+                    "type": "boolean",
+                    "description": "If true, just list what is cached without deleting anything.",
+                },
+            },
+        },
+    },
+    {
+        "name": "list_prs",'''
+
+if OLD_BEFORE_MERGE_DEF_2 not in boss:
+    print("ERROR: anchor before list_prs not found")
+    sys.exit(1)
+boss = boss.replace(OLD_BEFORE_MERGE_DEF_2, NEW_BEFORE_MERGE_DEF_2, 1)
+print("Step 4 OK: refresh_knowledge tool definition added")
+
+# ── 5. Add refresh_knowledge handler ──────────────────────────────────────────
+
+OLD_LIST_PRS_HANDLER = '''        if name == "list_prs":
+            if not is_admin:
+                return json.dumps({"error": "list_prs is admin-only. Ask a Sentinel admin (SLACK_ADMIN_USERS) to run this for you."})'''
+
+NEW_LIST_PRS_HANDLER = '''        if name == "refresh_knowledge":
+            repo_filter = inputs.get("repo", "").strip()
+            list_only   = bool(inputs.get("list_only", False))
+            if list_only:
+                entries = store.list_knowledge(repo_name=repo_filter)
+                if not entries:
+                    return json.dumps({"message": "Knowledge cache is empty.", "entries": []})
+                return json.dumps({
+                    "total": len(entries),
+                    "entries": [
+                        {
+                            "repo":       e["repo_name"],
+                            "question":   e["question"][:80],
+                            "cached_at":  e["cached_at"][:16],
+                            "expires_at": e["expires_at"][:16],
+                            "hits":       e["hit_count"],
+                            "tool":       e["source_tool"],
+                        }
+                        for e in entries
+                    ],
+                })
+            deleted = store.invalidate_knowledge(repo_name=repo_filter)
+            scope   = f"repo '{repo_filter}'" if repo_filter else "all repos"
+            logger.info("Boss refresh_knowledge: cleared %d entries for %s by %s", deleted, scope, user_id)
+            return json.dumps({
+                "status":  "cleared",
+                "deleted": deleted,
+                "scope":   scope,
+                "note":    "Next ask_codebase call will fetch a fresh answer from Claude.",
+            })
+
+        if name == "list_prs":
+            if not is_admin:
+                return json.dumps({"error": "list_prs is admin-only. Ask a Sentinel admin (SLACK_ADMIN_USERS) to run this for you."})'''
+
+if OLD_LIST_PRS_HANDLER not in boss:
+    print("ERROR: list_prs handler anchor not found")
+    sys.exit(1)
+boss = boss.replace(OLD_LIST_PRS_HANDLER, NEW_LIST_PRS_HANDLER, 1)
+print("Step 5 OK: refresh_knowledge handler added")
+
+with open(BOSS, 'w', encoding='utf-8') as f:
+    f.write(boss)
+print("Written OK")
+
+try:
+    ast.parse(boss)
+    print("sentinel_boss.py Syntax OK")
+except SyntaxError as e:
+    lines = boss.splitlines()
+    print(f"SyntaxError at line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-5), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)

package/python/scripts/fix_knowledge_cache_staleness.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+Make the knowledge cache commit-aware:
+- Store the repo's HEAD commit SHA when caching an answer
+- In get_knowledge, if a current_sha is passed and differs from stored sha → cache miss
+- In ask_codebase handler, read git HEAD before checking cache
+- Also: background refresh — _pr_check_loop detects HEAD changes and invalidates cache
+"""
+import ast, sys
+
+STORE = '/home/sentinel/sentinel/code/sentinel/state_store.py'
+BOSS  = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+# ── 1. Add commit_hash column to knowledge_cache migration ────────────────────
+
+with open(STORE, 'r', encoding='utf-8') as f:
+    store_src = f.read()
+
+OLD_KC_TABLE = '''             """CREATE TABLE IF NOT EXISTS knowledge_cache (
+                    cache_key    TEXT    PRIMARY KEY,
+                    repo_name    TEXT    NOT NULL,
+                    question     TEXT    NOT NULL,
+                    answer       TEXT    NOT NULL,
+                    source_tool  TEXT    DEFAULT 'ask_codebase',
+                    cached_at    TEXT    NOT NULL,
+                    expires_at   TEXT    NOT NULL,
+                    hit_count    INTEGER DEFAULT 0
+                )"""),'''
+
+NEW_KC_TABLE = '''             """CREATE TABLE IF NOT EXISTS knowledge_cache (
+                    cache_key    TEXT    PRIMARY KEY,
+                    repo_name    TEXT    NOT NULL,
+                    question     TEXT    NOT NULL,
+                    answer       TEXT    NOT NULL,
+                    source_tool  TEXT    DEFAULT 'ask_codebase',
+                    cached_at    TEXT    NOT NULL,
+                    expires_at   TEXT    NOT NULL,
+                    hit_count    INTEGER DEFAULT 0,
+                    commit_hash  TEXT    DEFAULT ''
+                )"""),
+            ("add_knowledge_commit_hash",
+             "ALTER TABLE knowledge_cache ADD COLUMN commit_hash TEXT DEFAULT ''"),'''
+
+if OLD_KC_TABLE not in store_src:
+    print("ERROR: knowledge_cache table definition not found")
+    sys.exit(1)
+store_src = store_src.replace(OLD_KC_TABLE, NEW_KC_TABLE, 1)
+print("Step 1 OK: commit_hash column added to knowledge_cache")
+
+# ── 2. Update get_knowledge to accept and check current_sha ───────────────────
+
+OLD_GET_KNOWLEDGE = '''    def get_knowledge(self, repo_name: str, question: str) -> str | None:
+        """Return a cached answer if it exists and has not expired."""
+        key = self._knowledge_key(repo_name, question)
+        now = _now()
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT answer, expires_at, hit_count FROM knowledge_cache "
+                "WHERE cache_key=? AND expires_at > ?",
+                (key, now),
+            ).fetchone()
+            if row:
+                conn.execute(
+                    "UPDATE knowledge_cache SET hit_count=? WHERE cache_key=?",
+                    (row["hit_count"] + 1, key),
+                )
+                return row["answer"]
+        return None'''
+
+NEW_GET_KNOWLEDGE = '''    def get_knowledge(self, repo_name: str, question: str,
+                      current_sha: str = "") -> str | None:
+        """Return a cached answer if it exists, not expired, and commit hash matches."""
+        key = self._knowledge_key(repo_name, question)
+        now = _now()
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT answer, expires_at, hit_count, commit_hash FROM knowledge_cache "
+                "WHERE cache_key=? AND expires_at > ?",
+                (key, now),
+            ).fetchone()
+            if not row:
+                return None
+            # If we know the current HEAD, verify cache was made from same commit
+            stored_sha = row["commit_hash"] or ""
+            if current_sha and stored_sha and current_sha != stored_sha:
+                logger.debug("Knowledge cache stale for %s (sha %s→%s)",
+                             repo_name, stored_sha[:8], current_sha[:8])
+                conn.execute("DELETE FROM knowledge_cache WHERE cache_key=?", (key,))
+                return None  # stale — fetch fresh
+            conn.execute(
+                "UPDATE knowledge_cache SET hit_count=? WHERE cache_key=?",
+                (row["hit_count"] + 1, key),
+            )
+            return row["answer"]'''
+
+if OLD_GET_KNOWLEDGE not in store_src:
+    print("ERROR: get_knowledge method not found")
+    sys.exit(1)
+store_src = store_src.replace(OLD_GET_KNOWLEDGE, NEW_GET_KNOWLEDGE, 1)
+print("Step 2 OK: get_knowledge checks commit_hash")
+
+# ── 3. Update save_knowledge to store commit_hash ─────────────────────────────
+
+OLD_SAVE_KNOWLEDGE = '''    def save_knowledge(self, repo_name: str, question: str, answer: str,
+                       ttl_hours: int = 24, source_tool: str = "ask_codebase") -> None:
+        """Cache an answer. Overwrites any existing entry for this key."""
+        from datetime import timedelta
+        key       = self._knowledge_key(repo_name, question)
+        now       = _now()
+        expires   = (datetime.now(timezone.utc) + timedelta(hours=ttl_hours)).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO knowledge_cache "
+                "(cache_key, repo_name, question, answer, source_tool, cached_at, expires_at, hit_count) "
+                "VALUES (?,?,?,?,?,?,?,0)",
+                (key, repo_name, question, answer, source_tool, now, expires),
+            )'''
+
+NEW_SAVE_KNOWLEDGE = '''    def save_knowledge(self, repo_name: str, question: str, answer: str,
+                       ttl_hours: int = 24, source_tool: str = "ask_codebase",
+                       commit_hash: str = "") -> None:
+        """Cache an answer, optionally tagging it with the repo's HEAD SHA."""
+        from datetime import timedelta
+        key       = self._knowledge_key(repo_name, question)
+        now       = _now()
+        expires   = (datetime.now(timezone.utc) + timedelta(hours=ttl_hours)).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO knowledge_cache "
+                "(cache_key, repo_name, question, answer, source_tool, "
+                " cached_at, expires_at, hit_count, commit_hash) "
+                "VALUES (?,?,?,?,?,?,?,0,?)",
+                (key, repo_name, question, answer, source_tool, now, expires, commit_hash),
+            )'''
+
+if OLD_SAVE_KNOWLEDGE not in store_src:
+    print("ERROR: save_knowledge method not found")
+    sys.exit(1)
+store_src = store_src.replace(OLD_SAVE_KNOWLEDGE, NEW_SAVE_KNOWLEDGE, 1)
+print("Step 3 OK: save_knowledge stores commit_hash")
+
+with open(STORE, 'w', encoding='utf-8') as f:
+    f.write(store_src)
+try:
+    ast.parse(store_src)
+    print("state_store.py Syntax OK")
+except SyntaxError as e:
+    lines = store_src.splitlines()
+    print(f"SyntaxError line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-4), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)
+
+# ── 4. Update ask_codebase to pass git HEAD to cache layer ────────────────────
+
+with open(BOSS, 'r', encoding='utf-8') as f:
+    boss = f.read()
+
+OLD_ASK_CACHED = '''        def _ask_cached(repo_name, repo_cfg) -> dict:
+            # Check knowledge cache first (skip for issues mode — always fresh)
+            if mode != "issues":
+                cached = store.get_knowledge(repo_name, question)
+                if cached:
+                    logger.info("Boss ask_codebase %s: cache hit", repo_name)
+                    return {"repo": repo_name, "answer": cached, "cached": True}
+            result = _ask_one(repo_name, repo_cfg)
+            # Save to cache if we got a useful answer
+            if result.get("answer") and len(result["answer"]) > 50 and mode != "issues":
+                store.save_knowledge(repo_name, question, result["answer"], ttl_hours=24)
+            return result'''
+
+NEW_ASK_CACHED = '''        def _get_head_sha(repo_cfg) -> str:
+            """Get the current HEAD commit SHA from the local clone (fast, no network)."""
+            try:
+                import subprocess as _sp
+                r = _sp.run(
+                    ["git", "rev-parse", "--short", "HEAD"],
+                    cwd=str(Path(repo_cfg.local_path)),
+                    capture_output=True, text=True, timeout=5,
+                )
+                return r.stdout.strip() if r.returncode == 0 else ""
+            except Exception:
+                return ""
+
+        def _ask_cached(repo_name, repo_cfg) -> dict:
+            # Check knowledge cache first (skip for issues mode — always fresh)
+            if mode != "issues":
+                current_sha = _get_head_sha(repo_cfg)
+                cached = store.get_knowledge(repo_name, question, current_sha=current_sha)
+                if cached:
+                    logger.info("Boss ask_codebase %s: cache hit (sha=%s)", repo_name, current_sha[:8] if current_sha else "?")
+                    return {"repo": repo_name, "answer": cached, "cached": True}
+            else:
+                current_sha = ""
+            result = _ask_one(repo_name, repo_cfg)
+            # Save to cache if we got a useful answer
+            if result.get("answer") and len(result["answer"]) > 50 and mode != "issues":
+                store.save_knowledge(repo_name, question, result["answer"],
+                                     ttl_hours=24, commit_hash=current_sha)
+            return result'''
+
+if OLD_ASK_CACHED not in boss:
+    print("ERROR: _ask_cached block not found in boss")
+    sys.exit(1)
+boss = boss.replace(OLD_ASK_CACHED, NEW_ASK_CACHED, 1)
+print("Step 4 OK: ask_codebase passes HEAD SHA to cache")
+
+# ── 5. Add HEAD-change detection to _pr_check_loop ────────────────────────────
+
+with open(BOSS, 'w', encoding='utf-8') as f:
+    f.write(boss)
+try:
+    ast.parse(boss)
+    print("sentinel_boss.py Syntax OK (steps 1-4)")
+except SyntaxError as e:
+    lines = boss.splitlines()
+    print(f"SyntaxError line {e.lineno}: {e.msg}")
+    sys.exit(1)
+
+# ── 5 continues in main.py ────────────────────────────────────────────────────
+MAIN = '/home/sentinel/sentinel/code/sentinel/main.py'
+with open(MAIN, 'r', encoding='utf-8') as f:
+    boss = f.read()
+
+OLD_CLOSE_PRS = '''                # Mark PRs in DB that are no longer open on GitHub
+                all_tracked = store.get_prs(repo_name=repo_name, state="open")
+                for tracked in all_tracked:
+                    if tracked["pr_number"] not in seen_nums:
+                        store.close_pr(repo_name, tracked["pr_number"], state="closed")
+                        logger.info("PR check: closed PR %s #%d (no longer open on GitHub)",
+                                    repo_name, tracked["pr_number"])
+
+            except Exception as _e:
+                logger.debug("PR check error for %s: %s", repo_name, _e)
+                continue'''
+
+NEW_CLOSE_PRS = '''                # Mark PRs in DB that are no longer open on GitHub
+                all_tracked = store.get_prs(repo_name=repo_name, state="open")
+                for tracked in all_tracked:
+                    if tracked["pr_number"] not in seen_nums:
+                        store.close_pr(repo_name, tracked["pr_number"], state="closed")
+                        logger.info("PR check: closed PR %s #%d (no longer open on GitHub)",
+                                    repo_name, tracked["pr_number"])
+
+                # Detect HEAD change on default branch → invalidate knowledge cache
+                try:
+                    import subprocess as _sp2
+                    _lp = getattr(repo_cfg, "local_path", None)
+                    if _lp:
+                        _r = _sp2.run(
+                            ["git", "fetch", "--quiet", "origin"],
+                            cwd=str(_lp), capture_output=True, timeout=30,
+                        )
+                        if _r.returncode == 0:
+                            _local = _sp2.run(
+                                ["git", "rev-parse", "--short", "HEAD"],
+                                cwd=str(_lp), capture_output=True, text=True, timeout=5,
+                            ).stdout.strip()
+                            _remote = _sp2.run(
+                                ["git", "rev-parse", "--short", f"origin/{repo_cfg.branch}"],
+                                cwd=str(_lp), capture_output=True, text=True, timeout=5,
+                            ).stdout.strip()
+                            if _local and _remote and _local != _remote:
+                                deleted = store.invalidate_knowledge(repo_name)
+                                if deleted:
+                                    logger.info("PR check: HEAD changed for %s (%s→%s), "
+                                                "invalidated %d knowledge cache entries",
+                                                repo_name, _local, _remote, deleted)
+                except Exception as _ce:
+                    logger.debug("Head-change check failed for %s: %s", repo_name, _ce)
+
+            except Exception as _e:
+                logger.debug("PR check error for %s: %s", repo_name, _e)
+                continue'''
+
+if OLD_CLOSE_PRS not in boss:
+    print("ERROR: close PRs block not found in boss")
+    sys.exit(1)
+boss = boss.replace(OLD_CLOSE_PRS, NEW_CLOSE_PRS, 1)
+print("Step 5 OK: _pr_check_loop detects HEAD changes and invalidates cache")
+
+with open(MAIN, 'w', encoding='utf-8') as f:
+    f.write(boss)
+print("Written OK")
+
+try:
+    ast.parse(boss)
+    print("main.py Syntax OK")
+except SyntaxError as e:
+    lines = boss.splitlines()
+    print(f"SyntaxError line {e.lineno}: {e.msg}")
+    for i in range(max(0, e.lineno-5), min(len(lines), e.lineno+3)):
+        print(f"  {i+1}: {lines[i]}")
+    sys.exit(1)