Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

Keep linked contributor PRs open while awaiting assignment (#5048)

nate nowack53b14e4a6e35
diff --git a/.claude/skills/review-issue/SKILL.md b/.claude/skills/review-issue/SKILL.md
index 384aa137c..571eff495 100644
--- a/.claude/skills/review-issue/SKILL.md
+++ b/.claude/skills/review-issue/SKILL.md
@@ -5,25 +5,27 @@ description: Review an incoming external issue (and any gated-closed PR behind i
# Triaging contributions under the issue-link gate
-FastMCP auto-closes external PRs unless the author is **assigned to a referenced issue**
-(see [require-issue-link.yml](../../../.github/workflows/require-issue-link.yml)). The practical
-effect: contributors open an issue, open a PR, get auto-closed, and ask to be assigned. The
-maintainer almost never sees the PR directly β€” **the issue is the decision point**, and
-**assigning the author is the single action that reopens their PR** and sends it into review.
+FastMCP gates external PRs on a valid issue link and **assignment to a referenced issue**
+(see [require-issue-link.yml](../../../.github/workflows/require-issue-link.yml)). Linked PRs
+stay open with a failing check while maintainers decide on assignment. PRs without a valid
+issue link are closed. **The issue is the decision point**: assignment re-runs the check
+and reopens previously gate-closed PRs. Inspect both open and closed contributions.
This skill turns "look at this issue" into one of two outcomes:
- **Assign** β€” the issue is valid, we want it fixed, an external PR is appropriate, and a sound
- PR already exists β†’ assign the author (auto-reopens the PR) and queue it for code review.
-- **Decline** β€” leave the issue/PR closed and explain why on the issue.
+ PR already exists β†’ assign the author, clear the gate, and queue it for code review.
+- **Decline** β€” recommend closing an open contribution or leaving a closed one closed,
+ and explain why on the issue once authorized.
-Be opinionated about declining. The gate moved spam from junk PRs to junk issues; this skill is
-worthless if it just rubber-stamps assignment. Assignment is a commitment to review and likely
-merge, not a courtesy.
+Assignment is a commitment to review, not a promise to merge. Evaluate the contribution and
+the contributor with goodwill. An automatic gate closure is administrative, not a rejection
+on the merits; it must not raise the bar for an otherwise sound contribution.
## How the gate works (the part that matters here)
-- External PR is closed unless its body has `Fixes/Closes/Resolves #N` **and** the author is
- assigned to issue `#N`.
+- External PRs need `Fixes/Closes/Resolves #N` and assignment to that issue. Missing links
+ cause closure; missing assignment alone leaves the PR open with a failing check. Issues
+ marked `prs welcome` waive assignment, but still require the link.
- **Assigning the author to the issue auto-reopens their closed PR** and re-runs the check β€”
this is the lever you pull. `gh issue edit N --add-assignee <login>`. The assignment fires a
`require-issue-link` run; expect it to pass. If it fails, the gate itself misbehaved (not the
@@ -56,6 +58,26 @@ gh pr view <pr> --repo PrefectHQ/fastmcp --json number,title,body,labels,files,a
gh pr view <pr> --repo PrefectHQ/fastmcp --comments
```
+### Check the contributor before assignment
+
+Make a brief public-account check before assigning an unfamiliar contributor. Look at account
+age, a sample of contributions elsewhere, and how they respond to review. Merged fixes and
+substantive exchanges with maintainers are useful evidence of follow-through. GitHub's `User`
+account type does not establish that a human operates the account.
+
+```bash
+gh api users/<login>
+gh search prs --author <login> --limit 20 --sort created --order desc \
+ --json repository,title,state,createdAt,url
+```
+
+Avoid assigning obvious spam or unattended bot accounts: look for concrete patterns such as
+mass unrelated boilerplate, repeated nonresponsive replies, or explicit unattended automation.
+A new account, sparse profile, low follower count, or disclosed AI assistance alone is not a
+reason to decline. Do not demand identity proof or infer legitimacy from profile claims alone.
+When evidence is limited, say so and lean toward goodwill for a sound, scoped contribution;
+bring a material concern to the maintainer before assigning.
+
## Step 2 β€” Classify the issue (is it valid AND a real bug?)
- Is there a real, reproducible problem? For bugs, demand an MRE that shows FastMCP misbehaving
@@ -132,8 +154,9 @@ says we close those β€” a closed PR that reads that way is staying closed.
## Step 5 β€” Recommend, then act
Present a short verdict to the maintainer before mutating anything: **assign** or **decline**,
-one or two sentences of reasoning, and the exact command you'll run. Wait for confirmation on
-borderline calls; for clear-cut ones you may proceed and report.
+one or two sentences of reasoning, and the exact command you'll run. Act within the maintainer's
+existing authorization; do not ask again for an action already approved. Bring borderline
+calls back to the maintainer, and obtain approval for public actions not yet authorized.
**Assign** (valid issue + appropriate external contribution + sound PR exists):
@@ -141,15 +164,20 @@ borderline calls; for clear-cut ones you may proceed and report.
gh issue edit N --repo PrefectHQ/fastmcp --add-assignee <login>
```
-That reopens the PR automatically. Then hand off to code review β€” invoke the `code-review` /
+Verify that the assignment workflow clears the check and reopens the PR if it was closed.
+If it does not, inspect the run and the PR timeline. When reopening is authorized and the gate caused the closure, reopen the
+existing PR; do not override a substantive maintainer closure. A manual reopen applies the
+workflow's sticky bypass, so prefer the normal assignment path and do not manipulate labels.
+
+Then hand off to code review β€” invoke the `code-review` /
`review-pr` skills on the reopened PR. Assignment is not approval; the code still gets the normal
pass.
If a PR's head branch was deleted, assignment can't reopen it β€” the workflow comments asking the
author to open a fresh PR. Don't try to force it.
-**Decline** (invalid issue, wrong contribution type, or low-quality PR): leave it closed and
-comment on the **issue** explaining the decision, pointing to the relevant CONTRIBUTING.md
+**Decline** (invalid issue, wrong contribution type, or low-quality PR): with authorization,
+close the open contribution or leave it closed and comment on the **issue** explaining the decision, pointing to the relevant CONTRIBUTING.md
section. Per repo rules, use `--body-file`, never inline `--body`, for any comment that could
contain `$`, backticks, or code:
@@ -162,7 +190,7 @@ skill is available for maintainer voice/tone, use it β€” but it isn't required.)
## What this skill does NOT do
-- It doesn't bypass the gate via `trusted-contributor` / `bypass-issue-check` β€” that's a
- deliberate maintainer escalation, not a triage outcome.
+- It doesn't grant blanket trust via `trusted-contributor` or manually apply bypass labels.
+ An explicitly authorized reopen of a gate-closed PR is scoped to that PR.
- It doesn't merge. Assignment β†’ reopen β†’ review β†’ (maybe) merge are distinct steps.
- It doesn't re-run the first-pass triage the bots already did; read their output instead.
diff --git a/.github/scripts/test-issue-link.mjs b/.github/scripts/test-issue-link.mjs
new file mode 100644
index 000000000..889543449
--- /dev/null
+++ b/.github/scripts/test-issue-link.mjs
@@ -0,0 +1,218 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+// Execute the workflow's actual scripts against a fake GitHub API. Run after
+// uv sync: node --test .github/scripts/test-issue-link.mjs
+const repoRoot = fileURLToPath(new URL("../../", import.meta.url));
+const scripts = JSON.parse(
+ execFileSync(
+ "uv",
+ [
+ "run",
+ "--no-sync",
+ "python",
+ "-c",
+ `
+import json
+from pathlib import Path
+import yaml
+workflow = yaml.safe_load(Path('.github/workflows/require-issue-link.yml').read_text())
+print(json.dumps({name: job['steps'][0]['with']['script'] for name, job in workflow['jobs'].items()}))
+`,
+ ],
+ { cwd: repoRoot, encoding: "utf8" },
+ ),
+);
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+async function run(job, options = {}) {
+ const calls = [];
+ const failures = [];
+ const pr = {
+ number: 100,
+ user: { login: "contributor" },
+ body: options.body ?? "Fixes #42",
+ state: options.state ?? "open",
+ labels: options.gated ? [{ name: "missing-issue-link" }] : [],
+ head: { sha: "head" },
+ };
+ const context = {
+ repo: { owner: "PrefectHQ", repo: "fastmcp" },
+ payload: {
+ pull_request: pr,
+ action: "opened",
+ sender: { login: "contributor" },
+ issue: { number: 42 },
+ assignee: { login: "contributor" },
+ },
+ };
+ const record = (name) => async (args) => {
+ calls.push({ name, args });
+ return { data: {} };
+ };
+ const github = {
+ rest: {
+ repos: {
+ getCollaboratorPermissionLevel: async () => ({
+ data: { permission: options.maintainer ? "write" : "read" },
+ }),
+ },
+ issues: {
+ getLabel: async () => ({ data: {} }),
+ addLabels: record("addLabels"),
+ removeLabel: record("removeLabel"),
+ listLabelsOnIssue: async () => ({ data: [] }),
+ get: async ({ issue_number }) => ({
+ data:
+ issue_number === 42
+ ? {
+ assignees: options.assigned ? [{ login: "contributor" }] : [],
+ labels: options.welcome ? [{ name: "prs welcome" }] : [],
+ }
+ : { ...pr, labels: [{ name: "missing-issue-link" }] },
+ }),
+ listEvents: async () => options.events ?? [],
+ listComments: async () => [],
+ createComment: record("createComment"),
+ updateComment: record("updateComment"),
+ },
+ pulls: { update: record("updatePR"), get: async () => ({ data: pr }) },
+ search: {
+ issuesAndPullRequests: async ({ q }) => {
+ calls.push({ name: "search", args: q });
+ const excluded = q.includes("is:closed") && pr.state === "open";
+ return {
+ data: {
+ total_count: excluded ? 0 : 1,
+ items: excluded ? [] : [{ number: 100 }],
+ },
+ };
+ },
+ },
+ actions: {
+ listWorkflowRuns: async () => ({
+ data: { workflow_runs: [{ id: 7 }] },
+ }),
+ reRunWorkflowFailedJobs: record("rerun"),
+ },
+ },
+ paginate: async (method, args) => method(args),
+ graphql: record("graphql"),
+ };
+ const core = {
+ setFailed: (message) => failures.push(message),
+ warning: () => {},
+ };
+ process.env.ENFORCE_ISSUE_LINK = options.dryRun ? "false" : "true";
+ await new AsyncFunction("github", "context", "core", "console", scripts[job])(
+ github,
+ context,
+ core,
+ { log() {} },
+ );
+ return { calls, failures };
+}
+const check = "check-issue-link";
+const assign = "reopen-on-assignment";
+test("linked PR waits for assignment without closing", async () => {
+ const result = await run(check);
+ assert.equal(result.failures.length, 1);
+ assert(!result.calls.some((c) => c.name === "updatePR"));
+ assert(
+ result.calls
+ .find((c) => c.name === "createComment")
+ .args.body.includes("awaiting maintainer assignment"),
+ );
+});
+
+test("missing issue link closes the PR", async () => {
+ const result = await run(check, { body: "No link" });
+ assert.equal(result.failures.length, 1);
+ assert.equal(
+ result.calls.find((c) => c.name === "updatePR").args.state,
+ "closed",
+ );
+});
+
+for (const options of [
+ { assigned: true },
+ { welcome: true },
+ { maintainer: true },
+]) {
+ test(`eligible PR clears enforcement: ${JSON.stringify(options)}`, async () => {
+ const result = await run(check, options);
+ assert.equal(result.failures.length, 0);
+ assert(result.calls.some((c) => c.name === "removeLabel"));
+ assert(!result.calls.some((c) => c.name === "updatePR"));
+ });
+}
+
+test("assignment rechecks an open PR without reopening it", async () => {
+ const result = await run(assign);
+ assert(result.calls.some((c) => c.name === "rerun"));
+ assert(result.calls.some((c) => c.name === "removeLabel"));
+ assert(!result.calls.some((c) => c.name === "updatePR"));
+});
+
+test("assignment reopens a closed PR and reruns the check", async () => {
+ const result = await run(assign, { state: "closed" });
+ assert.equal(
+ result.calls.find((c) => c.name === "updatePR").args.state,
+ "open",
+ );
+ assert(result.calls.some((c) => c.name === "rerun"));
+});
+
+test("assignment does not change PRs for another issue", async () => {
+ const result = await run(assign, { body: "Fixes #99" });
+ assert(
+ !result.calls.some((c) =>
+ ["updatePR", "rerun", "removeLabel"].includes(c.name),
+ ),
+ );
+});
+
+const botClosure = { event: "closed", actor: { login: "github-actions[bot]" } };
+
+test("adding a link reopens a gate-closed PR but keeps assignment required", async () => {
+ const result = await run(check, {
+ state: "closed",
+ gated: true,
+ events: [botClosure],
+ });
+ assert.equal(
+ result.calls.find((c) => c.name === "updatePR")?.args.state,
+ "open",
+ );
+ assert.equal(result.failures.length, 1);
+ assert(!result.calls.some((c) => c.name === "removeLabel"));
+});
+
+test("a later maintainer closure takes precedence over an earlier gate closure", async () => {
+ const result = await run(check, {
+ state: "closed",
+ gated: true,
+ events: [botClosure, { event: "closed", actor: { login: "maintainer" } }],
+ });
+ assert(!result.calls.some((c) => c.name === "updatePR"));
+ assert.equal(result.failures.length, 1);
+});
+
+test("a closed PR without the gate label is not reopened", async () => {
+ const result = await run(check, { state: "closed", events: [botClosure] });
+ assert(!result.calls.some((c) => c.name === "updatePR"));
+});
+
+for (const job of [check, assign]) {
+ test(`dry run does not mutate GitHub: ${job}`, async () => {
+ const result = await run(job, {
+ dryRun: true,
+ state: "closed",
+ gated: true,
+ events: [botClosure],
+ });
+ assert.equal(result.failures.length, 0);
+ assert(!result.calls.some((c) => c.name !== "search"));
+ });
+}
diff --git a/.github/workflows/require-issue-link.yml b/.github/workflows/require-issue-link.yml
index fda27b36a..6e30f428d 100644
--- a/.github/workflows/require-issue-link.yml
+++ b/.github/workflows/require-issue-link.yml
@@ -3,9 +3,9 @@
# unless the referenced issue is labeled "prs welcome", which waives the
# assignment requirement for everyone (the link itself is still required,
# since that's how the check finds the issue to read the label from).
-# Otherwise the PR is labeled "missing-issue-link", commented on, and
-# closed. CONTRIBUTING.md requires external contributors to be assigned to
-# an issue before opening a PR; this enforces that.
+# Missing requirements fail the check and receive a "missing-issue-link"
+# label and explanatory comment. Only PRs without a valid issue link are
+# closed; linked PRs stay open while maintainers decide on assignment.
#
# Adapted from langchain-ai/langchain's require_issue_link.yml. Differences:
# - Self-contained: it does NOT depend on a separate labeler workflow
@@ -21,7 +21,7 @@
# version is split across four, forcing the label/comment/reopen helpers
# to be duplicated per scope).
# - Issue assignment events are handled in this same workflow so assigning
-# the linked issue reopens previously closed PRs automatically.
+# the linked issue clears waiting PRs and reopens previously gated PRs.
#
# Maintainer override: reopen the PR, or remove the "missing-issue-link"
# label β€” either applies a sticky "bypass-issue-check" label and reopens.
@@ -39,8 +39,8 @@ on:
# becomes reviewable.
types: [opened, edited, reopened, ready_for_review, labeled, unlabeled]
issues:
- # Assignment is what makes a previously closed "not assigned" PR compliant,
- # so it needs a separate event path that finds and reopens matching PRs.
+ # Assignment makes waiting PRs compliant, so it needs a separate event
+ # path that clears their checks and reopens previously gated PRs.
types: [assigned]
# Dry run: when 'false' the check still runs and logs its verdict but makes
@@ -302,9 +302,8 @@ jobs:
}
// The author must be assigned to at least one linked issue.
- // CONTRIBUTING.md requires external contributors to be assigned
- // before opening a PR (so maintainers can deconflict / steer
- // approach first).
+ // Linked PRs remain open while maintainers decide on assignment;
+ // the failing check keeps them gated until that decision.
//
// Exception: an issue labeled OPEN_LABEL waives that requirement
// for everyone. It's how maintainers advertise "the reporter
@@ -373,7 +372,7 @@ jobs:
console.log('Linked and assigned β€” clearing any prior enforcement');
await clearEnforcement();
- // ── Label, comment, close, and fail ────────────────────────────
+ // ── Explain missing requirements and fail ────────────────────────────
// `kind`: 'no-link' (no valid issue reference) or 'not-assigned'
// (referenced an issue, but the author isn't assigned to it).
async function enforceFailure(kind) {
@@ -385,20 +384,20 @@ jobs:
"2. Add `Fixes #<issue>`, `Closes #<issue>`, or `Resolves #<issue>` to **this** PR's description β€” edit it in place, don't open a new PR.",
]
: [
- "1. If you opened the linked issue, a maintainer will assign you when they pick it up and this PR reopens automatically. If someone else opened it, the PR reopens only if a maintainer chooses to assign it to you β€” please don't comment to ask.",
+ "1. A maintainer will review the issue and decide whether to assign you. Please don't comment just to request assignment.",
];
const commentBody = [
MARKER,
- '**This pull request was closed because it must link to an issue assigned to you.** ' +
- 'Once this PR links to an issue and a maintainer assigns that issue to you, it will ' +
- 'reopen automatically. Please update this PR rather than opening a new one.',
+ kind === 'no-link'
+ ? '**This pull request was closed because it needs a valid issue link.** Please update this PR rather than opening a new one.'
+ : '**This pull request is awaiting maintainer assignment.** Linked PRs stay open while maintainers triage the issue; this check remains failing until assignment.',
'',
`Per [CONTRIBUTING.md](https://github.com/${owner}/${repo}/blob/main/CONTRIBUTING.md), an external PR must reference an issue that's assigned to its author. To get there:`,
'',
...steps,
'',
- "Once you're assigned and the link is present, this PR reopens automatically β€” no further action needed.",
+ "Once you're assigned and the link is present, this check is re-run automatically. Previously gate-closed PRs also reopen β€” no further action needed.",
'',
`*Maintainers: reopen this PR or remove the \`${LABEL}\` label to bypass this check.*`,
].join('\n');
@@ -420,10 +419,27 @@ jobs:
console.log('Requirement comment already present β€” skipping');
}
- if (pr.state === 'open') {
+ if (kind === 'no-link' && pr.state === 'open') {
await mutate(`close PR #${prNumber}`, () => github.rest.pulls.update({
owner, repo, pull_number: prNumber, state: 'closed',
}));
+ } else if (
+ kind === 'not-assigned' && pr.state === 'closed' &&
+ pr.labels.some(label => label.name === LABEL)
+ ) {
+ // Adding the missing link moves a gate-closed PR back into
+ // the open triage queue. A later human closure takes priority
+ // even if the enforcement label was left on the PR.
+ const events = await github.paginate(
+ github.rest.issues.listEvents,
+ { owner, repo, issue_number: prNumber, per_page: 100 },
+ );
+ const lastClosure = events.filter(event => event.event === 'closed').pop();
+ if (lastClosure?.actor?.login === 'github-actions[bot]') {
+ await mutate(`reopen linked PR #${prNumber} for triage`, () => github.rest.pulls.update({
+ owner, repo, pull_number: prNumber, state: 'open',
+ }));
+ }
}
if (enforce) {
@@ -448,7 +464,7 @@ jobs:
pull-requests: write
steps:
- - name: Reopen linked PRs
+ - name: Clear assigned PRs
uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
with:
script: |
@@ -478,11 +494,11 @@ jobs:
await fn();
}
- console.log(`Issue #${issueNumber} assigned to ${assignee} β€” searching for closed PRs to reopen`);
+ console.log(`Issue #${issueNumber} assigned to ${assignee} β€” searching for gated PRs`);
const q = [
'is:pr',
- 'is:closed',
+ 'is:unmerged',
`author:${assignee}`,
`label:${LABEL}`,
`repo:${owner}/${repo}`,
@@ -496,13 +512,13 @@ jobs:
}));
} catch (e) {
throw new Error(
- `Failed to search closed PRs for ${assignee} after assigning #${issueNumber} ` +
+ `Failed to search gated PRs for ${assignee} after assigning #${issueNumber} ` +
`(HTTP ${e.status ?? 'unknown'}): ${e.message}`,
);
}
if (search.total_count === 0) {
- console.log('No matching closed PRs found');
+ console.log('No matching gated PRs found');
return;
}
@@ -534,9 +550,11 @@ jobs:
}
try {
- await mutate(`reopen PR #${prNumber}`, () => github.rest.pulls.update({
- owner, repo, pull_number: prNumber, state: 'open',
- }));
+ if (issue.state === 'closed') {
+ await mutate(`reopen PR #${prNumber}`, () => github.rest.pulls.update({
+ owner, repo, pull_number: prNumber, state: 'open',
+ }));
+ }
} catch (e) {
if (e.status === 422) {
core.warning(`Cannot reopen PR #${prNumber}: the head branch was likely deleted`);
diff --git a/.github/workflows/run-static.yml b/.github/workflows/run-static.yml
index 98e04ee9a..19332c11c 100644
--- a/.github/workflows/run-static.yml
+++ b/.github/workflows/run-static.yml
@@ -14,6 +14,7 @@ on:
- "pyproject.toml"
- "uv.lock"
- ".github/workflows/**"
+ - ".github/scripts/test-issue-link.mjs"
# run on all pull requests because these checks are required and will block merges otherwise
pull_request:
@@ -36,6 +37,9 @@ jobs:
with:
resolution: locked
+ - name: Test issue-link workflow
+ run: node --test .github/scripts/test-issue-link.mjs
+
- name: Run prek
uses: j178/[email protected]
env:
diff --git a/CLAUDE.md b/CLAUDE.md
index a1b9f9f4e..d305de077 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -58,6 +58,8 @@ When modifying MCP functionality, changes typically need to be applied across al
**Review closed contributor PRs.** When reviewing an issue, inspect every associated non-maintainer PR, including closed PRs. External PRs may be closed as part of the issue-link and assignment workflow, so closure alone is not a negative signal. Read `CONTRIBUTING.md` and the PR timeline and comments to understand its status before evaluating it.
+**Check unfamiliar contributors before assignment.** Follow `.claude/skills/review-issue/SKILL.md` for a brief public-history check. Avoid obvious spam or unattended bot accounts, but lean toward goodwill: account age, sparse profiles, and AI assistance alone are not reasons to reject a sound contribution.
+
### Git & CI
- Prek hooks are required (run automatically on commits)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 745bab294..51cef380c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -44,7 +44,7 @@ An open issue is not an invitation to submit a PR, and it is not a queue you joi
If you do open a PR:
-- **Reference an issue you're assigned to.** Every PR must reference a tracked issue using an auto-close keyword (`Fixes #123`, `Closes #123`, or `Resolves #123`), and the referenced issue must be assigned to you β€” unless it's labeled `prs welcome`, which waives the assignment requirement. If there isn't an issue, open one. This lets us deconflict effort and steer the approach before you invest time in code. External PRs that don't meet these conditions are automatically labeled `missing-issue-link` and closed; they reopen automatically once the link is present and you're assigned.
+- **Reference a tracked issue.** Every PR must reference an issue using an auto-close keyword (`Fixes #123`, `Closes #123`, or `Resolves #123`). You may open a linked PR before assignment, but the issue-link check passes only once a maintainer assigns you to the issue β€” unless it's labeled `prs welcome`, which waives the assignment requirement. If there isn't an issue, open one. This lets us deconflict effort and steer the approach before you invest time in code. External PRs that don't meet these conditions receive a failing check and the `missing-issue-link` label. PRs without a valid issue link are closed; linked PRs remain open while maintainers decide on assignment. Assignment automatically re-runs the check and reopens previously gate-closed PRs.
- **Leave "Allow edits by maintainers" enabled.** We frequently take a PR the last few steps ourselves rather than block on another round trip β€” tightening a test, adjusting naming, rebasing. It's enabled by default on PRs from personal forks; leave it that way. GitHub doesn't allow it at all for forks owned by an organization, so if you're contributing from one, expect us to land the final changes separately.
- **Target the right branch.** Open against `main` unless you're fixing something specific to a maintenance line, in which case target that branch directly (`release/3.x`, `release/2.x`).
- **If your PR was auto-closed, don't open a new one.** Edit the *existing* PR to add the issue link, get assigned to that issue, and it reopens on its own β€” the branch and history are preserved. A duplicate PR just starts you over and adds to the triage pile.