mcplane 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.1
+
+New ChatGPT checks (warnings)
+- `tools.destructive-option`: a tool marked non-destructive whose input schema offers a destructive option (`burn_after_read`, delete, overwrite, revoke, purge and the like), read from property names, descriptions and enum values one level deep. ChatGPT's scan flagged exactly that, and removing the option from the advertised schema cleared it. An expiry on a tool that creates something isn't flagged.
+- `tools.money-crypto`: tools that move money or handle crypto wallets, signing or stablecoins. ChatGPT's submit step has you attest to neither. Prices, pricing pages and billing links aren't flagged.
+
+Packs and drift
+- ChatGPT: the tool scan's timing and spinner, what "Needs further review" means, unclear tool names, and that a rescan doesn't update a submission in review (cancel, reconnect, resubmit). `drift` says so for a snapshot still in review.
+- Muse: Meta's developer portal at muse.ai/platform, its stages and three requirements, the 5 October intake questions, and per-tool Read/Write annotations drafted from your hints until the portal takes them.
+
 ## 0.5.0
 
 New command

package/README.md

@@ -77,7 +77,7 @@ npx mcplane fleet --root ~/Projects
 | 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 |
+| Muse | **Prepares** the form for Meta's developer portal, what its three requirements ask for, and per-tool Read/Write annotations to keep alongside the connector | Flags changes; Meta hasn't published an update process |
 | 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 | |
@@ -92,7 +92,7 @@ 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.
 - **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.
+- **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, for overwriting, revoking access or deleting, and for destructive options in the input schema (ChatGPT's scan flagged a non-destructive publish tool for offering `burn_after_read`). No catch-all request tools, no tool names over 64 characters, no sensitive inputs, no upgrade or pricing copy. Tools that move money or handle crypto wallets are flagged for ChatGPT, whose submit step has you attest to neither.
 - **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.
@@ -199,7 +199,7 @@ Since DevDay (September 2026) ChatGPT takes a plugin ZIP. `mcplane pack chatgpt`
 
 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.
+**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`, or offers an option that does. To keep such an option for other clients, stop advertising it in the schema you serve ChatGPT. `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
 

package/dist/checks/tools.js

@@ -19,16 +19,53 @@ const BEARER_INPUT = /^(token|edit_token|update_token|secret|access_key|api_key|
 /** OpenAI's destructive effects ("deletion, overwriting, cancellation, access revocation") in the words a tool uses about itself. */
 const DESTRUCTIVE = /\b(overwrit\w*|replac\w*|revo[kc]\w*|delet\w*|cancel\w*|archiv\w*|expir\w*|passwords?|gat(?:e|es|ed|ing))\b/gi;
 const NEGATED = /\b(never|not|no|without|nothing|refuses?|cannot|can['’]t|doesn['’]t|don['’]t|won['’]t)\b(\s+\w+){0,2}\s*$/i;
-/** The destructive words in a tool's name, title and description, skipping negated ones ("never overwrites"). */
-function destructiveWords(text) {
+/**
+ * Destructive options in an input schema. No "-ed" forms: they describe a state (include_deleted, "the deleted
+ * page's id"), not what the option does. Passcodes and gates stay out: a passcode on a page the call creates
+ * revokes nothing.
+ */
+const DESTRUCTIVE_OPTION = /\b(burn[\s_-]+after[\s_-]+read\w*|self[\s_-]?destruct(?:s|ing)?|delet(?:e|es|ing|ion)|destroy(?:s|ing)?|overwrit(?:e|es|ing)|replac(?:e|es|ing|ement)|revok(?:e|es|ing)|revocation|purg(?:e|es|ing)|wip(?:e|es|ing)|eras(?:e|es|ing|ure)|expir(?:e|es|ing|y|ation))\b/gi;
+/** Tools that make something new: a creating verb anywhere in the name (api_create_key), or first when it's also a noun (update_post isn't one). */
+const CREATES = /\b(create|add|new|publish|upload|mint|generate|insert)\b|^(post|share|invite|issue|schedule|make)\b/i;
+/** Crypto: wallets, chains, signing schemes and stablecoins. */
+const CRYPTO = /\b(crypto(?:currenc(?:y|ies))?|wallets?|on[\s-]?chain|blockchains?|web3|eip[\s-]?(?:191|712)|personal[\s_-]?sign|eth[\s_-]sign|sign[\s_-]?typed[\s_-]?data|usdc|usdt|stablecoins?|bitcoin|ethereum|solana|x402|nfts?|seed phrases?)\b/gi;
+/**
+ * Moving money, as a verb with what it moves. Like UPSELL, phrases only: prices, pricing pages and billing
+ * links aren't money movement, and neither is a purchase history or a hotel's check-out date.
+ */
+const MONEY = /\b(transfer(?:s|ring)? (?:the |your )?(?:funds|money|payments?)|send(?:s|ing)? (?:a |the |your )?(?:money|funds|payments?)|(?:make|makes|making|complete|completes|process|processes|processing|submit|submits|execute|executes) (?:a |the )?(?:payments?|purchases?)|pay(?:s|ing)? (?:an? |the |your )?(?:invoices?|bills?)|charg(?:e|es|ing) (?:a |the |their |your )?(?:cards?|customers?)|refund(?:s|ing)? (?:an? |the |their |your )?(?:customers?|orders?|payments?|charges?)|issu(?:e|es|ing) (?:a )?refunds?|(?:withdraw|deposit)(?:s|ing)? (?:funds|money)|(?:purchas(?:e|es|ing)|buy(?:s|ing)?) (?:an?|the|this|it)|checkouts?(?![\s_-]*(?:date|time|day)))\b/gi;
+/** The words a pattern finds in text, skipping negated ones ("never overwrites"). */
+function mentions(text, re) {
     const found = new Set();
-    for (const m of text.matchAll(DESTRUCTIVE)) {
+    for (const m of text.matchAll(re)) {
         if (NEGATED.test(text.slice(Math.max(0, m.index - 40), m.index)))
             continue;
-        found.add(m[1].toLowerCase());
+        found.add(m[0].toLowerCase().replace(/\s+/g, ' '));
     }
     return [...found];
 }
+/** The destructive words in a tool's name, title and description. */
+const destructiveWords = (text) => mentions(text, DESTRUCTIVE);
+/** A name as words: set_password and setPassword both read "set password". */
+const words = (name) => name.replace(/[_-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2');
+/** A tool's input properties and the ones a level down (an object's properties, an array's items), by path. */
+function inputProps(t) {
+    return Object.entries(t.inputSchema?.properties ?? {}).flatMap(([k, v]) => {
+        const p = (v ?? {});
+        const kids = (p.properties ?? p.items?.properties ?? {});
+        return [[k, p], ...Object.entries(kids).map(([c, cv]) => [`${k}.${c}`, (cv ?? {})])];
+    });
+}
+/**
+ * The destructive words in what a property says about itself: its name, string enum values ("overwrite") and
+ * description. "Replace" counts in names and values only: descriptions use it loosely ("until a refresh replaces them").
+ */
+function optionWords(path, p) {
+    const values = Array.isArray(p.enum) ? p.enum.filter((e) => typeof e === 'string').join(' ') : '';
+    const named = mentions(`${words(path.split('.').pop())} ${values}`, DESTRUCTIVE_OPTION);
+    const described = mentions(typeof p.description === 'string' ? p.description : '', DESTRUCTIVE_OPTION).filter((w) => !w.startsWith('replac'));
+    return [...new Set([...named, ...described])];
+}
 export function toolChecks(tools) {
     if (!tools.length)
         return [];
@@ -114,8 +151,8 @@ export function toolChecks(tools) {
     const destroys = tools.flatMap((t) => {
         if (t.annotations?.readOnlyHint !== false || t.annotations?.destructiveHint !== false)
             return [];
-        const words = destructiveWords(`${t.name.replace(/[_-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2')} ${t.title ?? ''} ${t.description ?? ''}`);
-        return words.length ? [`${t.name} (${words.join(', ')})`] : [];
+        const found = destructiveWords(`${words(t.name)} ${t.title ?? ''} ${t.description ?? ''}`);
+        return found.length ? [`${t.name} (${found.join(', ')})`] : [];
     });
     if (destroys.length) {
         checks.push({
@@ -127,6 +164,51 @@ export function toolChecks(tools) {
             stores: ['chatgpt'],
         });
     }
+    // ChatGPT's scan reads the input schema too: it flagged Stacktree's publish_html, marked non-destructive, for
+    // offering burn_after_read, and a rescan cleared it once the option was gone from the advertised schema (Oct 2026).
+    // Conservative: property names, descriptions and enum values, one level deep. Expiry is the trade-off: it only
+    // counts on tools that change something that exists. On a tool that creates (a publish's lifetime, a share
+    // link's expires_in) it bounds what the call itself adds, and publish_html kept expires_in_hours through
+    // that rescan. An expiry on an update tool still counts: it can take a live page down.
+    const options = tools.flatMap((t) => {
+        if (t.annotations?.readOnlyHint !== false || t.annotations?.destructiveHint !== false)
+            return [];
+        const creates = CREATES.test(words(t.name));
+        return inputProps(t).flatMap(([path, p]) => {
+            const found = optionWords(path, p).filter((w) => !(creates && w.startsWith('expir')));
+            return found.length ? [`${t.name}.${path} (${found.join(', ')})`] : [];
+        });
+    });
+    if (options.length) {
+        checks.push({
+            id: 'tools.destructive-option',
+            level: 'warn',
+            title: 'destructiveHint covers the options a tool’s schema offers',
+            detail: `${options.join('; ')}: destructiveHint is false, but the schema offers an option that deletes, overwrites, revokes or expires`,
+            fix: 'Set destructiveHint to true, or stop advertising the option in the schema you serve ChatGPT; your server can keep honouring it for older clients that still send it. ChatGPT’s scan flagged a publish tool marked non-destructive whose schema offered burn_after_read, and removing the option from the advertised schema cleared the flag on rescan.',
+            stores: ['chatgpt'],
+        });
+    }
+    // Before submitting, ChatGPT has the developer attest that the app involves no money or crypto.
+    // Moving money is a write, so read-only tools are judged by what they're about (name, title, property names) and a
+    // passing mention in their description doesn't count ("inflation, GDP, crypto and more").
+    const money = tools.flatMap((t) => {
+        const about = `${words(t.name)} ${t.title ?? ''} ${t.annotations?.title ?? ''} ${inputProps(t).map(([path]) => words(path.split('.').pop())).join(' ')}`;
+        const readOnly = t.annotations?.readOnlyHint === true;
+        const text = readOnly ? about : `${about} ${t.description ?? ''}`;
+        const found = [...mentions(text, CRYPTO), ...(readOnly ? [] : mentions(text, MONEY))];
+        return found.length ? [`${t.name} (${found.join(', ')})`] : [];
+    });
+    if (money.length) {
+        checks.push({
+            id: 'tools.money-crypto',
+            level: 'warn',
+            title: 'Tools don’t move money or handle crypto',
+            detail: `${money.join('; ')}: the tool seems to move money or handle crypto`,
+            fix: 'ChatGPT’s final submit step has you tick an attestation that the app involves no money or crypto. Remove the tool, or hide it from ChatGPT connections only: leave it out of their tools/list and refuse calls to it. Stacktree serves a per-client tool profile, and a client counts as ChatGPT when every OAuth redirect URI it registered is on chatgpt.com or openai.com, or its client name is "ChatGPT". "Every", not "any": some clients register a claude.ai callback beside a chatgpt.com one.',
+            stores: ['chatgpt'],
+        });
+    }
     const long = tools.filter((t) => t.name.length > 64);
     if (long.length)
         checks.push({ id: 'tools.name-length', level: 'fail', title: 'Tool names are 64 characters or fewer', detail: long.map((t) => t.name).join(', '), fix: 'Anthropic’s review criteria cap tool names at 64 characters.', stores: ['claude-connectors', 'claude-plugins'] });

package/dist/core.js

@@ -26,7 +26,7 @@ function reminders(m, stores) {
         r.push('ChatGPT needs a demo video recorded in developer mode that shows the tools your test cases use. Re-record it whenever tools change ("mcplane demo" records it on a Mac with ChatGPT desktop).');
         r.push('After "Submit for Review" the ChatGPT portal shows nothing for about 20 seconds. Confirm the status on the plugins list, not the button.');
         r.push('OpenAI no longer asks for hint justifications: its automated review checks each tool’s hints. If it flags one you believe is right, appeal with an explanation.');
-        r.push('ChatGPT allows one version in review at a time. To change a submission, Cancel Review and resubmit the same draft.');
+        r.push('ChatGPT allows one version in review at a time, and a rescan doesn’t update the tools it was submitted with. To change a submission, Cancel Review (back to Draft), reconnect if tools changed so ChatGPT rediscovers them, and resubmit.');
     }
     if (stores.includes('claude-connectors') || stores.includes('claude-plugins')) {
         if (stores.includes('claude-connectors'))

package/dist/drift.js

@@ -162,16 +162,19 @@ export async function drift(m, stores, opts = {}, dir = process.cwd()) {
         const since = `since ${snap.state === 'live' ? 'the live version' : 'your submission'}${snap.version ? ` (v${snap.version})` : ''} on ${snap.takenOn}`;
         if (store === 'chatgpt') {
             // OpenAI rescans published servers: removals apply at once, new and changed tools after automated checks.
-            // Listing text is part of the version and needs a new one.
+            // A version in review keeps the tool snapshot it was submitted with. Listing text is part of the version and needs a new one.
             const hintChanges = d.changed.filter((c) => c.fields.some((f) => f.includes('Hint')));
+            const inReview = snap.state === 'submitted';
             if (toolChange)
                 items.push({
                     store,
                     level: 'info',
                     what: `Tools changed ${since}: ${summary}`,
-                    todo: `No resubmission needed for tools: OpenAI rescans your server, drops removed tools at once and switches new or changed ones over after they pass automated checks (the old definition stays live until then).${d.added.length || d.removed.length ? ' Update the test cases and demo video in your next version.' : ''}`,
+                    todo: inReview
+                        ? 'A rescan doesn’t update a submission already in review: it keeps the tools it was submitted with. For review to see these changes, cancel the review (back to Draft), reconnect so ChatGPT rediscovers the tools, then resubmit. The scan takes about 4 to 6 minutes; reload the page to see the result.'
+                        : `No resubmission needed for tools: OpenAI rescans your server, drops removed tools at once and switches new or changed ones over after they pass automated checks (the old definition stays live until then).${d.added.length || d.removed.length ? ' Update the test cases and demo video in your next version.' : ''}`,
                 });
-            if (hintChanges.length)
+            if (hintChanges.length && !inReview)
                 items.push({ store, level: 'info', what: `Hints changed: ${hintChanges.map((c) => c.tool).join(', ')}`, todo: 'Nothing to resubmit: OpenAI re-checks changed annotations automatically and no longer asks for justifications. If its review flags a value you believe is right, appeal with an explanation.' });
             if (listingChange.length)
                 items.push({ store, level: 'action', what: `Listing text changed (${listingChange.join(', ')})`, todo: 'Listing changes need a new version, review and publication: "mcplane pack chatgpt", import it into a new version, submit.' });
@@ -198,7 +201,7 @@ export async function drift(m, stores, opts = {}, dir = process.cwd()) {
                 items.push({ store, level: 'info', what: `Grok serves ${pinned.slice(0, 7)}; your repo is at ${head.slice(0, 7)}`, todo: 'xAI bumps pins daily. If it’s still behind tomorrow, "mcplane publish grok" opens a pin-bump pull request.' });
         }
         if (store === 'muse' && (toolChange || listingChange.length)) {
-            items.push({ store, level: 'info', what: `Changed ${since}: ${[summary, listingChange.length && `listing ${listingChange.join(', ')}`].filter(Boolean).join('; ')}`, todo: 'Meta hasn’t published an update process yet. Update the listing in muse.ai/platform if it shows old details.' });
+            items.push({ store, level: 'info', what: `Changed ${since}: ${[summary, listingChange.length && `listing ${listingChange.join(', ')}`].filter(Boolean).join('; ')}`, todo: 'Meta hasn’t published an update process yet. Open the submission in muse.ai/platform, which shows its stage (Submitted, then In review) and three requirements, and update anything that shows old details. If tools changed, update the Read, Write and Sensitive annotations you keep alongside the connector too.' });
         }
         if (store === 'mcp-registry' && (toolChange || listingChange.length)) {
             items.push({ store, level: 'action', what: `Changed ${since}`, todo: 'Bump the version and run "mcplane publish mcp-registry".' });

package/dist/packs.d.ts

@@ -60,6 +60,11 @@ export declare function claudeEvalPack(m: Manifest, opts?: PackOptions): Promise
 /** Every pack by name: a store with a form, or one of the extras. */
 export declare const PACKS: readonly ["chatgpt", "claude-connectors", "vercel-connect", "cursor", "muse", "directories", "ard", "claude-eval"];
 export declare function packFor(m: Manifest, name: string, opts?: PackOptions): Promise<Pack>;
+/**
+ * Muse: the values for Meta's developer portal (muse.ai/platform, live since 2 Oct 2026), what each
+ * submission's three requirements ask for, and per-tool annotations to keep until the portal takes them.
+ */
+export declare function musePack(m: Manifest, opts?: PackOptions): Promise<Pack>;
 export declare function simplePack(m: Manifest, store: StoreId): Promise<Pack>;
 /** The long tail: directories that only take a web form. One sheet with every value to paste. */
 export declare function directoriesPack(m: Manifest): Pack;

package/dist/packs.js

@@ -295,6 +295,9 @@ It fills the listing, icons, test cases, demo video, release notes and translati
 ## 2. Resolve findings
 Open **Metadata & Skills** and **MCPs**, wait for the checks, fix anything listed (Copy issues is handy), and upload again if the package changes.
 Domain verification: serve the token it gives you as plain text at ${new URL(m.server.url).origin}/.well-known/openai-apps-challenge, and keep it there.
+- The tool scan takes about 4 to 6 minutes, and the page's spinner never finishes: reload to see the result.
+- "Needs further review" sends a tool to human review. It isn't an error, and the automated judge reshuffles which tools land there between scans.
+- Name tools by what they do. The scan flags names it can't understand: Stacktree's set_agentation, named after a product, was flagged "unclear name".
 
 ## 3. What only you can enter
 - **Review details:** reviewer credentials${m.server.auth === 'oauth' ? ` (${m.reviewerAccess ?? 'an email-and-password account with no 2FA, SMS or email confirmation, seeded for every test case'})` : ' (none needed: no sign-in)'}. Credentials never go in the ZIP.
@@ -305,7 +308,8 @@ Hints need no justification: OpenAI's automated review checks readOnlyHint, dest
 ## Traps
 - One review can be active per plugin. To replace a package in review, cancel the review first.
 - "Submit for review" can show nothing for a while; confirm the status on the Plugins page.
-- Tool changes don't need a new package: OpenAI's scans pick them up. Listing changes do.
+- Tool changes don't need a new package: OpenAI's scans pick them up once you're published. Listing changes do.
+- A rescan doesn't update a submission already in review: it keeps the tools it was submitted with. To change them, cancel the review (back to Draft), reconnect so ChatGPT rediscovers the tools, then resubmit.
 - The package takes icons up to 5 MiB, but developer mode's own icon upload (when you add the server by hand to record the demo) takes 10 KB at most.
 
 When it's in: \`mcplane submitted chatgpt --version ${m.version ?? '1.0.0'} --app-id <asdk_app_… from the URL>\`
@@ -637,8 +641,48 @@ export async function packFor(m, name, opts = {}) {
         return claudePack(m, opts);
     if (name === 'vercel-connect')
         return vercelConnectPack(m);
+    if (name === 'muse')
+        return musePack(m, opts);
     return simplePack(m, name);
 }
+/**
+ * Muse: the values for Meta's developer portal (muse.ai/platform, live since 2 Oct 2026), what each
+ * submission's three requirements ask for, and per-tool annotations to keep until the portal takes them.
+ */
+export async function musePack(m, opts = {}) {
+    m = forStore(m, 'muse');
+    const listed = await toolsFor(m, opts);
+    const oauth = m.server.auth === 'oauth';
+    const todo = listed.tools ? [] : [withoutTools(listed.why, 'the per-tool annotations')];
+    const annotations = listed.tools
+        ? listed.tools.map((t) => `- ${t.name}: ${t.annotations?.readOnlyHint === true ? 'Read' : 'Write'}`).join('\n') || 'No tools listed.'
+        : 'Unknown without the tool list (pass --token or --tools).';
+    const md = `# Muse connectors: ${m.title}
+
+Submit at muse.ai/platform, Meta's developer portal (launched 2 October 2026), choosing "Existing MCP". Meta's Jake Levine mentioned about 3,000 connector submissions when he announced it on X, so expect a queue.
+
+- MCP server URL: ${m.server.url}
+- Auth: ${oauth ? 'OAuth (PKCE)' : 'None'}
+- Name: ${m.title}
+- Description: ${m.oneLiner ?? m.description ?? 'MISSING'}
+- Privacy: ${m.links?.privacy ?? 'MISSING'}
+
+## After you submit
+Each submission shows its stage, Submitted then In review, and three requirements:
+- **Business verification:** a code sent by email. Each "Verify email" click sends a new code and invalidates the last one, so click once and don't leave the code box until the email arrives.
+- **Questionnaire:** your company details and where data is stored.
+- **Integration credentials:** ${oauth ? 'a test API key or similar, so Meta can reach the tools behind your sign-in.' : 'none required: for an authless MCP, the portal says so.'}
+
+On 5 October Meta emailed developers asking them to "complete the additional intake questions", so check the portal for anything still open.
+
+## Tool annotations
+Meta's docs ask for a Read, Write or Sensitive annotation on each tool. The portal's field for them is marked as coming soon, so document them alongside the connector for now. Drafted from your readOnlyHint values; Sensitive is your call against Meta's docs:
+${annotations}
+
+Meta hasn't published an update process yet. When it's in: \`mcplane submitted muse\`.
+`;
+    return { files: [{ path: 'muse.md', content: md }], problems: [], todo };
+}
 export async function simplePack(m, store) {
     m = forStore(m, store);
     const problems = [];
@@ -649,7 +693,7 @@ export async function simplePack(m, store) {
         md = `# Cursor Marketplace: ${m.title}\n\nSubmit at cursor.com/marketplace/publish.\n\n- Repository: ${m.repository ?? 'MISSING'} (public, with a Cursor plugin manifest)\n- Name: ${m.title}\n- Description: ${m.oneLiner ?? m.description ?? 'MISSING'}\n- Website: ${m.links?.website ?? ''}\n\nEvery plugin is reviewed by hand. When it's in: \`mcplane submitted cursor\`. Review Times closes the report itself when your plugin appears in the marketplace.\n`;
     }
     else if (store === 'muse') {
-        md = `# Muse connectors: ${m.title}\n\nSubmit at muse.ai/platform, choosing "Existing MCP".\n\n- MCP server URL: ${m.server.url}\n- Auth: ${m.server.auth === 'oauth' ? 'OAuth (PKCE)' : 'None'}\n- Name: ${m.title}\n- Description: ${m.oneLiner ?? m.description ?? 'MISSING'}\n- Privacy: ${m.links?.privacy ?? 'MISSING'}\n\nMeta onboards in waves and gives no status yet. When it's in: \`mcplane submitted muse\`.\n`;
+        return musePack(m);
     }
     else {
         throw new Error(`No pack for ${store} yet. Packs: ${PACKS.join(', ')}.`);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.5.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.5.0';
+export const VERSION = '0.5.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcplane",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "fastlane for MCP servers: preflight against every store's rejection causes, publish where you can, prepare the rest, track every review.",
   "type": "module",
   "bin": {