From 47f7ada70cfaf1df907977aae2c69ea53eb21814 Mon Sep 17 00:00:00 2001 From: Danathar <6772335+Danathar@users.noreply.github.com> Date: Tue, 17 Nov 2026 17:22:51 -0500 Subject: [PATCH 1/2] blocked sweep: wait on every blocked-on marker, not just the first One comment (or the body) may name several blockers. The sweep read only the first marker and lifted blocked when it settled, while another named blocker was still open (projectbluefin/testsuite#1023). Every marker of either form in the newest marker-bearing comment, else the body, now counts: blocked comes off once all are settled, with one note naming them; a re-target of one carries the others' markers forward. A single marker keeps the existing path. Signed-off-by: Danathar <6772335+Danathar@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BQYnPGFJx81c8JXR3o1sg1 --- changelog.d/fixed-blocked-every-marker.md | 1 + .../labels-and-control-signals/reference.md | 4 +- src/pkg/github/client.go | 4 + src/pkg/github/issue_blocked.go | 330 +++++++++++++++++- src/pkg/github/issue_blocked_test.go | 158 ++++++++- 5 files changed, 493 insertions(+), 4 deletions(-) create mode 100644 changelog.d/fixed-blocked-every-marker.md diff --git a/changelog.d/fixed-blocked-every-marker.md b/changelog.d/fixed-blocked-every-marker.md new file mode 100644 index 0000000000..fbd2a7cb46 --- /dev/null +++ b/changelog.d/fixed-blocked-every-marker.md @@ -0,0 +1 @@ +- The blocked sweep now waits on every blocker a blocked-on comment (or the issue body) names, not just the first. An issue blocked on two issues was unblocked and called "actionable again" as soon as the first one closed while the second was still open. `blocked` now comes off only once every named PR has merged or closed and every named issue has closed, with one note naming them all; `pr=` and `issue=` markers in the same comment are both honored, and a re-target of one blocker carries the others' markers forward. A single marker behaves as before. diff --git a/src/docs/labels-and-control-signals/reference.md b/src/docs/labels-and-control-signals/reference.md index 166f6691cd..cb8296dfca 100644 --- a/src/docs/labels-and-control-signals/reference.md +++ b/src/docs/labels-and-control-signals/reference.md @@ -94,7 +94,7 @@ Some hive-authored labels look like provenance but are read as signals, so they | `needs-sha` from SHA-hold | Issues | SHA-hold sweep | Trusted-reporter `kind/bug` without a SHA gets this soft label plus the same `` notice instead of `hold`; the issue stays actionable. The sweep removes it once a SHA appears. | Soft (informational) | Hive | Eval tick SHA sweep | Add SHA evidence, or remove the label | `issues.sha_hold_trusted_label` (default `needs-sha`; `hold` restores the hard hold for everyone) | | `do-not-merge` and `do-not-merge*` | Issues, PRs | Exempt filter, merge sweeps, task-list sweep | Permanently exempt; exact match is case-insensitive but prefix matching follows Go `strings.HasPrefix` on the original label. | Hard suppress | Human | Enumeration/sweeps | Human removes | Built-in `PermanentExemptLabels` (`src/pkg/github/client.go:750-755`, `src/pkg/github/client.go:2035-2053`) | | `governor.labels.exempt` entries | Issues, PRs | Exempt filter | Same exempt behavior as `do-not-merge`; wins over required-label admission. Defaults include `nightly-tests`, `LFX`, `meta-tracker`, `auto-qa-tuning-report`, `adopters`, `changes-requested`, `waiting-on-author`. | Hard suppress | Operator/dashboard | Enumeration/sweeps | Remove label or config entry | `governor.labels.exempt` (`src/pkg/config/governor_config.go:175-184`, `src/pkg/config/defaults.go:260-270`) | -| `blocked` | Issues and PRs | Enumeration, stage derivation, claim gate, review backlog, blocked sweep | The issue waits on an unmerged PR (or another outside blocker): the review backlog files a finding `blocked` when its evidence file exists only on the reviewed PR (absent on the base branch), and `hive-open-issue comment --blocked-on-pr ` parks an existing one; both write ``. A `blocked` issue is filtered (reason `blocked on owner/repo#N`), derives no stage label, is refused by every automated claim producer (`blocked: owner/repo#N`) including the contributor relay, and never carries `help wanted` ([#13093](https://github.com/hivecommons/hive/issues/13093)). When a blocked filing folds into an already-open twin, the twin's own state governs: `blocked` is not applied to it, because the folded body (and its marker) is discarded and the twin's earlier evidence stands on its own; the blocked sweep also lifts a hive-applied `blocked` that has no marker, no deadline and no ops-tracking marker, but only on a review-backlog item (its body carries `filed by Hive review backlog`) that GitHub reports no open "blocked by" link on ([#13364](https://github.com/hivecommons/hive/issues/13364)). A human's marker-less `blocked` stays. A contributor relay's `blocked` verdict that named nothing (GitHub records it as the App bot too, because the relay labels with its hub-minted task token) is turned into a `needs-human` ask instead: `needs-human` is added, `blocked` removed and one note says what is missing. Because the hive put that label on, the repair (write-back kind `blocked_repair`) also runs on an issue older than the hive's write access to the repository and on one without the review opt-in label. Lifting it only sent the issue back to the next agent, which re-applied it, and keeping it hid the issue from every inbox. A blocked verdict whose reason is empty or only the relay footer is booked idle and its label released, like a tooling failure. A marker in a comment counts like one in the body: the row's reason (`blocked on owner/repo#N`) and the band signal name it. With no blocked-on marker, a body deadline `` files it `blocked until ` and the activity monitor's blocked chip reads `re-check at ` ([#13310](https://github.com/hivecommons/hive/issues/13310)). On a PR, `blocked` holds the merge: the blocked sweep puts it on an open, non-draft PR whose `Depends-on:` line names an open pull request (same repository or another), with one `` comment per open target, and every merge lane refuses a `blocked` PR (`label:blocked`). A person's `blocked` is never lifted; a person who removes the hive's `blocked` is not overridden for the same dependencies. A dependency that closed without merging and was replaced by a pull request that is still open (a trusted "Superseded by #N") moves the hold to the replacement; an issue blocker closed as a duplicate of, or replaced by, an open issue moves the block the same way. | Hard suppress | Hive (reserved for agents; relay only) | Review backlog filing; blocked-on comment relay | The blocked sweep after each stage-label sync removes it, with one `` note, once the tracked PR is merged or closed, or once a recheck-after deadline passes (`deadline passed; re-triaging`) unless the body also carries ``. On a PR it removes the hive's own `blocked` once every marked pull request has merged or closed (the note says when one closed without merging) or is no longer listed under `Depends-on:`. An ops-tracking issue on the hive's own project keeps `blocked` once its deadline passes and instead gets soak triage: the hub's `/api/hub/hives` (or, with no hub, the spoke's own `/api/version`) is probed for every `stable`-channel hive (fresh heartbeat, no restart loop, running the candidate `sha256:` digest or `v5 ` named in the body), ONE `` comment is posted, only the checklist lines that evidence proves are ticked, and `` is appended to the body so the sweep does not repeat ([#13311](https://github.com/hivecommons/hive/issues/13311)); a human may remove it at any time | Fixed label (`src/pkg/github/issue_blocked.go`, `src/pkg/github/pr_blocked_depends_on.go`, `src/pkg/github/blocked_successor.go`, `src/pkg/github/issue_recheck_soak.go`, `src/pkg/github/issue_stage_labels.go`, `src/pkg/github/issue_claim_gate.go`) | +| `blocked` | Issues and PRs | Enumeration, stage derivation, claim gate, review backlog, blocked sweep | The issue waits on an unmerged PR (or another outside blocker): the review backlog files a finding `blocked` when its evidence file exists only on the reviewed PR (absent on the base branch), and `hive-open-issue comment --blocked-on-pr ` parks an existing one; both write ``. A `blocked` issue is filtered (reason `blocked on owner/repo#N`), derives no stage label, is refused by every automated claim producer (`blocked: owner/repo#N`) including the contributor relay, and never carries `help wanted` ([#13093](https://github.com/hivecommons/hive/issues/13093)). When a blocked filing folds into an already-open twin, the twin's own state governs: `blocked` is not applied to it, because the folded body (and its marker) is discarded and the twin's earlier evidence stands on its own; the blocked sweep also lifts a hive-applied `blocked` that has no marker, no deadline and no ops-tracking marker, but only on a review-backlog item (its body carries `filed by Hive review backlog`) that GitHub reports no open "blocked by" link on ([#13364](https://github.com/hivecommons/hive/issues/13364)). A human's marker-less `blocked` stays. A contributor relay's `blocked` verdict that named nothing (GitHub records it as the App bot too, because the relay labels with its hub-minted task token) is turned into a `needs-human` ask instead: `needs-human` is added, `blocked` removed and one note says what is missing. Because the hive put that label on, the repair (write-back kind `blocked_repair`) also runs on an issue older than the hive's write access to the repository and on one without the review opt-in label. Lifting it only sent the issue back to the next agent, which re-applied it, and keeping it hid the issue from every inbox. A blocked verdict whose reason is empty or only the relay footer is booked idle and its label released, like a tooling failure. A marker in a comment counts like one in the body: the row's reason (`blocked on owner/repo#N`) and the band signal name it. With no blocked-on marker, a body deadline `` files it `blocked until ` and the activity monitor's blocked chip reads `re-check at ` ([#13310](https://github.com/hivecommons/hive/issues/13310)). On a PR, `blocked` holds the merge: the blocked sweep puts it on an open, non-draft PR whose `Depends-on:` line names an open pull request (same repository or another), with one `` comment per open target, and every merge lane refuses a `blocked` PR (`label:blocked`). A person's `blocked` is never lifted; a person who removes the hive's `blocked` is not overridden for the same dependencies. A dependency that closed without merging and was replaced by a pull request that is still open (a trusted "Superseded by #N") moves the hold to the replacement; an issue blocker closed as a duplicate of, or replaced by, an open issue moves the block the same way. | Hard suppress | Hive (reserved for agents; relay only) | Review backlog filing; blocked-on comment relay | The blocked sweep after each stage-label sync removes it, with one `` note, once the tracked PR is merged or closed (when the newest marker-bearing comment, or else the body, names several blockers, once every one is settled: a PR merged or closed, an issue closed), or once a recheck-after deadline passes (`deadline passed; re-triaging`) unless the body also carries ``. On a PR it removes the hive's own `blocked` once every marked pull request has merged or closed (the note says when one closed without merging) or is no longer listed under `Depends-on:`. An ops-tracking issue on the hive's own project keeps `blocked` once its deadline passes and instead gets soak triage: the hub's `/api/hub/hives` (or, with no hub, the spoke's own `/api/version`) is probed for every `stable`-channel hive (fresh heartbeat, no restart loop, running the candidate `sha256:` digest or `v5 ` named in the body), ONE `` comment is posted, only the checklist lines that evidence proves are ticked, and `` is appended to the body so the sweep does not repeat ([#13311](https://github.com/hivecommons/hive/issues/13311)); a human may remove it at any time | Fixed label (`src/pkg/github/issue_blocked.go`, `src/pkg/github/pr_blocked_depends_on.go`, `src/pkg/github/blocked_successor.go`, `src/pkg/github/issue_recheck_soak.go`, `src/pkg/github/issue_stage_labels.go`, `src/pkg/github/issue_claim_gate.go`) | | `needs-human` | Issues | Enumeration, task-list sweep, claim escalation gate and un-park sweep | Filters issues from agent kicks and contributor offers; records a human decision requirement. See the [issue reference](#needs-human) and [Maintainer commands](../maintainer-commands.md). | Hard suppress | Hive or human | Enumeration/task-list sweep/kick building | An eligible maintainer's ordinary `/hive approve` or `/hive decision ` lifts it regardless of who applied it; label-driven un-parking remains provenance-sensitive. Keep `hold` if work must stay stopped. Agents may add, never remove it. | Fixed label (`src/pkg/github/client.go:1008-1024`, `src/pkg/github/task_list_sweep.go:611-641`, `src/pkg/github/task_list_sweep.go:874-880`, `src/cmd/hive/claimescalation.go`) | | `needs-spec` from the clarity gate | Issues | Scheduler kick assembly (`runs.triage.clarity_gate`) | With the gate on (default off), a human-filed, unclaimed issue whose clarity score (goal, acceptance criteria, scope, detail, open choices) is under `runs.triage.clarity_gate.threshold` gets one `` comment with concise questions for its author and the `needs-spec` hard-suppress label instead of a claim; it derives `stage/045-needs-decision` and leaves the agent queue ([#13577](https://github.com/hivecommons/hive/issues/13577)). | Hard suppress | Hive | Before kicks are built | The issue author, or a non-hive commenter with write/maintain/admin, replies after the marker and the resume sweep removes the hive's own `needs-spec` and records the un-park so the issue re-derives `stage/010-actionable` ([#13588](https://github.com/hivecommons/hive/issues/13588)); a `needs-spec` a person added is never lifted by the sweep. Or remove `needs-spec` by hand. The marker keeps the gate from asking again | `runs.triage.clarity_gate` (`src/pkg/scheduler/clarity_gate.go`, `src/pkg/classify/clarity.go`, `src/pkg/github/clarity_gate_resume.go`) | | `stage/017-possible-existing` from the prior-art gate | Issues | Scheduler kick assembly (`runs.triage.prior_art`) | With the gate on (default on), an unclaimed feature / RFC / epic issue whose key terms match an existing knowledge bead, setting, merged PR, closed issue, doc or code identifier at `runs.triage.prior_art.threshold` (default 70) gets one `` comment quoting the findings and the `stage/017-possible-existing` label instead of a claim; hive-filed issues get a `` note and are never parked ([#13575](https://github.com/hivecommons/hive/issues/13575)). | Hard suppress | Hive | Before kicks are built | The author or a write+ commenter replies `/hive decision proceed — ` (label lifted, a *Scope vs existing* section appended to the body, re-derives 010) or `/hive decision exists` (closed `not_planned` with `already-exists`); a plain reply lifts the label too. A clanker-filed park with no reply is closed `already-exists` after `runs.triage.prior_art.bot_close_ttl` (default 72h); reopen to continue. A 017 a person added is never lifted by the sweep | `runs.triage.prior_art` (`src/pkg/priorart`, `src/pkg/scheduler/prior_art_gate.go`, `src/pkg/github/prior_art_gate_resume.go`) | @@ -314,7 +314,7 @@ An open issue whose GitHub dependency list names an open blocker is enumerated w **Applies to:** Issues and PRs. **Kind:** Hard suppress. -The issue waits on an unmerged PR (or another outside blocker): the review backlog files a finding `blocked` when its evidence file exists only on the reviewed PR (absent on the base branch), and `hive-open-issue comment --blocked-on-pr ` parks an existing one; both write ``. A `blocked` issue is filtered (reason `blocked on owner/repo#N`), derives no stage label, is refused by every automated claim producer (`blocked: owner/repo#N`) including the contributor relay, and never carries `help wanted` ([#13093](https://github.com/hivecommons/hive/issues/13093)). A blocker that is an issue rather than a PR is named by the issue form, ``, in the body or a comment (a contributor's `blocked` verdict comment writes it); the issue is filtered `blocked on issue owner/repo#N`, its `blocked` stays while that issue is open and is never lifted as marker-less (projectbluefin/utah#10 and #855 were lifted, re-triaged and re-verified "still blocked" again and again). A malformed issue marker counts as no marker. +The issue waits on an unmerged PR (or another outside blocker): the review backlog files a finding `blocked` when its evidence file exists only on the reviewed PR (absent on the base branch), and `hive-open-issue comment --blocked-on-pr ` parks an existing one; both write ``. A `blocked` issue is filtered (reason `blocked on owner/repo#N`), derives no stage label, is refused by every automated claim producer (`blocked: owner/repo#N`) including the contributor relay, and never carries `help wanted` ([#13093](https://github.com/hivecommons/hive/issues/13093)). A blocker that is an issue rather than a PR is named by the issue form, ``, in the body or a comment (a contributor's `blocked` verdict comment writes it); the issue is filtered `blocked on issue owner/repo#N`, its `blocked` stays while that issue is open and is never lifted as marker-less (projectbluefin/utah#10 and #855 were lifted, re-triaged and re-verified "still blocked" again and again). A malformed issue marker counts as no marker. One comment (or the body) may carry several markers, of either form: the newest comment that carries any is the one that counts, and every blocker it names must be settled before `blocked` comes off, with one note naming them all. While any is open only `help wanted` is stripped. When one of them is replaced by a pull request or issue that is still open, one re-target comment carries the markers of every blocker still open, the untouched ones included (projectbluefin/testsuite#1023 was unblocked when the first of its two blocker issues closed). When a blocked filing folds into an already-open twin, the twin's own state governs: `blocked` is not applied to it, because the folded body (and its marker) is discarded and the twin's earlier evidence stands on its own; the blocked sweep also lifts a hive-applied `blocked` that has no marker, no deadline and no ops-tracking marker on a review-backlog item, leaving a human-applied one alone ([#13364](https://github.com/hivecommons/hive/issues/13364)). Any other hive-applied marker-less `blocked` (a contributor relay's verdict that named no issue or PR) becomes a `needs-human` ask, with one note naming the two ways out: name the dependency, or remove `needs-human` to re-queue it. A verdict with no reason at all is not blocked: the hub books it idle and releases the label. With no blocked-on marker, a body deadline `` files it `blocked until ` and the activity monitor's blocked chip reads `re-check at ` ([#13310](https://github.com/hivecommons/hive/issues/13310)). diff --git a/src/pkg/github/client.go b/src/pkg/github/client.go index 2439875b38..5e829017e9 100644 --- a/src/pkg/github/client.go +++ b/src/pkg/github/client.go @@ -5377,6 +5377,10 @@ type RepoWorkIssue struct { // (liftBlockedMarkerless). ReviewBacklog bool `json:"review_backlog,omitempty"` OpenBlockedBy int `json:"open_blocked_by,omitempty"` + // BlockedOn lists every blocker the body's blocked-on markers name + // ("owner/repo#N", or "issue owner/repo#N"), set only when there are + // several, so ReconcileBlockedIssues keeps the block until all settle. + BlockedOn []string `json:"blocked_on,omitempty"` // OpenBlockers are the keys ("repo#N") of a decision park's open // blocked-by issues, read only for such a park; the dashboard checks // whether one is itself a decision park (Issue.OpenBlockers). diff --git a/src/pkg/github/issue_blocked.go b/src/pkg/github/issue_blocked.go index a72e248b43..dc367a9b17 100644 --- a/src/pkg/github/issue_blocked.go +++ b/src/pkg/github/issue_blocked.go @@ -137,6 +137,97 @@ func ParseBlockedOnMarker(text string) (repo string, pr int, ok bool) { return m[1], n, true } +// blockedOnRef is one blocker a blocked-on marker names: a PR, or an issue +// when issue is set (the `issue=` form). +type blockedOnRef struct { + repo string + number int + issue bool +} + +func (r blockedOnRef) ref() string { return r.repo + "#" + strconv.Itoa(r.number) } + +func (r blockedOnRef) key() string { + kind := "pr " + if r.issue { + kind = "issue " + } + return kind + strings.ToLower(r.ref()) +} + +// marker renders the blocked-on marker that names r. +func (r blockedOnRef) marker() string { + if r.issue { + return blockedOnIssueMarker(r.repo, r.number) + } + return BlockedOnMarker(r.repo, r.number) +} + +// reasonRef is r as the filtered reason writes it after "blocked on ": +// "owner/repo#N", or "issue owner/repo#N" for the issue form. +func (r blockedOnRef) reasonRef() string { + if r.issue { + return blockedOnIssueReasonWord + r.ref() + } + return r.ref() +} + +// parseBlockedOnRefs returns every distinct blocked-on marker in text, both +// forms, in the order they appear. ParseBlockedOnMarker and +// parseBlockedOnIssueMarker read only the first; one comment (or body) may +// name several blockers (projectbluefin/testsuite#1023 named two issues), and +// the block lasts until every one of them is settled, as blockedPRMarkedTargets +// does for a PR's markers. +func parseBlockedOnRefs(text string) []blockedOnRef { + type hit struct { + at int + ref blockedOnRef + } + var hits []hit + for _, form := range []struct { + re *regexp.Regexp + issue bool + }{{blockedOnMarkerRE, false}, {blockedOnIssueMarkerRE, true}} { + for _, m := range form.re.FindAllStringSubmatchIndex(text, -1) { + n, err := strconv.Atoi(text[m[4]:m[5]]) + if err != nil || n <= 0 { + continue + } + hits = append(hits, hit{at: m[0], ref: blockedOnRef{repo: text[m[2]:m[3]], number: n, issue: form.issue}}) + } + } + sort.SliceStable(hits, func(i, j int) bool { return hits[i].at < hits[j].at }) + seen := map[string]bool{} + var out []blockedOnRef + for _, h := range hits { + if !seen[h.ref.key()] { + seen[h.ref.key()] = true + out = append(out, h.ref) + } + } + return out +} + +// blockedOnRefsIfSeveral is parseBlockedOnRefs(text) when it names more than +// one blocker, else nil: a single blocker keeps the one-target path. +func blockedOnRefsIfSeveral(text string) []blockedOnRef { + if refs := parseBlockedOnRefs(text); len(refs) > 1 { + return refs + } + return nil +} + +// blockedOnRefsFromReasons reads RepoWorkIssue.BlockedOn back into refs. +func blockedOnRefsFromReasons(reasons []string) []blockedOnRef { + var out []blockedOnRef + for _, s := range reasons { + if repo, n, issue, ok := parseBlockedOnReason(blockedFilterReasonPrefix + " on " + s); ok { + out = append(out, blockedOnRef{repo: repo, number: n, issue: issue}) + } + } + return out +} + // ParseBlockedOnReason returns the PR a blockedFilterReason names ("blocked // on owner/repo#N"); false for every other reason. func ParseBlockedOnReason(reason string) (repo string, pr int, ok bool) { @@ -235,6 +326,10 @@ func setBlockedRowFacts(row *RepoWorkIssue, body string, openBlockedBy int) { row.RecheckDone = blockedRecheckDone(body) row.ReviewBacklog = blockedReviewBacklogFiling(body) row.OpenBlockedBy = openBlockedBy + row.BlockedOn = nil + for _, r := range blockedOnRefsIfSeveral(body) { + row.BlockedOn = append(row.BlockedOn, r.reasonRef()) + } } // blockedStageReason is the IssueStageFor reason for an issue wearing the @@ -383,6 +478,9 @@ type blockedIssueTarget struct { // GitHub's open "blocked by" count. Both gate liftBlockedMarkerless. reviewBacklog bool openBlockedBy int + // blockers: every blocker the body's markers name, when there are + // several (blockedOnRefsIfSeveral); nil otherwise. + blockers []blockedOnRef } // ReconcileBlockedIssues walks the cycle's blocked issues (filtered rows @@ -420,7 +518,7 @@ func ReconcileBlockedIssues(ctx context.Context, client *Client, result *Actiona if row.Number <= 0 || row.Bucket != workBucketFiltered || !IsBlockedIssueReason(row.Reason) || !hasBlockedLabel(row.Labels) { continue } - targets = append(targets, blockedIssueTarget{repo: row.Repo, number: row.Number, labels: row.Labels, reason: row.Reason, recheckAfter: row.RecheckAfter, opsTracking: row.OpsTracking, recheckDone: row.RecheckDone, reviewBacklog: row.ReviewBacklog, openBlockedBy: row.OpenBlockedBy}) + targets = append(targets, blockedIssueTarget{repo: row.Repo, number: row.Number, labels: row.Labels, reason: row.Reason, recheckAfter: row.RecheckAfter, opsTracking: row.OpsTracking, recheckDone: row.RecheckDone, reviewBacklog: row.ReviewBacklog, openBlockedBy: row.OpenBlockedBy, blockers: blockedOnRefsFromReasons(row.BlockedOn)}) } } return client.reconcileBlockedTargets(ctx, targets, logger) @@ -470,6 +568,7 @@ func (c *Client) SweepBlockedIssues(ctx context.Context, opts BlockedSweepOption recheckDone: blockedRecheckDone(body), reviewBacklog: blockedReviewBacklogFiling(body), openBlockedBy: blockedBy[issue.GetNumber()], + blockers: blockedOnRefsIfSeveral(body), }) } } @@ -497,6 +596,11 @@ func (c *Client) reconcileBlockedTargets(ctx context.Context, targets []blockedI // scanned: the comments were read without error and hold no marker, // so a marker-less lift may trust that nothing names a blocker. scanned := false + // blockers: every blocker the newest marker-bearing comment names + // when it names several; fromComment: a comment carried the marker, + // so the body's markers no longer count. + var blockers []blockedOnRef + fromComment := false if lookups < blockedSweepCommentLookups { lookups++ scan, err := c.blockedSweepComments(ctx, t.repo, t.number, t.recheckAfter) @@ -504,6 +608,7 @@ func (c *Client) reconcileBlockedTargets(ctx context.Context, targets []blockedI if scan.ok { prRepo, prNumber, onIssue, ok = scan.prRepo, scan.pr, scan.issue, scan.ok noteBlockedOnSeen(t.repo, t.number, scan.prRepo, scan.pr) + blockers, fromComment = scan.refs, true } if !ok && !t.recheckAfter.IsZero() && !now.Before(t.recheckAfter) { if t.opsTracking && isRecheckSoakRepo(t.repo) { @@ -537,6 +642,16 @@ func (c *Client) reconcileBlockedTargets(ctx context.Context, targets []blockedI } // A block that names what it waits on is not one the repair converts. forgetBlockedRepairHeld(c, t) + // The body's markers stand when no comment carried one, provided the + // blocker this pass resolved is among them (a reason the enumeration + // took from a comment the budget left unread this pass is not). + if !fromComment && blockedOnRefsInclude(t.blockers, blockedOnRef{repo: prRepo, number: prNumber, issue: onIssue}) { + blockers = t.blockers + } + if len(blockers) > 1 { + reconcileBlockedOnAll(ctx, c, t, blockers, scanned, &res, logger) + continue + } if onIssue { reconcileBlockedOnIssue(ctx, c, t, prRepo, prNumber, scanned, &res, logger) continue @@ -996,6 +1111,213 @@ func reconcileBlockedOnIssue(ctx context.Context, c *Client, t blockedIssueTarge logger.Info("blocked sweep: issue unblocked", "repo", t.repo, "issue", t.number, "blocker", ref) } +// reconcileBlockedOnAll settles a block whose markers name several blockers, +// PRs and issues alike. projectbluefin/testsuite#1023 named two issues in one +// comment; the sweep read only the first and lifted `blocked` ("actionable +// again") the moment it closed, while the second was still open. The block +// now lifts, with one note naming every blocker, only once all of them are +// settled: a PR merged or closed, an issue closed. A closed blocker replaced +// by one still open (a superseding PR, an issue's duplicate or successor) +// holds as that replacement, and the pass that finds it posts one comment +// carrying the marker of every blocker still open, so the newest +// marker-bearing comment keeps naming all of them. While any blocker is open +// only `help wanted` comes off. A lookup error is counted and keeps the block +// for the pass. scanned says t's comments were read this pass (see +// retargetBlockedOnAll). +func reconcileBlockedOnAll(ctx context.Context, c *Client, t blockedIssueTarget, blockers []blockedOnRef, scanned bool, res *BlockedIssueResult, logger *slog.Logger) { + var open, settled []blockedOnRef + var moves []string + for _, b := range blockers { + cur, holds, move, err := c.blockedOnRefState(ctx, t, b) + if err != nil { + res.Errors++ + logger.Warn("blocked sweep: blocker lookup failed; block kept", "repo", t.repo, "issue", t.number, "blocker", b.ref(), "error", err) + return + } + if !holds { + settled = append(settled, b) + continue + } + if !blockedOnRefsInclude(open, cur) { + open = append(open, cur) + } + if move != "" { + moves = append(moves, move) + } + } + if len(open) == 0 { + if err := c.unblockIssue(ctx, t.repo, t.number); err != nil { + res.Errors++ + logger.Warn("blocked sweep: unblock failed", "repo", t.repo, "issue", t.number, "error", err) + return + } + c.postUnblockedNote(ctx, t.repo, t.number, blockedAllSettledNote(settled, c.unblockAdmission(t.labels)), logger) + res.Unblocked++ + logger.Info("blocked sweep: issue unblocked; every blocker settled", "repo", t.repo, "issue", t.number, "blockers", blockedOnRefList(settled)) + return + } + noteBlockedOnSeen(t.repo, t.number, open[0].repo, open[0].number) + if len(moves) > 0 { + retargetBlockedOnAll(ctx, c, t, open, moves, scanned, res, logger) + } + stripBlockedHelpWanted(ctx, c, t, res, logger) +} + +// blockedOnRefState reads one of several blockers: whether it still holds +// the issue, and as what. A closed-unmerged PR superseded by one still open, +// or a closed issue replaced by one still open (blockedIssueSuccessorOf), +// holds as that replacement, and move says so for the re-target note. A +// merged PR, or a closed one or a closed issue with no open replacement, is +// settled. A successor read that keeps failing past +// blockedSuccessorLookupGrace releases the issue blocker, as the +// single-blocker path does. +func (c *Client) blockedOnRefState(ctx context.Context, t blockedIssueTarget, b blockedOnRef) (cur blockedOnRef, holds bool, move string, err error) { + if b.issue { + owner, name := c.splitRepo(b.repo) + _, closed, err := c.IssueClosedAt(ctx, owner, name, b.number) + if err != nil { + return b, false, "", err + } + if !closed { + return b, true, "", nil + } + key := blockedSuccessorLookupKey(t.repo, t.number, b.ref()) + succ, ok, err := c.blockedIssueSuccessorOf(ctx, t, b.repo, b.number) + if err != nil { + if giveUp, _ := blockedSuccessorLookupFailed(key); !giveUp { + return b, false, "", err + } + return b, false, "", nil + } + blockedSuccessorLookupSettled(key) + if !ok { + return b, false, "", nil + } + how := "was replaced by" + if succ.duplicate { + how = "is a duplicate of" + } + return blockedOnRef{repo: succ.repo, number: succ.number, issue: true}, true, fmt.Sprintf("blocker %s %s %s", b.ref(), how, succ.ref()), nil + } + settled, merged, err := c.pullRequestSettledDetails(ctx, b.repo, b.number) + if err != nil { + return b, false, "", err + } + if !settled { + return b, true, "", nil + } + if merged { + return b, false, "", nil + } + sup, ok := c.pullRequestSupersededBy(ctx, b.repo, b.number) + if !ok || sup <= 0 || sup == b.number { + return b, false, "", nil + } + supSettled, _, err := c.pullRequestSettledDetails(ctx, b.repo, sup) + if err != nil { + return b, false, "", err + } + if supSettled { + return b, false, "", nil + } + return blockedOnRef{repo: b.repo, number: sup}, true, fmt.Sprintf("blocker %s was superseded by #%d", b.ref(), sup), nil +} + +// retargetBlockedOnAll posts blockedOnAllRetargetNote through the write-back +// gate, as the issue successor re-target does. A held or failed note leaves +// the block as it is: the next pass follows the closed blocker to its open +// replacement again and asks once more. When the comments were not read this +// pass (the per-pass budget ran out) the blockers came from the body, which +// an earlier re-target comment may already have moved off, so the comments +// are read first and a marker there means nothing is posted. +func retargetBlockedOnAll(ctx context.Context, c *Client, t blockedIssueTarget, open []blockedOnRef, moves []string, scanned bool, res *BlockedIssueResult, logger *slog.Logger) { + if !scanned { + scan, err := c.blockedSweepComments(ctx, t.repo, t.number, t.recheckAfter) + if err != nil { + res.Errors++ + logger.Warn("blocked sweep: comment lookup before re-target failed; block kept", "repo", t.repo, "issue", t.number, "error", err) + return + } + if scan.ok { + return + } + } + note := blockedOnAllRetargetNote(open, moves) + item, err := c.WritebackItemForNumber(ctx, t.repo, t.number) + if err != nil { + res.Errors++ + logger.Warn("blocked sweep: item lookup before re-target failed; block kept", "repo", t.repo, "issue", t.number, "error", err) + return + } + gateRepo := c.blockedRepairRepo(t.repo) + if d := c.WritebackAllowed(gateRepo, item, writeback.KindGateComment, note); !d.Allowed { + level := slog.LevelDebug + if c.WritebackGate().NoteHeld(gateRepo, t.number, writeback.KindGateComment, d.Reason) { + level = slog.LevelInfo + } + logger.Log(ctx, level, "blocked sweep: re-target of one of several blockers held by writeback gate; block kept", "repo", t.repo, "issue", t.number, "reason", d.Reason, "detail", d.Detail) + return + } + c.WritebackGate().ForgetHeld(gateRepo, t.number, writeback.KindGateComment) + if err := c.CreateIssueCommentBudgeted(ctx, t.repo, t.number, note); err != nil { // writeback:gated + logger.Warn("blocked sweep: re-target note not posted; block kept", "repo", t.repo, "issue", t.number, "error", err) + return + } + res.Retargeted++ + logger.Info("blocked sweep: one of several blockers re-targeted", "repo", t.repo, "issue", t.number, "blockers", blockedOnRefList(open)) +} + +// blockedOnAllRetargetNote is the standalone comment that moves one or more +// of several blockers to their open replacements. It carries the marker of +// every blocker still open, the untouched ones included, so the newest +// marker-bearing comment the sweep reads still names all of them. +func blockedOnAllRetargetNote(open []blockedOnRef, moves []string) string { + var b strings.Builder + for _, r := range open { + b.WriteString(r.marker()) + b.WriteString("\n") + } + b.WriteString("Re-targeted: " + strings.Join(moves, "; ") + ". Still blocked on " + blockedOnRefList(open) + ".") + return b.String() +} + +// blockedAllSettledNote is the note posted when every one of several +// blockers is settled. It names the first right after "Unblocked: " so +// unblockAlreadyNoted recognises a repeat. +func blockedAllSettledNote(settled []blockedOnRef, admission string) string { + lead := blockedUnblockedMarker + "\nUnblocked: " + blockedOnRefList(settled) + " are no longer open." + if admission != "" { + return lead + " Unblocked — waiting for a maintainer to admit it: " + admission + } + return lead + " This issue is actionable again." +} + +// blockedOnRefList names refs as prose: "a", "a and b", "a, b and c". +func blockedOnRefList(refs []blockedOnRef) string { + names := make([]string, 0, len(refs)) + for _, r := range refs { + names = append(names, r.ref()) + } + switch len(names) { + case 0: + return "" + case 1: + return names[0] + } + return strings.Join(names[:len(names)-1], ", ") + " and " + names[len(names)-1] +} + +// blockedOnRefsInclude reports whether refs names r (same form, repository +// compared case-insensitively). +func blockedOnRefsInclude(refs []blockedOnRef, r blockedOnRef) bool { + for _, x := range refs { + if x.key() == r.key() { + return true + } + } + return false +} + // liftBlockedDeadline lifts `blocked` from an issue with no tracked PR whose // recheck-after deadline has passed and posts the unblocked note, so the next // enumeration re-triages it — 010, or no stage while project.issue_filter @@ -1089,6 +1411,9 @@ type blockedSweepScan struct { ok bool deadlineNoted bool evidenceNoted bool + // refs: every blocker that newest marker-bearing comment names, when + // there are several (blockedOnRefsIfSeveral); nil otherwise. + refs []blockedOnRef } // blockedSweepComments reads the issue's comments once: the newest @@ -1114,6 +1439,9 @@ func (c *Client) blockedSweepComments(ctx context.Context, repo string, number i scan.prRepo, scan.pr, scan.ok = parseBlockedOnIssueMarker(body) scan.issue = scan.ok } + if scan.ok { + scan.refs = blockedOnRefsIfSeveral(body) + } } if passed != "" && strings.Contains(body, blockedUnblockedMarker) && strings.Contains(body, passed) { scan.deadlineNoted = true diff --git a/src/pkg/github/issue_blocked_test.go b/src/pkg/github/issue_blocked_test.go index 1112f88a5d..28b4338502 100644 --- a/src/pkg/github/issue_blocked_test.go +++ b/src/pkg/github/issue_blocked_test.go @@ -100,6 +100,50 @@ func TestBlockedOnIssueMarker(t *testing.T) { } } +// One comment or body may name several blockers, in either form; every +// distinct one is read, in order. A single marker keeps the one-target path +// (no BlockedOn on the row). +func TestParseBlockedOnRefs(t *testing.T) { + text := "\n" + + BlockedOnMarker("o/r", 7) + "\n" + + "\n" + + "\n" + + "" + got := parseBlockedOnRefs(text) + want := []blockedOnRef{ + {repo: "projectbluefin/utah", number: 1198, issue: true}, + {repo: "o/r", number: 7}, + {repo: "projectbluefin/testsuite", number: 1215, issue: true}, + } + if len(got) != len(want) { + t.Fatalf("parseBlockedOnRefs = %+v, want %+v", got, want) + } + for i := range want { + if got[i] != want[i] { + t.Fatalf("parseBlockedOnRefs[%d] = %+v, want %+v", i, got[i], want[i]) + } + } + if blockedOnRefsIfSeveral(BlockedOnMarker("o/r", 7)) != nil { + t.Fatal("a single marker must keep the one-target path") + } + var row RepoWorkIssue + setBlockedRowFacts(&row, BlockedOnMarker("o/r", 7), 0) + if row.BlockedOn != nil { + t.Fatalf("single marker BlockedOn = %q, want nil", row.BlockedOn) + } + setBlockedRowFacts(&row, text, 0) + if strings.Join(row.BlockedOn, ",") != "issue projectbluefin/utah#1198,o/r#7,issue projectbluefin/testsuite#1215" { + t.Fatalf("BlockedOn = %q", row.BlockedOn) + } + back := blockedOnRefsFromReasons(row.BlockedOn) + if len(back) != 3 || back[0] != want[0] || back[1] != want[1] || back[2] != want[2] { + t.Fatalf("BlockedOn round trip = %+v", back) + } + if got := blockedOnRefList(want); got != "projectbluefin/utah#1198, o/r#7 and projectbluefin/testsuite#1215" { + t.Fatalf("blockedOnRefList = %q", got) + } +} + // projectbluefin/utah#10 and #855: a `blocked` set for an issue dependency // was lifted as marker-less and re-verified "still blocked" nine times. A // block whose marker names an open issue stays (only `help wanted` comes @@ -216,6 +260,109 @@ func TestReconcileBlockedIssuesBlockedOnIssue(t *testing.T) { } } +// projectbluefin/testsuite#1023: one comment named two issue blockers. The +// sweep read only the first, lifted `blocked` and called the issue +// "actionable again" the moment it closed, while the second was still open. +// Every marker in the newest marker-bearing comment (else the body) now +// counts, PR and issue forms alike: the block lifts only once all of them +// are settled, with one note naming them all, and a re-target of one carries +// the other's marker forward. +func TestReconcileBlockedIssuesWaitsOnEveryMarker(t *testing.T) { + f := newBlockedSuccessorFake() + marker := func(ref string) string { return `{"id":1,"body":` + strconv.Quote(ref) + `}` } + closed := `{"number":%d,"state":"closed","state_reason":"completed","closed_at":"2026-11-16T15:06:00Z","user":{"login":"reporter"}}` + // #1: the testsuite#1023 shape, first blocker closed, second open. + f.issues["o/r#100"] = fmt.Sprintf(closed, 100) + f.issues["o/r#101"] = `{"number":101,"state":"open"}` + f.comments["o/r#1"] = []string{marker("\n\nRemaining: o/r#100, o/r#101")} + // #2: both closed. + f.issues["o/r#200"] = fmt.Sprintf(closed, 200) + f.issues["o/r#201"] = fmt.Sprintf(closed, 201) + f.comments["o/r#2"] = []string{marker("\n")} + // #3: a PR marker and an issue marker; the PR merged, the issue is open. + // Reading only the PR marker lifted the block. + f.pulls["o/r#31"] = `{"number":31,"state":"closed","merged":true}` + f.issues["o/r#301"] = `{"number":301,"state":"open"}` + f.comments["o/r#3"] = []string{marker(BlockedOnMarker("o/r", 31) + "\n")} + // #4: one of two blockers was replaced by an open issue. + f.issues["o/r#400"] = `{"number":400,"state":"closed","state_reason":"not_planned","closed_at":"2026-11-16T15:06:00Z","user":{"login":"reporter"}}` + f.comments["o/r#400"] = []string{`{"id":1,"body":"Superseded by #401.","user":{"login":"maintainer"},"author_association":"MEMBER"}`} + f.issues["o/r#401"] = `{"number":401,"state":"open"}` + f.issues["o/r#402"] = `{"number":402,"state":"open"}` + f.comments["o/r#4"] = []string{marker("\n")} + // #5: the markers are in the body only (the enumeration row carries + // them); first closed, second open. + f.issues["o/r#500"] = fmt.Sprintf(closed, 500) + f.issues["o/r#501"] = `{"number":501,"state":"open"}` + + c := testClient(t, f.server(t).URL) + c.appBotLogin = testBot + t.Cleanup(func() { + for n := 1; n <= 5; n++ { + forgetBlockedOnSeen("o/r", n) + } + }) + var body5 RepoWorkIssue + setBlockedRowFacts(&body5, "\n", 0) + rows := func() []RepoWorkIssue { + return []RepoWorkIssue{ + {Repo: "o/r", Number: 1, Labels: []string{"blocked", "help wanted"}, Bucket: workBucketFiltered, Reason: "blocked"}, + {Repo: "o/r", Number: 2, Labels: []string{"blocked"}, Bucket: workBucketFiltered, Reason: "blocked"}, + {Repo: "o/r", Number: 3, Labels: []string{"blocked"}, Bucket: workBucketFiltered, Reason: "blocked"}, + {Repo: "o/r", Number: 4, Labels: []string{"blocked"}, Bucket: workBucketFiltered, Reason: "blocked"}, + {Repo: "o/r", Number: 5, Labels: []string{"blocked"}, Bucket: workBucketFiltered, Reason: "blocked on issue o/r#500", BlockedOn: body5.BlockedOn}, + } + } + res := ReconcileBlockedIssues(context.Background(), c, &ActionableResult{WorkDetailsByRepo: map[string]RepoWorkDetails{"o/r": {Issues: rows()}}}, nil) + if res.Items != 5 || res.Unblocked != 1 || res.Retargeted != 1 || res.Stripped != 1 || res.Errors != 0 { + t.Fatalf("result = %+v, want Items=5 Unblocked=1 Retargeted=1 Stripped=1 Errors=0", res) + } + + f.mu.Lock() + posts, removed := f.posts, strings.Join(f.removed, "\n") + f.mu.Unlock() + for _, ref := range []string{"o/r#1", "o/r#3", "o/r#4", "o/r#5"} { + if strings.Contains(removed, ref+" blocked") { + t.Errorf("%s has an open blocker and must stay blocked; removed labels:\n%s", ref, removed) + } + } + for _, ref := range []string{"o/r#1", "o/r#3", "o/r#5"} { + if len(posts[ref]) != 0 { + t.Errorf("%s must get no note while a blocker is open: %q", ref, posts[ref]) + } + } + if !strings.Contains(removed, "o/r#1 help wanted") { + t.Errorf("the parked issue must not advertise itself; removed labels:\n%s", removed) + } + if !strings.Contains(removed, "o/r#2 blocked") { + t.Errorf("both blockers closed: o/r#2 must be unblocked; removed labels:\n%s", removed) + } + wantNote := blockedUnblockedMarker + "\nUnblocked: o/r#200 and o/r#201 are no longer open. This issue is actionable again." + if got := posts["o/r#2"]; len(got) != 1 || got[0] != wantNote { + t.Errorf("o/r#2 notes = %q, want exactly %q", got, wantNote) + } + wantRetarget := "\n\nRe-targeted: blocker o/r#400 was replaced by o/r#401. Still blocked on o/r#401 and o/r#402." + if got := posts["o/r#4"]; len(got) != 1 || got[0] != wantRetarget { + t.Errorf("o/r#4 comments = %q, want exactly %q", got, wantRetarget) + } + if !f.called("GET /repos/o/r/issues/301") { + t.Error("the issue marker beside a PR marker must be read") + } + + // A later pass: nothing moved, so nothing is written again, and the + // re-targeted issue now reads its open blockers from the new comment. + again := rows()[2:] + res = ReconcileBlockedIssues(context.Background(), c, &ActionableResult{WorkDetailsByRepo: map[string]RepoWorkDetails{"o/r": {Issues: again}}}, nil) + if res.Unblocked != 0 || res.Retargeted != 0 || res.Errors != 0 { + t.Fatalf("second pass = %+v, want nothing unblocked or re-targeted", res) + } + f.mu.Lock() + defer f.mu.Unlock() + if len(f.posts["o/r#4"]) != 1 { + t.Errorf("o/r#4 got a second re-target comment: %q", f.posts["o/r#4"]) + } +} + // hivecommons/hive#13093: a blocked issue derives no stage, whatever its // bucket, and the legacy deriver and the engine adapter agree (the golden // corpus carries the blocked label sets; this pins the live-shape input). @@ -1408,6 +1555,9 @@ type blockedSuccessorFake struct { duplicateOf map[string]string // moved maps "owner/repo#N" to the path GitHub redirects it to. moved map[string]string + // pulls maps "owner/repo#N" to a pull request's JSON, for a blocker + // that is a PR. + pulls map[string]string // commentsStatus maps "owner/repo#N" to the HTTP status its comment // listing answers with instead of the comments. commentsStatus map[string]int @@ -1423,7 +1573,7 @@ type blockedSuccessorFake struct { } func newBlockedSuccessorFake() *blockedSuccessorFake { - return &blockedSuccessorFake{issues: map[string]string{}, comments: map[string][]string{}, duplicateOf: map[string]string{}, moved: map[string]string{}, commentsStatus: map[string]int{}, posts: map[string][]string{}} + return &blockedSuccessorFake{issues: map[string]string{}, comments: map[string][]string{}, duplicateOf: map[string]string{}, moved: map[string]string{}, pulls: map[string]string{}, commentsStatus: map[string]int{}, posts: map[string][]string{}} } func (f *blockedSuccessorFake) server(t *testing.T) *httptest.Server { @@ -1458,6 +1608,12 @@ func (f *blockedSuccessorFake) server(t *testing.T) *httptest.Server { return } parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/repos/"), "/") + if len(parts) == 4 && parts[2] == "pulls" && r.Method == http.MethodGet { + if pr, ok := f.pulls[parts[0]+"/"+parts[1]+"#"+parts[3]]; ok { + _, _ = io.WriteString(w, pr) + return + } + } if len(parts) < 4 || parts[2] != "issues" { w.WriteHeader(http.StatusNotFound) _, _ = io.WriteString(w, `{"message":"Not Found"}`) From 47b9d7266107a7c45ff26bd086a90fe93eaf5669 Mon Sep 17 00:00:00 2001 From: Danathar <6772335+Danathar@users.noreply.github.com> Date: Tue, 17 Nov 2026 17:32:29 -0500 Subject: [PATCH 2/2] blocked sweep: tag retargetBlockedOnAll in the notification inventory The re-target note for several blockers is a notification-capable write carrying the machine-read blocked-on markers, like blockedSuccessorRetargetIssue; class it protocol_command in notificationWriteSites and the notifications doc table so TestNotificationWriteSitesInventory passes. Signed-off-by: Danathar <6772335+Danathar@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BQYnPGFJx81c8JXR3o1sg1 --- src/docs/notifications.md | 1 + src/pkg/github/notification_write_sites.go | 1 + 2 files changed, 2 insertions(+) diff --git a/src/docs/notifications.md b/src/docs/notifications.md index a12ed886da..9c6877b526 100644 --- a/src/docs/notifications.md +++ b/src/docs/notifications.md @@ -663,6 +663,7 @@ without a class. Review submissions and review requests are always counted as | `github.(*Client).postBlockedOnPRMarker` | `protocol_command` | carries the machine-consumed blocked-on marker; shared by a relay's blocked verdict and a PR's `Depends-on:` placement | | `github.(*Client).markBlockedPRSuccessor` | `protocol_command` | moves a PR's `Depends-on:` hold to the open pull request that replaced a target closed without merging; carries the blocked-on marker and the `hive:depends-on-successor` link the sweep reads back | | `github.blockedSuccessorRetargetIssue` | `protocol_command` | moves an issue's block to the open issue that replaced its closed blocker (a duplicate closure or a trusted "Superseded by"); carries the issue-form blocked-on marker | +| `github.retargetBlockedOnAll` | `protocol_command` | moves one or more of an issue's several blockers to their open replacements; carries the blocked-on marker of every blocker still open, so the newest marker-bearing comment names all of them | | `github.(*Client).handleOnePRRequest` | `security_event` | | | `github.(*Client).markReporterTrustAwaiting` | `security_event` | | | `github.(*Client).reconcileReporterTrustSignal` | `security_event` | | diff --git a/src/pkg/github/notification_write_sites.go b/src/pkg/github/notification_write_sites.go index 520ae18f3e..751e32bf5a 100644 --- a/src/pkg/github/notification_write_sites.go +++ b/src/pkg/github/notification_write_sites.go @@ -128,6 +128,7 @@ var notificationWriteSites = map[string]NotificationWriteSite{ "github.(*Client).postBlockedOnPRMarker": {Class: NotificationClassProtocolCommand}, "github.(*Client).markBlockedPRSuccessor": {Class: NotificationClassProtocolCommand}, "github.blockedSuccessorRetargetIssue": {Class: NotificationClassProtocolCommand}, + "github.retargetBlockedOnAll": {Class: NotificationClassProtocolCommand}, // security_event: trust and integrity signals. "github.(*Client).handleOnePRRequest": {Class: NotificationClassSecurityEvent},