Release v2.0.0: merge v2/main into main

.changeset/config.json

@@ -2,7 +2,10 @@
   "$schema": "https://unpkg.com/@changesets/config@4.0.1/schema.json",
   "changelog": [
     "@changesets/changelog-github",
-    { "repo": "modelcontextprotocol/servers" }
+    {
+      "repo": "modelcontextprotocol/servers",
+      "template": "\n\n- {pull} {commit} {authors} - {summary}"
+    }
   ],
   "commit": false,
   "fixed": [],

.claude/skills/board-ops/SKILL.md

@@ -429,13 +429,17 @@ if [ -s "$BOARD_TMP/lost-ids.json" ]; then
     gh project item-edit --project-id PVT_kwDOCt2Azc4BcZgq --id "$id" \
       --field-id PVTSSF_lADOCt2Azc4BcZgqzhXCpm0 --single-select-option-id <NEW_OPTION_ID> \
       || { echo "item-edit failed on $id — stopping; re-run step 1 to see what is left" >&2; break; }
-    sleep 0.4
+    sleep 8   # a sustained loop: see AGENTS.md "Pacing GitHub writes"
   done
 else
   echo "no lost-ids.json — step 1 did not complete; nothing re-applied" >&2
 fi
 ```
 
+Step 3 is a sustained loop, so it sleeps 8 s between edits, long enough to stay
+inside every limit in `AGENTS.md` **Pacing GitHub writes** for as long as it
+runs: a restore of 250 cards takes about 35 minutes.
+
 Step 1's join is the safety check: only a card that held the deleted option in
 the snapshot is re-applied, so you don't overwrite a card that was already blank
 or that someone legitimately cleared in the meantime. Read its "NOT restored"

.claude/skills/client-smoke/SKILL.md

@@ -172,27 +172,27 @@ CLI) or **Server Settings → Protocol Era** (the web UI):
 | `modern` | Pins 2026-07-28 through `server/discover`, with no fallback |
 | `auto` | Probes `server/discover`, and falls back to `initialize` |
 
-⚠️ **Only the legacy era can be exercised against these servers today.** All
-seven are on a v1 SDK (`@modelcontextprotocol/sdk` 1.x, `mcp` 1.x), whose
-newest protocol version is 2025-11-25. None implements `server/discover`. So:
-
-- `--protocol-era modern` fails, by design, with `Version negotiation failed:
-  the server did not offer pinned protocol version 2026-07-28 via
-  server/discover (no fallback in pin mode)` and exit 1. That is the expected
-  result for an unmigrated server, not a regression in your change.
-- `--protocol-era auto` succeeds, but through the fallback, so it is a legacy
-  connection and proves nothing about 2026-07-28.
-
-The both-eras check that `/pr-flow` asks for (#4857) therefore has one half
-that can pass today. For a server that does not yet serve the modern era,
-record the legacy run, and say in the PR that the server does not yet speak
-2026-07-28 rather than leaving the modern era unmentioned. Moving a server to
-a v2 SDK (#4856 for TypeScript, #4851 for Python) does not change that by
-itself: those keep the legacy wire behavior. Modern-era support arrives with
-#4852 (TypeScript) and #4853 (Python). Once a server has it, run every command
-twice, with `--protocol-era legacy` and `--protocol-era modern`, and expect
-both to succeed. Do not use `auto` for evidence in either case: it
-does not say which era answered.
+**Every server serves both eras**: the Python servers since #4853, the
+TypeScript servers since #4852 (stdio through the SDK's `serveStdio`, and
+`everything`'s Streamable HTTP endpoint through `createMcpHandler` for
+2026-07-28 requests). Run every command twice, with `--protocol-era legacy`
+and `--protocol-era modern`, and expect both to succeed. A 2026-07-28 result
+carries `io.modelcontextprotocol/serverInfo` in its `_meta`, which is the
+quick way to see which era answered. Do not use `auto` for evidence: it does
+not say which era answered.
+
+`everything` lists some tools on one era only (the task tools on 2026-07-28,
+the two `toggle-*` tools on the 2025 era), so a `tools/list` that differs
+between the two runs is expected.
+
+The CLI declares no client capabilities, so a tool that asks the client for
+input (elicitation, sampling, roots) cannot run from it: on the 2025 era
+`everything` does not list it (`tool_not_found`, exit 5), and on 2026-07-28
+the SDK refuses the call because the request did not declare the capability
+(`Cannot request input 'form' (elicitation/create): the request's client
+capabilities do not declare the required capability`, exit 1). Drive those
+from the web UI. On 2026-07-28 the CLI does follow a task handle: a call to
+`simulate-research-query` polls the task and prints its final result.
 
 ## The Inspector web UI
 
@@ -259,8 +259,10 @@ Claude Code, run this way, has no era switch and does not print the protocol
 version it negotiated. `/pr-flow` asks for the LLM client in both eras as well;
 where the client gives no way to choose, record the client and its version and
 say that the era could not be selected, rather than labelling the run with an
-era it was not shown to use. Against a v1-SDK server the connection is legacy
-whatever the client prefers, for the reason given under Protocol eras.
+era it was not shown to use. `everything` shows which era a client
+negotiated through its tool list: a 2026-07-28 client sees
+`simulate-research-query` and no `toggle-*` tools, a 2025-era client the
+reverse. Claude Code 2.1.296 negotiates 2026-07-28 against these servers.
 
 ## What to write down
 

.claude/skills/issue-triage/SKILL.md

@@ -42,9 +42,9 @@ reporter is notified of each one. So:
   manifest** that lists each item, its class, and the issue it will point at.
   A wrong class is cheap to fix in a file and expensive to fix after a
   notification went out. Closing a single item the maintainer named is fine.
-- **Pace every write loop**: a few seconds between calls, and **stop on the
-  first failed call** rather than carrying on blind. GitHub's secondary rate
-  limit on content creation trips well before its primary one, and a loop that
+- **Pace every write loop** by `AGENTS.md` **Pacing GitHub writes**, and
+  **stop on the first failed call** rather than carrying on blind. GitHub's
+  secondary rate limit trips well before its primary one, and a loop that
   keeps going after a 403 leaves a half-applied batch nobody can see.
 - **Never restate a vulnerability in public**, not even to summarize a report
   that was already filed publicly. See [Security reports](#security-reports).
@@ -86,14 +86,22 @@ D=${D:-$(mktemp -d)}
 # Copy the class's response from Canned responses into "$D/response.md" (the
 # text inside the quote, with #ORIGINAL or the SDK link filled in) first.
 # Close as not planned, with that response (body in a file, so quoting is
-# safe). NOT for a duplicate: post the Duplicate response with `gh issue
-# comment`, close it with the `board-ops` state_reason=duplicate call, and
-# delete its card if it has one (`board-ops`, Delete a card). An empty or missing response stops here instead of closing silently.
+# safe). The comment and the close are two writes (`gh issue close --comment`
+# sends them back to back), and a run closes several issues, so every write
+# here is followed by the PR-close loop's `sleep 8`, including the last one
+# before the next issue. NOT for a duplicate: post the Duplicate response with
+# `gh issue comment`, close it with the `board-ops` state_reason=duplicate
+# call, and delete its card if it has one (`board-ops`, Delete a card), with
+# the same `sleep 8` after each of those three writes. An empty or missing
+# response stops here instead of closing silently.
 BODY=$(cat "$D/response.md") && [ -n "$BODY" ] \
-  && gh issue close <N> --repo modelcontextprotocol/servers --reason "not planned" --comment "$BODY" \
-  || { echo "no response or close failed for #<N> — stop and check it" >&2; false; }
+  && gh issue comment <N> --repo modelcontextprotocol/servers --body "$BODY" \
+  && sleep 8 \
+  && gh issue close <N> --repo modelcontextprotocol/servers --reason "not planned" \
+  && sleep 8 \
+  || { echo "no response, or the comment or close failed for #<N> — look before retrying" >&2; false; }
 # Spam or empty, the one class with no response:
-gh issue close <N> --repo modelcontextprotocol/servers --reason "not planned"
+gh issue close <N> --repo modelcontextprotocol/servers --reason "not planned" && sleep 8
 ```
 
 ## Pass 1 — sweep onto the board (no approval implied)
@@ -447,13 +455,22 @@ while IFS=$'\t' read -r PR CLASS ISSUE _; do
   if [ -n "$SWEEP_LABEL" ]; then
     gh pr edit "$PR" --repo modelcontextprotocol/servers --add-label "$SWEEP_LABEL" </dev/null \
       || { echo "label FAILED on #$PR — stopping" >&2; break; }
+    sleep 8
   fi
-  gh pr close "$PR" --repo modelcontextprotocol/servers --comment "$BODY" </dev/null \
-    || { echo "close FAILED on #$PR — stopping; re-snapshot to see what is left" >&2; break; }
-  sleep 5
+  # Comment and close as two writes, so each is paced: `gh pr close --comment`
+  # sends both back to back.
+  gh pr comment "$PR" --repo modelcontextprotocol/servers --body "$BODY" </dev/null \
+    || { echo "comment FAILED on #$PR — stopping; look before retrying, it may have landed" >&2; break; }
+  sleep 8
+  gh pr close "$PR" --repo modelcontextprotocol/servers </dev/null \
+    || { echo "close FAILED on #$PR (its comment is posted; close it, do not re-comment) — stopping" >&2; break; }
+  sleep 8
 done < "$D/manifest.tsv"
 ```
 
+Each `sleep 8` paces a sustained loop, long enough to stay inside every limit
+in `AGENTS.md` **Pacing GitHub writes** for as long as the batch runs.
+
 The step 0 issue closes take the same two sweep additions during the backlog
 sweep: the close label (`gh issue edit <N> --add-label`) and the `#4875`
 sentence at the end of the response, in the original comment rather than a

.claude/skills/local-dev/SKILL.md

@@ -14,7 +14,8 @@ Driving a running server with a client is `/client-smoke`; tests are
 
 ## Install and build
 
-Node 22 for the TypeScript servers, and `uv` for the Python ones.
+Node 24 (the development version, and the oldest supported) for the
+TypeScript servers, and `uv` for the Python ones.
 
 ```sh
 npm install        # at the repo root: all four TypeScript workspaces

.claude/skills/pr-flow/SKILL.md

@@ -39,13 +39,40 @@ gh issue edit <N> --repo modelcontextprotocol/servers --add-assignee @me
 
 ## 2. Branch
 
-`v2/<type>/<N>-<slug>`, cut from **`origin/v2/main`**:
+`v2/<type>/<N>-<slug>`, cut from **`origin/v2/main`** into a **new git
+worktree**, never by switching branches in the primary checkout. Several agent
+sessions work this repo on one machine at once and share the primary checkout:
+a `git switch` there moves the branch out from under every other session using
+it, and carries one task's uncommitted edits, `dist/` output and
+`node_modules` into another's. A worktree per issue gives each task its own
+tree and leaves the primary checkout alone.
+
+Run it from the primary checkout. The worktree is a **sibling** directory named
+for the checkout plus the issue number (`servers` → `../servers-4810`), never a
+directory inside the repo, where every format, lint and typecheck scope would
+see a second copy of the source:
 
 ```sh
 git fetch origin v2/main
-git switch -c v2/fix/4810-filesystem-symlink-escape origin/v2/main
+git worktree add --no-track "../$(basename "$PWD")-4810" \
+  -b v2/fix/4810-filesystem-symlink-escape origin/v2/main
+cd "../$(basename "$PWD")-4810"
+npm install
 ```
 
+- `--no-track` keeps the new branch from tracking `origin/v2/main`, so
+  `git status` does not report your work as "ahead of v2/main", and the first
+  push is an explicit `git push -u origin <branch>` to a branch of its own name.
+- ⚠️ **The `npm install` is part of the step.** A worktree starts with no
+  `node_modules`, no `dist/` and no `.venv` (`/local-dev`). The root install
+  builds every TypeScript server; a Python server builds its `.venv` on its
+  first `uv run`. Background the install if you have edits to make first; the
+  gate needs it finished.
+- Every later step (edits, the gate, commits, the push) runs **inside the
+  worktree**.
+- The harness's `EnterWorktree` tool, where available, does the same; name the
+  branch by the rule above.
+
 `<type>` follows the issue's type label: `bug` → `fix`, `enhancement` → `feat`,
 `documentation` → `docs`, `chore` → `chore`. A `question` has no branch type,
 because answering one ships nothing: if it turns out to need a change, relabel
@@ -56,10 +83,11 @@ branch and keeps the work legible in `git branch -a` next to `main`.
 history, so the PR diff would show unrelated changes.
 
 **Stacking.** When one issue's work depends on another PR that has not merged
-yet, branch from that PR's branch and open the PR with `--base` set to it. Say
-in the body that it is stacked and on which PR. When the lower PR merges,
-retarget the stacked one to `v2/main` (`gh pr edit <PR> --base v2/main`) and
-rebase it if GitHub reports conflicts.
+yet, branch from that PR's branch (its worktree is cut from it:
+`git worktree add … -b <child> <parent-branch>`) and open the PR with `--base`
+set to it. Say in the body that it is stacked and on which PR. When the lower
+PR merges, retarget the stacked one to `v2/main`
+(`gh pr edit <PR> --base v2/main`) and rebase it if GitHub reports conflicts.
 
 ## 3. Sign off every commit (DCO)
 
@@ -310,6 +338,9 @@ worth doing on its own. Implementing a suggestion differently is fine.
     -f body='Fixed in <sha>: …'
   ```
 
+  A round with many comments is a bulk write: send the replies one at a time,
+  paced by `AGENTS.md` **Pacing GitHub writes**.
+
 - ⚠️ **Then post a PR-level summary of the round, in addition, never instead.**
   Inline replies go hidden once the fix is pushed, because the threads become
   outdated, so the summary is what keeps the round readable afterwards. It does
@@ -391,3 +422,16 @@ issue will not be done, the issue shipped nothing: close it as not planned and
 **delete its card** (`/board-ops`) rather than moving it to Done.
 
 If PRs were stacked on this one, retarget each to `v2/main` (step 2).
+
+**Then remove the worktree and its local branch**, from the primary checkout,
+once the PR shows as merged (or closed, for abandoned work). A stale worktree
+keeps its branch checked out, so git refuses to check that branch out anywhere
+else, and it holds a full `node_modules` on disk per issue:
+
+```sh
+git worktree remove "../$(basename "$PWD")-<N>"
+git branch -D v2/<type>/<N>-<slug>
+```
+
+`git worktree remove` refuses a worktree with uncommitted or untracked changes;
+read what is there before reaching for `--force`.

.claude/skills/pre-push-gate/SKILL.md

@@ -273,6 +273,31 @@ of the server's stderr. Re-run a subset with
 - **A new server fails `test:scripts`** with "every server directory in the
   repo has a smoke entry": add it to `SERVERS` in `scripts/smoke-servers.mjs`.
 
+### `interface-diff`
+
+The last stage diffs the `everything` server's MCP interface (capabilities,
+tools, prompts, resources, resource templates) in this checkout's build
+against the same server built from the merge-base with `origin/v2/main`, and
+prints the report. **A changed interface does not fail it**: the report is
+what the PR's sticky comment will show, so read it, and if a change is not
+one you meant, that is the finding. It fails only when the diff cannot run,
+with `❌ The interface diff could not run` and the reason:
+
+- **"origin/v2/main is not available"**: `git fetch origin v2/main`.
+- **"src/everything/dist/index.js does not exist"**: you ran it on its own
+  before building: `npm run build -w src/everything`.
+- **An `npm ci` or `npm run build` failure**: the _base_ did not install or
+  build. Offline with a cold npm cache is the usual cause; otherwise name a
+  base that builds with `npm run interface-diff -- --base <ref>`.
+- **"Base server probe failed" / "Target probe failed"**: a server did not
+  answer the probe. A target failure is this checkout's server and is the
+  real defect; the smoke stage before it usually fails first.
+
+Re-run it on its own with `npm run interface-diff` (about ten seconds). What
+it compares against in CI, and why it is a script rather than an action, is
+in [`docs/quality-gate.md`](../../../docs/quality-gate.md) and the header of
+`scripts/interface-diff.mjs`.
+
 ## Waiting on the lease
 
 A gate that starts with