test(eligibility): close the last coverage gaps without suppressions

Codecov counts a /* v8 ignore */ line as unhit, so both suppressions are gone rather
than carried:

DEFAULT_PRIORITY_LABEL names the built-in value, so resolvePriorityTypeLabel returns
it directly. PrTypeLabelSet is an open Record, which made DEFAULT_TYPE_LABELS.priority
read as possibly-undefined and forced a fallback branch nothing could ever take.

The .catch on resolvePriorityEligibilityHold is removed: that function catches its own
GitHub read and cannot reject, so the guard was unreachable code that read as
tested-and-fine while never running.

The remaining branch is closed by an end-to-end test instead: a clean, approved, green
PR that would MERGE is held because the priority issue it closes only became public a
minute ago -- held, never closed.

Author: JSONbored

packages/loopover-engine/src/settings/pr-type-label.ts

@@ -22,10 +22,16 @@ export type { PrTypeLabelSet } from "../types/manifest-deps-types.js";
  *  assumption (#label-modularity): a self-hoster's `typeLabels` fully replaces the category set these
  *  keys are drawn from. The built-in categories are mutually exclusive by default (see
  *  `resolvePrTypeLabel`'s `removeLabels`) unless a propagation mapping is explicitly additive. */
+/** The built-in PRIORITY label, named on its own so it reads as `string`. `PrTypeLabelSet` is an open
+ *  `Record`, which makes `DEFAULT_TYPE_LABELS.priority` optional to the type system even though the
+ *  built-in set always defines it -- naming the value is what lets `resolvePriorityTypeLabel` return it
+ *  without a fallback branch nothing can ever take. */
+export const DEFAULT_PRIORITY_LABEL = "gittensor:priority";
+
 export const DEFAULT_TYPE_LABELS: PrTypeLabelSet = {
   bug: "gittensor:bug",
   feature: "gittensor:feature",
-  priority: "gittensor:priority",
+  priority: DEFAULT_PRIORITY_LABEL,
 };
 
 export const MAX_TYPE_LABEL_CATEGORIES = 32;
@@ -153,9 +159,7 @@ export type PrTypeLabelDecision = {
 export function resolvePriorityTypeLabel(labels: PrTypeLabelSet | null | undefined): string {
   const configured = labels?.priority;
   if (typeof configured === "string" && configured.trim().length > 0) return configured;
-  /* v8 ignore next -- noUncheckedIndexedAccess: PrTypeLabelSet is a Record<string, string>, so this reads
-     as possibly-undefined to the type system though the built-in set always defines `priority`. */
-  return DEFAULT_TYPE_LABELS.priority ?? "gittensor:priority";
+  return DEFAULT_PRIORITY_LABEL;
 }
 
 export function resolvePrTypeLabel(input: {

src/queue/processors.ts

@@ -3479,10 +3479,10 @@ async function runAgentMaintenancePlanAndExecute(
     windowMinutes: settings.priorityEligibilityWindowMinutes ?? DEFAULT_PRIORITY_ELIGIBILITY_WINDOW_MINUTES,
     priorityLabel: resolvePriorityTypeLabel(settings.typeLabels),
     token: ciToken,
-    /* v8 ignore next -- defensive: resolvePriorityEligibilityHold catches its own GitHub read, so it has no
-       reject path today. The guard stays so a future edit inside it degrades to "no hold" rather than
-       failing the whole maintenance pass -- which is the fail-open posture the rest of this rule has. */
-  }).catch(() => undefined);
+    // No `.catch` here on purpose: resolvePriorityEligibilityHold catches its own GitHub read and returns
+    // undefined, so it has no reject path. A guard for one that cannot happen is unreachable code that
+    // reads as tested-and-fine while never running.
+  });
   const unlinkedIssueMatchClose = unlinkedIssueMatchDisposition?.kind === "close" ? unlinkedIssueMatchDisposition : undefined;
 
   // Contributor blacklist (#1425): resolve whether the PR author is on the repo's blacklist (the shared/global

test/unit/queue-3.test.ts

@@ -2502,6 +2502,53 @@ describe("queue processors", () => {
       await upsertPullRequestFromGitHub(env, "owner/repo", { number: prNumber, title: "Migration PR", state: "open", user: { login: "contributor" }, head: { sha: "sha1" }, base: { ref: "main" }, labels: [], body: "" });
     }
 
+    it("holds a would-otherwise-merge PR while its linked priority issue is still inside the eligibility window (#9738)", async () => {
+      // The end-to-end shape of the rule: a clean, approved, green PR that would MERGE is held instead,
+      // because the priority issue it closes only became public minutes ago. Held, never closed -- the PR
+      // is early, not wrong.
+      const env = createTestEnv({ GITHUB_APP_PRIVATE_KEY: await generatePrivateKeyPem() });
+      await seedMigrationRecheckRepo(env, 61);
+      await upsertPullRequestFromGitHub(env, "owner/repo", {
+        number: 61,
+        title: "Fix the thing",
+        state: "open",
+        user: { login: "contributor" },
+        head: { sha: "sha1" },
+        base: { ref: "main" },
+        labels: [],
+        body: "Closes #7",
+        created_at: new Date(Date.now() - 60_000).toISOString(),
+      } as never);
+      const seen = { closed: false, merged: false, labels: [] as string[], comments: [] as string[], treeCalls: 0 };
+      stubMigrationRecheckFetch(61, { filename: "src/a.ts", status: "modified" }, [], seen);
+      // The one extra fact the rule needs: the priority label landed on issue #7 a minute ago, so the
+      // 30-minute window has not elapsed.
+      const inner = globalThis.fetch as typeof fetch;
+      vi.stubGlobal("fetch", async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        if (url === "https://api.github.com/graphql" && String(init?.body ?? "").includes("LABELED_EVENT")) {
+          return Response.json({
+            data: {
+              repository: {
+                issue: {
+                  timelineItems: {
+                    nodes: [{ createdAt: new Date(Date.now() - 60_000).toISOString(), label: { name: "gittensor:priority" } }],
+                  },
+                },
+              },
+            },
+          });
+        }
+        return inner(input as never, init as never);
+      });
+
+      await processJob(env, { type: "agent-regate-pr", deliveryId: "priority-eligibility-hold", repoFullName: "owner/repo", prNumber: 61, installationId: 123 });
+
+      expect(seen.merged, "an unelapsed window must stop the auto-merge").toBe(false);
+      expect(seen.closed, "a hold is never a close -- the contributor keeps their work").toBe(false);
+      expect(seen.comments.some((c) => c.includes("continues normally")), "the comment reads as a wait, not a rejection").toBe(true);
+    });
+
     it("holds a would-otherwise-merge PR when the live base has a colliding migration number, with the distinct label + rebase comment", async () => {
       const env = createTestEnv({ GITHUB_APP_PRIVATE_KEY: await generatePrivateKeyPem() });
       await seedMigrationRecheckRepo(env, 60, { premergeContentRecheck: true });