mickyarun
diff --git a/‎backend/app/api/v1/bud_prs.py‎
Lines changed: 26 additions & 12 deletions b/‎backend/app/api/v1/bud_prs.py‎
Lines changed: 26 additions & 12 deletions
diff --git a/‎backend/app/mcp/handlers_hooks.py‎
Lines changed: 9 additions & 9 deletions b/‎backend/app/mcp/handlers_hooks.py‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎backend/app/repositories/pull_request.py‎
Lines changed: 28 additions & 10 deletions b/‎backend/app/repositories/pull_request.py‎
Lines changed: 28 additions & 10 deletions
diff --git a/‎backend/app/services/github_webhook_handler.py‎
Lines changed: 119 additions & 5 deletions b/‎backend/app/services/github_webhook_handler.py‎
Lines changed: 119 additions & 5 deletions
@@ -35,6 +35,7 @@
     ReleaseTimelineEvent,
 )
 from app.schemas.pull_request import PRChecklistItem, PullRequestRead
+from app.services.pr_auto_transition import pr_references_bud
 from app.utils.branch_matching import branch_matches
 
 router = APIRouter()
@@ -232,18 +233,31 @@ async def get_bud_release_stage(
         target_branch = (
             (repo.uat_branch if typed_stage == "uat" else repo.main_branch) if repo else None
         )
-        if target_branch and branch_matches(pr.base_branch, target_branch):
-            seen_pr_ids.add(pr.github_pr_id)
-            open_prs.append(
-                ReleasePR(
-                    pr_number=pr.github_pr_number,
-                    repo_name=repo.name if repo else "",
-                    html_url=pr.html_url,
-                    title=pr.title,
-                    author_login=pr.author_github_login,
-                    merged_at=None,
-                ),
-            )
+        if not (target_branch and branch_matches(pr.base_branch, target_branch)):
+            continue
+        # Content guard for unlinked PRs (``bud_id IS NULL``): the
+        # release-PR fallback in the repository surfaces every PR
+        # targeting the stage branch on an impacted repo, but the
+        # release-stage tab must only show PRs that reference THIS BUD.
+        # ``pr_references_bud`` looks for ``bud-NNN`` in the head ref
+        # or title, so a release branch like
+        # ``release/bud-001-bud-004`` correctly appears on both BUD-001
+        # and BUD-004 tabs, while an unrelated PR to ``main`` does not
+        # leak through. Directly-linked PRs (``bud_id == bud_id``)
+        # short-circuit so the user-edited link wins over text matching.
+        if pr.bud_id != bud_id and not pr_references_bud(bud.bud_number, pr.head_branch, pr.title):
+            continue
+        seen_pr_ids.add(pr.github_pr_id)
+        open_prs.append(
+            ReleasePR(
+                pr_number=pr.github_pr_number,
+                repo_name=repo.name if repo else "",
+                html_url=pr.html_url,
+                title=pr.title,
+                author_login=pr.author_github_login,
+                merged_at=None,
+            ),
+        )
 
     return BUDReleaseStage(
         bud_id=str(bud_id),
 
@@ -21,7 +21,6 @@
 
 import asyncio
 import os
-import re
 import uuid
 
 import structlog
@@ -35,12 +34,15 @@
 from app.schemas.dev_activity import DevActivityHookRequest, DevActivityHookResponse
 from app.services.colyseus_bridge import publish_to_colyseus
 from app.services.event_bus import publish
+from app.services.pr_auto_transition import extract_bud_number
 from app.services.user_resolution import resolve_user_by_email
 from app.services.xp_service import check_and_award_streak
 
 logger = structlog.get_logger(__name__)
 
-_BUD_BRANCH_RE = re.compile(r"^bud-(\d+)/")
+# BUD number extraction is owned by ``pr_auto_transition.extract_bud_number``
+# so a single matcher governs PR linking, the dev-activity hook below, and any
+# future reuse — keeping branch heuristics from drifting between call sites.
 
 # Strong references to in-flight Colyseus publish tasks. ``asyncio.create_task``
 # only holds a weak reference to the task it returns, so without an external
@@ -297,13 +299,11 @@ async def _resolve_bud(
             return bud.id, bud.bud_number
 
     # Auto-detect from branch name: bud-001/feature → 1
-    if branch:
-        match = _BUD_BRANCH_RE.match(branch)
-        if match:
-            detected_num = int(match.group(1))
-            bud = await bud_repo.get_by_number(detected_num)
-            if bud:
-                return bud.id, bud.bud_number
+    detected_num = extract_bud_number(branch)
+    if detected_num is not None:
+        bud = await bud_repo.get_by_number(detected_num)
+        if bud:
+            return bud.id, bud.bud_number
 
     return None, None
 
 
@@ -17,7 +17,7 @@
 import uuid
 from datetime import datetime
 
-from sqlalchemy import func, or_, select
+from sqlalchemy import and_, func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.pull_request import PRState, PullRequest
@@ -172,22 +172,40 @@ async def list_open_for_bud_with_repo(
     ) -> list[tuple[PullRequest, TrackedRepository | None]]:
         """List open PRs for a BUD joined with their tracked repository.
 
-        When ``impacted_repo_ids`` is provided, the result includes any open
-        PR that is either linked to ``bud_id`` directly OR targets one of
-        the impacted repos. Used by release-stage views that need to surface
-        open PRs in repos affected by the BUD even if the PR forgot to set
-        a ``bud_id``.
+        Three-way predicate so the release-stage views (UAT / PROD tabs)
+        only surface PRs that genuinely relate to ``bud_id``:
+
+        * ``bud_id == X`` — the PR is directly linked to this BUD.
+        * ``bud_id IS NULL AND repo_id IN impacted_repo_ids`` — aggregate
+          release PRs like ``develop → main`` legitimately carry no single
+          owning BUD; we keep them visible on the impacted repo's stage tab
+          because the SHA-walk in the release detector uses them to attribute
+          merges back to multiple BUDs.
+
+        A plain ``OR(bud_id == X, repo_id IN impacted)`` would also let
+        through PRs linked to a **different** BUD that happens to touch the
+        same impacted repo — which is the over-matching bug this method now
+        prevents.
 
         Args:
             bud_id: The BUD UUID to filter on.
-            impacted_repo_ids: Additional repo UUIDs to include open PRs for.
+            impacted_repo_ids: Repo UUIDs whose unlinked release PRs should
+                stay visible. When ``None`` / empty, only directly-linked
+                PRs are returned.
 
         Returns:
             List of ``(PullRequest, TrackedRepository | None)`` tuples.
         """
-        filters = [PullRequest.bud_id == bud_id]
         if impacted_repo_ids:
-            filters.append(PullRequest.repo_id.in_(impacted_repo_ids))
+            bud_predicate = or_(
+                PullRequest.bud_id == bud_id,
+                and_(
+                    PullRequest.bud_id.is_(None),
+                    PullRequest.repo_id.in_(impacted_repo_ids),
+                ),
+            )
+        else:
+            bud_predicate = PullRequest.bud_id == bud_id
 
         stmt = self._scoped(
             select(PullRequest, TrackedRepository)
@@ -198,7 +216,7 @@ async def list_open_for_bud_with_repo(
             )
             .where(
                 PullRequest.state == PRState.OPEN,
-                or_(*filters),
+                bud_predicate,
             )
         )
         result = await self._db.execute(stmt)
 
@@ -19,7 +19,6 @@
 Triggers auto-transitions when all impacted repos have PRs or all merge.
 """
 
-import re
 import uuid
 from typing import Any
 
@@ -43,7 +42,7 @@
 from app.services.pr_auto_transition import (
     check_all_prs_merged,
     check_all_repos_have_prs,
-    resolve_bud_from_branch,
+    resolve_bud_from_pr,
 )
 from app.services.release_detection import detect_release_promotion
 from app.services.stage_award import award_stage_xp_to_contributors
@@ -52,8 +51,6 @@
 
 logger = structlog.get_logger(__name__)
 
-_BUD_BRANCH_RE = re.compile(r"bud-0*(\d+)/", re.IGNORECASE)
-
 
 async def handle_github_event(
     org_id: uuid.UUID,
@@ -79,6 +76,16 @@ async def handle_github_event(
             await _handle_pr_closed(org_id, repo, pr_data, db)
         elif action == "synchronize":
             await _handle_pr_synchronize(org_id, pr_data, db)
+        elif action == "edited":
+            # GitHub's ``edited`` action fires on every body / label / title /
+            # base / head change. We act on the subset that affects either
+            # the BUD link (title edits relink to a different BUD-NNN) or
+            # the release-stage filter (base change moves the PR off the
+            # tab that watches ``main`` / ``release/*``). Body and label
+            # edits stay silent to keep the log quiet.
+            changes = payload.get("changes") or {}
+            if changes.keys() & {"title", "base"}:
+                await _handle_pr_edited(org_id, pr_data, db)
     elif event_type == "pull_request_review" and action == "submitted":
         review = GitHubReview.model_validate(payload["review"])
         pr_data = GitHubPullRequest.model_validate(payload["pull_request"])
@@ -104,7 +111,7 @@ async def _handle_pr_opened(
     db: AsyncSession,
 ) -> None:
     """Create PR record and check if all impacted repos have PRs."""
-    bud_id, bud = await resolve_bud_from_branch(db, org_id, pr_data.head.ref)
+    bud_id, bud = await resolve_bud_from_pr(db, org_id, pr_data.head.ref, pr_data.title)
 
     pr_repo = PullRequestRepository(db, org_id=org_id)
     existing = await pr_repo.get_by_github_pr_id(pr_data.id)
@@ -408,6 +415,113 @@ async def _handle_pr_synchronize(
         await db.commit()
 
 
+async def _handle_pr_edited(
+    org_id: uuid.UUID,
+    pr_data: GitHubPullRequest,
+    db: AsyncSession,
+) -> None:
+    """Pick up the title + base/head changes GitHub reports on edit.
+
+    Two concerns share this handler because both ride the same webhook:
+
+    * **Title edits** can relink the PR to a different BUD. We re-run
+      ``resolve_bud_from_pr`` and emit ``pr_linked`` / ``pr_unlinked``
+      timeline events so the audit trail stays symmetric.
+    * **Base-branch edits** move the PR between release-stage tabs.
+      Without syncing ``pr.base_branch``, a PR retargeted from ``main``
+      to ``develop`` keeps showing on the PROD tab indefinitely because
+      ``branch_matches`` runs against the stale value. ``head_branch``
+      is synced for the same reason (force-pushes that rename the
+      branch land here too).
+
+    Stale state is what makes ``BUD-004`` keep ``#1997`` on its PROD
+    tab even after the PR was retargeted to ``develop`` — fixing the
+    sync side closes that loop for future edits.
+    """
+    pr_repo = PullRequestRepository(db, org_id=org_id)
+    pr = await pr_repo.get_by_github_pr_id(pr_data.id)
+    if pr is None:
+        return
+
+    # Title / base / head are always synced — the dispatcher only fires
+    # this handler when at least one of them changed, so the writes are
+    # never wasted.
+    title_changed = pr.title != pr_data.title
+    pr.title = pr_data.title
+    pr.base_branch = pr_data.base.ref
+    pr.head_branch = pr_data.head.ref
+
+    # Only re-resolve the BUD link when the title actually changed. A
+    # base-only edit (the BUD-004 / PR-1997 case) must NOT trigger a
+    # re-resolution that could unlink a PR whose old title once carried
+    # a now-rejected reference shape (``auth1-bud-7``-style strings the
+    # previous, looser regex used to accept). The auto-transition checks
+    # downstream key off ``pr.bud_id``; leaving the link intact keeps
+    # the development → code_review threshold stable across base edits.
+    if not title_changed:
+        await db.commit()
+        return
+
+    new_bud_id, new_bud = await resolve_bud_from_pr(db, org_id, pr_data.head.ref, pr_data.title)
+    if new_bud_id == pr.bud_id:
+        await db.commit()
+        return
+
+    old_bud_id = pr.bud_id
+    pr.bud_id = new_bud_id
+
+    # Audit symmetry: both BUDs record the rebind. Skipping the unlink
+    # event would leave the previous BUD's timeline showing a PR that
+    # quietly stopped belonging to it.
+    if old_bud_id is not None and old_bud_id != new_bud_id:
+        await record_event(
+            db,
+            org_id,
+            old_bud_id,
+            "pr_unlinked",
+            detail={
+                "pr_number": pr_data.number,
+                "reason": "title_edited",
+                "new_bud_id": str(new_bud_id) if new_bud_id else None,
+            },
+        )
+
+    if new_bud is not None:
+        await record_event(
+            db,
+            org_id,
+            new_bud.id,
+            "pr_linked",
+            detail={
+                "pr_number": pr_data.number,
+                "reason": "title_edited",
+                "previous_bud_id": str(old_bud_id) if old_bud_id else None,
+            },
+        )
+
+    await db.commit()
+
+    # Re-run the auto-advance check on both sides. ``check_all_repos_have_prs``
+    # only fires forward transitions (development → code_review) and no-ops
+    # outside that stage, so the old-BUD call is defensive: it covers the
+    # case where stripping a PR drops the old BUD back below the "all
+    # impacted repos have PRs" threshold while it's still in development.
+    if old_bud_id is not None and old_bud_id != new_bud_id:
+        bud_repo = BUDRepository(db, org_id=org_id)
+        old_bud = await bud_repo.get_by_id(old_bud_id)
+        if old_bud is not None:
+            await check_all_repos_have_prs(db, org_id, old_bud)
+    if new_bud is not None:
+        await check_all_repos_have_prs(db, org_id, new_bud)
+
+    logger.info(
+        "pr_relinked_on_title_edit",
+        pr_number=pr_data.number,
+        from_bud=str(old_bud_id) if old_bud_id else None,
+        to_bud=str(new_bud_id) if new_bud_id else None,
+    )
+
+
 async def _handle_review_submitted(
     org_id: uuid.UUID,
     pr_data: GitHubPullRequest,