@extension.dev/mcp 10.10.7 → 10.10.9

package/dist/module.js

@@ -9,7 +9,7 @@ import node_os from "node:os";
 import cross_spawn from "cross-spawn";
 import { PROD_ORIGINS, resolveOrigins } from "@extension.dev/urls/origins";
 import node_crypto, { createHash, randomUUID } from "node:crypto";
-import { consoleProjectPath, wwwNewPath } from "@extension.dev/urls/paths";
+import { ConsoleProjectPage, consoleProjectPath, wwwNewPath } from "@extension.dev/urls/paths";
 import { UserlandProjectPage, userlandUrl } from "@extension.dev/urls/userland";
 import { CLOSE_BAD_HELLO, CLOSE_BAD_INSTANCE, CLOSE_CONTROL_UNAVAILABLE, CLOSE_SLOW_CONSUMER, CONTROL_ENVELOPE_VERSION, CONTROL_WS_PATH, actionsPath, browserArtifactsDir, buildSummaryPath, eventsPath, logsPath, matchesLogQuery, readLogEvents, readReadyContract, readyContractPath as bridge_readyContractPath, sessionArtifactsRootDir, sessionStateDir as bridge_sessionStateDir } from "extension-develop/bridge";
 import { fileURLToPath } from "node:url";
@@ -92,6 +92,7 @@ var dom_snapshot_namespaceObject = {};
 __webpack_require__.r(dom_snapshot_namespaceObject);
 __webpack_require__.d(dom_snapshot_namespaceObject, {
     handler: ()=>dom_snapshot_handler,
+    protocolSnapshotExpression: ()=>protocolSnapshotExpression,
     schema: ()=>dom_snapshot_schema
 });
 var eval_namespaceObject = {};
@@ -242,7 +243,7 @@ __webpack_require__.d(workspace_create_namespaceObject, {
     handler: ()=>workspace_create_handler,
     schema: ()=>workspace_create_schema
 });
-var package_namespaceObject = JSON.parse('{"rE":"10.10.7","El":{"OP":"4.1.31"}}');
+var package_namespaceObject = JSON.parse('{"rE":"10.10.9","El":{"OP":"4.1.31"}}');
 const ENVELOPE_SCHEMA = 1;
 const collectWarnings = (warnings)=>{
     if (!warnings) return [];
@@ -578,6 +579,21 @@ function writeCredentials(creds) {
         entries
     });
 }
+function writeCredentialBatch(batch) {
+    if (0 === batch.length) return null;
+    const existing = readCredentialStore();
+    const entries = {
+        ...existing?.entries ?? {}
+    };
+    for (const creds of batch)entries[credentialKey(creds.workspaceSlug, creds.projectSlug)] = creds;
+    const first = batch[0];
+    const active = existing?.active && entries[existing.active] ? existing.active : credentialKey(first.workspaceSlug, first.projectSlug);
+    return writeStore({
+        version: 2,
+        active,
+        entries
+    });
+}
 function clearCredentials(selector) {
     const file = credentialsPath();
     const store = readCredentialStore();
@@ -659,6 +675,91 @@ const PROJECT_TOKEN_INPUT = {
 function noStoredLoginHint(project) {
     return `No stored login for ${project}. extension_auth (action: status) lists the logins on this machine; extension_auth (action: login, project: "${project}") adds one. Logging in to another project no longer replaces this one.`;
 }
+const MAX_BATCH_PROJECTS = 20;
+const MAX_PROJECT_SLUG_LENGTH = 48;
+const MAX_WORKSPACE_SLUG_LENGTH = 64;
+const PLATFORM_CREATES_PER_HOUR = 10;
+const DEFAULT_CREATE_PROJECTS_PER_APPROVAL = 10;
+function capFrom(value, fallback) {
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 1) return fallback;
+    return Math.min(count, MAX_BATCH_PROJECTS);
+}
+function readBatchCapability(config) {
+    const raw = config?.batchOnboarding;
+    if (!raw || "object" != typeof raw || Array.isArray(raw)) return null;
+    const record = raw;
+    return {
+        createProjectsPerApproval: capFrom(record.createProjectsPerApproval, DEFAULT_CREATE_PROJECTS_PER_APPROVAL),
+        loginProjectsPerApproval: capFrom(record.loginProjectsPerApproval, MAX_BATCH_PROJECTS)
+    };
+}
+const BATCH_UNSUPPORTED_MESSAGE = "This platform does not advertise batch onboarding, so a list of projects was not sent and no device code was spent.";
+const PROJECT_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isExactProjectSlug(slug) {
+    return slug.length <= MAX_PROJECT_SLUG_LENGTH && PROJECT_SLUG.test(slug);
+}
+function parseProjectBatch(input) {
+    if (!Array.isArray(input)) return {
+        ok: false,
+        message: "projects must be an array of '<workspace>/<project>' names."
+    };
+    if (input.length < 1 || input.length > MAX_BATCH_PROJECTS) return {
+        ok: false,
+        message: `projects must name between 1 and ${MAX_BATCH_PROJECTS} projects; got ${input.length}. One approval covers at most ${MAX_BATCH_PROJECTS}, so split a longer list into separate calls.`
+    };
+    const refs = [];
+    const slugs = [];
+    let workspace = "";
+    for (const entry of input){
+        const raw = "string" == typeof entry ? entry.trim() : "";
+        if (!/^[^/]+\/[^/]+$/.test(raw)) return {
+            ok: false,
+            message: `Every entry in projects must be '<workspace>/<project>'; got ${JSON.stringify(entry)}.`
+        };
+        const slash = raw.indexOf("/");
+        const entryWorkspace = raw.slice(0, slash).trim().toLowerCase();
+        const slug = raw.slice(slash + 1).trim().toLowerCase();
+        if (!entryWorkspace || entryWorkspace.length > MAX_WORKSPACE_SLUG_LENGTH) return {
+            ok: false,
+            message: `The workspace in '${raw}' must be a slug of at most ${MAX_WORKSPACE_SLUG_LENGTH} characters.`
+        };
+        if (!isExactProjectSlug(slug)) return {
+            ok: false,
+            message: `'${raw}' does not name a project by its exact slug. A batch takes each project slug exactly as the platform registers it: lowercase letters and digits joined by single dashes, at most ${MAX_PROJECT_SLUG_LENGTH} characters. The console address bar shows it as console.extension.dev/<workspace>/<project>.`
+        };
+        if (workspace && entryWorkspace !== workspace) return {
+            ok: false,
+            message: `One approval covers one workspace: '${raw}' is in '${entryWorkspace}' but the list started in '${workspace}'. Make one call per workspace.`
+        };
+        workspace = entryWorkspace;
+        if (slugs.includes(slug)) return {
+            ok: false,
+            message: `'${entryWorkspace}/${slug}' is named twice in projects. Name each project once.`
+        };
+        slugs.push(slug);
+        refs.push(`${entryWorkspace}/${slug}`);
+    }
+    return {
+        ok: true,
+        batch: {
+            workspace,
+            slugs,
+            refs
+        }
+    };
+}
+function sameProjectSet(a, b) {
+    if (a.length !== b.length) return false;
+    const wanted = new Set(a.map((value)=>value.toLowerCase()));
+    return b.every((value)=>wanted.has(value.toLowerCase()));
+}
+function createRateLimitNote() {
+    return `The platform creates at most ${PLATFORM_CREATES_PER_HOUR} projects per hour for one approving account, and a provisioning grant lives 15 minutes. Creations the same account already made in the last hour count against it.`;
+}
+function createCapNote(cap) {
+    return `One approval creates at most ${cap} projects on this platform. Send the first ${cap}; the next ${cap} can start in a new call, with its own approval, once the hourly creation limit allows.`;
+}
 const DEFAULT_API = PROD_ORIGINS.www;
 function tokenTtlNote(workspaceSlug, projectSlug) {
     const tokensUrl = workspaceSlug && projectSlug ? consoleProjectUrl({
@@ -710,7 +811,8 @@ async function fetchLoginConfig(apiBase, fetchImpl = fetch) {
     return {
         deviceCodeUrl: String(data.deviceCodeUrl || "/api/cli/device/code"),
         deviceTokenUrl: String(data.deviceTokenUrl || "/api/cli/device/token"),
-        verificationUri: String(data.verificationUri || `${apiBase.replace(/\/+$/, "")}/device`)
+        verificationUri: String(data.verificationUri || `${apiBase.replace(/\/+$/, "")}/device`),
+        batch: readBatchCapability(data)
     };
 }
 function persistTokenResponse(args) {
@@ -734,6 +836,30 @@ function persistTokenResponse(args) {
     writeCredentials(creds);
     return creds;
 }
+function persistBatchTokenResponse(args) {
+    const raw = Array.isArray(args.data.tokens) ? args.data.tokens : null;
+    if (!raw) throw new Error("The platform answered this batch login with a single token and no per-project list, so nothing was stored. It may predate batch login: sign in to each project with its own extension_auth (action: login, project) call.");
+    const batch = raw.map((entry)=>{
+        const record = entry ?? {};
+        const token = String(record.token || "").trim();
+        const workspaceSlug = String(record.workspaceSlug || "").trim();
+        const projectSlug = String(record.projectSlug || "").trim();
+        if (!token || !workspaceSlug || !projectSlug) throw new Error("The batch login returned an entry without a token or a workspace/project scope; nothing was stored. Run extension_auth (action: login) again.");
+        return {
+            version: 1,
+            token,
+            workspaceSlug,
+            projectSlug,
+            expiresAt: Number(record.expiresAt || 0),
+            api: args.apiBase,
+            provider: "extensiondev"
+        };
+    });
+    const returned = batch.map((creds)=>`${creds.workspaceSlug}/${creds.projectSlug}`);
+    if (new Set(returned.map((ref)=>ref.toLowerCase())).size !== returned.length || !sameProjectSet(args.projects, returned)) throw new Error(`The batch login returned tokens scoped to [${returned.join(", ")}], not the requested [${args.projects.join(", ")}]; nothing was stored. Run extension_auth (action: login) again with the intended projects.`);
+    writeCredentialBatch(batch);
+    return batch;
+}
 const INSTALL_HEADER = "x-extensiondev-install";
 const SESSION_HEADER = "x-extensiondev-session";
 const TOOL_HEADER = "x-extensiondev-tool";
@@ -884,7 +1010,9 @@ class RegistryAccessTokens {
         return result;
     }
     async mint(ref, apiHint) {
-        const creds = readValidCredentials();
+        const creds = readValidCredentials(void 0, {
+            project: `${ref.workspace}/${ref.project}`
+        });
         const token = String(process.env.EXTENSION_DEV_TOKEN || creds?.token || "").trim();
         if (!token) return {
             status: "no-credential"
@@ -1064,14 +1192,33 @@ function consoleBase(apiHint) {
 function registryBase() {
     return mcpOrigins().registry;
 }
+function splitProjectName(name) {
+    const parts = name.split("/");
+    const workspace = String(parts[0] ?? "").trim();
+    const project = String(parts[1] ?? "").trim();
+    if (2 !== parts.length || !workspace || !project) return null;
+    return {
+        workspace,
+        project
+    };
+}
 function resolveProjectRef(overrides) {
-    const workspace = String(overrides?.workspace || "").trim();
-    const project = String(overrides?.project || "").trim();
+    let workspace = String(overrides?.workspace || "").trim();
+    let project = String(overrides?.project || "").trim();
+    if (project.includes("/")) {
+        const named = splitProjectName(project);
+        if (!named) return null;
+        if (workspace && workspace.toLowerCase() !== named.workspace.toLowerCase()) return null;
+        workspace = named.workspace;
+        project = named.project;
+    }
     if (workspace && project) return {
         workspace,
         project
     };
-    const creds = readCredentials();
+    const creds = (project ? readCredentials({
+        project
+    }) : null) ?? readCredentials();
     const ws = workspace || String(creds?.workspaceSlug || "").trim();
     const proj = project || String(creds?.projectSlug || "").trim();
     if (!ws || !proj) return null;
@@ -1080,6 +1227,20 @@ function resolveProjectRef(overrides) {
         project: proj
     };
 }
+function loginProjectRef(selector) {
+    const named = String(selector ?? "").trim();
+    if (!named) return resolveProjectRef();
+    const creds = readCredentials({
+        project: named
+    });
+    const workspace = String(creds?.workspaceSlug || "").trim();
+    const project = String(creds?.projectSlug || "").trim();
+    if (workspace && project) return {
+        workspace,
+        project
+    };
+    return splitProjectName(named);
+}
 function registryFileUrl(ref, file) {
     return `${registryBase()}/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.project)}/_extension-dev/${file}`;
 }
@@ -1743,6 +1904,7 @@ const LAUNCH_BROWSER = {
 };
 async function requestDeviceCode(args) {
     const doFetch = args.fetchImpl ?? fetch;
+    const batch = Array.isArray(args.projects) && args.projects.length > 0;
     const res = await doFetch(`${args.apiBase}${args.path}`, {
         method: "POST",
         headers: {
@@ -1750,7 +1912,10 @@ async function requestDeviceCode(args) {
             accept: "application/json"
         },
         body: JSON.stringify({
-            ...args.project ? {
+            ...batch ? {
+                projects: args.projects
+            } : {},
+            ...!batch && args.project ? {
                 project: args.project
             } : {},
             ...args.workspace ? {
@@ -1774,6 +1939,8 @@ async function requestDeviceCode(args) {
     if (!res.ok) {
         const error = new Error(`Device code request failed (${res.status}): ${data.message || "unknown error"}`);
         if ("string" == typeof data.message && data.message.trim()) error.serverMessage = data.message.trim();
+        if ("string" == typeof data.code && data.code.trim()) error.serverCode = data.code.trim();
+        error.httpStatus = res.status;
         throw error;
     }
     const deviceCode = String(data.device_code || "").trim();
@@ -1792,6 +1959,7 @@ async function pollDeviceGrant(args) {
     const doFetch = args.fetchImpl ?? fetch;
     const deadline = Date.now() + args.budgetMs;
     let interval = Math.max(1, args.interval);
+    const batch = Array.isArray(args.projects) && args.projects.length > 0;
     for(;;){
         const res = await doFetch(`${args.apiBase}${args.path}`, {
             method: "POST",
@@ -1801,7 +1969,10 @@ async function pollDeviceGrant(args) {
             },
             body: JSON.stringify({
                 device_code: args.deviceCode,
-                ...args.project ? {
+                ...batch ? {
+                    projects: args.projects
+                } : {},
+                ...!batch && args.project ? {
                     project: args.project
                 } : {},
                 ...args.workspace ? {
@@ -1823,9 +1994,18 @@ async function pollDeviceGrant(args) {
             data
         };
         const error = String(data.error || "");
+        const code = String(data.code || "").trim();
+        const refusal = code ? {
+            code,
+            body: data
+        } : {};
         if ("access_denied" === error) return {
             ok: false,
-            reason: "denied"
+            reason: "denied",
+            ...data.message ? {
+                message: String(data.message)
+            } : {},
+            ...refusal
         };
         if ("expired_token" === error) return {
             ok: false,
@@ -1835,12 +2015,14 @@ async function pollDeviceGrant(args) {
         else if (error && "authorization_pending" !== error) return {
             ok: false,
             reason: "error",
-            message: String(data.message || error)
+            message: String(data.message || error),
+            ...refusal
         };
         else if (!error && !res.ok) return {
             ok: false,
             reason: "error",
-            message: `Device token poll failed (${res.status}): ${String(data.message || text || "no response body").slice(0, 200)}`
+            message: `Device token poll failed (${res.status}): ${String(data.message || text || "no response body").slice(0, 200)}`,
+            ...refusal
         };
         if (Date.now() + 1000 * interval >= deadline) return {
             ok: false,
@@ -1863,55 +2045,716 @@ async function pollDeviceToken(args) {
             creds
         };
     } catch (err) {
-        return {
-            ok: false,
-            reason: "error",
-            message: err?.message ? String(err.message) : String(err)
-        };
+        return {
+            ok: false,
+            reason: "error",
+            message: err?.message ? String(err.message) : String(err)
+        };
+    }
+}
+const FREE_ALLOWANCE_PHRASE = "counts against your free allowance";
+function allowanceWallUrl(apiHint) {
+    return `${mcpOrigins(apiHint).www.replace(/\/+$/, "")}/pricing`;
+}
+function allowance_asRecord(value) {
+    return value && "object" == typeof value && !Array.isArray(value) ? value : null;
+}
+function asCount(value) {
+    return "number" == typeof value && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readPlatformAllowance(body) {
+    const record = allowance_asRecord(body);
+    if (!record) return null;
+    for (const key of [
+        "allowance",
+        "quota"
+    ]){
+        const nested = allowance_asRecord(record[key]);
+        if (!nested) continue;
+        const used = asCount(nested.used);
+        const limit = asCount(nested.limit);
+        if (null !== used && null !== limit) return {
+            used,
+            limit
+        };
+    }
+    return null;
+}
+function spendNarration(options) {
+    const counted = readPlatformAllowance(options.body);
+    return {
+        spent: `${options.what} ran on extension.dev's machines and ${FREE_ALLOWANCE_PHRASE}.`,
+        remains: counted ? `The platform reports ${counted.used} of ${counted.limit} used.` : "The platform sent no remaining count on this call, and this client never invents one. When the allowance runs out, the platform refuses with its own numbers.",
+        wall: `What the free allowance covers and when the paid plan starts are published at ${allowanceWallUrl(options.api)}.`
+    };
+}
+function buildCreateBody(args) {
+    const installCommand = String(args.installCommand || "npm install").trim();
+    const buildCommand = String(args.buildCommand || "npm run build").trim();
+    const wanted = new Set((Array.isArray(args.browsers) && args.browsers.length ? args.browsers : [
+        "chrome"
+    ]).map((name)=>String(name).trim().toLowerCase()));
+    const several = wanted.size > 1;
+    const outputFor = (name)=>{
+        const override = args.outputDirectories?.[name];
+        if ("string" == typeof override && override.trim()) return override.trim();
+        const pattern = String(args.outputDirectory || "").trim();
+        if (pattern.includes("<browser>")) return pattern.replaceAll("<browser>", name);
+        if (pattern && !several) return pattern;
+        return `dist/${name}`;
+    };
+    const browser = (name)=>({
+            enabled: wanted.has(name),
+            installCommand,
+            buildCommand,
+            outputDirectory: outputFor(name)
+        });
+    return {
+        info: {
+            id: "",
+            name: args.projectSlug,
+            displayName: String(args.displayName || args.projectSlug).trim(),
+            description: String(args.description || `Browser extension project for ${args.owner}/${args.repoName}.`).trim()
+        },
+        build: {
+            chrome: browser("chrome"),
+            edge: browser("edge"),
+            firefox: browser("firefox")
+        },
+        deployment: {
+            branch: "",
+            nodeVersion: "",
+            runWhatsNew: false,
+            runExtensionExecutables: false
+        },
+        github: {
+            owner: args.owner,
+            repo: args.repoName,
+            installationId: args.installationId,
+            createdAt: new Date().toISOString(),
+            pullRequestComments: true,
+            commitComments: false
+        },
+        workspaceSlug: args.workspace,
+        createdFrom: {
+            kind: "repository",
+            ref: `${args.owner}/${args.repoName}`
+        }
+    };
+}
+const project_create_batch_COMMAND = "extension_project_create";
+const FIRST_CALL_BUDGET_MS = 8000;
+const RESUME_BUDGET_MS = 22000;
+const SLICE_BUDGET_MS = 20000;
+const GRANT_EXPIRY_MARGIN_SECONDS = 5;
+const ENTRY_KEYS = [
+    "project",
+    "repo",
+    "displayName",
+    "description",
+    "installCommand",
+    "buildCommand",
+    "outputDirectory",
+    "browsers",
+    "outputDirectories"
+];
+const ENTRY_STRING_KEYS = [
+    "displayName",
+    "description",
+    "installCommand",
+    "buildCommand",
+    "outputDirectory"
+];
+const BROWSERS = [
+    "chrome",
+    "edge",
+    "firefox"
+];
+const SINGLE_ONLY_KEYS = [
+    "project",
+    "repo",
+    "displayName",
+    "description"
+];
+const sessions = new Map();
+const SESSION_KEEP_SECONDS = 3600;
+function sweepSessions(nowSeconds) {
+    for (const [key, session] of sessions)if (!session.busy) {
+        if (session.grantExpiresAt <= nowSeconds) session.grant = "";
+        if (session.grantExpiresAt + SESSION_KEEP_SECONDS <= nowSeconds) sessions.delete(key);
+    }
+}
+function fail(name, message, status, code, extra) {
+    return envelope_envelope({
+        ok: false,
+        command: project_create_batch_COMMAND,
+        status,
+        error: {
+            code,
+            name,
+            message
+        },
+        ...extra?.value ? {
+            value: extra.value
+        } : {},
+        ...extra?.hint ? {
+            hint: extra.hint
+        } : {}
+    });
+}
+function laneClosedHint() {
+    return `Create the projects in the console at ${consoleBase()} (workspace page, New project), then run extension_auth (action: login) against them. While the public hold is on, headless creation is open only to workspaces on the platform's allowlist (WWW_MCP_ACTION_ALLOWED_WORKSPACES), the same list that already lets publish, submit and promote run headlessly; this workspace is not on it, so the console is the route.`;
+}
+function isRecord(value) {
+    return Boolean(value) && "object" == typeof value && !Array.isArray(value);
+}
+function parseBatchCreateArgs(args) {
+    for (const key of SINGLE_ONLY_KEYS){
+        const value = args[key];
+        if (null != value && "" !== String(value).trim()) return {
+            ok: false,
+            message: `With projects, ${key} belongs inside each entry, not beside the list. Pass either the single form (project, repo) or projects, not both.`
+        };
+    }
+    if (!Array.isArray(args.projects)) return {
+        ok: false,
+        message: "projects must be an array of entries shaped { project: '<workspace>/<project>', repo: '<owner>/<repo>' }."
+    };
+    const refs = [];
+    for (const entry of args.projects){
+        if (!isRecord(entry)) return {
+            ok: false,
+            message: `Every entry in projects must be an object shaped { project, repo }; got ${JSON.stringify(entry)}. Each new project needs its own source repository, so a bare name is not enough.`
+        };
+        const unknown = Object.keys(entry).filter((key)=>!ENTRY_KEYS.includes(key));
+        if (unknown.length) return {
+            ok: false,
+            message: `Unknown key ${unknown.map((key)=>`'${key}'`).join(", ")} in a projects entry. An entry takes: ${ENTRY_KEYS.join(", ")}.`
+        };
+        refs.push(entry.project);
+    }
+    const parsed = parseProjectBatch(refs);
+    if (!parsed.ok) return parsed;
+    const entries = [];
+    for (const [index, raw] of args.projects.entries()){
+        const ref = parsed.batch.refs[index];
+        const slug = parsed.batch.slugs[index];
+        const repo = "string" == typeof raw.repo ? raw.repo.trim() : "";
+        if (!/^[^/]+\/[^/]+$/.test(repo)) return {
+            ok: false,
+            message: `The entry for '${ref}' needs repo as '<owner>/<repo>', the GitHub repository that project's source is pushed to.`
+        };
+        for (const key of ENTRY_STRING_KEYS)if (void 0 !== raw[key] && "string" != typeof raw[key]) return {
+            ok: false,
+            message: `In the entry for '${ref}', ${key} must be a string.`
+        };
+        if (void 0 !== raw.browsers) {
+            const list = raw.browsers;
+            if (!Array.isArray(list) || 0 === list.length || list.some((name)=>!BROWSERS.includes(String(name)))) return {
+                ok: false,
+                message: `In the entry for '${ref}', browsers must be a non-empty array of: ${BROWSERS.join(", ")}.`
+            };
+        }
+        if (void 0 !== raw.outputDirectories && !isRecord(raw.outputDirectories)) return {
+            ok: false,
+            message: `In the entry for '${ref}', outputDirectories must be an object such as {"edge": "build/edge"}.`
+        };
+        const [owner = "", repoName = ""] = repo.split("/");
+        entries.push({
+            ref,
+            workspace: parsed.batch.workspace,
+            slug,
+            repo,
+            owner,
+            repoName,
+            displayName: raw.displayName,
+            description: raw.description,
+            installCommand: raw.installCommand ?? args.installCommand,
+            buildCommand: raw.buildCommand ?? args.buildCommand,
+            outputDirectory: raw.outputDirectory ?? args.outputDirectory,
+            browsers: raw.browsers ?? args.browsers,
+            outputDirectories: raw.outputDirectories ?? args.outputDirectories
+        });
+    }
+    return {
+        ok: true,
+        workspace: parsed.batch.workspace,
+        entries
+    };
+}
+function pendingEnvelope(args) {
+    const complete = String(args.verificationUriComplete || "").trim();
+    const hasCompleteLink = complete.length > 0 && complete !== args.verificationUri;
+    const again = "then call extension_project_create again with this deviceCode and the same arguments";
+    const page = `The page lists all ${args.refs.length} projects this one approval creates and says this device is also signed in to each for 7 days`;
+    const hint = args.userCode ? hasCompleteLink ? `Open ${complete} and approve creating the projects (code ${args.userCode} is pre-filled). ${page}; ${again}. If the page asks for a code, enter ${args.userCode} at ${args.verificationUri}.` : `Open ${args.verificationUri}, enter code ${args.userCode} and approve creating the projects. ${page}; ${again}.` : `Still waiting for approval at ${args.verificationUri}. Approve there, ${again}.`;
+    return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "authorization-pending",
+        value: {
+            ...args.userCode ? {
+                userCode: args.userCode
+            } : {},
+            verificationUri: args.verificationUri,
+            ...args.userCode && hasCompleteLink ? {
+                verificationUriComplete: complete
+            } : {},
+            deviceCode: args.deviceCode,
+            projects: args.refs
+        },
+        hint
+    });
+}
+const STOP_CODES = new Set([
+    "TOKEN_EXPIRED",
+    "BAD_TOKEN",
+    "AUTH_REQUIRED",
+    "NOT_A_PROVISIONING_GRANT",
+    "MEMBERSHIP_REVOKED",
+    "WORKSPACE_NOT_FOUND",
+    "CLI_PROJECT_CREATE_DISABLED",
+    "PLATFORM_NOT_OPEN",
+    "RATE_LIMITED",
+    "PROJECT_LIMIT_EXCEEDED",
+    "INSTALLATION_ABSENT",
+    "INSTALLATION_ORG_UNSUPPORTED",
+    "INSTALLATION_AMBIGUOUS"
+]);
+function refusalHint(code, ref, retryAfterSeconds) {
+    if ("PROJECT_EXISTS" === code) return `${ref} already exists, so there was nothing to create and no token came back. Sign in to it with extension_auth (action: login).`;
+    if ("RATE_LIMITED" === code) return `${createRateLimitNote()}${retryAfterSeconds ? ` The platform says to wait ${retryAfterSeconds} seconds.` : ""} The grant will have expired by then, so the projects not created need a new extension_project_create call, and its approval, after the wait.`;
+    if ("TOKEN_EXPIRED" === code) return "The provisioning grant lives 15 minutes and ran out. Start a new extension_project_create call for the projects not created.";
+    if ("PROJECT_LIMIT_EXCEEDED" === code) return "The workspace is at its plan's project limit. Nothing more can be created in it until a project is removed or the plan changes.";
+    if ("RESERVED_PROJECT_SLUG" === code) return "That slug is reserved on extension.dev. Pick another name for this project.";
+}
+async function createOne(session, entry, installationId) {
+    const url = `${session.apiBase}/api/cli/projects/create`;
+    const body = {
+        ...buildCreateBody({
+            workspace: entry.workspace,
+            projectSlug: entry.slug,
+            owner: entry.owner,
+            repoName: entry.repoName,
+            installationId,
+            displayName: entry.displayName,
+            description: entry.description,
+            installCommand: entry.installCommand,
+            buildCommand: entry.buildCommand,
+            outputDirectory: entry.outputDirectory,
+            browsers: entry.browsers,
+            outputDirectories: entry.outputDirectories
+        }),
+        project: entry.ref
+    };
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${session.grant}`,
+                "content-type": "application/json",
+                ...identityHeaders(project_create_batch_COMMAND)
+            },
+            body: JSON.stringify(body)
+        });
+    } catch (err) {
+        session.unanswered += 1;
+        const message = `Could not reach ${url}: ${err?.message || err}`;
+        return {
+            row: {
+                project: entry.ref,
+                status: "unconfirmed",
+                message,
+                hint: `The request for ${entry.ref} left this machine and no answer came back, so the project may or may not exist. It is not retried, because a second create racing the first would be two builds claiming one name. Check the console at ${consoleBase()}; if it exists, sign in with extension_auth (action: login).`
+            },
+            halt: true,
+            ...session.unanswered >= 2 ? {
+                stop: {
+                    code: "PLATFORM_UNREACHABLE",
+                    message
+                }
+            } : {}
+        };
+    }
+    session.unanswered = 0;
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    } catch  {
+        data = {
+            message: text
+        };
+    }
+    if (!res.ok) {
+        const held = sawPlatformHold(res, data);
+        const code = held ? "PLATFORM_NOT_OPEN" : String(data.code || "").trim() || `HTTP_${res.status}`;
+        const message = String(data.message || data.error || text || "unknown error").slice(0, 500);
+        const connectUrl = String(data.connectUrl || "").trim();
+        const retryAfterSeconds = Number(data.retryAfterSeconds || res.headers.get("retry-after") || 0) || void 0;
+        const hint = refusalHint(code, entry.ref, retryAfterSeconds);
+        const row = {
+            project: entry.ref,
+            status: "refused",
+            httpStatus: res.status,
+            code,
+            message,
+            ...connectUrl ? {
+                connectUrl
+            } : {},
+            ...retryAfterSeconds ? {
+                retryAfterSeconds
+            } : {},
+            ...hint ? {
+                hint
+            } : {}
+        };
+        return STOP_CODES.has(code) ? {
+            row,
+            stop: {
+                code,
+                message,
+                body: data,
+                held
+            }
+        } : {
+            row
+        };
+    }
+    session.lastBody = data;
+    const finalWorkspace = String(data.workspaceSlug || entry.workspace).trim();
+    const finalProject = String(data.projectSlug || entry.slug).trim();
+    const consoleUrl = consoleProjectUrl({
+        workspace: finalWorkspace,
+        project: finalProject
+    }, "");
+    const token = String(data.token || "").trim();
+    const scoped = finalWorkspace.toLowerCase() === entry.workspace && finalProject.toLowerCase() === entry.slug;
+    if (true === data.tokenIssued && token && scoped) {
+        const expiresAt = Number(data.expiresAt || 0);
+        writeCredentialBatch([
+            {
+                version: 1,
+                token,
+                workspaceSlug: finalWorkspace,
+                projectSlug: finalProject,
+                expiresAt,
+                api: session.apiBase,
+                provider: "extensiondev"
+            }
+        ]);
+        return {
+            row: {
+                project: entry.ref,
+                status: "created",
+                loggedIn: true,
+                projectId: data.projectId ?? null,
+                consoleUrl,
+                expiresAt: expiresAt ? new Date(1000 * expiresAt).toISOString() : null
+            }
+        };
+    }
+    const tokenCode = scoped ? String(data.tokenCode || "").trim() || "NO_TOKEN_IN_RESPONSE" : "PROJECT_NAME_MISMATCH";
+    return {
+        row: {
+            project: entry.ref,
+            status: "created",
+            loggedIn: false,
+            projectId: data.projectId ?? null,
+            consoleUrl,
+            tokenCode,
+            hint: scoped ? `${entry.ref} was created but the platform issued no token for it. Sign in with extension_auth (action: login).` : `The platform registered this project as ${finalWorkspace}/${finalProject}, not the ${entry.ref} that was asked for, so no login was stored. Sign in to the name it has with extension_auth (action: login).`
+        }
+    };
+}
+function rowsInOrder(session) {
+    return session.entries.map((entry)=>session.rows.get(entry.ref) ?? {
+            project: entry.ref,
+            status: "pending"
+        });
+}
+function quoteList(refs) {
+    return `[${refs.map((ref)=>`'${ref}'`).join(", ")}]`;
+}
+function finalEnvelope(session) {
+    const stop = session.stop;
+    for (const entry of session.entries)if (!session.rows.has(entry.ref)) session.rows.set(entry.ref, {
+        project: entry.ref,
+        status: "not-attempted",
+        code: stop?.code ?? "NOT_ATTEMPTED",
+        message: stop ? `Not attempted: an earlier project in this list was refused with ${stop.code}, which applies to the whole approval.` : "Not attempted."
+    });
+    const rows = rowsInOrder(session);
+    const created = rows.filter((row)=>"created" === row.status);
+    const loggedIn = created.filter((row)=>"created" === row.status && row.loggedIn);
+    const needLogin = [
+        ...created.filter((row)=>"created" === row.status && !row.loggedIn),
+        ...rows.filter((row)=>"refused" === row.status && "PROJECT_EXISTS" === row.code)
+    ].map((row)=>row.project);
+    const retry = rows.filter((row)=>"not-attempted" === row.status || "refused" === row.status && "PROJECT_EXISTS" !== row.code).map((row)=>row.project);
+    const unconfirmed = rows.filter((row)=>"unconfirmed" === row.status).map((row)=>row.project);
+    if (0 === created.length && stop?.held) return platformHoldEnvelope({
+        command: project_create_batch_COMMAND,
+        name: "CreateHeld",
+        body: stop.body,
+        value: {
+            workspace: session.workspace,
+            projects: session.refs,
+            results: rows
+        }
+    });
+    if (0 === created.length && stop?.code === "CLI_PROJECT_CREATE_DISABLED") return fail("CreateClosed", stop.message, "lane-closed", "E_PLATFORM", {
+        hint: laneClosedHint(),
+        value: {
+            workspaceSlug: session.workspace,
+            results: rows
+        }
+    });
+    const nextSteps = [
+        ...needLogin.length ? [
+            `extension_auth (action: login, projects: ${quoteList(needLogin)})`
+        ] : [],
+        ...retry.length ? [
+            `extension_project_create with projects limited to ${quoteList(retry)}, once what refused them is fixed (a new approval; a create list may only name projects that do not exist yet)`
+        ] : [],
+        ...unconfirmed.length ? [
+            `check ${quoteList(unconfirmed)} in the console at ${consoleBase()} before creating them again`
+        ] : [],
+        ...loggedIn.length ? [
+            "extension_publish (project: one of the logged-in projects)"
+        ] : []
+    ];
+    const value = {
+        workspaceSlug: session.workspace,
+        results: rows,
+        counts: {
+            listed: rows.length,
+            created: created.length,
+            loggedIn: loggedIn.length,
+            refused: rows.filter((row)=>"refused" === row.status).length,
+            unconfirmed: unconfirmed.length,
+            notAttempted: rows.filter((row)=>"not-attempted" === row.status).length
+        },
+        ...created.length ? {
+            allowance: spendNarration({
+                what: `Creating ${created.length} project${1 === created.length ? "" : "s"}, including each first build,`,
+                body: session.lastBody ?? void 0,
+                api: session.apiBase
+            })
+        } : {},
+        nextSteps
+    };
+    const spent = "The provisioning grant is spent or discarded and was never written to this machine.";
+    if (created.length === rows.length) return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "created",
+        value,
+        hint: 0 === needLogin.length ? `All ${rows.length} projects exist, each first build was dispatched, and this machine is signed in to every one of them for 7 days. ${spent} Token-scoped tools take \`project\` to pick one.` : `All ${rows.length} projects exist and each first build was dispatched, but no token was stored for ${needLogin.join(", ")}. ${spent} Sign in to those with one batch login: ${nextSteps[0]}.`,
+        ...needLogin.length ? {
+            warnings: [
+                `Created without a stored login: ${needLogin.join(", ")}. Run ${nextSteps[0]}.`
+            ]
+        } : {}
+    });
+    return envelope_envelope({
+        ok: false,
+        command: project_create_batch_COMMAND,
+        status: "batch-incomplete",
+        error: {
+            code: "E_PLATFORM",
+            name: "BatchIncomplete",
+            message: `${created.length} of ${rows.length} projects were created. Each project has its own row in results with the platform's code; nothing is retried automatically.${stop ? ` The list stopped at ${stop.code}: ${stop.message}` : ""}`
+        },
+        value,
+        hint: `${spent} ${stop?.code === "RATE_LIMITED" ? `${createRateLimitNote()} ` : ""}Next: ${nextSteps.join("; then ") || "read results"}.`
+    });
+}
+async function runSlice(session, deviceCode, installationId) {
+    if (session.busy) return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "creating",
+        value: {
+            workspaceSlug: session.workspace,
+            deviceCode,
+            results: rowsInOrder(session)
+        },
+        hint: "Another call with this deviceCode is creating projects right now. Wait for it to answer, then call again with the same deviceCode and arguments if projects are still pending."
+    });
+    session.busy = true;
+    let halted = false;
+    try {
+        const started = Date.now();
+        let attempted = 0;
+        for (const entry of session.entries){
+            if (session.rows.has(entry.ref)) continue;
+            if (session.stop) break;
+            if (Math.floor(Date.now() / 1000) >= session.grantExpiresAt - GRANT_EXPIRY_MARGIN_SECONDS) {
+                session.stop = {
+                    code: "TOKEN_EXPIRED",
+                    message: "The provisioning grant expired; it lives fifteen minutes."
+                };
+                break;
+            }
+            if (attempted > 0 && Date.now() - started >= SLICE_BUDGET_MS) break;
+            attempted += 1;
+            const outcome = await createOne(session, entry, installationId);
+            session.rows.set(entry.ref, outcome.row);
+            if (outcome.stop) session.stop = outcome.stop;
+            if (outcome.halt) {
+                halted = true;
+                break;
+            }
+        }
+    } finally{
+        session.busy = false;
+    }
+    const remaining = session.entries.filter((entry)=>!session.rows.has(entry.ref));
+    if (remaining.length > 0 && !session.stop) {
+        const done = session.entries.length - remaining.length;
+        return envelope_envelope({
+            ok: true,
+            command: project_create_batch_COMMAND,
+            status: "creating",
+            value: {
+                workspaceSlug: session.workspace,
+                deviceCode,
+                results: rowsInOrder(session),
+                remaining: remaining.map((entry)=>entry.ref)
+            },
+            hint: `${done} of ${session.entries.length} projects handled so far; ${remaining.length} still to create. Call extension_project_create again with this same deviceCode and the same arguments to continue. No new approval is needed: the grant is held in this server's memory until ${new Date(1000 * session.grantExpiresAt).toISOString()} and is lost if the server restarts.${halted ? " The last request got no answer, so its project is marked unconfirmed and is not retried." : ""}`
+        });
+    }
+    sessions.delete(deviceCode);
+    return finalEnvelope(session);
+}
+async function createProjectBatch(args) {
+    const parsed = parseBatchCreateArgs(args);
+    if (!parsed.ok) return fail("BadRequest", parsed.message, "bad-request", "E_BAD_REQUEST", {
+        hint: parsed.hint
+    });
+    const installationId = String(args.installationId || "").trim();
+    if (installationId && !/^\d+$/.test(installationId)) return fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
+    const refs = parsed.entries.map((entry)=>entry.ref);
+    const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
+    if (!apiCheck.ok) return fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
+    const apiBase = apiCheck.base;
+    sweepSessions(Math.floor(Date.now() / 1000));
+    let deviceCode = String(args.deviceCode || "").trim();
+    const held = deviceCode ? sessions.get(deviceCode) : void 0;
+    if (held) {
+        if (held.apiBase !== apiBase || !sameProjectSet(held.refs, refs)) return fail("BadRequest", `This deviceCode belongs to an approval for ${quoteList(held.refs)}. Call again with that same list, or start a new call without deviceCode for a different one.`, "bad-request", "E_BAD_REQUEST");
+        return runSlice(held, deviceCode, installationId || void 0);
+    }
+    let config;
+    try {
+        config = await fetchLoginConfig(apiBase);
+    } catch (err) {
+        return fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
     }
-}
-const FREE_ALLOWANCE_PHRASE = "counts against your free allowance";
-function allowanceWallUrl(apiHint) {
-    return `${mcpOrigins(apiHint).www.replace(/\/+$/, "")}/pricing`;
-}
-function allowance_asRecord(value) {
-    return value && "object" == typeof value && !Array.isArray(value) ? value : null;
-}
-function asCount(value) {
-    return "number" == typeof value && Number.isFinite(value) && value >= 0 ? value : null;
-}
-function readPlatformAllowance(body) {
-    const record = allowance_asRecord(body);
-    if (!record) return null;
-    for (const key of [
-        "allowance",
-        "quota"
-    ]){
-        const nested = allowance_asRecord(record[key]);
-        if (!nested) continue;
-        const used = asCount(nested.used);
-        const limit = asCount(nested.limit);
-        if (null !== used && null !== limit) return {
-            used,
-            limit
-        };
+    if (!config.batch) return fail("CreateBatchUnsupported", BATCH_UNSUPPORTED_MESSAGE, "batch-unsupported", "E_PLATFORM", {
+        value: {
+            projects: refs
+        },
+        hint: "Create the projects one extension_project_create call each (project, repo)."
+    });
+    const createCap = config.batch.createProjectsPerApproval;
+    if (refs.length > createCap) return fail("BadRequest", `projects names ${refs.length} projects to create, and one approval creates at most ${createCap} on this platform.`, "bad-request", "E_BAD_REQUEST", {
+        value: {
+            maxProjects: createCap,
+            listed: refs.length
+        },
+        hint: `${createCapNote(createCap)} ${createRateLimitNote()} Nothing was started and no device code was spent.`
+    });
+    let interval = 5;
+    let budgetMs = RESUME_BUDGET_MS;
+    let start = null;
+    if (!deviceCode) {
+        try {
+            start = await requestDeviceCode({
+                apiBase,
+                path: config.deviceCodeUrl,
+                projects: refs,
+                intent: "create"
+            });
+        } catch (err) {
+            const serverCode = String(err?.serverCode || "");
+            const serverMessage = "string" == typeof err?.serverMessage ? err.serverMessage.trim() : "";
+            if ("CLI_PROJECT_CREATE_DISABLED" === serverCode) return fail("CreateStartError", serverMessage || "Headless project creation is not open on this host yet.", "lane-closed", "E_PLATFORM", {
+                hint: laneClosedHint()
+            });
+            return fail("CreateStartError", String(err?.message || "Could not start the device flow."), "create-failed", "E_PLATFORM", {
+                hint: "No device code was issued and nothing was created. Fix what the platform refused and try the list again, or create the projects one extension_project_create call each (project, repo)."
+            });
+        }
+        deviceCode = start.deviceCode;
+        interval = start.interval;
+        budgetMs = FIRST_CALL_BUDGET_MS;
     }
-    return null;
-}
-function spendNarration(options) {
-    const counted = readPlatformAllowance(options.body);
-    return {
-        spent: `${options.what} ran on extension.dev's machines and ${FREE_ALLOWANCE_PHRASE}.`,
-        remains: counted ? `The platform reports ${counted.used} of ${counted.limit} used.` : "The platform sent no remaining count on this call, and this client never invents one. When the allowance runs out, the platform refuses with its own numbers.",
-        wall: `What the free allowance covers and when the paid plan starts are published at ${allowanceWallUrl(options.api)}.`
+    const poll = await pollDeviceGrant({
+        apiBase,
+        path: config.deviceTokenUrl,
+        projects: refs,
+        deviceCode,
+        interval,
+        budgetMs
+    });
+    if (!poll.ok) {
+        if ("pending" === poll.reason) return pendingEnvelope({
+            deviceCode,
+            refs,
+            verificationUri: start?.verificationUri ?? config.verificationUri,
+            userCode: start?.userCode,
+            verificationUriComplete: start?.verificationUriComplete
+        });
+        const code = String(poll.code || "");
+        if ("CLI_PROJECT_CREATE_DISABLED" === code) return fail("CreateClosed", poll.message || "Headless project creation is not open yet.", "lane-closed", "E_PLATFORM", {
+            hint: laneClosedHint()
+        });
+        if ("denied" === poll.reason) return fail("CreateDenied", "Creating the projects was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
+        if ("expired" === poll.reason) return fail("CreateExpired", "The device code expired or was already redeemed. If an earlier call with this deviceCode had started creating projects and this server restarted since, the grant it held is gone: the projects it created still exist.", "create-expired", "E_AUTH_EXPIRED", {
+            hint: `Check which of ${quoteList(refs)} exist in the console at ${consoleBase()}. Sign in to those with extension_auth (action: login, projects), and start a new extension_project_create call naming only the ones that do not exist yet.`
+        });
+        return fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED", {
+            value: {
+                ...code ? {
+                    code
+                } : {},
+                projects: refs
+            }
+        });
+    }
+    const grant = poll.data;
+    const token = String(grant.token || "").trim();
+    const grantWorkspace = String(grant.workspaceSlug || "").trim().toLowerCase();
+    const grantSlugs = Array.isArray(grant.projectSlugs) ? grant.projectSlugs.map((slug)=>String(slug).toLowerCase()) : null;
+    if ("provisioning" !== String(grant.tokenKind || "") || !grantSlugs || grantWorkspace !== parsed.workspace || !sameProjectSet(grantSlugs, parsed.entries.map((entry)=>entry.slug))) return fail("CreateScopeError", `The approval did not come back as a provisioning grant for exactly ${quoteList(refs)}, so it was discarded and nothing was created. Run extension_project_create again.`, "create-failed", "E_AUTH_FAILED", {
+        hint: "If one of these projects already exists, a create list is refused: sign in to existing projects with extension_auth (action: login, projects) and list only new ones here."
+    });
+    const session = {
+        apiBase,
+        workspace: parsed.workspace,
+        refs,
+        entries: parsed.entries,
+        grant: token,
+        grantExpiresAt: Number(grant.expiresAt || 0) || Math.floor(Date.now() / 1000) + 900,
+        rows: new Map(),
+        busy: false,
+        stop: null,
+        lastBody: null,
+        unanswered: 0
     };
+    sessions.set(deviceCode, session);
+    return runSlice(session, deviceCode, installationId || void 0);
 }
 const project_create_COMMAND = "extension_project_create";
-const FIRST_CALL_BUDGET_MS = 8000;
-const RESUME_BUDGET_MS = 22000;
+const project_create_FIRST_CALL_BUDGET_MS = 8000;
+const project_create_RESUME_BUDGET_MS = 22000;
 const project_create_schema = {
     name: "extension_project_create",
-    description: "Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where the signed-in workspace owner approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project, its mirror repository, and dispatches the first build. Then run extension_auth (action: login) against the new project, and extension_publish to share it.",
+    description: "Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where the signed-in workspace owner approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project, its mirror repository, and dispatches the first build. Then run extension_auth (action: login) against the new project, and extension_publish to share it. To create several projects in one workspace under one approval, pass `projects` instead of `project` and `repo`: the approval page lists every name, each project is created by its own request, and each one's 7-day token is stored as that project's login, so no extension_auth call is needed afterwards. A list takes a few calls to finish: while projects remain the answer is status 'creating' with the same deviceCode to call again, and the grant is held in this server's memory only. One approval creates at most 10 projects, the cap the platform states in its login config, because it creates at most 10 per hour for one approving account; the next 10 can start in a new call once that limit allows. A longer list is refused before any approval is asked for, never split silently, and so is any list on a platform that does not advertise batch onboarding.",
     inputSchema: {
         type: "object",
         properties: {
@@ -1969,19 +2812,23 @@ const project_create_schema = {
                 type: "object",
                 description: "Per-browser output directory overrides, for example {\"edge\": \"build/manifestv3\"}. A browser named here wins over `outputDirectory`."
             },
+            projects: {
+                type: "array",
+                items: {
+                    type: "object"
+                },
+                description: "Create several projects in one workspace under one approval, instead of `project` and `repo`. 1 to 10 entries (the platform's cap per approval; never more than 20), each { project: '<workspace>/<project>', repo: '<owner>/<repo>' }, all in the same workspace, each project named by its exact slug (lowercase letters and digits joined by single dashes, at most 48 characters), none twice and none existing yet. An entry may also carry displayName, description, installCommand, buildCommand, outputDirectory, browsers and outputDirectories for that project alone; the same inputs at the top level are the shared default for every entry that leaves them out. The answer carries one row per project: created and logged in, created with no token (run a batch extension_auth login), refused with the platform's code, or not attempted. A refusal on one project never hides the others."
+            },
             deviceCode: {
                 type: "string",
-                description: "Resume token from the prior call's `deviceCode`; omit on the first call."
+                description: "Resume token from the prior call's `deviceCode`; omit on the first call. A batch returns the same deviceCode until every listed project has an answer."
             },
             api: API_BASE
         },
-        required: [
-            "project",
-            "repo"
-        ]
+        required: []
     }
 };
-function fail(name, message, status, code, hint) {
+function project_create_fail(name, message, status, code, hint) {
     return envelope_envelope({
         ok: false,
         command: project_create_COMMAND,
@@ -1996,10 +2843,10 @@ function fail(name, message, status, code, hint) {
         } : {}
     });
 }
-function laneClosedHint() {
+function project_create_laneClosedHint() {
     return `Create the project in the console at ${consoleBase()} (workspace page, New project), then run extension_auth (action: login) against it. While the public hold is on, headless creation is open only to workspaces on the platform's allowlist (WWW_MCP_ACTION_ALLOWED_WORKSPACES), the same list that already lets publish, submit and promote run headlessly; this workspace is not on it, so the console is the route.`;
 }
-function pendingEnvelope(start) {
+function project_create_pendingEnvelope(start) {
     const complete = String(start.verificationUriComplete || "").trim();
     const hasCompleteLink = complete.length > 0 && complete !== start.verificationUri;
     const message = hasCompleteLink ? `Open ${complete} and approve creating the project (code ${start.userCode} is pre-filled), then call extension_project_create again with this deviceCode and the same arguments. If the page asks for a code, enter ${start.userCode} at ${start.verificationUri}.` : `Open ${start.verificationUri}, enter code ${start.userCode}, approve creating the project, then call extension_project_create again with this deviceCode and the same arguments.`;
@@ -2018,79 +2865,26 @@ function pendingEnvelope(start) {
         hint: message
     });
 }
-function buildCreateBody(args) {
-    const installCommand = String(args.installCommand || "npm install").trim();
-    const buildCommand = String(args.buildCommand || "npm run build").trim();
-    const wanted = new Set((Array.isArray(args.browsers) && args.browsers.length ? args.browsers : [
-        "chrome"
-    ]).map((name)=>String(name).trim().toLowerCase()));
-    const several = wanted.size > 1;
-    const outputFor = (name)=>{
-        const override = args.outputDirectories?.[name];
-        if ("string" == typeof override && override.trim()) return override.trim();
-        const pattern = String(args.outputDirectory || "").trim();
-        if (pattern.includes("<browser>")) return pattern.replaceAll("<browser>", name);
-        if (pattern && !several) return pattern;
-        return `dist/${name}`;
-    };
-    const browser = (name)=>({
-            enabled: wanted.has(name),
-            installCommand,
-            buildCommand,
-            outputDirectory: outputFor(name)
-        });
-    return {
-        info: {
-            id: "",
-            name: args.projectSlug,
-            displayName: String(args.displayName || args.projectSlug).trim(),
-            description: String(args.description || `Browser extension project for ${args.owner}/${args.repoName}.`).trim()
-        },
-        build: {
-            chrome: browser("chrome"),
-            edge: browser("edge"),
-            firefox: browser("firefox")
-        },
-        deployment: {
-            branch: "",
-            nodeVersion: "",
-            runWhatsNew: false,
-            runExtensionExecutables: false
-        },
-        github: {
-            owner: args.owner,
-            repo: args.repoName,
-            installationId: args.installationId,
-            createdAt: new Date().toISOString(),
-            pullRequestComments: true,
-            commitComments: false
-        },
-        workspaceSlug: args.workspace,
-        createdFrom: {
-            kind: "repository",
-            ref: `${args.owner}/${args.repoName}`
-        }
-    };
-}
 async function project_create_handler(args) {
+    if (void 0 !== args.projects && null !== args.projects) return createProjectBatch(args);
     const project = String(args.project || "").trim();
-    if (!/^[^/]+\/[^/]+$/.test(project)) return fail("BadRequest", "project must be in the form '<workspace>/<project>'.", "bad-request", "E_BAD_REQUEST");
+    if (!/^[^/]+\/[^/]+$/.test(project)) return project_create_fail("BadRequest", "project must be in the form '<workspace>/<project>'.", "bad-request", "E_BAD_REQUEST");
     const repo = String(args.repo || "").trim();
-    if (!/^[^/]+\/[^/]+$/.test(repo)) return fail("BadRequest", "repo must be in the form '<owner>/<repo>', a GitHub repository the extension's source is pushed to.", "bad-request", "E_BAD_REQUEST");
+    if (!/^[^/]+\/[^/]+$/.test(repo)) return project_create_fail("BadRequest", "repo must be in the form '<owner>/<repo>', a GitHub repository the extension's source is pushed to.", "bad-request", "E_BAD_REQUEST");
     const installationId = String(args.installationId || "").trim();
-    if (installationId && !/^\d+$/.test(installationId)) return fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
+    if (installationId && !/^\d+$/.test(installationId)) return project_create_fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
     const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
-    if (!apiCheck.ok) return fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
+    if (!apiCheck.ok) return project_create_fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
     const apiBase = apiCheck.base;
     let config;
     try {
         config = await fetchLoginConfig(apiBase);
     } catch (err) {
-        return fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
+        return project_create_fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
     }
     let deviceCode = String(args.deviceCode || "").trim();
     let interval = 5;
-    let budgetMs = RESUME_BUDGET_MS;
+    let budgetMs = project_create_RESUME_BUDGET_MS;
     if (!deviceCode) {
         let start;
         try {
@@ -2104,11 +2898,11 @@ async function project_create_handler(args) {
             const message = err?.message || "Could not start the device flow.";
             const laneClosed = /CLI_PROJECT_CREATE_DISABLED|403/.test(String(message));
             const serverMessage = "string" == typeof err?.serverMessage ? err.serverMessage.trim() : "";
-            return fail("CreateStartError", laneClosed ? serverMessage || `Headless project creation is not open on this host yet. Create the project in the console instead, then run extension_auth (action: login) against it. (${message})` : String(message), laneClosed ? "lane-closed" : "create-failed", "E_PLATFORM", laneClosed ? laneClosedHint() : void 0);
+            return project_create_fail("CreateStartError", laneClosed ? serverMessage || `Headless project creation is not open on this host yet. Create the project in the console instead, then run extension_auth (action: login) against it. (${message})` : String(message), laneClosed ? "lane-closed" : "create-failed", "E_PLATFORM", laneClosed ? project_create_laneClosedHint() : void 0);
         }
         deviceCode = start.deviceCode;
         interval = start.interval;
-        budgetMs = FIRST_CALL_BUDGET_MS;
+        budgetMs = project_create_FIRST_CALL_BUDGET_MS;
         const early = await pollDeviceGrant({
             apiBase,
             path: config.deviceTokenUrl,
@@ -2117,7 +2911,7 @@ async function project_create_handler(args) {
             interval,
             budgetMs
         });
-        if (!early.ok && "pending" === early.reason) return pendingEnvelope(start);
+        if (!early.ok && "pending" === early.reason) return project_create_pendingEnvelope(start);
         return finishFromPoll(early, {
             apiBase,
             project,
@@ -2154,16 +2948,16 @@ async function finishFromPoll(poll, ctx) {
             },
             hint: `Still waiting for approval at ${ctx.verificationUri}. Approve there, then call extension_project_create again with this same deviceCode.`
         });
-        if ("denied" === poll.reason) return fail("CreateDenied", "Creating the project was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
-        if ("expired" === poll.reason) return fail("CreateExpired", "The device code expired. Run extension_project_create again to restart.", "create-expired", "E_AUTH_EXPIRED");
-        return fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED");
+        if ("denied" === poll.reason) return project_create_fail("CreateDenied", "Creating the project was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
+        if ("expired" === poll.reason) return project_create_fail("CreateExpired", "The device code expired. Run extension_project_create again to restart.", "create-expired", "E_AUTH_EXPIRED");
+        return project_create_fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED");
     }
     const grant = poll.data;
     const token = String(grant.token || "").trim();
     const workspaceSlug = String(grant.workspaceSlug || "").trim();
     const projectSlug = String(grant.projectSlug || "").trim();
     const [wantWorkspace = "", wantProject = ""] = ctx.project.split("/");
-    if (workspaceSlug.toLowerCase() !== wantWorkspace.toLowerCase() || projectSlug.toLowerCase() !== wantProject.toLowerCase()) return fail("CreateScopeError", `The approval was scoped to ${workspaceSlug}/${projectSlug}, not the requested ${ctx.project}. Nothing was created. Run extension_project_create again with the intended project.`, "create-failed", "E_AUTH_FAILED");
+    if (workspaceSlug.toLowerCase() !== wantWorkspace.toLowerCase() || projectSlug.toLowerCase() !== wantProject.toLowerCase()) return project_create_fail("CreateScopeError", `The approval was scoped to ${workspaceSlug}/${projectSlug}, not the requested ${ctx.project}. Nothing was created. Run extension_project_create again with the intended project.`, "create-failed", "E_AUTH_FAILED");
     if ("provisioning" !== String(grant.tokenKind || "")) return envelope_envelope({
         ok: false,
         command: project_create_COMMAND,
@@ -2174,7 +2968,7 @@ async function finishFromPoll(poll, ctx) {
         },
         hint: `Run extension_auth (action: login) with project '${ctx.project}' instead; the login lane mints the project token this tool deliberately does not.`
     });
-    const [owner = "", repoName = ""] = ctx.args.repo.split("/");
+    const [owner = "", repoName = ""] = String(ctx.args.repo || "").split("/");
     const body = buildCreateBody({
         workspace: wantWorkspace,
         projectSlug: wantProject,
@@ -2202,7 +2996,7 @@ async function finishFromPoll(poll, ctx) {
             body: JSON.stringify(body)
         });
     } catch (err) {
-        return fail("CreateNetworkError", `Could not reach ${url}: ${err?.message || err}`, "create-failed", "E_NETWORK");
+        return project_create_fail("CreateNetworkError", `Could not reach ${url}: ${err?.message || err}`, "create-failed", "E_NETWORK");
     }
     const text = await res.text();
     let data;
@@ -2224,7 +3018,7 @@ async function finishFromPoll(poll, ctx) {
                 project: wantProject
             }
         });
-        if ("CLI_PROJECT_CREATE_DISABLED" === code) return fail("CreateClosed", String(data.message || "Headless project creation is not open yet."), "lane-closed", "E_PLATFORM", laneClosedHint());
+        if ("CLI_PROJECT_CREATE_DISABLED" === code) return project_create_fail("CreateClosed", String(data.message || "Headless project creation is not open yet."), "lane-closed", "E_PLATFORM", project_create_laneClosedHint());
         const connectUrl = String(data.connectUrl || "").trim();
         if ("INSTALLATION_ABSENT" === code || "INSTALLATION_ORG_UNSUPPORTED" === code || "INSTALLATION_AMBIGUOUS" === code) return envelope_envelope({
             ok: false,
@@ -2252,7 +3046,7 @@ async function finishFromPoll(poll, ctx) {
             },
             hint: `Run extension_auth (action: login) with project '${ctx.project}'.`
         });
-        return fail("CreateError", `create failed (${res.status}): ${String(data.message || data.error || text || "unknown error").slice(0, 500)}`, "create-failed", "E_PLATFORM");
+        return project_create_fail("CreateError", `create failed (${res.status}): ${String(data.message || data.error || text || "unknown error").slice(0, 500)}`, "create-failed", "E_PLATFORM");
     }
     const finalWorkspace = String(data.workspaceSlug || wantWorkspace);
     const finalProject = String(data.projectSlug || wantProject);
@@ -3053,7 +3847,7 @@ async function outputFlagRefusalMessage(command, cliName, projectPath) {
     if (true === verdict.supported) return `${preamble} It reports ${verdict.version}, which is at or above ${verdict.floor}, the release where that flag reached \`extension ${cliName}\`, so the binary being run is not the version it claims to be. ${why} Check the project's node_modules/.bin/extension and reinstall it, rather than upgrading a version that already looks new enough.`;
     return `${preamble} Its version could not be read, so the cause cannot be confirmed, but that flag only reached \`extension ${cliName}\` in ${verdict.floor} and a refusal is what an engine below that does. ${why} Check the project's Extension.js install and bring it to ${verdict.floor} or newer.`;
 }
-const sessions = new Map();
+const process_manager_sessions = new Map();
 const registrationStamps = new Map();
 function sessionKey(projectPath, browser) {
     return `${node_path.resolve(projectPath)}::${browser}`;
@@ -3114,7 +3908,7 @@ function registerSession(info) {
         pid: info.pid,
         at
     });
-    sessions.set(key, info);
+    process_manager_sessions.set(key, info);
     writeMarkerBestEffort(info, at);
 }
 function sessionSinceMs(projectPath, browser) {
@@ -3132,19 +3926,19 @@ function sessionSinceMs(projectPath, browser) {
     return null;
 }
 function findSessionInfo(projectPath, browser) {
-    const inMemory = sessions.get(sessionKey(projectPath, browser));
+    const inMemory = process_manager_sessions.get(sessionKey(projectPath, browser));
     if (inMemory) return inMemory;
     const resolved = node_path.resolve(projectPath);
     for (const marker of listSessionMarkers())if (node_path.resolve(marker.projectPath) === resolved && marker.browser === browser) return marker;
 }
 function removeSession(projectPath, browser, pid) {
     const key = sessionKey(projectPath, browser);
-    if (void 0 !== pid && sessions.get(key)?.pid !== pid) return;
-    sessions.delete(key);
+    if (void 0 !== pid && process_manager_sessions.get(key)?.pid !== pid) return;
+    process_manager_sessions.delete(key);
     registrationStamps.delete(key);
 }
 function listSessions() {
-    return Array.from(sessions.values());
+    return Array.from(process_manager_sessions.values());
 }
 const PROJECT_MANIFEST_FILENAMES = [
     "package.json",
@@ -13567,46 +14361,263 @@ async function rdpCollectConsoleMessages(port, options) {
         if (!watcherActor) throw new Error("tab descriptor returned no watcher");
         const messages = [];
         const untap = session.tap((packet)=>{
-            if ("resources-available-array" !== packet.type) return;
-            const array = Array.isArray(packet.array) ? packet.array : [];
-            for (const entry of array){
-                if (!Array.isArray(entry) || entry.length < 2) continue;
-                const [resourceType, resources] = entry;
-                if (Array.isArray(resources)) for (const raw of resources){
-                    const resource = raw;
-                    if ("console-message" === resourceType) {
-                        const args = Array.isArray(resource.arguments) ? resource.arguments : [];
-                        messages.push({
-                            level: String(resource.level ?? "log"),
-                            text: args.map(formatConsoleArg).join(" ")
-                        });
-                    } else if ("error-message" === resourceType) {
-                        const pageError = resource.pageError ?? {};
-                        messages.push({
-                            level: true === pageError.warning ? "warn" : "error",
-                            text: String(pageError.errorMessage ?? "")
-                        });
-                    }
-                }
-            }
+            if ("resources-available-array" !== packet.type) return;
+            const array = Array.isArray(packet.array) ? packet.array : [];
+            for (const entry of array){
+                if (!Array.isArray(entry) || entry.length < 2) continue;
+                const [resourceType, resources] = entry;
+                if (Array.isArray(resources)) for (const raw of resources){
+                    const resource = raw;
+                    if ("console-message" === resourceType) {
+                        const args = Array.isArray(resource.arguments) ? resource.arguments : [];
+                        messages.push({
+                            level: String(resource.level ?? "log"),
+                            text: args.map(formatConsoleArg).join(" ")
+                        });
+                    } else if ("error-message" === resourceType) {
+                        const pageError = resource.pageError ?? {};
+                        messages.push({
+                            level: true === pageError.warning ? "warn" : "error",
+                            text: String(pageError.errorMessage ?? "")
+                        });
+                    }
+                }
+            }
+        });
+        try {
+            await session.request(watcherActor, {
+                type: "watchTargets",
+                targetType: "frame"
+            }, timeoutMs);
+            await session.request(watcherActor, {
+                type: "watchResources",
+                resourceTypes: [
+                    "console-message",
+                    "error-message"
+                ]
+            }, timeoutMs);
+            await new Promise((resolve)=>setTimeout(resolve, settleMs));
+        } finally{
+            untap();
+        }
+        return messages;
+    });
+}
+const RDP_EVAL_SLOT = "__extensionDevRdpEval";
+const RDP_FRAME_WAIT_MS = 5000;
+const RDP_FRAME_POLL_MS = 50;
+const RDP_RESULT_POLL_MS = 100;
+function rdpStartExpression(expression, token) {
+    const key = JSON.stringify(token);
+    return `(function () {
+  var store = globalThis.${RDP_EVAL_SLOT} = globalThis.${RDP_EVAL_SLOT} || {};
+  store[${key}] = { state: "pending" };
+  function settle(next) { store[${key}] = next; }
+  function encode(value) {
+    if (value === undefined) return { state: "value" };
+    var json;
+    try { json = JSON.stringify(value); } catch (error) { json = undefined; }
+    return { state: "value", json: json === undefined ? JSON.stringify(String(value)) : json };
+  }
+  function thrown(error) {
+    return { state: "throw", name: (error && error.name) || "EvalError", message: (error && error.message) || String(error) };
+  }
+  try {
+    Promise.resolve((${expression}
+)).then(function (value) { settle(encode(value)); }, function (error) { settle(thrown(error)); });
+  } catch (error) {
+    settle(thrown(error));
+  }
+  return "started";
+})()`;
+}
+function rdpPollExpression(token) {
+    const key = JSON.stringify(token);
+    return `(function () {
+  var store = globalThis.${RDP_EVAL_SLOT};
+  var entry = (store && store[${key}]) || null;
+  if (entry && entry.state !== "pending") {
+    delete store[${key}];
+    if (Object.keys(store).length === 0) { try { delete globalThis.${RDP_EVAL_SLOT}; } catch (error) {} }
+  }
+  var encoded = JSON.stringify(entry);
+  return encoded;
+})()`;
+}
+function readRdpEvalSlot(raw) {
+    if ("string" != typeof raw) return "lost";
+    let slot;
+    try {
+        slot = JSON.parse(raw);
+    } catch  {
+        return "lost";
+    }
+    if (!slot || "object" != typeof slot) return "lost";
+    if ("pending" === slot.state) return "pending";
+    if ("throw" === slot.state) return {
+        ok: false,
+        name: "string" == typeof slot.name && slot.name ? slot.name : "EvalError",
+        message: "string" == typeof slot.message && slot.message ? slot.message : "the expression threw inside the document"
+    };
+    if ("value" !== slot.state) return "lost";
+    if ("string" != typeof slot.json) return {
+        ok: true,
+        value: null
+    };
+    try {
+        return {
+            ok: true,
+            value: JSON.parse(slot.json)
+        };
+    } catch  {
+        return {
+            ok: true,
+            value: slot.json
+        };
+    }
+}
+function exceptionText(packet) {
+    const message = packet.exceptionMessage;
+    if ("string" == typeof message) return message;
+    const initial = message?.initial;
+    if ("string" == typeof initial) return initial;
+    return true === packet.hasException || void 0 !== packet.exception && null !== packet.exception ? "the expression threw inside the document" : "";
+}
+async function readStringResult(session, result, timeoutMs) {
+    if (!result || "object" != typeof result) return result;
+    const grip = result;
+    if ("longString" !== grip.type || "string" != typeof grip.actor) return result;
+    const length = "number" == typeof grip.length ? grip.length : 0;
+    const reply = await session.request(grip.actor, {
+        type: "substring",
+        start: 0,
+        end: length
+    }, timeoutMs);
+    return "string" == typeof reply.substring ? reply.substring : grip.initial;
+}
+async function consoleEvaluate(session, consoleActor, text, timeoutMs) {
+    const results = [];
+    let wake = null;
+    const untap = session.tap((packet)=>{
+        if (packet.from !== consoleActor || "evaluationResult" !== packet.type) return;
+        results.push(packet);
+        wake?.();
+    });
+    try {
+        const reply = await session.request(consoleActor, {
+            type: "evaluateJSAsync",
+            text
+        }, timeoutMs);
+        const resultId = String(reply.resultID ?? "");
+        const deadline = Date.now() + timeoutMs;
+        for(;;){
+            const hit = results.find((p)=>String(p.resultID ?? "") === resultId);
+            if (hit) return {
+                result: await readStringResult(session, hit.result, timeoutMs),
+                threw: exceptionText(hit)
+            };
+            const left = deadline - Date.now();
+            if (left <= 0) throw new Error(`Firefox sent no evaluation result within ${timeoutMs}ms`);
+            await new Promise((resolve)=>{
+                const timer = setTimeout(resolve, Math.min(left, 250));
+                wake = ()=>{
+                    clearTimeout(timer);
+                    resolve();
+                };
+            });
+            wake = null;
+        }
+    } finally{
+        untap();
+    }
+}
+function topFrameConsoleActor(frames) {
+    const usable = frames.filter((frame)=>"string" == typeof frame.consoleActor);
+    const top = usable.find((frame)=>true === frame.isTopLevelTarget) ?? usable[0];
+    return top ? String(top.consoleActor) : void 0;
+}
+async function rdpEvaluateInTab(port, options) {
+    const timeoutMs = options.timeoutMs ?? 10000;
+    return withSession(port, timeoutMs, async (session)=>{
+        const listed = await session.request("root", {
+            type: "listTabs"
+        }, timeoutMs);
+        const tab = options.select(listed.tabs ?? []);
+        if (!tab?.actor) return {
+            ok: false,
+            name: "TargetNotFound",
+            message: "no open tab matches"
+        };
+        const watcher = await session.request(String(tab.actor), {
+            type: "getWatcher",
+            isServerTargetSwitchingEnabled: true
+        }, timeoutMs);
+        const watcherActor = String(watcher.actor ?? "");
+        if (!watcherActor) return {
+            ok: false,
+            name: "Unsupported",
+            message: "this Firefox build exposes no watcher actor for a tab, so the tab cannot be evaluated over the debugger protocol"
+        };
+        const frames = [];
+        const untap = session.tap((packet)=>{
+            if ("target-available-form" !== packet.type) return;
+            const target = packet.target;
+            if (target && "object" == typeof target) frames.push(target);
         });
         try {
             await session.request(watcherActor, {
                 type: "watchTargets",
                 targetType: "frame"
             }, timeoutMs);
-            await session.request(watcherActor, {
-                type: "watchResources",
-                resourceTypes: [
-                    "console-message",
-                    "error-message"
-                ]
-            }, timeoutMs);
-            await new Promise((resolve)=>setTimeout(resolve, settleMs));
+            const frameDeadline = Date.now() + Math.min(timeoutMs, RDP_FRAME_WAIT_MS);
+            let consoleActor = topFrameConsoleActor(frames);
+            while(!consoleActor && Date.now() < frameDeadline){
+                await new Promise((resolve)=>setTimeout(resolve, RDP_FRAME_POLL_MS));
+                consoleActor = topFrameConsoleActor(frames);
+            }
+            if (!consoleActor) return {
+                ok: false,
+                name: "TargetNotFound",
+                message: "the tab announced no document to evaluate in (it may still be loading)"
+            };
+            const token = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+            const started = await consoleEvaluate(session, consoleActor, rdpStartExpression(options.expression, token), timeoutMs);
+            if (started.threw) return {
+                ok: false,
+                name: "EvalError",
+                message: started.threw
+            };
+            const resultDeadline = Date.now() + timeoutMs;
+            for(;;){
+                const polled = await consoleEvaluate(session, consoleActor, rdpPollExpression(token), timeoutMs);
+                const settled = readRdpEvalSlot(polled.result);
+                if ("lost" === settled) return {
+                    ok: false,
+                    name: "EvalLost",
+                    message: "the document reloaded or navigated before the expression settled, so its result is gone"
+                };
+                if ("pending" !== settled) return settled.ok ? {
+                    ok: true,
+                    value: settled.value,
+                    tab: {
+                        url: String(tab.url ?? ""),
+                        title: String(tab.title ?? "")
+                    }
+                } : settled;
+                if (Date.now() >= resultDeadline) return {
+                    ok: false,
+                    name: "Timeout",
+                    message: `the expression did not settle within ${timeoutMs}ms`
+                };
+                await new Promise((resolve)=>setTimeout(resolve, RDP_RESULT_POLL_MS));
+            }
         } finally{
             untap();
+            session.request(watcherActor, {
+                type: "unwatchTargets",
+                targetType: "frame"
+            }, 1000).catch(()=>{});
         }
-        return messages;
     });
 }
 const inspect_schema_schema = {
@@ -14443,7 +15454,7 @@ function readRelayFrame(value) {
 }
 const eval_schema = {
     name: "extension_eval",
-    description: "Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab, because the MV3 service worker CSP blocks eval; pass context:'background' to target the worker anyway and get that explanation back. For content and page, pass `url` to pick the tab, or omit both `url` and `tab` for the active tab; a numeric `tab` only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages (newtab, history, bookmarks) need no tab id but must already be open: open one with extension_open first, because a closed one returns an explicit error. On a Chromium MV3 session those pages, and context:'page' with a chrome-extension:// url, evaluate over CDP, the inspector path the extension page CSP does not govern; elsewhere they evaluate over the in-bundle relay. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.",
+    description: "Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab, because the MV3 service worker CSP blocks eval; pass context:'background' to target the worker anyway and get that explanation back. For content and page, pass `url` to pick the tab, or omit both `url` and `tab` for the active tab; a numeric `tab` only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages (newtab, history, bookmarks) need no tab id but must already be open: open one with extension_open first, because a closed one returns an explicit error. On a Chromium MV3 session those pages, and context:'page' with a chrome-extension:// url, evaluate over CDP, the inspector path the extension page CSP does not govern; elsewhere they evaluate over the in-bundle relay. On Firefox a document whose content security policy forbids eval (the extension's own pages, or a site's) is evaluated over the debugger protocol instead, which takes one expression; a page inside the extension that is no declared surface (pages/*) is reached the same way by context:'page' and its moz-extension:// url once a tab shows it. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.",
     inputSchema: {
         type: "object",
         properties: {
@@ -14764,6 +15775,7 @@ async function evaluateThroughRelay(args, browser, context) {
         ], args.projectPath, args.timeout, eval_schema.name);
     let raw = await run(relaySafeExpression(args.expression, token));
     let parsed = tryParseFrame(raw);
+    if (isGeckoFamily(browser) && cspRefusedFrame(parsed)) return evaluatePastSurfaceCsp(args, context, run);
     if (!parsed || true !== parsed.ok) return raw;
     let frame = readRelayFrame(parsed.value);
     if (!frame) return raw;
@@ -14810,21 +15822,28 @@ async function evaluateThroughRelay(args, browser, context) {
     return actFrameJson(parsed);
 }
 const CSP_EVAL_REFUSAL = /blocked by CSP|call to eval|unsafe-eval|Content Security Policy/i;
+function cspRefusedFrame(parsed) {
+    if (!parsed || false !== parsed.ok) return false;
+    const code = "string" == typeof parsed.error?.code ? parsed.error.code : "";
+    if ("E_CSP_BLOCKS_EVAL" === code) return true;
+    return "E_EVAL" === code && CSP_EVAL_REFUSAL.test(String(parsed.error?.message ?? ""));
+}
+function cspRefusalHint(context) {
+    if ("page" === context) return "This page's own Content-Security-Policy forbids eval, so the in-page executor cannot run any expression in it; this is the site's policy, not a fault in the expression. Pass url so the tab is evaluated through the browser's debugger, which the policy does not govern (CDP on Chromium, the debugger protocol on Firefox), or read the page with extension_dom_snapshot or extension_inspect.";
+    if ("content" === context) return "The extension's content_security_policy forbids eval in its content-script world on this engine, so no string runs there; this is the extension's policy, not a fault in the expression. Evaluate the page itself with context: \"page\" and a url, or read the DOM the content script sees with extension_dom_snapshot or extension_inspect.";
+    return `The extension's content_security_policy (or the MV3 default) forbids eval in its own ${context ?? "background"} context, so the in-page executor cannot run any expression there; this is the extension's policy, not a fault in the expression. Read the page instead with extension_dom_snapshot or extension_inspect, evaluate a web page with context: \"page\" and a url, or read the extension's console with extension_logs. On a Chromium MV3 session the extension's own pages evaluate over CDP, which the page policy does not govern. On Firefox, Extension.js 4.1.31 and later evaluate them over the debugger protocol instead: if this session runs an older engine, upgrade the project's extension dependency and restart it.`;
+}
 function explainCspRefusal(raw, context) {
     const parsed = tryParseFrame(raw);
-    if (!parsed || false !== parsed.ok) return null;
-    const code = "string" == typeof parsed.error?.code ? parsed.error.code : "";
-    const message = String(parsed.error?.message ?? "");
-    if ("E_EVAL" !== code || !CSP_EVAL_REFUSAL.test(message)) return null;
+    if (!parsed || !cspRefusedFrame(parsed)) return null;
     parsed.error.name = "CspBlocksEval";
-    parsed.hint = `The extension's content_security_policy (or the MV3 default) forbids eval in its own ${context ?? "background"} context, so the in-page executor cannot run any expression there; this is the extension's policy, not a fault in the expression. Read the page instead with extension_dom_snapshot or extension_inspect, evaluate a web page with context: \"page\" and a url, or read the extension's console with extension_logs. On a Chromium MV3 session the extension's own pages evaluate over CDP, which the page policy does not govern.`;
+    parsed.hint = cspRefusalHint(context);
     if ("string" == typeof parsed.error.hint) delete parsed.error.hint;
     return actFrameJson(parsed);
 }
 const NO_SCRIPTING_API = /scripting is not available/i;
 function pageEvalRefusedByCsp(parsed) {
-    const code = "string" == typeof parsed.error?.code ? parsed.error.code : "";
-    return "E_EVAL" === code && CSP_EVAL_REFUSAL.test(String(parsed.error?.message ?? ""));
+    return cspRefusedFrame(parsed);
 }
 function isSingleExpression(source) {
     try {
@@ -14834,6 +15853,110 @@ function isSingleExpression(source) {
         return false;
     }
 }
+function notOneExpression() {
+    return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "bad-request",
+        error: {
+            code: "E_BAD_REQUEST",
+            name: "NotOneExpression",
+            message: "This document's content security policy forbids eval, so Firefox evaluates it over the debugger protocol, which takes one expression, and this input is a statement list."
+        },
+        hint: "Pass one expression. Wrap statements in a function that returns the value, for example (() => { const a = 20; return a + 1; })()."
+    });
+}
+async function evaluatePastSurfaceCsp(args, context, run) {
+    if (!isSingleExpression(args.expression)) return notOneExpression();
+    const direct = await run(args.expression);
+    const frame = tryParseFrame(direct);
+    if (!frame) return direct;
+    if (cspRefusedFrame(frame)) return explainCspRefusal(direct, context) ?? direct;
+    if (true === frame.ok && void 0 === frame.value) {
+        frame.value = null;
+        return actFrameJson(frame);
+    }
+    return direct;
+}
+const sameDocumentUrl = (a, b)=>String(a ?? "").replace(/[?#].*$/, "") === b.replace(/[?#].*$/, "");
+function tabByUrl(tabs, url) {
+    const exact = tabs.filter((tab)=>sameDocumentUrl(tab.url, url));
+    const covered = exact.length ? exact : tabs.filter((tab)=>matchPatternCovers(url, String(tab.url ?? "")));
+    const candidates = covered.length ? covered : tabs.filter((tab)=>String(tab.url ?? "").includes(url));
+    return candidates.find((tab)=>true === tab.selected) ?? candidates[0];
+}
+async function evaluateInGeckoTab(args, browser, select, missing) {
+    const resolved = await resolveRdpPort(args.projectPath, browser, {
+        waitMs: 3000,
+        graceMs: 1000
+    });
+    if (!resolved) return null;
+    let outcome;
+    try {
+        outcome = await rdpEvaluateInTab(resolved.port, {
+            select,
+            expression: args.expression,
+            timeoutMs: args.timeout ?? 10000
+        });
+    } catch  {
+        return null;
+    }
+    if (outcome.ok) return envelope_envelope({
+        ok: true,
+        command: eval_schema.name,
+        status: "ok",
+        value: void 0 === outcome.value ? null : outcome.value
+    });
+    if ("TargetNotFound" === outcome.name) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "no-matching-target",
+        error: {
+            code: "E_NO_MATCHING_TARGET",
+            name: "NoMatchingTarget",
+            message: missing
+        },
+        hint: "Open the page first with extension_open and its url, then retry; extension_dom_snapshot with listTabs: true lists what is open."
+    });
+    if ("Timeout" === outcome.name) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "eval-pending",
+        error: {
+            code: "E_WAIT_TIMEOUT",
+            name: "EvalPending",
+            message: outcome.message
+        },
+        hint: "The expression returned a promise that is still pending; pass a larger timeout to wait for it."
+    });
+    return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "eval-failed",
+        error: {
+            code: "E_EVAL",
+            name: outcome.name,
+            message: outcome.message
+        },
+        hint: "The expression threw inside the document. It ran over the debugger protocol, which the document's content security policy does not govern, so this is the expression's own error."
+    });
+}
+function backgroundRouteRefusedStatements(args, browser, context, raw) {
+    if (!isGeckoFamily(browser) || (context ?? "background") !== "background") return false;
+    const failed = tryParseFrame(raw);
+    if (!failed || false !== failed.ok) return false;
+    if (failed.error?.name !== "Unavailable") return false;
+    if (!/SyntaxError/.test(String(failed.error?.message ?? ""))) return false;
+    return !isSingleExpression(args.expression);
+}
+async function evaluatePagePastSiteCsp(args, browser, context, raw) {
+    if ("page" !== context || !isGeckoFamily(browser)) return null;
+    if (!cspRefusedFrame(tryParseFrame(raw))) return null;
+    if (!args.url && null != args.tab) return null;
+    if (!isSingleExpression(args.expression)) return notOneExpression();
+    const url = args.url;
+    return evaluateInGeckoTab(args, browser, url ? (tabs)=>tabByUrl(tabs, url) : (tabs)=>tabs.find((tab)=>true === tab.selected), url ? `No open tab matches url: ${url}` : "No tab is selected in the dev browser.");
+}
 async function evaluateThroughExecuteScript(args, browser, context, raw) {
     if ("page" !== context && "content" !== context) return null;
     if (isChromiumFamily(browser)) return null;
@@ -14928,6 +16051,12 @@ async function eval_handler(args) {
             }
             return raw;
         }
+        if (isGeckoFamily(browser)) {
+            if (!isSingleExpression(args.expression)) return notOneExpression();
+            const url = args.url;
+            const overProtocol = await evaluateInGeckoTab(args, browser, (tabs)=>tabs.find((tab)=>sameDocumentUrl(tab.url, url)), `No open tab shows ${url}.`);
+            if (null !== overProtocol) return overProtocol;
+        }
         const declared = declaredSurfaces(args.projectPath, browser) ?? [];
         return envelope_envelope({
             ok: false,
@@ -14955,6 +16084,9 @@ async function eval_handler(args) {
     ], args.projectPath, args.timeout, eval_schema.name);
     const mv2Fallback = await evaluateThroughExecuteScript(args, browser, context, raw);
     if (null !== mv2Fallback) return mv2Fallback;
+    const pastSiteCsp = await evaluatePagePastSiteCsp(args, browser, context, raw);
+    if (null !== pastSiteCsp) return pastSiteCsp;
+    if (backgroundRouteRefusedStatements(args, browser, context, raw)) return notOneExpression();
     const cspRefusal = explainCspRefusal(raw, context);
     if (null !== cspRefusal) return cspRefusal;
     const trustedTypes = tryParseFrame(raw);
@@ -15191,6 +16323,72 @@ const dom_snapshot_schema = {
         ]
     }
 };
+const GECKO_EXTENSION_URL = /^moz-extension:\/\//;
+const dom_snapshot_sameDocumentUrl = (a, b)=>String(a ?? "").replace(/[?#].*$/, "") === b.replace(/[?#].*$/, "");
+function protocolSnapshotExpression(wantHtml, maxBytes) {
+    return `(function () {
+  var doc = document;
+  function countShadow(root) {
+    var n = 0, els = root.querySelectorAll("*");
+    for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
+    return n;
+  }
+  var html = doc.documentElement.outerHTML;
+  var snap = {
+    context: "page",
+    url: String(location.href),
+    title: doc.title,
+    summary: {
+      htmlLength: html.length,
+      scriptCount: doc.querySelectorAll("script").length,
+      styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
+      extensionRootCount: doc.querySelectorAll("#extension-root,[data-extension-root]").length,
+      openShadowRoots: countShadow(doc),
+      bodyChildCount: doc.body ? doc.body.children.length : 0
+    }
+  };
+  if (${wantHtml ? "true" : "false"}) {
+    var cap = ${Math.max(0, Math.floor(maxBytes))};
+    if (cap > 0 && html.length > cap) { snap.html = html.slice(0, cap); snap.htmlTruncated = true; }
+    else { snap.html = html; }
+  }
+  return snap;
+})()`;
+}
+async function snapshotExtensionPageOverProtocol(args, browser, url, raw, consoleAsked) {
+    if (!url || !isGeckoFamily(browser) || !GECKO_EXTENSION_URL.test(url)) return null;
+    try {
+        const refused = JSON.parse(raw);
+        if (!refused || false !== refused.ok) return null;
+    } catch  {
+        return null;
+    }
+    const resolved = await resolveRdpPort(args.projectPath, browser, {
+        waitMs: 3000,
+        graceMs: 1000
+    });
+    if (!resolved) return null;
+    const wantHtml = args.include?.includes("html") === true;
+    try {
+        const outcome = await rdpEvaluateInTab(resolved.port, {
+            select: (tabs)=>tabs.find((tab)=>dom_snapshot_sameDocumentUrl(tab.url, url)),
+            expression: protocolSnapshotExpression(wantHtml, args.maxBytes ?? 262144),
+            timeoutMs: args.timeout ?? 10000
+        });
+        if (!outcome.ok) return null;
+        return envelope_envelope({
+            ok: true,
+            command: dom_snapshot_schema.name,
+            status: "ok",
+            value: outcome.value,
+            warnings: [
+                `${url} is a page inside the extension, which Firefox lets no script be injected into, so this snapshot was read over the debugger protocol from the tab showing it.` + (consoleAsked ? " Console lines are not collected on this path; read them with extension_logs." : "")
+            ]
+        });
+    } catch  {
+        return null;
+    }
+}
 async function cdpPortOrError(projectPath, browser, feature) {
     if (!isChromiumFamily(browser)) return {
         error: envelope_envelope({
@@ -15433,7 +16631,10 @@ async function dom_snapshot_handler(args) {
     if (null != withConsole) cli.push("--with-console", String(withConsole));
     cli.push("--browser", resolveSessionBrowser(args.projectPath, args.browser).browser);
     if (null != args.timeout) cli.push("--timeout", String(args.timeout));
-    const raw = await runActVerb(cli, args.projectPath, args.timeout, dom_snapshot_schema.name);
+    const sessionBrowser = resolveSessionBrowser(args.projectPath, args.browser).browser;
+    const asked = await runActVerb(cli, args.projectPath, args.timeout, dom_snapshot_schema.name);
+    const overProtocol = await snapshotExtensionPageOverProtocol(args, sessionBrowser, targetUrl ?? ("string" == typeof resolvedTarget?.url ? resolvedTarget.url : void 0), asked, null != withConsole);
+    const raw = overProtocol ?? asked;
     if (!resolvedTarget) return raw;
     try {
         const parsed = JSON.parse(raw);
@@ -15532,7 +16733,7 @@ async function publish_handler(args) {
     let note = null;
     if (null != args.ttlHours && "public" === data.visibility) note = "ttlHours was ignored: this is a public project, whose share URL is its canonical public page.";
     let buildNote = null;
-    const ref = resolveProjectRef();
+    const ref = loginProjectRef(args.project);
     if (ref) {
         const buildsUrl = registryFileUrl(ref, "builds/index.json");
         const buildsRes = await fetchRegistryJson(buildsUrl, fetch, {
@@ -15736,7 +16937,7 @@ async function release_promote_handler(args) {
         const code = "string" == typeof data?.code ? data.code : void 0;
         const enrich = {};
         let hint = "";
-        const ref = resolveProjectRef();
+        const ref = loginProjectRef(args.project);
         if (404 === res.status || "UNKNOWN_BUILD" === code) {
             enrich.buildsPageUrl = consoleProjectUrl(ref, "builds", args.api);
             hint = "Run extension_release_status to see this project's channels, their promoted shas, and recent builds.";
@@ -15772,7 +16973,7 @@ async function release_promote_handler(args) {
             hint
         });
     }
-    const promotedRef = resolveProjectRef();
+    const promotedRef = loginProjectRef(args.project);
     const publicChannelUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.channel(channel), args.api);
     const publicBuildUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.build(buildId), args.api);
     const allowance = spendNarration({
@@ -16005,7 +17206,7 @@ async function readStores(args) {
     const healthUrl = registryFileUrl(ref, "stores/health.json");
     const statusUrl = registryFileUrl(ref, "stores/status.json");
     const submissionsUrl = registryFileUrl(ref, "stores/submissions.json");
-    const consoleStoresUrl = consoleProjectUrl(ref, "stores", args.api);
+    const consoleStoresUrl = consoleProjectUrl(ref, ConsoleProjectPage.submissions, args.api);
     const [healthRes, statusRes, submissionsRes] = await Promise.all([
         fetchRegistryJson(healthUrl, fetch, {
             ref,
@@ -16035,7 +17236,7 @@ async function readStores(args) {
             project: ref.project
         }
     });
-    if (!healthRes.ok && !statusRes.ok && !submissionsRes.ok) return store_status_fail("StoreStatusNotFound", `No store data on the registry for ${ref.workspace}/${ref.project} (${healthRes.message}). The project may have no stores configured yet, be private (private registry data needs a share token), or the workspace/project slugs may be wrong. Configure stores at ${consoleStoresUrl}/new; the console Stores page is the authoritative view: ${consoleStoresUrl}`, "unavailable", "E_PLATFORM", {
+    if (!healthRes.ok && !statusRes.ok && !submissionsRes.ok) return store_status_fail("StoreStatusNotFound", `No store data on the registry for ${ref.workspace}/${ref.project} (${healthRes.message}). The project may have no stores configured yet, be private (private registry data needs a share token), or the workspace/project slugs may be wrong. Configure stores at ${consoleStoresUrl}/new; the console Submissions page is the authoritative view: ${consoleStoresUrl}`, "unavailable", "E_PLATFORM", {
         workspace: ref.workspace,
         project: ref.project,
         registryUrls: {
@@ -16446,8 +17647,8 @@ async function submit_handler(args) {
     let channelNote = null;
     let statusNote = null;
     if (dryRun) {
-        const ref = resolveProjectRef();
-        const consoleStoresUrl = consoleProjectUrl(ref, "stores", args.api);
+        const ref = loginProjectRef(args.project);
+        const consoleStoresUrl = consoleProjectUrl(ref, ConsoleProjectPage.submissions, args.api);
         const storeModeNote = `Store publish mode (draft / skip-publish / live) is not readable with the CLI token, so it cannot be verified from here; check per-store settings at ${consoleStoresUrl}.`;
         let health = null;
         let healthUnreadable = null;
@@ -17041,7 +18242,7 @@ async function add_feature_handler(args) {
 const login_FIRST_CALL_BUDGET_MS = 8000;
 const login_RESUME_BUDGET_MS = 22000;
 const PENDING_TTL_NOTE = "Once authorized, the minted token lives at most 7 days (server-enforced); CI must re-mint before expiry (console: project settings -> Access tokens).";
-function login_fail(name, message, status, code) {
+function login_fail(name, message, status, code, extra) {
     return envelope_envelope({
         ok: false,
         command: "extension_auth",
@@ -17050,7 +18251,13 @@ function login_fail(name, message, status, code) {
             code,
             name,
             message
-        }
+        },
+        ...extra?.value ? {
+            value: extra.value
+        } : {},
+        ...extra?.hint ? {
+            hint: extra.hint
+        } : {}
     });
 }
 function success(creds) {
@@ -17166,6 +18373,156 @@ async function loginToProject(args) {
         verificationUriComplete: start.verificationUriComplete
     });
 }
+const BATCH_FINAL_POLL_NOTE = "The platform records one token per project before it answers, so the call that completes a batch login can take up to a minute. Let it finish: the device code is spent the moment minting starts, and a call abandoned midway cannot be resumed.";
+function batchPending(args) {
+    const complete = String(args.verificationUriComplete || "").trim();
+    const hasCompleteLink = complete.length > 0 && complete !== args.verificationUri;
+    const again = "then call extension_auth (action: login) again with this deviceCode and the same projects";
+    const hint = args.userCode ? hasCompleteLink ? `Open ${complete} and approve (code ${args.userCode} is pre-filled). The page lists all ${args.projects.length} projects this one approval signs in to; ${again}. If the page asks for a code, enter ${args.userCode} at ${args.verificationUri}.` : `Open ${args.verificationUri} and enter code ${args.userCode}. The page lists all ${args.projects.length} projects this one approval signs in to; ${again}.` : `Still waiting for authorization. The link and code from the previous response are still valid: approve at ${args.verificationUri}, ${again}.`;
+    return envelope_envelope({
+        ok: true,
+        command: "extension_auth",
+        status: "authorization-pending",
+        value: {
+            ...args.userCode ? {
+                userCode: args.userCode
+            } : {},
+            verificationUri: args.verificationUri,
+            ...args.userCode && hasCompleteLink ? {
+                verificationUriComplete: complete
+            } : {},
+            deviceCode: args.deviceCode,
+            projects: args.projects,
+            legacyStatus: "authorization_pending"
+        },
+        hint,
+        warnings: [
+            PENDING_TTL_NOTE,
+            BATCH_FINAL_POLL_NOTE
+        ]
+    });
+}
+function batchRefusal(poll, projects) {
+    if ("expired" === poll.reason) return login_fail("LoginExpired", "The device code expired or was already spent. Run extension_auth (action: login) again with the same projects to restart.", "login-expired", "E_AUTH_EXPIRED");
+    const code = String(poll.code || "");
+    if ("PROJECT_NOT_FOUND" === code) {
+        const missing = Array.isArray(poll.body?.missingProjects) ? (poll.body?.missingProjects).map(String) : [];
+        return login_fail("LoginProjectNotFound", poll.message || "At least one listed project does not exist, so no token was minted for any of them.", "login-failed", "E_AUTH_FAILED", {
+            value: {
+                code,
+                missingProjects: missing,
+                projects
+            },
+            hint: `A batch login is all or nothing and covers only projects that already exist. ${missing.length ? `Drop or fix ${missing.join(", ")} and run extension_auth (action: login) again with the rest` : "Check each name against the console and run extension_auth (action: login) again"}; create missing projects with extension_project_create or at ${consoleBase()}.`
+        });
+    }
+    if ("MEMBERSHIP_REVOKED" === code) return login_fail("LoginMembershipRevoked", poll.message || "The member who approved this login is no longer in the workspace, so no token was minted.", "login-failed", "E_AUTH_FAILED", {
+        value: {
+            code,
+            projects
+        }
+    });
+    if ("denied" === poll.reason) return login_fail("LoginDenied", "Authorization was denied at extension.dev/device.", "login-denied", "E_AUTH_DENIED");
+    return login_fail("LoginError", poll.message || "Device login failed.", "login-failed", "E_AUTH_FAILED", {
+        value: {
+            ...code ? {
+                code
+            } : {},
+            projects
+        },
+        hint: "No token from this batch was stored. Run extension_auth (action: login) again with the same projects; a batch that was refused or failed midway is closed on the platform and needs a fresh approval."
+    });
+}
+async function loginToProjects(args) {
+    const parsed = parseProjectBatch(args.projects);
+    if (!parsed.ok) return login_fail("BadRequest", parsed.message, "bad-request", "E_BAD_REQUEST");
+    const projects = parsed.batch.refs;
+    const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
+    if (!apiCheck.ok) return login_fail("LoginConfigError", apiCheck.message, "login-failed", "E_AUTH_FAILED");
+    const apiBase = apiCheck.base;
+    let config;
+    try {
+        config = await fetchLoginConfig(apiBase);
+    } catch (err) {
+        return login_fail("LoginConfigError", err?.message || "Could not load login config.", "login-failed", "E_AUTH_FAILED");
+    }
+    if (!config.batch) return login_fail("LoginBatchUnsupported", BATCH_UNSUPPORTED_MESSAGE, "batch-unsupported", "E_PLATFORM", {
+        value: {
+            projects
+        },
+        hint: "Sign in to each project with its own extension_auth (action: login, project) call."
+    });
+    if (projects.length > config.batch.loginProjectsPerApproval) return login_fail("BadRequest", `projects names ${projects.length} projects, and one approval signs in to at most ${config.batch.loginProjectsPerApproval} on this platform.`, "bad-request", "E_BAD_REQUEST", {
+        hint: `Split the list into calls of ${config.batch.loginProjectsPerApproval} or fewer; each call is its own approval. No device code was spent.`
+    });
+    let deviceCode = String(args.deviceCode || "").trim();
+    let interval = 5;
+    let budgetMs = login_RESUME_BUDGET_MS;
+    let start = null;
+    if (!deviceCode) {
+        try {
+            start = await requestDeviceCode({
+                apiBase,
+                path: config.deviceCodeUrl,
+                projects
+            });
+        } catch (err) {
+            return login_fail("LoginStartError", err?.message || "Could not start the device flow.", "login-failed", "E_AUTH_FAILED", {
+                hint: "No device code was issued. Sign in to each project with its own extension_auth (action: login, project) call, or fix what the platform refused and try the list again."
+            });
+        }
+        deviceCode = start.deviceCode;
+        interval = start.interval;
+        budgetMs = login_FIRST_CALL_BUDGET_MS;
+    }
+    const poll = await pollDeviceGrant({
+        apiBase,
+        path: config.deviceTokenUrl,
+        projects,
+        deviceCode,
+        interval,
+        budgetMs
+    });
+    if (!poll.ok) {
+        if ("pending" === poll.reason) return batchPending({
+            deviceCode,
+            projects,
+            verificationUri: start?.verificationUri ?? config.verificationUri,
+            userCode: start?.userCode,
+            verificationUriComplete: start?.verificationUriComplete
+        });
+        return batchRefusal(poll, projects);
+    }
+    let stored;
+    try {
+        stored = persistBatchTokenResponse({
+            apiBase,
+            projects,
+            data: poll.data
+        });
+    } catch (err) {
+        return login_fail("LoginError", err?.message ? String(err.message) : String(err), "login-failed", "E_AUTH_FAILED");
+    }
+    const logins = stored.map((creds)=>({
+            project: `${creds.workspaceSlug}/${creds.projectSlug}`,
+            workspaceSlug: creds.workspaceSlug,
+            projectSlug: creds.projectSlug,
+            expiresAt: creds.expiresAt ? new Date(1000 * creds.expiresAt).toISOString() : null
+        }));
+    return envelope_envelope({
+        ok: true,
+        command: "extension_auth",
+        status: "logged-in",
+        value: {
+            workspaceSlug: parsed.batch.workspace,
+            logins
+        },
+        hint: `Logged in to ${logins.length} project${1 === logins.length ? "" : "s"} in ${parsed.batch.workspace}: ${logins.map((login)=>login.projectSlug).join(", ")}. Each has its own stored token; token-scoped tools take \`project\` to pick one, and extension_auth (action: status) lists them. The default login was left as it was unless none existed. Every token expires within 7 days, so one batch login renews them together.`,
+        warnings: [
+            tokenTtlNote()
+        ]
+    });
+}
 const server_identity_DEFAULT_TIMEOUT_MS = 5000;
 async function askServerIdentity(args) {
     const fetchImpl = args.fetchImpl ?? fetch;
@@ -17355,7 +18712,7 @@ async function clearLocalCredentials(project) {
 }
 const auth_schema = {
     name: "extension_auth",
-    description: "Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer is reported as confirmed, refused-by-server, or unverified when the server cannot be reached, so a local file claiming a login the server would refuse is never reported as simply logged in. Pass action:'login' for a two-phase flow: call with `project` to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned `deviceCode`. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with `project`, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under `logins`.",
+    description: "Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer is reported as confirmed, refused-by-server, or unverified when the server cannot be reached, so a local file claiming a login the server would refuse is never reported as simply logged in. Pass action:'login' for a two-phase flow: call with `project` to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned `deviceCode`. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with `project`, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under `logins`. To sign in to several existing projects of one workspace at once, pass `projects` instead of `project`: one approval, one stored token per project.",
     inputSchema: {
         type: "object",
         properties: {
@@ -17372,6 +18729,13 @@ const auth_schema = {
                 type: "string",
                 description: "login: target project as '<workspace>/<project>'; the token is scoped to it. The slug pair is the console address bar: an existing project's page is console.extension.dev/<workspace>/<project>. Create one at extension.dev/new if none exists yet. Logins to several projects are all kept, the latest is the default; token-scoped tools take `project` to pick another. logout: remove only this project's login (omitted, every stored login goes)."
             },
+            projects: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "login: sign in to several existing projects of one workspace with one approval, instead of one approval each. 1 to 20 names as '<workspace>/<project>', all in the same workspace, each by its exact slug (lowercase letters and digits joined by single dashes, at most 48 characters), none twice. Pass it instead of `project`, never beside it. The approval page lists every name; one missing project refuses the whole list and mints nothing. Resume with the returned `deviceCode` and the same list. Every token is stored as that project's own login and all expire within 7 days, so the same call renews them together."
+            },
             deviceCode: {
                 type: "string",
                 description: "login: resume token from the prior call's `deviceCode`; omit on the first call."
@@ -17381,9 +18745,31 @@ const auth_schema = {
         required: []
     }
 };
+function listMisuse(message) {
+    return envelope_envelope({
+        ok: false,
+        command: "extension_auth",
+        status: "bad-request",
+        error: {
+            code: "E_BAD_REQUEST",
+            name: "BadRequest",
+            message
+        }
+    });
+}
 async function auth_handler(args) {
     const action = args.action ?? "status";
+    const hasList = void 0 !== args.projects && null !== args.projects;
+    if (hasList && "login" !== action) return listMisuse(`projects is a login input: action '${action}' does not take a list. Use project to name one login, or call once per project.`);
     if ("logout" === action) return clearLocalCredentials(args.project);
+    if ("login" === action && hasList) {
+        if (String(args.project ?? "").trim()) return listMisuse("Pass either project (one login) or projects (one approval for several), not both.");
+        return loginToProjects({
+            projects: args.projects,
+            deviceCode: args.deviceCode,
+            api: args.api
+        });
+    }
     if ("login" === action) return loginToProject({
         project: String(args.project ?? ""),
         deviceCode: args.deviceCode,
@@ -18577,6 +19963,35 @@ function pinProjectArgs(name, args, inputSchema, options) {
     if (!pinned) return {
         args
     };
+    if (void 0 !== args.projects && null !== args.projects) {
+        const entries = Array.isArray(args.projects) ? args.projects : [
+            args.projects
+        ];
+        const names = entries.map((entry)=>"string" == typeof entry ? entry.trim() : entry && "object" == typeof entry && !Array.isArray(entry) ? String(entry.project ?? "").trim() : "");
+        const others = names.filter((entry)=>!entry.includes("/") || !sameProject(entry, pinned));
+        if (others.length > 0 || 0 === entries.length) {
+            const shown = others.map((entry)=>entry || "(an unnamed entry)");
+            return {
+                refused: envelope_envelope({
+                    ok: false,
+                    command: name,
+                    status: "project-pinned",
+                    error: {
+                        code: "E_TOOL_DISABLED",
+                        message: `This server is pinned to ${pinned} and was asked to act on a list naming ${shown.length ? shown.join(", ") : "no project"}.`
+                    },
+                    value: {
+                        pinned,
+                        named: shown
+                    },
+                    hint: `A pinned server takes a batch only when every entry is ${pinned}. Work on other projects through an MCP server configured without --project, or with its own --project (or ${PROJECT_PIN_ENV}).`
+                })
+            };
+        }
+        return {
+            args
+        };
+    }
     const named = "string" == typeof args.project ? args.project : "";
     if (named && !sameProject(named, pinned)) return {
         refused: envelope_envelope({