mcplane 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## 0.5.0
+
+New command
+- `mcplane demo` (experimental): records the developer-mode demo video ChatGPT's review asks for, from your positive tests, by driving the ChatGPT desktop app on a Mac. It asks before sending any prompt, hides the sidebar, and writes the video to `.mcplane/packs/chatgpt/demo.mp4`. It finds its way by ChatGPT's button labels, so a ChatGPT release can break it.
+
+New stores and checks
+- Vercel Connect: preflight against its Required, Recommended and Optional tiers, from your discovery documents alone; `pack vercel-connect`; its directory in `listings`; drift rules. Manifests without `stores` now get these checks too, so an OAuth server with a Required gap exits 1 where it didn't before.
+- Readiness for MCP 2026-07-28, in its own preflight section and never blocking: `server/discover`, `initialize` negotiated down, the `Mcp-Method` and `Mcp-Name` headers and CORS for them, issuer, CIMD, RFC 9207 `iss`, MCP Events.
+- ARD: preflight reads `/.well-known/ard.json` (and the older `ai-catalog.json`) and validates it against ARD v0.91 and Lighthouse 13.5; `pack ard` writes a manifest both accept.
+- `pack claude-eval`: your review tests as a `claude plugin eval` suite.
+- Sign-in chain: plain GETs from the authorization endpoint to the sign-in page and the identity-provider hosts it loads, flagging bot challenges (`cf-mitigated: challenge`) and 403s. Nothing signs in and no client is registered. `server.signIn` or `--sign-in` names pages to check when the authorization server wants a registered client first.
+- A new check level, `info`: a note that never blocks and isn't counted as something to review. Code that maps levels one by one needs to handle it.
+
+OpenAI's annotation rules
+- No more drafted hint justifications or 200-character warnings: OpenAI no longer asks for them. Any in `mcplane.json` become optional appeal notes.
+- A new warning when a write that overwrites, revokes or deletes says `destructiveHint: false`.
+- A ChatGPT hint change is a note in `drift`, so `drift --ci` no longer fails on it.
+
+ChatGPT plugin ZIP
+- Bundles Agent Skills from `chatgpt.skills`, checking names against folders, description length, front matter and scripts a skill runs but doesn't ship.
+- Checks `plugin.json` and `mcp.json` against the Agent Plugins 1.0.0 JSON Schemas, and the root description against 1,024 characters (`plugin_description_too_long`, also in preflight).
+- Icons can be local files (`icon`, `chatgpt.logo`, `composerIcon`, `logoDark`), and sizes are read from PNG, JPEG, WebP and SVG bytes, in preflight too.
+- Builds behind sign-in without `--token`, and says what it couldn't check; `--tools <file>` takes a saved `tools/list` result.
+- Entries are dated 1980-01-01 and keep Unix modes, so scripts stay executable and the same files give the same ZIP.
+- The 10 KB icon warning is gone: the ZIP takes icons up to 5 MiB, and only developer mode's own upload is capped at 10 KB. An icon over 5 MiB now blocks.

package/README.md

@@ -17,9 +17,10 @@ No terminal handy? Paste your URL at [reviewtimes.fyi/check](https://reviewtimes
 ✗ Every tool has a human-readable title [Claude connectors, Claude plugins]
     search_docs, fetch_page
     Add "title" (or annotations.title) to each tool. Anthropic rejects connectors without them.
-! A small icon is available for ChatGPT's dialogs [ChatGPT]
-    28 KB
-    ChatGPT's icon upload in developer mode caps at 10 KB. Export an 8-bit PNG.
+! Reviewers can reach your sign-in page
+    https://accounts.example.com/sign-in: Cloudflare challenge (cf-mitigated: challenge)
+    A bot challenge or a 403 on the sign-in chain leaves the OAuth window blank for reviewers, who sign
+    in from data-centre networks. Exempt the authorization endpoint, consent page and sign-in hosts …
 ✓ 15 checks passed (--verbose to list them)
 
 2 blocking, 1 to review.
@@ -27,11 +28,11 @@ No terminal handy? Paste your URL at [reviewtimes.fyi/check](https://reviewtimes
 
 ## Why
 
-An MCP server now has a dozen places to be listed: ChatGPT, Claude, Cursor, Grok, Muse, the official MCP Registry, Docker, Smithery and the directories that read from them. Each has its own form, its own rules and its own idea of what an update is. Most rejections are for the same few mechanical things, and each one costs you days in the queue. With one app that's annoying. With seventeen you stop shipping.
+An MCP server now has a dozen places to be listed: ChatGPT, Claude, Cursor, Grok, Muse, Vercel Connect, the official MCP Registry, Docker, Smithery and the directories that read from them. Each has its own form, its own rules and its own idea of what an update is. Most rejections are for the same few mechanical things, and each one costs you days in the queue. With one app that's annoying. With seventeen you stop shipping.
 
 iOS had the same problem in 2014. fastlane fixed it by putting your metadata in the repo, checking it before Apple could reject it, and turning every release into one command. mcplane does that for agent-era stores.
 
-An agent with a browser could fill in a form. It can't tell you that your DNS will make ChatGPT's reviewer time out, that a hint needs a justification you haven't written, or which of your seventeen listings went stale on Tuesday. That's the part mcplane does.
+An agent with a browser could fill in a form. It can't tell you that your DNS will make ChatGPT's reviewer time out, that ChatGPT counts overwriting a page as destructive, or which of your seventeen listings went stale on Tuesday. That's the part mcplane does.
 
 ## Use it from your agent
 
@@ -58,7 +59,7 @@ npx mcplane fleet --root ~/Projects
 ✓ Review Times             preflight clean · listed on mcp-registry, glama, chatgpt
 ✗ Invoice Bot              2 blocking · waiting on claude-connectors · listed on mcp-registry
 ✗ Weather Pro              1 store update needed · listed on mcp-registry, claude-connectors · 1 listing fix
-    chatgpt: Hints changed: send_alert
+    chatgpt: Listing text changed (description)
     claude-connectors: listing doesn't show: forecast_hourly (ask the review team to resync)
 
 3 projects, 2 need attention.
@@ -72,11 +73,12 @@ npx mcplane fleet --root ~/Projects
 |---|---|---|
 | Official MCP Registry | **Publishes**: writes `server.json`, runs `mcp-publisher`, signs in with GitHub OIDC in Actions. Glama and PulseMCP import from it; GitHub's MCP gallery (VS Code) syncs it after a one-time manual onboarding | Versions can't change: bump, or a prerelease like `1.2.0-1` for listing-only edits. mcplane checks what's already published |
 | Grok plugins | **Publishes**: opens the pull request to `xai-org/plugin-marketplace`, validated with xAI's own scripts | Opens a pin-bump PR when xAI's daily bump lags |
-| ChatGPT | **Builds the plugin ZIP** the portal uploads since DevDay: `plugin.json` (Agent Plugins format) with listing, icons, 5+3 tests, demo video, release notes and translations, plus `mcp.json`. Checked against OpenAI's submission rules | Tool changes roll out after OpenAI's scans. Listing changes need a new ZIP and review, and drift says when |
+| ChatGPT | **Builds the plugin ZIP** the portal uploads since DevDay: `plugin.json` (Agent Plugins format) with listing, icons, 5+3 tests, demo video, release notes and translations, plus `mcp.json` and your Agent Skills. Checked against the Agent Plugins 1.0.0 schema and OpenAI's submission rules | Tool changes, hints included, roll out after OpenAI's scans. Listing changes need a new ZIP and review, and drift says when |
 | Claude connectors | **Prepares** every field of the directory form | Tool changes are live on deploy; listing edits (tool names included) are reviewed |
 | Claude plugins | **Prepares** and checks the plugin repo | The portal tracks your branch; drift tells you a new version is waiting for review |
 | Cursor | **Prepares** and checks the plugin repo | Pinned to the commit first added; drift flags when you've moved on |
 | Muse | **Prepares** the form | Flags changes |
+| Vercel Connect | **Checks** your OAuth discovery documents against Vercel's Required, Recommended and Optional tiers, and **prepares** Submit a Service: every field, the OAuth method as Connect will discover it, and the token test each OAuth method needs | Listing edits go back through review (Edit and Resubmit); tools aren't listed, so they can change freely |
 | awesome-remote-mcp-servers | The three-line entry with your Glama connector badge and auth marker, ready for the PR | |
 | Cline, Glama, LobeHub, Smithery, Docker, awesome-mcp-servers | The prefilled issue, `glama.json`, CLI command or entry | |
 | mcp.so, MCP Market, mcpservers.org, cursor.directory | `mcplane pack directories`: one sheet with every value to paste | |
@@ -89,14 +91,66 @@ Checks come from real rejections, most of them ours:
 
 - **Server**: `initialize`, `tools/list` and `ping` work. An OAuth server that initializes without a token also lists its tools without one (the half-way state leaves a new ChatGPT connector stuck on "no actions available"). Unknown methods return `-32601` (OpenAI's tool scan probes `server/discover` and gives up on a crash). The URL works with a trailing slash. CORS preflight answers. Automated clients aren't blocked by a bot filter. A TLS 1.2 client connects. DNS doesn't advertise Encrypted ClientHello, which review proxies reset without a trace in your logs.
 - **OAuth**: unauthenticated calls get `401` with `resource_metadata`. Protected-resource and authorization-server metadata resolve, and PKCE S256 is supported. With `--register`, Dynamic Client Registration is tested, including the `cursor://` and other native redirect schemes that locked out every desktop client for us.
-- **Tools**: every tool has a title and explicit `readOnlyHint`, `destructiveHint` and `openWorldHint`, and the hints are consistent. Tools declare `outputSchema`. Descriptions don't instruct the model. Writes aren't authorised by a token passed through the chat (Anthropic rejected exactly that). Hints follow OpenAI's current definitions: `openWorldHint` for anything that reaches the public internet (read-only web search included), `destructiveHint` for messages that can't be unsent. No catch-all request tools, no tool names over 64 characters, no sensitive inputs, no upgrade or pricing copy.
-- **Listing**: the icon is a square PNG of at least 512px behind a direct link, and `/favicon.ico` resolves. The privacy policy covers collection, retention and user controls. Support is a web page. Name, subtitle, one-liner, description and starter prompts fit each store's limits. Every test case uses tools the live server actually has. The ChatGPT domain challenge is served.
+- **Sign-in chain**: plain GETs, the way a reviewer's browser goes: the authorization endpoint, the sign-in page it sends people to, and the identity-provider hosts that page loads. A bot challenge (`cf-mitigated: challenge`) or a 403 anywhere on it is flagged: every MCP check can pass while reviewers never reach your sign-in page. Nothing signs in and no client is registered, so an authorization server that wants a registered client stops the walk at its error page: name your sign-in pages in `server.signIn` (or `--sign-in <url>`) and they're checked too. A pass from your own network proves less than one from a cloud VM or CI.
+- **Tools**: every tool has a title and explicit `readOnlyHint`, `destructiveHint` and `openWorldHint`, and the hints are consistent. Tools declare `outputSchema`. Descriptions don't instruct the model. Writes aren't authorised by a token passed through the chat (Anthropic rejected exactly that). Hints follow OpenAI's current definitions: `openWorldHint` for public or open-ended destinations (read-only web search included; connectivity alone doesn't decide it), `destructiveHint` for messages that can't be unsent and for overwriting, revoking access or deleting. No catch-all request tools, no tool names over 64 characters, no sensitive inputs, no upgrade or pricing copy.
+- **Listing**: the icon is square and at least 512px behind a direct link (PNG, JPEG, WebP or SVG, measured from the bytes), and `/favicon.ico` resolves. The privacy policy covers collection, retention and user controls. Support is a web page. Name, subtitle, one-liner, description and starter prompts fit each store's limits, including the 1,024 characters the ChatGPT package allows for its root description. Every test case uses tools the live server actually has. The ChatGPT domain challenge is served.
 - **Plugin repo**: public, on GitHub, with `.claude-plugin/plugin.json`, and no root `SKILL.md` shadowing the plugin's skills. Grok plugins come from an organisation.
+- **Vercel Connect**: what its [For Service Providers](https://vercel.com/docs/connect/providers) page asks for, read from your discovery documents alone (nothing is registered). Required items block: metadata served as JSON (at the path-suffixed form when the issuer has a path), `token_endpoint`, `grant_types_supported`, and OAuth and OpenID Connect documents that agree. Recommended items warn: DCR or CIMD so Connect can create the client, a `token_endpoint_auth_methods_supported` it can use, PKCE S256, refresh tokens. Optional ones are notes: protected-resource metadata, `revocation_endpoint`, `scopes_supported`. What needs a real token (`expires_in`, refresh rotation, the `https://connect.vercel.com/callback` redirect) is on the list of things to check yourself.
+- **ARD**: whether your domain publishes an [Agentic Resource Discovery](https://agenticresourcediscovery.org/spec/) manifest at `/.well-known/ard.json`, whether it's valid, whether it lists this server, and whether Lighthouse 13.5 (which still reads the older `/.well-known/ai-catalog.json`) accepts it.
 
-`--json` for machines; exit code 1 when something blocks.
+`--json` for machines; exit code 1 when something blocks. A check at level `info` is a note: it never blocks and isn't counted as something to review.
 
 Preflight also lists what no script can see and that has still cost real submissions. For example: a reviewer account a stranger can actually use (not your Google login, email already confirmed, no 2FA), and a safe target for write tools so reviewers don't post to a real timeline.
 
+## Readiness for MCP 2026-07-28
+
+The [2026-07-28 revision](https://modelcontextprotocol.io/specification/2026-07-28/changelog) drops the `initialize` handshake for per-request metadata and `server/discover`, requires `Mcp-Method` and `Mcp-Name` headers, and deprecates Dynamic Client Registration for Client ID Metadata Documents. Preflight reports how your server meets it in its own section. These checks never block: a warning means a 2026-07-28 client would fail against you today, a note means something deprecated or optional.
+
+```
+Readiness for MCP 2026-07-28 (never blocking)
+  i Speaks MCP 2026-07-28
+      legacy only: server/discover got HTTP 200, JSON-RPC -32601 Method not found: server/discover
+  ! An initialize that offers 2026-07-28 is negotiated down
+      initialize answered with "2026-07-28"
+      2026-07-28 has no initialize handshake, so answering one with it tells the client you speak something you don't. …
+  i CORS allows the Mcp-Method and Mcp-Name headers
+      Access-Control-Allow-Headers: content-type, mcp-protocol-version, mcp-session-id, authorization
+```
+
+- **Era**: a 2026-07-28 `server/discover` gets a `DiscoverResult` (modern), a JSON-RPC error or a 4xx (legacy, and clients that speak both fall back to `initialize`), or a crash (a warning).
+- **Negotiation**: an `initialize` offering `2026-07-28` is answered with a version you implement, not echoed back.
+- **Headers**: requests carrying `Mcp-Method` and `Mcp-Name` work, and your CORS preflight allows them.
+- **Authorization**: the metadata's `issuer` matches the URL it was fetched from (2026-07-28 clients must refuse it otherwise), `client_id_metadata_document_supported`, and RFC 9207 `authorization_response_iss_parameter_supported`.
+- **MCP Events**: whether `events/list` answers. Events is a [draft](https://github.com/modelcontextprotocol/experimental-ext-triggers-events) from the Triggers and Events Working Group, not part of 2026-07-28, so this is only ever a note.
+
+Servers behind sign-in need `--token` for the probes; the authorization checks run from the discovery documents either way.
+
+## ARD manifest
+
+`mcplane pack ard` writes `.mcplane/packs/ard/ard.json`: one entry for your server (`application/mcp-server-card+json`, pointing at your server card when you serve one), with representative queries from your prompts and tests and capabilities from your tool names. It validates against [ARD v0.91](https://agenticresourcediscovery.org/spec/) and against the older schema [Lighthouse 13.5](https://github.com/GoogleChrome/lighthouse/blob/v13.5.0/core/audits/agentic/ard-schema.js) audits. Serve it at `/.well-known/ard.json`, and either at `/.well-known/ai-catalog.json` too or from an `Agentmap:` line in robots.txt, which Lighthouse reads first. ARD is a proposal, so treat it as cheap insurance rather than a requirement.
+
+## Plugin evals
+
+If a Claude Code plugin ships your server, `mcplane pack claude-eval` turns your review tests into a suite for [`claude plugin eval`](https://code.claude.com/docs/en/plugin-evals), which scores the plugin against a no-plugin baseline. Each positive test becomes a case graded on the reply, with the tools it names as indicators; each negative test a case that must not call your server. Tools answer from mocks built from your live `tools/list`, so a run needs no network or sign-in and writes nothing. The plugin and server names come from the plugin repo (or `claudePlugin` in mcplane.json).
+
+Copy `.mcplane/packs/claude-eval/evals/` into the plugin repo, then gate pull requests on it:
+
+```yaml
+# .github/workflows/plugin-eval.yml, in the plugin repo
+on: [pull_request]
+jobs:
+  eval:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm install -g @anthropic-ai/claude-code
+      - run: claude plugin eval . --trust-plugin --json results.json --threshold 0.8 --model claude-sonnet-5 --judge-model claude-haiku-4-5 --no-publish --max-cost-usd 5
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+```
+
+It exits 1 when a case scores under the threshold or a case file doesn't load. Every run and every llm grader is a model call on your account.
+
 ## Where you're listed
 
 ```sh
@@ -119,27 +173,56 @@ A form that returned 200 is a claim; the public record is the result. `listings`
 - Cursor and Grok.
 - Glama's registry import.
 - Both awesome lists and Docker's catalog.
+- Vercel Connect's directory, from the agent-readable copy of [vercel.com/connect/browse](https://vercel.com/connect/browse) (it has no feed; if that copy stops parsing, mcplane says so and sends you to the page).
 
 Coverage decays quietly, so run it on a schedule (`--ci` exits 1 on a mismatch). `fleet` runs it for every project.
 
 ## ChatGPT's plugin ZIP
 
-Since DevDay (September 2026) ChatGPT takes a plugin ZIP. `mcplane pack chatgpt` builds it from `mcplane.json`: `plugin.json` in the Agent Plugins format, with listing, icons, the 5 positive and 3 negative test cases, demo video, release notes and translations, plus `mcp.json`. It checks the package against OpenAI's submission rules first: name and description lengths, category, the four https URLs, at most 3 starter prompts, square icons of 48 to 4096 px, brand-colour contrast.
+Since DevDay (September 2026) ChatGPT takes a plugin ZIP. `mcplane pack chatgpt` builds it from `mcplane.json`: `plugin.json` in the Agent Plugins format, with listing, icons, the 5 positive and 3 negative test cases, demo video, release notes and translations, plus `mcp.json` and any Agent Skills you bundle. It checks the package first: `plugin.json` and `mcp.json` against the [Agent Plugins 1.0.0](https://agent-plugins.org) JSON Schemas, then OpenAI's submission rules: name and description lengths (1,024 characters for the root description), category, the four https URLs, at most 3 starter prompts, square icons of 48 to 4096 px in any of PNG, JPEG, WebP or SVG, brand-colour contrast.
 
 ```json
 "chatgpt": {
   "demoVideo": "https://example.com/demo.mp4",
   "releaseNotes": "Adds hourly forecasts.",
   "capabilities": ["Search forecasts", "Compare cities"],
-  "brandColor": "#2357C6"
+  "brandColor": "#2357C6",
+  "logo": "assets/logo.png",
+  "skills": "skills"
 }
 ```
 
-What stays with you: upload the ZIP, enter reviewer credentials and the per-tool hint justifications (drafted in `chatgpt.md`), and make the attestations. Bump `version` for every upload. Tool changes don't need a new ZIP; OpenAI's scans pick them up, and `drift` tracks extension metadata (sidebar, panels, file viewers) as part of each tool.
+- **Icons** can be URLs or local files (relative to `mcplane.json`), so the package builds offline. `logo` defaults to `icon`, which stays a URL for the other stores.
+- **Skills**: `skills` is a folder of skill folders, or a list of them, each with a `SKILL.md`. They go in the ZIP under `skills/` with their scripts, executable bits kept. mcplane checks what clients and OpenAI refuse: a `name` that doesn't match its folder, a description over 1,024 characters, front matter YAML can't read, a script the `SKILL.md` runs but the folder doesn't hold. Hidden files stay out. Skills are scanned at upload; `"skills": []` ships the server alone.
+- **Behind sign-in**: the ZIP doesn't need your tool list, so `pack chatgpt` builds without `--token` and says what it couldn't check. `--tools <file>` takes a saved `tools/list` result instead.
+- The ZIP is reproducible: entries are dated 1980-01-01 and carry Unix modes, so the same files give the same bytes.
+
+What stays with you: upload the ZIP, enter reviewer credentials and make the attestations. Bump `version` for every upload. Tool changes don't need a new ZIP; OpenAI's scans pick them up, and `drift` tracks extension metadata (sidebar, panels, file viewers) as part of each tool.
+
+**Annotation rules.** OpenAI's [plugin guidelines](https://developers.openai.com/plugins/plugin-guidelines) now ask only for explicit `readOnlyHint`, `destructiveHint` and `openWorldHint` booleans on every tool; its automated review checks them, and you appeal if it flags one you believe is right. Justifications are no longer required, so the pack no longer drafts them: any you wrote in `mcplane.json` become optional appeal notes. Writes count as destructive unless they only add (overwriting, cancelling, revoking access and irreversible sends are all destructive, and an undo button doesn't change that), and preflight warns when a write that overwrites, revokes or deletes says `destructiveHint: false`. `openWorldHint` is about where a tool reaches, not whether it calls an API. A hint change is a note in `drift`, not an action: OpenAI re-checks annotations itself, so `drift --ci` doesn't fail on one.
+
+## Demo video
+
+ChatGPT's review asks for a video recorded in developer mode that shows the main use cases and tools, and it goes stale whenever your tools change. `mcplane demo` records it from your positive tests, the way fastlane's `snapshot` takes screenshots:
+
+```sh
+mcplane demo --only 1,2,3
+```
+
+On a Mac with the ChatGPT desktop app, it opens ChatGPT with a local debugging port and hides the sidebar. For each test it opens a new chat, @mentions your plugin (the developer-mode one, when two share the name), types the prompt, waits for the answer and opens the summary of tool calls. ffmpeg joins the scenes behind a title card, with each test's scenario as its caption, into `.mcplane/packs/chatgpt/demo.mp4`. Upload it where a reviewer can open it without signing in and set `chatgpt.demoVideo` to its URL.
+
+It drives ChatGPT with your account, so:
+- it lists the prompts and asks before it starts (`--yes` skips that), and marks tests that call tools which write;
+- it records only while a test runs, with the sidebar (your chats and name) hidden;
+- tool approvals are yours to click, unless you pass `--approve`, which clicks "Allow once" (never "Always allow");
+- it quits ChatGPT afterwards so the debugging port doesn't stay open (`--keep-open` leaves it running);
+- the chats stay in your history, and answers can draw on your ChatGPT memory, so watch the video before you share it.
+
+`--plugin` names the plugin as ChatGPT shows it, `--work` records in Work mode and `--out` writes somewhere else. It needs ffmpeg (`brew install ffmpeg`). It finds its way around ChatGPT by the labels on buttons, so a ChatGPT release can break it; they're all in one table at the top of `src/demo.ts`.
 
 ## Keeping listings current
 
-Every store calls your live server, so fixes reach users on their own. What doesn't: listing text, tool names in Claude's listing, ChatGPT's hint justifications, registry versions and plugins pinned to a commit. Each store has different rules for these. When you record a submission, mcplane snapshots what the store is reviewing. `mcplane drift` compares your live server and `mcplane.json` against that snapshot and tells you what each store needs.
+Every store calls your live server, so fixes reach users on their own. What doesn't: listing text, tool names in Claude's listing, registry versions and plugins pinned to a commit. Each store has different rules for these. When you record a submission, mcplane snapshots what the store is reviewing. `mcplane drift` compares your live server and `mcplane.json` against that snapshot and tells you what each store needs.
 
 ```sh
 mcplane submitted chatgpt --version 1.2.0 --app-id asdk_app_…
@@ -219,8 +302,8 @@ For a reverse-DNS name, set an `MCP_PRIVATE_KEY` secret and mcplane signs in wit
 
 ```
 init --url <mcp url>          Create mcplane.json from your live server
-preflight [--store <id>]      Check against every store's rejection causes (--url, --json, --verbose, --register, --token)
-pack <store>                  Write a submission pack to .mcplane/packs (or "pack directories")
+preflight [--store <id>]      Check against every store's rejection causes (--url, --json, --verbose, --register, --token, --sign-in)
+pack <store>                  Write a submission pack to .mcplane/packs (or "pack directories", "pack ard", "pack claude-eval"; --tools)
 publish <store> [--yes]       Publish where the store allows it; dry run without --yes
 submitted <store>             Record a submission (--date, --kind, --version, --app-id, --private)
 decided <store> <outcome>     approved | rejected | withdrawn
@@ -229,13 +312,14 @@ drift [--ci]                  What each store needs since it last saw your serve
 baseline <store>              Mark an existing live listing as the drift baseline
 listings [--ci]               Where you're listed, and whether what went live matches
 try                           Install links for every client, for you and your testers
+demo                          Record ChatGPT's review video from your positive tests (macOS; --only, --approve, --out)
 fleet [--root <dir>]          Every project at a glance (--quick, --json, --ci)
 fleet run <command...>        Run a command in every project
 lanes / <lane>                List lanes / run one
 mcp                           Run as an MCP server over stdio
 ```
 
-Servers behind sign-in: pass `--token` or set `MCPLANE_TOKEN` so tool checks can run.
+Servers behind sign-in: pass `--token` or set `MCPLANE_TOKEN` so tool checks can run. Packs also take `--tools <file>`, a saved `tools/list` result.
 
 ## Use the checks in your own code
 
@@ -264,19 +348,25 @@ Each store can have its own listing text, the way fastlane keeps metadata per la
 
 Packs, checks, `drift` and `listings` all use the right text for each store.
 
+Store fields with no shared equivalent have their own blocks: `chatgpt` for the plugin ZIP (including its `logo` and `skills`), `grok` for the marketplace entry, and `vercelConnect` for a REST API target (`apiBase`), default OAuth `scopes` and an `apiKey` connection method. For OAuth servers, `server.signIn` lists the sign-in pages your consent screen uses, for the sign-in chain check.
+
 ## fastlane, mapped
 
 | fastlane | mcplane |
 |---|---|
 | `precheck` | `preflight` |
-| `deliver` + metadata in the repo | `mcplane.json`, `pack`, `publish` |
+| `deliver` + metadata in the repo | `mcplane.json`, `pack`, `publish`; for ChatGPT, one reproducible ZIP with your skills |
 | `download_metadata` | `listings`: reads what went live back and diffs it |
 | `pilot` (TestFlight testers) | `try`: install links for every client |
+| `snapshot` (screenshots on every device) | `demo`: the review video, recorded in ChatGPT from your tests |
 | Fastfile lanes | `lanes` |
 | `fastlane init` | `init`, and the **onboard** prompt that writes the listing for you |
 | CI-first | `--ci` exit codes, JSON output, GitHub Action |
+| `scan` (tests in CI) | `pack claude-eval`: your review tests as a `claude plugin eval` suite, scored against a no-plugin baseline |
 | New: agent-driven | the whole thing is an MCP server |
 | New: drift | knows what each store needs when your server changes |
+| New: readiness | how your server meets the next MCP revision (2026-07-28), before clients require it |
+| New: discovery | `pack ard`: the ARD manifest agents and Lighthouse look for |
 
 ## Contributing
 

package/dist/agent-plugins.d.ts

@@ -0,0 +1,6 @@
+export declare const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+/** OpenAI's limit for plugin.json's root description (plugin_description_too_long). */
+export declare const DESCRIPTION_MAX = 1024;
+/** Every way plugin.json and mcp.json break the Agent Plugins 1.0.0 schemas; empty when both pass. */
+export declare function schemaProblems(plugin: unknown, mcp: unknown): Promise<string[]>;

package/dist/agent-plugins.js

@@ -0,0 +1,76 @@
+/**
+ * Agent Plugins 1.0.0, the open package format ChatGPT's portal takes: plugin.json and mcp.json
+ * checked against the official JSON Schemas.
+ *
+ * schemas/agent-plugins-1.0.0/ holds unmodified copies of https://agent-plugins.org/schemas/1.0.0/
+ * (github.com/agentplugins/agent-plugins-spec), Apache License 2.0; the licence is in the same folder.
+ */
+import { readFile } from 'node:fs/promises';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+export const PLUGIN_SCHEMA = 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json';
+export const MCP_SCHEMA = 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json';
+/** OpenAI's limit for plugin.json's root description (plugin_description_too_long). */
+export const DESCRIPTION_MAX = 1024;
+/** The MCP server forms, by the "type" that selects each one. */
+const SERVER_FORMS = { stdio: 'stdioServer', 'streamable-http': 'streamableHttpServer', sse: 'sseServer' };
+let compiled;
+function validators() {
+    compiled ??= (async () => {
+        const load = async (file) => JSON.parse(await readFile(new URL(`../schemas/agent-plugins-1.0.0/${file}`, import.meta.url), 'utf8'));
+        const [plugin, mcp] = await Promise.all([load('plugin.schema.json'), load('mcp.schema.json')]);
+        const ajv = new Ajv2020({ allErrors: true, strict: true, logger: false });
+        const v = { plugin: ajv.compile(plugin), mcp: ajv.compile(mcp) };
+        const forms = Object.fromEntries(Object.entries(SERVER_FORMS).map(([type, def]) => [type, ajv.getSchema(`${MCP_SCHEMA}#/$defs/${def}`)]));
+        return { ...v, forms };
+    })();
+    return compiled;
+}
+/** One readable line per schema error, e.g. `plugin.json /author: "phone" isn't allowed by the Agent Plugins schema`. */
+function describe(file, e) {
+    const at = `${file}${e.instancePath ? ` ${e.instancePath}` : ''}`;
+    const p = e.params;
+    switch (e.keyword) {
+        case 'required':
+            return `${at}: "${p.missingProperty}" is required by the Agent Plugins schema`;
+        case 'additionalProperties':
+            return `${at}: "${p.additionalProperty}" isn't allowed by the Agent Plugins schema`;
+        case 'const':
+            return `${at} must be ${JSON.stringify(p.allowedValue)}`;
+        case 'pattern':
+            return e.instancePath === '/name' ? `${at} must be lowercase letters, digits, dots and hyphens, with no "--" or ".." (Agent Plugins schema)` : `${at} must match ${p.pattern}`;
+        default:
+            return `${at} ${e.message ?? 'is invalid'} (Agent Plugins schema)`;
+    }
+}
+/**
+ * Ajv reports every branch of a oneOf. An MCP server entry is checked again against the one form its
+ * "type" names, so a missing url reads as one problem rather than three.
+ */
+function readable(file, errors, doc, forms) {
+    const oneOfs = errors.filter((e) => e.keyword === 'oneOf').map((e) => e.instancePath);
+    const out = [];
+    for (const path of oneOfs) {
+        const entry = path.split('/').slice(1).reduce((v, k) => v?.[k.replace(/~1/g, '/').replace(/~0/g, '~')], doc);
+        const form = typeof entry?.type === 'string' ? forms[entry.type] : undefined;
+        if (form && !form(entry))
+            out.push(...(form.errors ?? []).map((e) => describe(file, { ...e, instancePath: path + e.instancePath })));
+        else
+            out.push(`${file} ${path}: "type" must be stdio, streamable-http or sse (Agent Plugins schema)`);
+    }
+    for (const e of errors) {
+        if (e.keyword === 'oneOf' || oneOfs.some((p) => e.instancePath.startsWith(p)))
+            continue;
+        out.push(describe(file, e));
+    }
+    return [...new Set(out)];
+}
+/** Every way plugin.json and mcp.json break the Agent Plugins 1.0.0 schemas; empty when both pass. */
+export async function schemaProblems(plugin, mcp) {
+    const v = await validators();
+    const out = [];
+    if (!v.plugin(plugin))
+        out.push(...readable('plugin.json', v.plugin.errors ?? [], plugin, v.forms));
+    if (!v.mcp(mcp))
+        out.push(...readable('mcp.json', v.mcp.errors ?? [], mcp, v.forms));
+    return out;
+}

package/dist/cdp.d.ts

@@ -0,0 +1,49 @@
+export interface Target {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+}
+/** The debugging port's target list. Plain http with no keep-alive, so nothing holds the process open afterwards. */
+export declare function listTargets(port: number, timeoutMs?: number): Promise<Target[]>;
+/**
+ * The app's main window: the page target at exactly `url` (ChatGPT desktop: app://-/index.html).
+ * Its other windows (app://-/index.html?initialRoute=…), MCP App iframes, webviews and
+ * workers are separate targets and never match.
+ */
+export declare function pickMainWindow(targets: Target[], url: string): Target | undefined;
+/** One client-to-server frame: final, masked as the RFC requires of clients. */
+export declare function encodeFrame(payload: Buffer, opcode?: number, mask?: Buffer): Buffer;
+export interface WsFrame {
+    fin: boolean;
+    opcode: number;
+    payload: Buffer;
+}
+/** Takes every complete frame off the front of `buf`; `rest` is the partial frame still arriving. */
+export declare function decodeFrames(buf: Buffer): {
+    frames: WsFrame[];
+    rest: Buffer;
+};
+export declare class Cdp {
+    private socket;
+    private next;
+    private pending;
+    private listeners;
+    private closed;
+    private buf;
+    private parts;
+    private constructor();
+    /** Opens a DevTools WebSocket URL (ws://127.0.0.1:<port>/devtools/page/<id>). */
+    static connect(url: string, timeoutMs?: number): Promise<Cdp>;
+    send<T = any>(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+    /** Runs an expression in the page and returns its JSON value. */
+    evaluate<T>(expression: string): Promise<T>;
+    /** Subscribes to an event; returns the unsubscribe function. */
+    on(event: string, fn: (params: any) => void): () => void;
+    /** Sends a close frame and drops the socket without waiting for an answer. */
+    close(): void;
+    private ended;
+    private data;
+    private receive;
+}