@misterhuydo/sentinel 1.4.68 → 1.4.69

package/python/scripts/fix_pr_check_head_detect.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Add HEAD-change detection to _pr_check_loop in main.py."""
+import ast, sys
+
+MAIN = '/home/sentinel/sentinel/code/sentinel/main.py'
+
+with open(MAIN, 'r', encoding='utf-8') as f:
+    src = f.read()
+
+OLD = '''                # 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 = '''                # 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)
+                    _branch = getattr(repo_cfg, "branch", "main") or "main"
+                    if _lp:
+                        _fetch = _sp2.run(
+                            ["git", "fetch", "--quiet", "origin"],
+                            cwd=str(_lp), capture_output=True, timeout=30,
+                        )
+                        if _fetch.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/{_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 cached knowledge 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 not in src:
+    print("ERROR: close_pr block not found in main.py")
+    idx = src.find("no longer open on GitHub")
+    if idx >= 0:
+        print(repr(src[max(0,idx-100):idx+300]))
+    sys.exit(1)
+
+src = src.replace(OLD, NEW, 1)
+with open(MAIN, 'w', encoding='utf-8') as f:
+    f.write(src)
+print("Step 5 OK: HEAD-change detection added to _pr_check_loop")
+
+try:
+    ast.parse(src)
+    print("main.py Syntax OK")
+except SyntaxError as e:
+    lines = src.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)

package/python/scripts/fix_pr_msg_newlines.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Fix broken f-string literal newlines in _pr_check_loop notification block."""
+import ast, sys
+
+MAIN = '/home/sentinel/sentinel/code/sentinel/main.py'
+with open(MAIN, 'r', encoding='utf-8') as f:
+    src = f.read()
+
+# The broken block — literal newlines inside f-strings
+# We find it by unique surrounding context
+if 'f":bell: *New PR*' not in src:
+    print("ERROR: broken block not found")
+    sys.exit(1)
+
+# Find start and end of the broken msg = (...) block
+start_marker = '                msg = (\n                    f":bell: *New PR*'
+end_marker   = '                    f"or `drop PR #{pr[\'pr_number\']} in {pr[\'repo_name\']}`_"\n                )'
+
+start_idx = src.find(start_marker)
+end_idx   = src.find(end_marker)
+if start_idx == -1 or end_idx == -1:
+    print(f"ERROR: markers not found (start={start_idx}, end={end_idx})")
+    # Show context around the bell
+    idx = src.find('"bell:')
+    print(repr(src[max(0,idx-200):idx+400]))
+    sys.exit(1)
+
+end_idx += len(end_marker)
+old_block = src[start_idx:end_idx]
+
+new_block = (
+    '                _pr_parts = [\n'
+    '                    f":bell: *New PR* \u2014 `{pr[\'repo_name\']}` #{pr[\'pr_number\']} [{source_tag}]",\n'
+    '                    f"*{pr[\'title\']}*",\n'
+    '                    f"By `{pr[\'author\']}` on branch `{pr[\'head_branch\']}` | {pr[\'pr_url\']}",\n'
+    '                    ("_Reply:_ `list prs` to review, then"\n'
+    '                     f" `merge PR #{pr[\'pr_number\']} in {pr[\'repo_name\']}` or"\n'
+    '                     f" `drop PR #{pr[\'pr_number\']} in {pr[\'repo_name\']}`"),\n'
+    '                ]\n'
+    '                msg = "\\n".join(_pr_parts)'
+)
+
+src = src[:start_idx] + new_block + src[end_idx:]
+
+with open(MAIN, 'w', encoding='utf-8') as f:
+    f.write(src)
+print("Fixed: notification message block rewritten")
+
+try:
+    ast.parse(src)
+    print("Syntax OK")
+except SyntaxError as e:
+    lines = src.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_pr_tracking_boss.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+Add list_prs and drop_pr tools to sentinel_boss.py.
+Update merge_pr to record admin decision in pull_requests DB on success.
+"""
+import ast, sys
+
+BOSS = '/home/sentinel/sentinel/code/sentinel/sentinel_boss.py'
+
+with open(BOSS, 'r', encoding='utf-8') as f:
+    boss = f.read()
+
+# ── 1. Insert list_prs + drop_pr tool definitions before merge_pr ─────────────
+
+OLD_BEFORE_MERGE_DEF = '''        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "merge_pr",'''
+
+NEW_BEFORE_MERGE_DEF = '''        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "list_prs",
+        "description": (
+            "ADMIN ONLY. List all tracked pull requests across managed repos. "
+            "Shows open PRs waiting for decision, plus recent merges and drops. "
+            "Use for: 'show open PRs', 'what PRs are waiting?', 'list renovate PRs', "
+            "'what did I merge last week?', 'show all PRs for TypeLib'."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "repo": {
+                    "type": "string",
+                    "description": "Filter by repo name (partial match). Omit for all repos.",
+                },
+                "status": {
+                    "type": "string",
+                    "enum": ["open", "merged", "closed", "pending"],
+                    "description": (
+                        "open = all open PRs, pending = open with no admin decision yet, "
+                        "merged = merged PRs, closed = dropped/closed without merge. "
+                        "Omit for all."
+                    ),
+                },
+            },
+        },
+    },
+    {
+        "name": "drop_pr",
+        "description": (
+            "ADMIN ONLY. Mark a PR as dropped/rejected — do NOT merge it. "
+            "Records who dropped it and when. "
+            "Use for: 'drop PR #247 in TypeLib', 'reject the renovate PR for Java-SDK', "
+            "'close without merging PR #12 in STS'."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "repo_name": {
+                    "type": "string",
+                    "description": "Repository name (must match a repo in config/repos/)",
+                },
+                "pr_number": {
+                    "type": "integer",
+                    "description": "PR number to drop",
+                },
+            },
+            "required": ["repo_name", "pr_number"],
+        },
+    },
+    {
+        "name": "merge_pr",'''
+
+if OLD_BEFORE_MERGE_DEF not in boss:
+    print("ERROR: anchor before merge_pr not found")
+    sys.exit(1)
+boss = boss.replace(OLD_BEFORE_MERGE_DEF, NEW_BEFORE_MERGE_DEF, 1)
+print("Step 1 OK: list_prs + drop_pr tool definitions added")
+
+# ── 2. Add handlers for list_prs and drop_pr before the merge_pr handler ──────
+
+OLD_MERGE_HANDLER_START = '''        if name == "merge_pr":
+            import re as _re
+            import requests as _req
+            repo_name    = inputs.get("repo_name", "").strip()'''
+
+NEW_MERGE_HANDLER_START = '''        if name == "list_prs":
+            if not is_admin:
+                return json.dumps({"error": "Admin access required."})
+            repo_filter   = inputs.get("repo", "").strip()
+            status_filter = inputs.get("status", "").strip()
+            # "pending" = open with no admin decision
+            if status_filter == "pending":
+                prs = store.get_prs(repo_name=repo_filter, state="open", decision="pending")
+            elif status_filter:
+                prs = store.get_prs(repo_name=repo_filter, state=status_filter)
+            else:
+                prs = store.get_prs(repo_name=repo_filter)
+            if not prs:
+                return json.dumps({"message": "No PRs found matching the filter.", "prs": []})
+            # Format for readability
+            formatted = []
+            for p in prs:
+                entry = {
+                    "repo":       p["repo_name"],
+                    "pr_number":  p["pr_number"],
+                    "title":      p["title"],
+                    "author":     p["author"],
+                    "source":     p["source"],
+                    "state":      p["pr_state"],
+                    "url":        p["pr_url"],
+                    "first_seen": p["first_seen"][:10] if p["first_seen"] else "",
+                }
+                if p.get("admin_decision"):
+                    entry["decision"]    = p["admin_decision"]
+                    entry["decided_by"]  = p.get("admin_user_id", "")
+                    entry["decided_at"]  = (p.get("admin_decided_at") or "")[:10]
+                else:
+                    entry["decision"] = "pending"
+                formatted.append(entry)
+            return json.dumps({"total": len(formatted), "prs": formatted})
+
+        if name == "drop_pr":
+            if not is_admin:
+                return json.dumps({"error": "Admin access required."})
+            repo_name  = inputs.get("repo_name", "").strip()
+            pr_number  = inputs.get("pr_number")
+            if not repo_name or not pr_number:
+                return json.dumps({"error": "repo_name and pr_number are required"})
+            pr_number = int(pr_number)
+            # Fuzzy match repo name
+            if repo_name not in cfg_loader.repos:
+                for rname in cfg_loader.repos:
+                    if repo_name.lower() in rname.lower():
+                        repo_name = rname
+                        break
+            store.record_pr_decision(repo_name, pr_number, "rejected", user_id)
+            logger.info("Boss drop_pr: PR #%d for %s dropped by admin %s", pr_number, repo_name, user_id)
+            return json.dumps({
+                "status": "dropped",
+                "repo":      repo_name,
+                "pr_number": pr_number,
+                "dropped_by": user_id,
+                "note": f"PR #{pr_number} marked as dropped. It will not be re-notified.",
+            })
+
+        if name == "merge_pr":
+            import re as _re
+            import requests as _req
+            repo_name    = inputs.get("repo_name", "").strip()'''
+
+if OLD_MERGE_HANDLER_START not in boss:
+    print("ERROR: merge_pr handler start not found")
+    sys.exit(1)
+boss = boss.replace(OLD_MERGE_HANDLER_START, NEW_MERGE_HANDLER_START, 1)
+print("Step 2 OK: list_prs + drop_pr handlers added")
+
+# ── 3. Record admin decision in merge_pr Path A on success ───────────────────
+
+OLD_PATH_A_SUCCESS = '''                if merge_resp.status_code == 200:
+                    sha = merge_resp.json().get("sha", "")[:8]
+                    logger.info("Boss merge_pr: merged PR #%d for %s by admin %s", pr_number_in, repo_name, user_id)
+                    return json.dumps({
+                        "status": "merged",
+                        "pr": pr_url,
+                        "pr_number": pr_number_in,
+                        "title": pr_title,
+                        "sha": sha,
+                        "repo": repo_name,
+                        "note": f"PR #{pr_number_in} merged. Branch '{branch}' can now be deleted.",
+                    })'''
+
+NEW_PATH_A_SUCCESS = '''                if merge_resp.status_code == 200:
+                    sha = merge_resp.json().get("sha", "")[:8]
+                    store.record_pr_decision(repo_name, pr_number_in, "merged", user_id)
+                    logger.info("Boss merge_pr: merged PR #%d for %s by admin %s", pr_number_in, repo_name, user_id)
+                    return json.dumps({
+                        "status": "merged",
+                        "pr": pr_url,
+                        "pr_number": pr_number_in,
+                        "title": pr_title,
+                        "sha": sha,
+                        "repo": repo_name,
+                        "note": f"PR #{pr_number_in} merged. Branch '{branch}' can now be deleted.",
+                    })'''
+
+if OLD_PATH_A_SUCCESS not in boss:
+    print("ERROR: Path A success block not found")
+    sys.exit(1)
+boss = boss.replace(OLD_PATH_A_SUCCESS, NEW_PATH_A_SUCCESS, 1)
+print("Step 3 OK: Path A merge records decision in PR table")
+
+# ── 4. Record admin decision in merge_pr Path B on success ───────────────────
+
+OLD_PATH_B_SUCCESS = '''            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)
+                logger.info("Boss merge_pr: merged PR #%s for %s (fp=%s) by admin %s",
+                            pr_number, repo_name, fp[:8], user_id)
+                return json.dumps({
+                    "status": "merged",
+                    "pr": pr_url,
+                    "sha": sha,
+                    "repo": repo_name,
+                    "note": f"PR #{pr_number} merged into main. Branch '{branch}' can now be deleted.",
+                })'''
+
+NEW_PATH_B_SUCCESS = '''            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
+                logger.info("Boss merge_pr: merged PR #%s for %s (fp=%s) by admin %s",
+                            pr_number, repo_name, fp[:8], user_id)
+                return json.dumps({
+                    "status": "merged",
+                    "pr": pr_url,
+                    "sha": sha,
+                    "repo": repo_name,
+                    "note": f"PR #{pr_number} merged into main. Branch '{branch}' can now be deleted.",
+                })'''
+
+if OLD_PATH_B_SUCCESS not in boss:
+    print("ERROR: Path B success block not found")
+    sys.exit(1)
+boss = boss.replace(OLD_PATH_B_SUCCESS, NEW_PATH_B_SUCCESS, 1)
+print("Step 4 OK: Path B merge records decision in PR table")
+
+# ── 5. Update tool list header comment to mention new tools ──────────────────
+# Find the line that has "merge_pr" in the boss description list
+
+OLD_TOOL_LIST = '''19. ask_codebase     — Ask any natural-language question about a managed repo's codebase.'''
+NEW_TOOL_LIST = '''19. ask_codebase     — Ask any natural-language question about a managed repo's codebase.
+20. list_prs         — List tracked PRs (open, pending decision, merged, dropped). Admin only.
+21. drop_pr          — Mark a PR as dropped/rejected without merging. Admin only.'''
+
+if OLD_TOOL_LIST not in boss:
+    print("WARNING: tool list comment not found — skipping (non-critical)")
+else:
+    boss = boss.replace(OLD_TOOL_LIST, NEW_TOOL_LIST, 1)
+    print("Step 5 OK: tool list comment updated")
+
+with open(BOSS, 'w', encoding='utf-8') as f:
+    f.write(boss)
+print("Written OK")
+
+# ── Syntax check ──────────────────────────────────────────────────────────────
+with open(BOSS, 'r', encoding='utf-8') as f:
+    src = f.read()
+try:
+    ast.parse(src)
+    print("Syntax OK")
+except SyntaxError as e:
+    lines = src.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_pr_tracking_db.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Add pull_requests table and methods to state_store.py:
+- CREATE TABLE pull_requests (tracks ALL open PRs across managed repos)
+- upsert_pr / mark_pr_notified / record_pr_decision / get_prs / get_prs_for_notification
+"""
+import ast, sys
+
+STORE = '/home/sentinel/sentinel/code/sentinel/state_store.py'
+
+with open(STORE, 'r', encoding='utf-8') as f:
+    src = f.read()
+
+# ── 1. Add migration entry for pull_requests table ───────────────────────────
+
+OLD_MIGRATE_BLOCK = '''        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"),
+        ]'''
+
+NEW_MIGRATE_BLOCK = '''        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"),
+            ("create_pull_requests",
+             """CREATE TABLE IF NOT EXISTS pull_requests (
+                    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+                    repo_name        TEXT    NOT NULL,
+                    pr_number        INTEGER NOT NULL,
+                    pr_url           TEXT    NOT NULL,
+                    title            TEXT,
+                    author           TEXT,
+                    head_branch      TEXT,
+                    base_branch      TEXT,
+                    source           TEXT,
+                    pr_state         TEXT    DEFAULT 'open',
+                    first_seen       TEXT    NOT NULL,
+                    last_seen        TEXT    NOT NULL,
+                    notified_at      TEXT,
+                    admin_decision   TEXT,
+                    admin_user_id    TEXT,
+                    admin_decided_at TEXT,
+                    UNIQUE(repo_name, pr_number)
+                )"""),
+        ]'''
+
+if OLD_MIGRATE_BLOCK not in src:
+    print("ERROR: migrations block not found")
+    sys.exit(1)
+src = src.replace(OLD_MIGRATE_BLOCK, NEW_MIGRATE_BLOCK, 1)
+print("Step 1 OK: migration entry added")
+
+# ── 2. Fix migration runner to handle multi-line SQL ─────────────────────────
+# The existing runner tries conn.execute(sql) which fails for CREATE TABLE.
+# Replace with a try/except that skips DDL errors and always marks done.
+
+OLD_MIGRATE_RUN = '''        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'''
+
+NEW_MIGRATE_RUN = '''        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.executescript(sql) if sql.strip().upper().startswith("CREATE") else conn.execute(sql)
+                        conn.execute("INSERT INTO _sentinel_migrations VALUES (?)", (name,))
+                        conn.commit()
+                        logger.debug("Migration applied: %s", name)
+                    except Exception as _me:
+                        logger.debug("Migration skipped %s: %s", name, _me)
+                        pass  # column / table may already exist'''
+
+if OLD_MIGRATE_RUN not in src:
+    print("ERROR: migration runner not found")
+    sys.exit(1)
+src = src.replace(OLD_MIGRATE_RUN, NEW_MIGRATE_RUN, 1)
+print("Step 2 OK: migration runner updated")
+
+# ── 3. Add PR tracking methods (insert before the last method / end of class) ─
+# Find a good anchor — the delete_fix method or end of class
+
+ANCHOR = '''    def get_all_errors(self, hours: int = 0) -> list[dict]:'''
+
+if ANCHOR not in src:
+    print("ERROR: anchor method not found")
+    sys.exit(1)
+
+NEW_METHODS = '''    # ── Pull-request tracking ────────────────────────────────────────────────
+
+    def upsert_pr(self, repo_name: str, pr_number: int, pr_url: str,
+                  title: str = "", author: str = "", head_branch: str = "",
+                  base_branch: str = "main", source: str = "external",
+                  pr_state: str = "open") -> bool:
+        """Insert or update a PR record. Returns True if this is a NEW (unseen) PR."""
+        now = _now()
+        with self._conn() as conn:
+            existing = conn.execute(
+                "SELECT id, notified_at FROM pull_requests WHERE repo_name=? AND pr_number=?",
+                (repo_name, pr_number),
+            ).fetchone()
+            if existing:
+                conn.execute(
+                    "UPDATE pull_requests SET pr_state=?, title=?, last_seen=? "
+                    "WHERE repo_name=? AND pr_number=?",
+                    (pr_state, title, now, repo_name, pr_number),
+                )
+                return False  # not new
+            conn.execute(
+                "INSERT INTO pull_requests "
+                "(repo_name, pr_number, pr_url, title, author, head_branch, base_branch, "
+                " source, pr_state, first_seen, last_seen) "
+                "VALUES (?,?,?,?,?,?,?,?,?,?,?)",
+                (repo_name, pr_number, pr_url, title, author, head_branch, base_branch,
+                 source, pr_state, now, now),
+            )
+            return True  # new PR
+
+    def get_prs_for_notification(self) -> list[dict]:
+        """PRs that are open and have not yet been notified to admins."""
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM pull_requests WHERE pr_state='open' AND notified_at IS NULL "
+                "ORDER BY first_seen ASC"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def mark_pr_notified(self, repo_name: str, pr_number: int) -> None:
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE pull_requests SET notified_at=? WHERE repo_name=? AND pr_number=?",
+                (_now(), repo_name, pr_number),
+            )
+
+    def record_pr_decision(self, repo_name: str, pr_number: int,
+                           decision: str, user_id: str) -> None:
+        """Record admin decision: merged | rejected | dropped."""
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE pull_requests SET admin_decision=?, admin_user_id=?, "
+                "admin_decided_at=?, pr_state=? "
+                "WHERE repo_name=? AND pr_number=?",
+                (decision,
+                 user_id,
+                 _now(),
+                 "merged" if decision == "merged" else "closed",
+                 repo_name,
+                 pr_number),
+            )
+
+    def get_prs(self, repo_name: str = "", state: str = "",
+                decision: str = "") -> list[dict]:
+        """List tracked PRs with optional filters."""
+        clauses, params = [], []
+        if repo_name:
+            clauses.append("repo_name LIKE ?")
+            params.append(f"%{repo_name}%")
+        if state:
+            clauses.append("pr_state=?")
+            params.append(state)
+        if decision == "pending":
+            clauses.append("admin_decision IS NULL AND pr_state='open'")
+        elif decision:
+            clauses.append("admin_decision=?")
+            params.append(decision)
+        where = ("WHERE " + " AND ".join(clauses)) if clauses else ""
+        with self._conn() as conn:
+            rows = conn.execute(
+                f"SELECT * FROM pull_requests {where} ORDER BY first_seen DESC LIMIT 100",
+                params,
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def close_pr(self, repo_name: str, pr_number: int, state: str = "closed") -> None:
+        """Mark a tracked PR as closed/merged (from external GitHub event)."""
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE pull_requests SET pr_state=?, last_seen=? "
+                "WHERE repo_name=? AND pr_number=?",
+                (state, _now(), repo_name, pr_number),
+            )
+
+'''
+
+src = src.replace(ANCHOR, NEW_METHODS + "\n    " + ANCHOR, 1)
+print("Step 3 OK: PR tracking methods added")
+
+with open(STORE, 'w', encoding='utf-8') as f:
+    f.write(src)
+print("Written OK")
+
+try:
+    ast.parse(src)
+    print("Syntax OK")
+except SyntaxError as e:
+    lines = src.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)