willow-bot 1.2.2__tar.gz → 1.2.4__tar.gz

willow_bot-1.2.4/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.2.4"
+}

{willow_bot-1.2.2 → willow_bot-1.2.4}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project are documented here.
 
+## [1.2.4](https://github.com/willow-memory/willow-bot/compare/v1.2.3...v1.2.4) (2026-10-11)
+
+
+### Fixed
+
+* a check run's PR is only one whose base is the check's repo ([9aa1e48](https://github.com/willow-memory/willow-bot/commit/9aa1e48666b7631ba29900774a57a8cafe0ab80b))
+* a check run's PR is only one whose base is the check's repo (stalled [#1702](https://github.com/willow-memory/willow-bot/issues/1702)) ([36c52a9](https://github.com/willow-memory/willow-bot/commit/36c52a9f1cc1d7516e4a5e69ec771fed05cfd589))
+
+## [1.2.3](https://github.com/willow-memory/willow-bot/compare/v1.2.2...v1.2.3) (2026-10-11)
+
+
+### Fixed
+
+* **bridge:** one inbox item per event; archive kinds no step reads ([54cb180](https://github.com/willow-memory/willow-bot/commit/54cb180705edff027aa186243bae59d17d54fde2))
+* inbox replay, one item per event, unhandled-kind pile, ungated gap_filed quip ([47945e8](https://github.com/willow-memory/willow-bot/commit/47945e877cd912f88faa32441906b2695f422fa7))
+* **router:** the gap_filed quip passes the voice's gate ([c15934c](https://github.com/willow-memory/willow-bot/commit/c15934ccd416dc21e4c58e95b30938ca237bb7ca))
+
 ## [1.2.2](https://github.com/willow-memory/willow-bot/compare/v1.2.1...v1.2.2) (2026-10-11)
 
 

{willow_bot-1.2.2 → willow_bot-1.2.4}/INSTALL.md

@@ -174,7 +174,7 @@ Verified webhooks fan out into local queues under `$WILLOW_HOME`:
 
 | Event | Local action |
 |-------|----------------|
-| `pull_request`, `issues`, `issue_comment`, `check_run` | `upstream_steward/webhook_inbox/*.json` |
+| `pull_request`, `issues`, `issue_comment`, `check_run` | `upstream_steward/webhook_inbox/*.json`, one item per event; the steward's inbox step moves consumed items to `webhook_inbox/consumed/<YYYY-MM>/` and kinds no step reads (`issue`, `issue_comment`, `installation*`) to `webhook_inbox/unhandled/<YYYY-MM>/` |
 | `push` to `main`/`master` (local clone exists) | `gitsync/trigger-<owner>-<repo>.flag` |
 | all events | `willow-bot/event-log.jsonl` audit trail |
 | PRs, issues, comments, reviews, forks, stars, releases, discussions | `willow-bot/contributions.jsonl` ledger (`willow-bot-steward contributions`) |

{willow_bot-1.2.2 → willow_bot-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: willow-bot
-Version: 1.2.2
+Version: 1.2.4
 Summary: Willow GitHub App webhook + orchestrator-feeding steward (propose-only deposits)
 Project-URL: Homepage, https://github.com/willow-memory/willow-bot
 Project-URL: Repository, https://github.com/willow-memory/willow-bot

{willow_bot-1.2.2 → willow_bot-1.2.4}/integrations/fleet_bridge.py

@@ -106,6 +106,13 @@ def _work_id(repo: str, kind: str, number: int | str) -> str:
     return f"wh-{safe_repo}-{kind}-{number}-{digest}"
 
 
+def _event_key(number: object, *parts: object) -> str:
+    """`<number>-<digest of parts>`: the same for a redelivery of one webhook,
+    different for the next event on the same PR, issue or installation."""
+    digest = hashlib.sha256("|".join(str(p or "") for p in parts).encode()).hexdigest()[:10]
+    return f"{number}-{digest}"
+
+
 def _append_log(record: dict) -> None:
     event_log = _event_log()
     event_log.parent.mkdir(parents=True, exist_ok=True)
@@ -251,7 +258,13 @@ def handle(event: str, payload: dict) -> None:
             _queue_upstream(
                 {
                     **base,
-                    "work_id": _work_id(repo, "pr", number),
+                    # One item per event, not per PR: the action, the head and
+                    # GitHub's updated_at name it, so a redelivery of the same
+                    # webhook is the same item and a later synchronize, close
+                    # or reopen is a new one. Keyed on the number alone, the
+                    # file of the first event made every later one skip.
+                    "work_id": _work_id(repo, "pr", _event_key(
+                        number, action, (pr.get("head") or {}).get("sha"), pr.get("updated_at"))),
                     "kind": "pull_request",
                     "number": number,
                     "title": pr.get("title", ""),
@@ -278,7 +291,8 @@ def handle(event: str, payload: dict) -> None:
             _queue_upstream(
                 {
                     **base,
-                    "work_id": _work_id(repo, "issue", number),
+                    "work_id": _work_id(repo, "issue", _event_key(
+                        number, action, (payload.get("label") or {}).get("name"), issue.get("updated_at"))),
                     "kind": "issue",
                     "number": number,
                     "title": issue.get("title", ""),
@@ -318,8 +332,12 @@ def handle(event: str, payload: dict) -> None:
             # is unique per run and stable across redeliveries, so the dedup
             # still holds where it should (the same completion twice) and
             # nowhere it should not.
-            prs = check.get("pull_requests") or []
-            pr_number = prs[0].get("number") if prs else None
+            # Only a PR of THIS repo: a check on a fork also lists the fork's
+            # PR into upstream, whose number names nothing here.
+            from willow_bot.check_prs import pr_numbers
+
+            prs = pr_numbers(check, repo)
+            pr_number = prs[0] if prs else None
             _queue_upstream(
                 {
                     **base,
@@ -363,7 +381,12 @@ def handle(event: str, payload: dict) -> None:
         _queue_upstream(
             {
                 **base,
-                "work_id": _work_id("app", event, payload.get("action", "change")),
+                "work_id": _work_id("app", event, _event_key(
+                    payload.get("action", "change"),
+                    (payload.get("installation") or {}).get("id"),
+                    ",".join(sorted(str(r.get("full_name")) for r in (payload.get("repositories_added") or []))),
+                    ",".join(sorted(str(r.get("full_name")) for r in (payload.get("repositories_removed") or []))),
+                )),
                 "kind": event,
                 "repositories_added": [
                     r.get("full_name") for r in (payload.get("repositories_added") or [])

{willow_bot-1.2.2 → willow_bot-1.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "willow-bot"
-version = "1.2.2"
+version = "1.2.4"
 description = "Willow GitHub App webhook + orchestrator-feeding steward (propose-only deposits)"
 readme = "README.md"
 requires-python = ">=3.10"

{willow_bot-1.2.2 → willow_bot-1.2.4}/router.py

@@ -14,6 +14,7 @@ import sigh
 import troll
 from integrations import fleet_bridge
 from willow_bot import contributions, welcome
+from willow_bot.check_prs import pr_numbers
 
 log = logging.getLogger("willow-bot.router")
 
@@ -215,26 +216,28 @@ def _handle_check_run(payload: dict, post: Callable) -> None:
     conclusion = check.get("conclusion")
     repo = payload.get("repository", {}).get("full_name", "")
 
-    prs = check.get("pull_requests") or []
+    # Only PRs of this repo: a fork's check also lists its PR into upstream,
+    # whose number names nothing here (or an unrelated issue that shares it).
+    prs = pr_numbers(check, repo)
 
     if action == "completed":
         if conclusion == "success":
             msg = quips.pick("ci_pass")
             for pr in prs:
-                reds = sigh.get(repo, pr["number"])
-                sigh.reset(repo, pr["number"])
+                reds = sigh.get(repo, pr)
+                sigh.reset(repo, pr)
                 # Once per recovery: the first green leg resets the streak,
                 # so later legs of the same head see 0 and say nothing.
                 head = str(check.get("head_sha") or "")
                 if (reds >= troll.RECOVERY_REDS and not _mode_override()
-                        and _may(repo, pr["number"], f"recovered:{head}", None, bot=True)):
+                        and _may(repo, pr, f"recovered:{head}", None, bot=True)):
                     line = _troll_line("ci_recovered", repo, {"reds": reds}, head)
                     if line:
-                        post(repo, pr["number"], line)
+                        post(repo, pr, line)
         elif conclusion in ("failure", "timed_out", "startup_failure"):
             msg = quips.pick("ci_fail")
             for pr in prs:
-                streak = sigh.bump_fail(repo, pr["number"])
+                streak = sigh.bump_fail(repo, pr)
                 line = sigh.sigh_line(streak)
                 if line:
                     msg = line
@@ -270,6 +273,13 @@ def _handle_issues(payload: dict, post: Callable) -> None:
         # A first-timer gets the welcome instead of a quip: one comment, not two.
         if _welcome(repo, issue.get("number"), issue.get("user"), issue.get("author_association"), post):
             return
+        # The same gate every other line passes: the voice's orgs, never an
+        # outside contributor, once per issue, under the daily cap. This line
+        # used to post on every issue in every repo the App can see.
+        user = issue.get("user") or {}
+        if not _may(repo, issue.get("number"), "gap_filed", issue.get("author_association"),
+                    bot=user.get("type") == "Bot"):
+            return
         msg = quips.pick("gap_filed")
         if msg:
             post(repo, issue.get("number"), msg)

{willow_bot-1.2.2 → willow_bot-1.2.4}/tests/steward/test_ci_comment.py

@@ -1258,3 +1258,48 @@ def test_verdict_empty_live_head_is_unverified_not_confirmed(home, monkeypatch):
 def test_verdict_confirmed_live_head_has_no_note(home, monkeypatch):
     monkeypatch.setattr(tick, "_ci_fetch_pull", _Pulls({(RAT, 48): ("open", False, SHA)}))
     assert tick._ci_head_verdict(RAT, 48, SHA, {}, SEEN) == (None, None)
+
+
+# ── ci-comments-retire: the one explicit, receipted way to stop owing ────────
+
+
+def _owe(where: str, sha: str = "a" * 40) -> None:
+    from willow_bot.steward import ci_comments
+
+    owed, _ = ci_comments.load()
+    repo, pr = where.split("#")
+    e = ci_comments.entry_for(owed, f"{where}@{sha}", repo=repo, pr=int(pr), head_sha=sha, where=where)
+    e["comment"].update(status="stalled", attempts=275, last_error="list: 404 Client Error")
+    ci_comments.save(owed)
+
+
+def test_retire_is_a_dry_run_by_default_and_needs_a_reason(capsys):
+    from willow_bot.steward import ci_comments, tick
+
+    _owe("o/fork#1702")
+    with pytest.raises(SystemExit):
+        tick.main(["ci-comments-retire", "o/fork#1702"])  # no --reason
+    capsys.readouterr()
+    assert tick.main(["ci-comments-retire", "o/fork#1702", "--reason", "upstream PR number"]) == 0
+    assert "would_retire" in capsys.readouterr().out
+    owed, _ = ci_comments.load()
+    assert ci_comments.head_keys(owed)  # nothing removed
+
+
+def test_retire_apply_removes_only_that_pr_and_leaves_a_receipt(capsys):
+    from willow_bot.steward import ci_comments, tick
+
+    _owe("o/fork#1702")
+    _owe("o/fork#5")
+    assert tick.main(["ci-comments-retire", "o/fork#1702", "--reason", "upstream PR number", "--apply"]) == 0
+    owed, _ = ci_comments.load()
+    assert [owed[k]["where"] for k in ci_comments.head_keys(owed)] == ["o/fork#5"]
+    receipt = [json.loads(ln) for ln in tick._receipts_path().read_text().splitlines()][-1]
+    assert receipt["event"] == "steward_ci_comments_retire"
+    assert receipt["reason"] == "upstream PR number" and receipt["retired"][0]["attempts"] == 275
+
+
+def test_retire_with_nothing_owed_says_so(capsys):
+    from willow_bot.steward import tick
+
+    assert tick.main(["ci-comments-retire", "o/none#1", "--reason", "x", "--apply"]) == 1

{willow_bot-1.2.2 → willow_bot-1.2.4}/tests/steward/test_inbox.py

@@ -282,12 +282,13 @@ def test_ingest_check_run_and_pull_request_share_state(
     assert check_signals[0]["conclusion"] == "failure"
 
 
-def test_ingest_unknown_kind_stays_in_inbox(
+def test_ingest_unknown_kind_is_archived_unemitted(
     tmp_path: Path, monkeypatch, capsys
 ) -> None:
     """An installation / issue_comment / other-kind row is not consumed
-    here — this step names only the kinds it knows how to emit for. The
-    row stays for a later step and its work_id stays out of consumed."""
+    here — this step names only the kinds it knows how to emit for. No
+    step reads those kinds, so the row moves to unhandled/<YYYY-MM>/
+    (kept, not emitted) and its work_id stays out of consumed."""
     home = tmp_path / "willow"
     inbox = home / "upstream_steward" / "webhook_inbox"
     inbox.mkdir(parents=True)
@@ -312,3 +313,123 @@ def test_ingest_unknown_kind_stays_in_inbox(
     assert capsys.readouterr().out.strip() == ""
     saved = json.loads(state.read_text())
     assert item["work_id"] not in saved.get("inbox_consumed", [])
+    assert not (inbox / f"{item['work_id']}.json").exists()
+    assert [p.name for p in (inbox / "unhandled").glob("*/*.json")] == [f"{item['work_id']}.json"]
+
+
+# ── consumed items leave the inbox ────────────────────────────────────────
+
+
+def _box(tmp_path: Path, monkeypatch) -> tuple[Path, Path]:
+    home = tmp_path / "willow"
+    inbox = home / "upstream_steward" / "webhook_inbox"
+    inbox.mkdir(parents=True)
+    monkeypatch.setenv("WILLOW_HOME", str(home))
+    monkeypatch.delenv("LOKI_PR_WATCH_CALL_WATCHER", raising=False)
+    monkeypatch.delenv("WILLOW_BOT_STEWARD_CALL_WATCHER", raising=False)
+    return inbox, tmp_path / "state.json"
+
+
+def _pr(n: int) -> dict:
+    return {"kind": "pull_request", "work_id": f"wh-o-r-pr-{n}-x", "repo": "o/r", "number": n,
+            "action": "opened", "received_at": "2026-10-11T00:00:00+00:00"}
+
+
+def _check(cid: int) -> dict:
+    return {"kind": "check_run", "work_id": f"wh-o-r-check-{cid}-x", "repo": "o/r", "check_id": cid,
+            "conclusion": "success", "status": "completed", "head_sha": "abc"}
+
+
+def _put(inbox: Path, item: dict) -> Path:
+    p = inbox / f"{item['work_id']}.json"
+    p.write_text(json.dumps(item), encoding="utf-8")
+    return p
+
+
+def _emitted(capsys) -> list[dict]:
+    return [json.loads(ln) for ln in capsys.readouterr().out.splitlines() if ln.strip()]
+
+
+def test_consumed_items_move_to_the_month_archive(tmp_path, monkeypatch, capsys):
+    import time
+
+    inbox, state = _box(tmp_path, monkeypatch)
+    _put(inbox, _pr(1))
+    _put(inbox, _check(7))
+    other = _put(inbox, {"kind": "issue_comment", "work_id": "wh-o-r-comment-1-x"})
+    assert ingest(state) == 0
+    assert len(_emitted(capsys)) == 2
+    stamp = time.strftime("%Y-%m", time.gmtime())
+    month = inbox / "consumed" / stamp
+    assert sorted(p.name for p in month.iterdir()) == ["wh-o-r-check-7-x.json", "wh-o-r-pr-1-x.json"]
+    assert list(inbox.glob("*.json")) == []  # the inbox holds only what waits
+    assert [p.name for p in (inbox / "unhandled" / stamp).iterdir()] == [other.name]
+
+
+def test_a_later_webhook_for_a_consumed_work_id_is_archived_not_re_emitted(tmp_path, monkeypatch, capsys):
+    """fleet_bridge keys a PR by its number. Once the first item leaves the
+    inbox, a later action for the same PR writes the file again; emitting once
+    per work_id is unchanged, and the file still leaves the inbox."""
+    inbox, state = _box(tmp_path, monkeypatch)
+    _put(inbox, _pr(1))
+    ingest(state)
+    capsys.readouterr()
+    again = _put(inbox, {**_pr(1), "action": "closed"})
+    ingest(state)
+    assert _emitted(capsys) == []
+    assert not again.exists()
+
+
+def test_the_cap_keeps_the_most_recent_ids_and_nothing_replays(tmp_path, monkeypatch, capsys):
+    """The old cap kept the alphabetically last ids and left files in place,
+    so every evicted item was emitted again on the next tick."""
+    import willow_bot.steward.inbox as inbox_mod
+
+    monkeypatch.setattr(inbox_mod, "_MAX_CONSUMED", 3)
+    inbox, state = _box(tmp_path, monkeypatch)
+    for n in (5, 4, 3, 2, 1):  # names sort opposite to the order they arrive in
+        _put(inbox, _pr(n))
+        ingest(state)
+    assert len(_emitted(capsys)) == 5
+    saved = json.loads(state.read_text())["inbox_consumed"]
+    assert saved == ["wh-o-r-pr-3-x", "wh-o-r-pr-2-x", "wh-o-r-pr-1-x"]  # newest three, in order
+    for _ in range(3):
+        ingest(state)
+    assert _emitted(capsys) == []  # nothing left in the inbox to replay
+
+
+def test_a_failed_move_is_not_emitted_twice(tmp_path, monkeypatch, capsys):
+    import willow_bot.steward.inbox as inbox_mod
+
+    inbox, state = _box(tmp_path, monkeypatch)
+    stuck = _put(inbox, _pr(1))
+    monkeypatch.setattr(inbox_mod, "_archive", lambda *a, **k: False)
+    ingest(state)
+    ingest(state)
+    assert len(_emitted(capsys)) == 1 and stuck.exists()
+
+
+def test_a_legacy_sorted_consumed_list_is_kept_and_ages_out_first(tmp_path, monkeypatch, capsys):
+    """A box upgraded from the old cap: its sorted list is read as-is, those
+    items are archived without being emitted, and new ids go after them."""
+    inbox, state = _box(tmp_path, monkeypatch)
+    old = _put(inbox, _pr(9))
+    state.write_text(json.dumps({"inbox_consumed": ["wh-o-r-pr-9-x"]}))
+    _put(inbox, _pr(1))
+    ingest(state)
+    assert [e["repo_pr"] for e in _emitted(capsys)] == ["o/r#1"]
+    assert not old.exists()
+    assert json.loads(state.read_text())["inbox_consumed"] == ["wh-o-r-pr-9-x", "wh-o-r-pr-1-x"]
+
+
+def test_status_pending_counts_only_what_is_left(tmp_path, monkeypatch, capsys):
+    from willow_bot import status
+
+    inbox, _ = _box(tmp_path, monkeypatch)
+    from willow_bot.steward.config import state_path
+
+    _put(inbox, _pr(1))
+    _put(inbox, {"kind": "issue", "work_id": "wh-o-r-issue-1-x"})
+    ingest(state_path())
+    r = status.report()["inbox"]
+    assert r["total"] == 0 and r["pending"] == 0  # consumed and unhandled both left

willow_bot-1.2.4/tests/test_check_prs.py

@@ -0,0 +1,74 @@
+"""A check run's `pull_requests` lists open PRs whose HEAD matches, so a
+fork's check also lists the fork's PR into upstream. Only a PR whose BASE
+is the check's own repo is a PR of that repo."""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+import router
+from integrations import fleet_bridge
+from willow_bot import deposits
+from willow_bot.check_prs import pr_numbers
+
+FORK = "rudi193-cmd/codebase-memory-mcp"
+UPSTREAM = "DeusData/codebase-memory-mcp"
+API = "https://api.github.com/repos"
+
+
+def _pr(number: int, base: str) -> dict:
+    return {"number": number, "url": f"{API}/{base}/pulls/{number}",
+            "base": {"ref": "main", "repo": {"url": f"{API}/{base}", "name": base.split("/")[1]}},
+            "head": {"ref": "fix", "repo": {"url": f"{API}/{FORK}"}}}
+
+
+def _check(*prs, conclusion="failure") -> dict:
+    return {"action": "completed", "repository": {"full_name": FORK}, "sender": {"type": "Bot"},
+            "check_run": {"id": 77, "name": "Tests", "status": "completed", "conclusion": conclusion,
+                          "head_sha": "a" * 40, "html_url": "https://x/77", "pull_requests": list(prs)}}
+
+
+def test_only_prs_based_on_the_checks_repo_count():
+    check = _check(_pr(1702, UPSTREAM), _pr(3, FORK))["check_run"]
+    assert pr_numbers(check, FORK) == [3]
+    assert pr_numbers(check, FORK.upper()) == [3]  # GitHub names are case-insensitive
+
+
+def test_a_fork_check_listing_only_its_upstream_pr_has_no_pr_here():
+    assert pr_numbers(_check(_pr(1702, UPSTREAM))["check_run"], FORK) == []
+
+
+def test_an_entry_naming_no_repo_is_kept():
+    assert pr_numbers({"pull_requests": [{"number": 4}]}, FORK) == [4]
+
+
+def test_the_deposit_files_no_foreign_pr(tmp_path):
+    deposits.deposit_from_check_run_payload(_check(_pr(1702, UPSTREAM)))
+    rows = [json.loads(ln) for ln in deposits.deposits_jsonl().read_text().splitlines() if ln.strip()]
+    assert rows[-1]["repo"] == FORK and rows[-1]["pr_number"] is None
+
+
+def test_the_bridge_inbox_item_names_no_foreign_pr(tmp_path, monkeypatch):
+    monkeypatch.setattr(deposits, "deposit_from_check_run_payload", lambda p: None)
+    fleet_bridge.handle("check_run", _check(_pr(1702, UPSTREAM), _pr(3, FORK)))
+    inbox = tmp_path / "upstream_steward" / "webhook_inbox"
+    [item] = [json.loads(p.read_text()) for p in inbox.glob("*.json")]
+    assert item["pr_number"] == 3
+
+
+@pytest.fixture
+def posts(monkeypatch):
+    monkeypatch.delenv("FRANK_MODE", raising=False)
+    monkeypatch.delenv("PROPHET_MODE", raising=False)
+    monkeypatch.setattr(router.fleet_bridge, "handle", lambda *a, **k: None)
+    out = []
+    return out, (lambda repo, number, body: out.append((repo, number, body)))
+
+
+def test_the_router_never_counts_or_speaks_on_a_foreign_pr(posts, monkeypatch):
+    out, post = posts
+    bumped = []
+    monkeypatch.setattr(router.sigh, "bump_fail", lambda repo, pr: bumped.append((repo, pr)) or 1)
+    router.route("check_run", _check(_pr(1702, UPSTREAM)), post)
+    assert bumped == [] and out == []

{willow_bot-1.2.2 → willow_bot-1.2.4}/tests/test_contributions.py

@@ -360,3 +360,29 @@ def test_a_custom_message_and_a_broken_one(posts, welcoming):
     welcoming.write_text(json.dumps({"welcome": {"orgs": ["willow-memory"], "message": "Hi {nope}"}}))
     operator_profile.reset()
     assert "first contribution" in welcome.line_for(REPO, {"login": "cy", "type": "User"}, "FIRST_TIMER")
+
+
+# ── the gap_filed quip passes the voice's gate ────────────────────────────
+
+
+def _issue_opened(assoc, typ="User", repo=REPO, number=4):
+    return {"action": "opened", "repository": {"full_name": repo},
+            "issue": {"number": number, "author_association": assoc, "user": {"login": "x", "type": typ}}}
+
+
+def test_gap_filed_speaks_to_an_insider_once_in_scope(posts):
+    out, post = posts
+    router.route("issues", _issue_opened("OWNER"), post)
+    router.route("issues", _issue_opened("OWNER"), post)  # the same issue again
+    assert len(out) == 1
+
+
+@pytest.mark.parametrize("assoc,repo", [
+    ("NONE", REPO),                       # an outside contributor is never quipped at
+    ("CONTRIBUTOR", REPO),
+    ("OWNER", "someone-else/their-repo"),  # outside the voice's orgs
+])
+def test_gap_filed_is_silent_out_of_scope(posts, assoc, repo):
+    out, post = posts
+    router.route("issues", _issue_opened(assoc, repo=repo), post)
+    assert out == []

{willow_bot-1.2.2 → willow_bot-1.2.4}/tests/test_fleet_bridge.py

@@ -262,3 +262,57 @@ def test_vault_only_env_files_where_the_steward_reads(monkeypatch, tmp_path):
     fleet_bridge.handle("pull_request", _PR)
     assert webhook_inbox_dir() == box / "upstream_steward" / "webhook_inbox"
     assert list(webhook_inbox_dir().glob("*.json"))
+
+
+# ── one inbox item per event, not per PR / issue / installation ─────────────
+
+
+def _pr_event(action: str, sha: str, updated: str, number: int = 4) -> dict:
+    return {"action": action, "repository": {"full_name": REPO},
+            "pull_request": {"number": number, "state": "open", "head": {"sha": sha}, "updated_at": updated}}
+
+
+def test_every_pr_event_reaches_the_inbox_not_only_the_first(home):
+    """Keyed on the PR number, the first event's file made every later one
+    skip: a synchronize's new head and the close never arrived."""
+    fleet_bridge.handle("pull_request", _pr_event("opened", "a" * 40, "2026-10-11T00:00:00Z"))
+    fleet_bridge.handle("pull_request", _pr_event("synchronize", "b" * 40, "2026-10-11T01:00:00Z"))
+    fleet_bridge.handle("pull_request", _pr_event("closed", "b" * 40, "2026-10-11T02:00:00Z"))
+    items = _inbox(home)
+    assert sorted(i["action"] for i in items) == ["closed", "opened", "synchronize"]
+    assert {i["head_sha"] for i in items} == {"a" * 40, "b" * 40}
+    assert len({i["work_id"] for i in items}) == 3
+
+
+def test_a_redelivered_pr_webhook_is_still_one_item(home):
+    ev = _pr_event("opened", "a" * 40, "2026-10-11T00:00:00Z")
+    fleet_bridge.handle("pull_request", ev)
+    fleet_bridge.handle("pull_request", ev)
+    assert len(_inbox(home)) == 1
+
+
+def test_each_issue_event_and_each_label_is_its_own_item(home):
+    def issue(action, updated, label=None):
+        p = {"action": action, "repository": {"full_name": REPO},
+             "issue": {"number": 9, "updated_at": updated}}
+        if label:
+            p["label"] = {"name": label}
+        return p
+
+    fleet_bridge.handle("issues", issue("opened", "t0"))
+    fleet_bridge.handle("issues", issue("labeled", "t1", "bug"))
+    fleet_bridge.handle("issues", issue("labeled", "t2", "help wanted"))
+    fleet_bridge.handle("issues", issue("labeled", "t2", "help wanted"))  # redelivery
+    assert len(_inbox(home)) == 3
+
+
+def test_each_installation_change_is_its_own_item(home):
+    def change(*names):
+        return {"action": "added", "installation": {"id": 7},
+                "repositories_added": [{"full_name": n} for n in names]}
+
+    fleet_bridge.handle("installation_repositories", change("o/a"))
+    fleet_bridge.handle("installation_repositories", change("o/b"))
+    fleet_bridge.handle("installation_repositories", change("o/b"))  # redelivery
+    assert [i["repositories_added"] for i in _inbox(home)] in (
+        [["o/a"], ["o/b"]], [["o/b"], ["o/a"]])

{willow_bot-1.2.2 → willow_bot-1.2.4}/willow_bot/__init__.py

@@ -1,3 +1,3 @@
 """willow-bot — GitHub App webhook + orchestrator-feeding steward."""
 
-__version__ = "1.2.2"
+__version__ = "1.2.4"

willow_bot-1.2.4/willow_bot/check_prs.py

@@ -0,0 +1,38 @@
+"""check_prs.py — which of a check run's `pull_requests` belong to its repo.
+
+GitHub lists, on a check run, the open PRs whose HEAD matches the check's
+sha or branch. A check that runs on a fork therefore also lists the fork's
+PR into the upstream repo, whose number means nothing in the fork: filed
+as ``<fork>#<n>``, the bot commented on a PR that does not exist (a 404
+retried every tick, forever) or, worse, on an unrelated issue that happens
+to share the number. Only a PR whose BASE repo is the check's own repo is
+a PR of that repo.
+"""
+from __future__ import annotations
+
+
+def _base_full_name(pr: dict) -> str:
+    """``owner/name`` of the PR's base repo, from what GitHub sends: the base
+    repo's API url (``…/repos/owner/name``), else the PR's own url
+    (``…/repos/owner/name/pulls/N``). "" when the entry carries neither."""
+    base_repo = ((pr.get("base") or {}).get("repo") or {})
+    for url in (base_repo.get("url"), pr.get("url")):
+        if isinstance(url, str) and "/repos/" in url:
+            rest = url.split("/repos/", 1)[1].split("/")
+            if len(rest) >= 2:
+                return f"{rest[0]}/{rest[1]}"
+    return ""
+
+
+def pr_numbers(check: dict, repo: str) -> list[int]:
+    """The numbers of the check's PRs that are PRs of ``repo``. An entry that
+    names no repo at all is kept (older payload shapes, fixtures)."""
+    out: list[int] = []
+    for pr in check.get("pull_requests") or []:
+        if not isinstance(pr, dict) or pr.get("number") is None:
+            continue
+        base = _base_full_name(pr)
+        if base and base.lower() != str(repo).lower():
+            continue
+        out.append(pr["number"])
+    return out

{willow_bot-1.2.2 → willow_bot-1.2.4}/willow_bot/deposits.py

@@ -547,8 +547,12 @@ def deposit_from_check_run_payload(payload: dict) -> dict[str, Any] | None:
     repo = (payload.get("repository") or {}).get("full_name") or ""
     if not repo:
         return None
-    prs = check.get("pull_requests") or []
-    pr_number = prs[0].get("number") if prs else None
+    from willow_bot.check_prs import pr_numbers
+
+    # Only a PR of THIS repo (`check_prs`): a fork's check also lists its PR
+    # into upstream, and filed under the fork that number named nothing.
+    prs = pr_numbers(check, repo)
+    pr_number = prs[0] if prs else None
     sender_type = str((payload.get("sender") or {}).get("type") or "")
     suite = check.get("check_suite") if isinstance(check.get("check_suite"), dict) else {}
     rec = ci_outcome_record(

{willow_bot-1.2.2 → willow_bot-1.2.4}/willow_bot/status.py

@@ -246,9 +246,11 @@ def _read_inbox_depth() -> dict[str, Any]:
     ``depth_by_kind``), and how many of them the inbox step has not yet
     consumed (``pending``, ``pending_by_kind``).
 
-    The inbox step never deletes a file: it records each consumed
-    ``work_id`` in the steward state's ``inbox_consumed``. So ``total`` is
-    what sits on disk, and ``pending`` is what is actually waiting. When
+    The inbox step moves each item it consumes into ``consumed/<YYYY-MM>/``
+    (out of this glob) and records its ``work_id`` in the steward state's
+    ``inbox_consumed``. So ``total`` is what sits in the inbox, and
+    ``pending`` is what is actually waiting (a failed move stays in
+    ``total`` but not in ``pending``). When
     the state cannot be read, ``pending`` is ``None`` (unknown), never a
     guess."""
     consumed = _read_inbox_consumed()