Repository navigation
🐛 fix(automerge): isolate repos GitHub refuses to search in contributor auto-promotion - #17151
hivecommons-hive[bot] merged 16 commits into
Conversation
…or auto-promotion GitHub answers the hive-wide `is:pr is:merged author:X repo:… repo:…` search with 422 Validation Failed when any listed repository or user cannot be searched (renamed, deleted or invisible repo; unsearchable author). contributorMergedRepos treated that like a transient failure: it dropped every other repository from the clean-merge count and re-issued the same doomed query, with the same warning, on every PR evaluation of every sweep (561 warnings in 10 minutes on one hive). On a 422 the chunk is now re-asked one repository at a time so the searchable repositories still count; each refused (author, repository) pair warns once per process and is left out of the search for contributorUnsearchableTTL (1h). Other search failures keep degrading to the PR's own repository. Fixes hivecommons#17148 Hive-Run: hivecommons#17148 Hive-Plan: selfreport unclassified_error_repeated — contributor-lane auto-promotion repo search Hive-Spec: hive-merge#contributor-lane-auto-promotion Signed-off-by: Karibhou <Karibhou@users.noreply.github.com>
Open PR overlap checkBase branch: Conflicts are checked with every PR merged onto the current tip of No conflicting open PRs or same-file overlaps were found. |
There was a problem hiding this comment.
Correctness review (head 56db613) — the isolation logic and TTL cache read correctly; the three error paths (422 → per-repo probe, 5xx/rate-limit → old own-repo fallback, single-repo chunk → note and continue) are each exercised by the new tests. Approving from this perspective; one advisory edge case:
Per-(author, repo) cache key rediscovers an unsearchable repo once per author — src/pkg/github/automerge/automerge_contributor_unsearchable.go:33-35 keys the skip on author|owner/repo, so for the issue's actual case (a renamed/deleted repo, not an unsearchable author) every distinct contributor author evaluated in a sweep pays the full chunk query plus one probe per repo in that chunk (automerge_contributor_lane.go:935-953) before their pair is cached. For A authors and a chunk of N repos that is A×(1+N) search/issues calls per hour against GitHub's 30/min search budget (previously A). A rate-limit hit there is a *gh.RateLimitError, so it falls through searchQueryUnsearchable to the old repo search failed warning and own-repo count — correct, but it means the WARN this PR aims to silence can still appear on large hives for the first sweep each hour. The PR body already names the reason for the pair key (the 422 does not say which qualifier it refused), so this is a deliberate trade-off; flagging it only so the choice is on record. Not blocking.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
|
Hive status — updated in place; edits do not notify. Full history is in the Activity Monitor. Review findings from Read the diff against What I verified:
One observation, not a defect: stage 095-pre-merge-soak → 074-adopted-by-hive: untrusted-author-role Review findings from Style perspective (read head Advisory — name promises more than the check (
Non-blocking; fine to land as-is if you prefer the broader match, in which case the doc comment should say "any 422". Review findings from Read the diff against What I verified
One note, not a defect. Any 422 from search/issues is treated as "this pair is unsearchable" and cached for an hour. GitHub also uses 422 for other query validation failures; the chunker rules out the length case, and an unsearchable author is the intended all-repos-refused outcome (covered by the new test), so I don't see a realistic misattribution today — just flagging the assumption so a future qualifier added to CI. hive/awaiting-ci: the red 🐝 Hive Agent: — hive: agent=scanner backend=copilot model=claude-fable-5.1 copilot=1.0.88 Evidence bundle `#171514d66702` sha256:8f4265bd61f780c4b3e7864bf9719ece02b7e030585b8c7b1c4e5bfa925d6baf — download from the dashboard or `hivectl review evidence #17151`. |
|
Ready for a human merge: verdict approved @4d66702, 61/61 checks green, DCO yes, soak 10m0s elapsed. Blocked only by The hive never approves on your behalf: Updated 2026-11-08 14:45 UTC. |
There was a problem hiding this comment.
Read the diff against the tree. This looks correct to me.
automerge_contributor_lane.go:935-955—flushonly takes the per-repo path onsearchQueryUnsearchable(err); any other error still returns and hits the existing "repo search failed; counting the PR's repository only" warning at lines 966/973, so the 5xx behaviour is unchanged as the body claims. A one-repo chunk short-circuits tonoteContributorUnsearchablewithout a redundant second query.- The chunker now guards with
len(chunk) > 0 &&before flushing, so a single over-longrepo:qualifier is still asked on its own rather than skipped — a small improvement over the oldlen(query)+len(qualifier)check. automerge_contributor_unsearchable.go:57-62— entries are never deleted, so a refusal after the TTL findsseen == trueand logs at Debug; that matches the stated "warn once per process" intent, and the> 4096reset bounds the map.c.debugexists (automerge_sweep_queued.go) andc.clock()is the same clock the existing contributor-lane fixtures inject.- Skipped pairs are filtered at candidate-building time (line 905), so
foundcan never name a repo that was not searched.
One thing worth knowing, not a defect: searchQueryUnsearchable treats every 422 as "a listed user or repo cannot be searched". GitHub also returns 422 for a malformed query. With contributorSearchQueryMaxLen = 256 and a fixed base, I could not find a way for this code to build a malformed query, so the per-repo retry just costs N extra calls once per hour in that hypothetical case and then degrades exactly as before.
The new test asserts the exact query sequence across TTL boundaries and that the old warning never fires, which is the regression #17148 describes.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
|
Thanks — both reviews flag the same advisory: the 🐝 Hive Agent: |
…7188) * fix(dashboard): hide preparation train header for a lone ticket A single base-preparation ticket is the update-branch lock holder, not a train. After its refresh moves the head the ticket is unverified, so the header read 'Preparation train · 0 confirmed PRs · recorded front: #N' above one row (hive #17151). Draw the header only when two or more tickets are recorded; the row comment keeps the owner/unverified state. Signed-off-by: Andrew Anderson <andy@clubanderson.com> * fix(dashboard): mobile-shots fixture expects no header over a lone preparation ticket Re-pin TRUSTED_SCRIPTS_TREE for the fixture change. Signed-off-by: Andrew Anderson <andy@clubanderson.com> --------- Signed-off-by: Andrew Anderson <andy@clubanderson.com>
There was a problem hiding this comment.
Read the diff against the v5 tree (src/pkg/github/automerge/automerge_contributor_lane.go, the test fixture, and the existing Engine helpers). The change does what the body says and I found no defects.
What I verified
flush(automerge_contributor_lane.go:935-955at head) only takes the per-repo path on a 422; any other error still returns and hits the unchangedrepo search faileddegrade-to-own-repo branch at:961/:969. The pre-existing semantics for 5xx/rate-limit are preserved, and the test that covered them was correctly moved from 422 to 500.- The chunk loop (
:956-968) can never callflushwith an empty chunk:candidatesis non-empty by the early return at:910, and after each flush the currentrefis appended before the loop continues. So the bareis:pr is:merged author:<login>query (norepo:qualifier, which would count merges across all of GitHub) is unreachable. Worth knowing because the oldif query == base { return nil }guard is gone and nothing replaced it — the loop shape is what protects it now. contributorSearchSkipsreads from a possibly-nil map under the mutex (automerge_contributor_unsearchable.go:40-46) — fine in Go;noteContributorUnsearchablelazily allocates (:56).c.clock()andc.debugexist onv5(automerge_held_runs.go,automerge_sweep_queued.go), as do thecontributorLaneClock/newContributorLaneEngineRepostest helpers the new test uses.- The GitHub 422 for an unsearchable qualifier comes back from go-github as
*gh.ErrorResponse, soerrors.Asat:30-31matches it. src/docs/hive-merge.mdand the changelog fragment describe the behaviour the code implements, including the one-hour TTL and the once-per-pair WARN.
One suggestion, not a defect
searchQueryUnsearchable (automerge_contributor_unsearchable.go:28-32) is byte-for-byte the existing isGitHubStatus(err, http.StatusUnprocessableEntity) from automerge_sweep_queued.go:526-529, which this package already uses for the same purpose in automerge_contributor_adopt.go:926. Reusing it would drop a helper; keep the doc comment, it is the useful part.
Note for the v5→v6 forward-merge, not for this PR
v6 already carries #15371's per-author result cache in this same function (contributorMergedReposEntry, v6:automerge_contributor_lane.go:968+), which v5 does not have. The port will need to be done by hand inside the cached version rather than taken as a textual merge.
Looks correct to me; CI is green on the head I read.
— hive: agent=reviewer backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read at head c3f32d6 against the v5 tree. Looks correct to me.
What I verified
automerge_contributor_lane.go:935-955—flushonly takes the per-repo path onsearchQueryUnsearchable(err); any other error (5xx, rate limit) still returns to the two existingwarn(...); return nilsites, so the "own repository only" degradation is unchanged. A non-422 error inside the per-repo retry also propagates there rather than being swallowed.automerge_contributor_unsearchable.go:41-47—contributorSearchSkipsreads the nil map safely before any 422 has been noted;noteContributorUnsearchablebounds the map at 4096 entries and keys on(author, owner/repo), which is the right key given GitHub does not say which qualifier it refused.- Chunking: the new
len(chunk) > 0 &&guard means a single over-longrepo:qualifier is still sent rather than flushing an empty chunk; the old code had the same effective behaviour viaquery == base, so nothing regresses there. - The caller (
automerge_contributor_lane.go:829-835) iterates whatevercontributorMergedReposreturns, so a shrunk candidate list is simply fewerwalkcalls. c.clock()(automerge_held_runs.go:260) is used for the TTL, so the test clock drives expiry.
One wording note, not a defect: the body says a refused pair "warns once per process". In the code the WARN→Debug downgrade keys on the pair still being present in the map, so it is once per process unless the map is reset by the 4096-entry bound — which only matters on a very large hive. The changelog's "warns once" is fine as-is.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Security perspective — approve (advisory only).
No new permission, token, or injection surface: the 422 isolation and the (author, repo) skip cache in src/pkg/github/automerge/automerge_contributor_unsearchable.go:40-66 are driven solely by GitHub's own refusal, so a third party cannot seed the cache; the map is bounded (reset above 4096 entries) and searchQueryUnsearchable (:28-31) matches only *gh.ErrorResponse with 422, so rate-limit/abuse errors still take the existing degrade path.
One trust-boundary note (low, not blocking): on the parent commit a 422 degraded the hive-wide count to the PR's own repo, which was conservative for promotion. Now flush drops the refused repo and the rest keep counting (automerge_contributor_lane.go:935-955), and contributorCleanMergedHistory only walks repos that search surfaced (:829-834). So an author's reverted or sentinel-labelled merge in a repo that search refuses (e.g. renamed — PullRequests.List would still follow the redirect) is no longer revert evidence, and the author can be promoted to contributor-lane auto-merge without it. This is the trade-off #17148 asks for and the WARN names the repo, so operators can repair config; flagging it so the widening is on record rather than implicit.
— hive: agent=ci-maintainer backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read the diff against the v5 tree, including the callers and helpers it relies on. This looks correct to me.
What I verified:
src/pkg/github/automerge/automerge_contributor_lane.go:945-966— the 422 fallback re-asks one repo at a time and only swallows 422s; any non-422 error from the per-repo retry still propagates to the existingrepo search failedwarning and own-repo fallback, so the 5xx / rate-limit behaviour is unchanged.automerge_contributor_lane.go:967-979— the newlengthbookkeeping (len(" repo:")+len(owner)+1+len(repo)) equals the length of the qualifier string the old code appended, and thelen(chunk) > 0 &&guard means a chunk is never empty when flushed. Candidates skipped bycontributorSearchSkipsfall through to the pre-existinglen(candidates) == 0 → nilreturn at line 911, so the own-repo degradation path is the same onev5already has.automerge_contributor_unsearchable.go:40-66—c.clock()(automerge_held_runs.go:260) falls back totime.Now()whenc.nowis nil, andwarn/debug(automerge_sweep_queued.go:677,711) are nil-logger safe. The map reset at 4096 entries follows theselfSkipWarnedpattern atautomerge_sweep_queued.go:697.- The PR body's claims (isolate-on-422, warn once then Debug, 1h TTL keyed by
(author, repo)) match what the code does; the tests atautomerge_contributor_lane_test.go:1345-1365cover both the single-repo and whole-author refusal.
One open question, not a defect: searchQueryUnsearchable (automerge_contributor_unsearchable.go:28-31) treats every 422 as "resource cannot be searched". A 422 for a malformed query would also mark each repo in the chunk unsearchable for an hour. The consequence is the same own-repo count the old code already produced plus one WARN per pair, so it degrades safely — just noting it in case a future change wants to match on the message body too.
Checks were still running when I read this (tide pending); nothing here needs a maintainer decision beyond the normal merge.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read the full contributorMergedRepos at head (src/pkg/github/automerge/automerge_contributor_lane.go:887-979), the new helpers in automerge_contributor_unsearchable.go, the Engine fields added in automerge_sweep.go:293-297, and the existing clock() (automerge_held_runs.go:260) / warn / debug (automerge_sweep_queued.go:677,711) this relies on. Looks correct to me.
What I verified:
- Chunk-length accounting (
lane.go:960-971) reproduces the oldlen(query)+len(qualifier) > 256boundary exactly, including the first-ref-always-added case, so chunking behaviour is unchanged for non-422 paths. - Non-422 errors still hit
flush → return err → warn("…counting the PR's repository only") → return nil(lane.go:963-975), so the 5xx/rate-limit degradation the PR body describes is intact. searchQueryUnsearchableonly matches a*gh.ErrorResponsewith status 422 (unsearchable.go:28-31); the other 422s search can return (query >256 chars, paging past 1000) are not reachable here because of the chunk cap andPerPage:100first-page-only.- Cache key,
foundlookup andrepoFromRepositoryURLall lower-case consistently. fixed-17148.mdfragment is present andhive-merge.mdis updated to describe the new behaviour.
One observation, not a defect: when the author is the refused qualifier (every repo 422s), a chunk of N repos now costs N+1 search calls instead of 1 before the pair cache fills (lane.go:936-951). That is bounded, happens once per author per contributorUnsearchableTTL, and is covered by the "unsearchable author" test case, so I think it is the right trade — just noting it for whoever watches the search budget.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read the diff against v5 together with the caller (contributorCleanHistory → automerge_contributor_lane.go:830) and the helpers it leans on (Engine.clock at automerge_held_runs.go:260, warn/debug in automerge_sweep_queued.go). The change does what the body says, and I found no defect.
What I verified:
- Chunking is behaviour-preserving. The old code appended qualifiers to a string and flushed when
len(query)+len(qualifier) > 256; the new loop trackslengththe same way (len(" repo:")+len(owner)+1+len(repo)) and flushes with the identical threshold. The addedlen(chunk) > 0 &&guard only changes the degenerate case where a single qualifier alone exceeds 256, which previously produced a silent no-op flush and now still issues the query — strictly better. - Non-422 failures keep the pre-#17148 path.
flushreturns any non-422 error unchanged (automerge_contributor_lane.go, newflush), and both call sites still emit the originalrepo search failed; counting the PR's repository onlywarning and returnnil, so the caller at:830falls through to the own-repo count exactly as before. The retest of the generic-failure case with 500 instead of 422 is the right adjustment. - The per-repo retry cannot loop. A single-repo 422 is recorded and skipped (
len(chunk) == 1branch); a non-422 on a single repo is returned and degrades the whole search. No path re-asks the same chunk twice in one call. - The TTL cache is safe under the engine's clock.
contributorSearchSkips/noteContributorUnsearchabletakecontributorUnsearchableMuaround the map and usec.clock(), which falls back totime.Now()whenc.nowis nil, so production and the fake-clock test share one code path. Resetting the map above 4096 entries bounds memory; the only cost is a repeat WARN for a pair, which is acceptable. - Skipped pairs cannot inflate the result.
candidatesexcludes skipped refs beforefoundis built, andoutis filtered fromcandidates, so a skipped repo can never appear in the returned list.
One design note, not a defect: searchQueryUnsearchable treats every 422 from search/issues as "cannot see repository", not just the "listed users and repositories cannot be searched" message. With chunking already keeping queries under 256 chars, the other 422 causes (malformed qualifier, too many operators) do not arise from this query shape, so this is fine today; it is worth knowing if the query ever grows.
Tests cover both the integration path (TestTrySweepContributorLanePRAutoPromotionScope, two new cases) and the exact query sequence across the TTL (TestContributorMergedReposRemembersUnsearchableRepository), and the body's claim that the first new case fails on the parent is consistent with the old code returning nil on any error.
Looks correct to me. This is a fork PR, so a maintainer needs to merge once checks finish.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read the change against v5 at 7e19f30 (callers in automerge_contributor_lane.go, Engine in automerge_sweep.go). Looks correct to me.
What I verified
contributorHistory(automerge_contributor_lane.go:827) walks the PR's own repository before callingcontributorMergedRepos, so the new earlyreturn nilwhen every candidate is inside the skip window (:912) degrades to exactly the pre-#14517 own-repo count — same as a search failure, no new blank spot.- The
flushclosure (:935-954) only re-asks per repo on a 422 (searchQueryUnsearchable); 5xx/rate-limit still take the existingrepo search failedpath, as the body says. A single-repo chunk that 422s is recorded and skipped rather than retried — no fan-out loop. - Chunking (
:957-967):len(chunk) > 0 &&means an over-long single qualifier gets its own chunk instead of the oldquery == baseno-op flush, so nothing is silently dropped. noteContributorUnsearchableleaves expired keys in the map, soseensurvives the TTL and a permanently refused pair warns once per process, then Debug — matches the stated intent. The> 4096reset would re-WARN once; negligible.c.clock()(automerge_held_runs.go:260) andc.debug(automerge_sweep_queued.go:711) already exist onEngine; the new state is mutex-guarded consistently.TestContributorMergedReposRemembersUnsearchableRepositorypins the exact query sequence across the TTL boundary and asserts the old warning never fires — it would fail on the parent, where the first 422 returnednilfrom the whole function.
One note, not a defect: GitHub also returns 422 for other search validation problems (e.g. a malformed qualifier). With single-repo chunks any 422 is attributed to that repo and cached for an hour. Query length is already bounded by contributorSearchQueryMaxLen, so I could not construct a realistic case; mentioning it only so the 1h TTL is understood as the recovery path if it ever happens.
Docs (hive-merge.md) and the changelog fragment match the behaviour. CI is green.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Style/maintainability pass at 2960be0. The new once-per-pair warn cache mirrors the existing warnSelfAuthoredSkipOnce idiom (automerge_sweep_queued.go:686-703) and the TTL goes through c.clock(), so this reads as native to the package. One advisory note:
searchQueryUnsearchable doc describes a narrower check than it implements — src/pkg/github/automerge/automerge_contributor_unsearchable.go:24-31. The comment says it reports GitHub's "cannot be searched" 422, and the WARN text (...search cannot see repository for this author) and the 1h cache both assume that meaning, but the predicate only tests StatusCode == 422. Any other search validation error (bad qualifier, oversized q) would be attributed to a repository and cached for an hour under the same message. Either narrow the predicate to the Search/q/invalid error entry GitHub returns, or reword the comment so the next reader knows it is status-only:
// searchQueryUnsearchable reports whether err is GitHub's 422 Validation
// Failed for a search whose listed users or repositories "cannot be searched
// either because the resources do not exist or you do not have permission to
// view them". It does not say which qualifier it refused.
func searchQueryUnsearchable(err error) bool {
var ghErr *gh.ErrorResponse
if !errors.As(err, &ghErr) || ghErr.Response == nil || ghErr.Response.StatusCode != http.StatusUnprocessableEntity {
return false
}
for _, e := range ghErr.Errors {
if e.Resource == "Search" && e.Field == "q" && e.Code == "invalid" {
return true
}
}
return false
}
The fake in automerge_contributor_lane_test.go:256-262 already emits that exact error entry, so the tests cover the narrowed form as written. Non-blocking.
— hive: agent=ci-maintainer backend=copilot model=claude-fable-5.1 copilot=1.0.88
There was a problem hiding this comment.
Read the full diff against v5 plus the surrounding contributorMergedRepos body and the Engine helpers it leans on. This looks correct to me.
What I checked:
- Chunking invariant —
automerge_contributor_lane.go:959-968: the in-loop flush is guarded bylen(chunk) > 0and every iteration appends before the next check, so the finalflush(chunk)at:970never runs with an empty chunk. That matters becausesearch([])would otherwise issue a bareis:pr is:merged author:Xquery with norepo:qualifier and count merges hive-wide across any repo. The oldquery == baseearly-return is gone, but the guard makes it unreachable. - 422 isolation —
:935-955: a 422 on a multi-repo chunk re-asks each repo singly; a non-422 error on the single retry still propagates to the existing "counting the PR's repository only" warning, so 5xx/rate-limit behaviour is unchanged fromv5. - Once-per-process WARN —
automerge_contributor_unsearchable.go:54-65:seenis read before the entry is overwritten and entries are never deleted (only the >4096 reset), so a pair that expires and is refused again logs at Debug, exactly as the doc comment andTestContributorMergedReposRemembersUnsearchableRepositorystate. c.clock()(automerge_held_runs.go:260) andc.debug(automerge_sweep_queued.go:711) exist onEngine; the map is mutex-guarded on both read and write paths.
One non-blocking note for whoever merges: searchQueryUnsearchable treats any 422 from Search.Issues as "unsearchable pair". With the query capped at 256 chars the only other 422 GitHub returns here is a malformed qualifier, which cannot arise from owner/repo tokens, so I agree it is safe — just naming the assumption.
CI is green across the test matrix. I have not approved or changed anything; this is advisory.
— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88
|
/lgtm Posted by @clubanderson from the Hive dashboard; the merge gate decides from here. |
|
@hivecommons-hive[bot]: changing LGTM is restricted to collaborators DetailsIn response to this:
Instructions for interacting with me using PR comments are available here. If you have questions or suggestions related to my behavior, please file an issue against the kubernetes-sigs/prow repository. |
|
/approve Posted by @clubanderson from the Hive dashboard; the merge gate decides from here. |
There was a problem hiding this comment.
Approved by @clubanderson for Hive auto-merge on green CI.
Approved from the Hive dashboard by @clubanderson as the owner decision on a Ready-for-human-merge pull request; hive merges it on its next merge pass once CI is green.
|
[APPROVALNOTIFIER] This PR is NOT APPROVED This pull-request has been approved by: hivecommons-hive[bot] The full list of commands accepted by this bot can be found here. DetailsNeeds approval from an approver in each of these files:Approvers can indicate their approval by writing |
|
@hivecommons-hive[bot]: changing LGTM is restricted to collaborators DetailsIn response to this:
Instructions for interacting with me using PR comments are available here. If you have questions or suggestions related to my behavior, please file an issue against the kubernetes-sigs/prow repository. |
|
Hive queued this PR but could not set the |
What
contributorMergedRepos(hive-wide contributor-lane auto-promotion) asks GitHubis:pr is:merged author:<login> repo:… repo:…. When any listed repository or user cannot be searched, GitHub rejects the whole query with422 Validation Failed("The listed users and repositories cannot be searched…"). Before this change, that 422 was handled like a transient failure:author:repires repo:tuna-os/xfce-linux.Change
(author, repository)pair warns once per process (contributor-lane auto-promotion search cannot see repository for this author; …, withsearched_repo=). Later refusals log at Debug. The pair is left out of the search forcontributorUnsearchableTTL(1h), so a repaired repo or account comes back without a restart. The 422 does not say which qualifier it refused, so the cache key is the pair, not the repo alone.New helpers:
src/pkg/github/automerge/automerge_contributor_unsearchable.go. Docs:src/docs/hive-merge.md(auto-promotion paragraph). Changelog:changelog.d/fixed-17148.md.Tests
TestTrySweepContributorLanePRAutoPromotionScope: the fake search endpoint can now refuse named repos with a GitHub-shaped 422.acme/docsno longer hidesacme/hive, and the author is admitted. On the parent commit this case fails withclaim-tier-untrustedafter 1 search.TestContributorMergedReposRemembersUnsearchableRepository: asserts the exact query sequence across sweeps. The first refusal isolates the repo. The next sweep and a sweep 59 minutes later omit it. TTL expiry asks GitHub again. Exactly one WARN, and the oldrepo search failedline never fires.Per the repo's AGENTS.md, tests are not run locally; CI is the verdict. Locally I ran only
gofmt -l(clean) andcheck-docs-citations.py --fix(no drift).Fixes #17148
— hive: backend=omp model=anthropic/claude-opus-5-5
🐝 Hive Agent:
contributor| SHA:56db61373