@extension.dev/mcp 5.7.0 → 6.0.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "extension-mcp",
       "source": "./",
       "description": "MCP tools for browser extension development: scaffold from 60+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox.",
-      "version": "5.7.0",
+      "version": "6.0.0",
       "category": "development",
       "author": {
         "name": "Cezar Augusto"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "extension-mcp",
   "description": "MCP tools for browser extension development: scaffold from 60+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox. Ships /extension, /extension-add, /extension-debug, and /extension-publish commands.",
-  "version": "5.7.0",
+  "version": "6.0.0",
   "author": {
     "name": "Cezar Augusto",
     "email": "hello@extension.dev",

package/CHANGELOG.md

@@ -1,10 +1,19 @@
 # Changelog
 
-## 5.7.0
+## 6.0.0
 
-The live-preview carrier stops living in your project, reports what it
-refused, and rides an engine that tells you when the browser turned your
-extension away.
+The server moves to Apache-2.0, and the live-preview carrier stops living
+in your project, reports what it refused, and rides an engine that tells
+you when the browser turned your extension away.
+
+### Changed
+
+- **License: MIT is now Apache-2.0.** Everything published up to and
+  including 5.6.1 was released under MIT and stays MIT forever; you keep
+  those rights on those versions. From 6.0.0 forward the license is
+  Apache-2.0, which adds an express patent grant and requires anyone
+  shipping a modified copy to state that they changed the files. For almost
+  every user this changes nothing about what you are allowed to do.
 
 ### Fixed
 
@@ -55,6 +64,15 @@ extension away.
   again: the platform's Safari/App Store submission lane is now enabled
   for every project, so the store enum and the per-store status report
   treat it like chrome, firefox, and edge.
+- `extension_list_templates` and `extension_get_template_source` resolve
+  the template catalog and sources from the pinned, content-addressed
+  corpus served at `media.extension.land`, with a commit-pinned GitHub
+  raw fallback. Both tools previously read a floating `nightly`/`main`
+  ref, so two runs could disagree; they now resolve one immutable
+  release whose files are sha256-verified at the origin.
+- Console and dashboard links come from a shared URL contract and are
+  environment aware, so a local or development run no longer hands back
+  hardcoded production console URLs.
 
 ### Added
 

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) Cezar Augusto and the extension.dev collaborators
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Cezar Augusto and the extension.dev collaborators
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -156,4 +156,4 @@ All of it rides on [Extension.js](https://github.com/extension-js/extension.js),
 
 ## License
 
-MIT (c) Cezar Augusto and the extension.dev collaborators
+Apache-2.0 (c) 2026 Cezar Augusto and the extension.dev collaborators. See [LICENSE](LICENSE).

package/bin/extension-mcp.js

@@ -5,7 +5,7 @@
 // ██║╚██╔╝██║██║     ██╔═══╝
 // ██║ ╚═╝ ██║╚██████╗██║
 // ╚═╝     ╚═╝ ╚═════╝╚═╝
-// MIT License (c) Cezar Augusto and the extension.dev collaborators
+// Apache License 2.0 (c) 2026 Cezar Augusto and the extension.dev collaborators
 import {startServer, runCli} from '../dist/module.js'
 
 const [, , cmd, ...rest] = process.argv

package/dist/module.js

@@ -138,7 +138,8 @@ __webpack_require__.r(open_namespaceObject);
 __webpack_require__.d(open_namespaceObject, {
     clampPopupBounds: ()=>clampPopupBounds,
     handler: ()=>open_handler,
-    schema: ()=>open_schema
+    schema: ()=>open_schema,
+    sessionIsHeadless: ()=>sessionIsHeadless
 });
 var preview_namespaceObject = {};
 __webpack_require__.r(preview_namespaceObject);
@@ -388,10 +389,85 @@ async function create_handler(args) {
         }
     });
 }
+const DEFAULT_MEDIA_ORIGIN = "https://media.extension.land";
+const DEFAULT_CHANNEL = "latest";
+const PINNED_COMMIT = "2d2ed9668cca002148d9eecd953a08b54d0bad9d";
+const CHANNEL_CACHE_TTL_MS = 300000;
+function mediaOrigin() {
+    return (process.env.EXTENSION_MEDIA_ORIGIN || "").trim() || DEFAULT_MEDIA_ORIGIN;
+}
+function channelName() {
+    return (process.env.EXTENSION_TEMPLATES_CHANNEL || "").trim() || DEFAULT_CHANNEL;
+}
+function pinnedCommitOverride() {
+    return (process.env.EXTENSION_TEMPLATES_COMMIT || "").trim();
+}
+function rawBaseForCommit(commit) {
+    return `https://raw.githubusercontent.com/extension-js/examples/${commit}`;
+}
+let releaseCache = null;
+let releaseCacheExpiresAt = 0;
+let releaseRequest = null;
+function releaseForCommit(origin, commit) {
+    return {
+        commit,
+        metaUrl: `${origin}/templates/${commit}/templates-meta.json`,
+        filesBaseUrl: `${origin}/templates/${commit}/files`
+    };
+}
+async function resolveRelease() {
+    const now = Date.now();
+    if (releaseCache && now < releaseCacheExpiresAt) return releaseCache;
+    if (releaseRequest) return releaseRequest;
+    const origin = mediaOrigin();
+    const override = pinnedCommitOverride();
+    if (override) {
+        releaseCache = releaseForCommit(origin, override);
+        releaseCacheExpiresAt = now + CHANNEL_CACHE_TTL_MS;
+        return releaseCache;
+    }
+    releaseRequest = (async ()=>{
+        try {
+            const pointerUrl = `${origin}/templates/${channelName()}.json`;
+            const response = await fetch(pointerUrl, {
+                headers: {
+                    Accept: "application/json"
+                }
+            });
+            if (!response.ok) return null;
+            const pointer = await response.json();
+            const commit = String(pointer?.commit || "").trim();
+            if (!commit) return null;
+            releaseCache = releaseForCommit(origin, commit);
+            releaseCacheExpiresAt = Date.now() + CHANNEL_CACHE_TTL_MS;
+            return releaseCache;
+        } catch  {
+            return null;
+        }
+    })();
+    try {
+        return await releaseRequest;
+    } finally{
+        releaseRequest = null;
+    }
+}
+async function templateMetaUrls() {
+    const urls = [];
+    const release = await resolveRelease();
+    if (release) urls.push(release.metaUrl);
+    urls.push(`${rawBaseForCommit(PINNED_COMMIT)}/templates-meta.json`);
+    return urls;
+}
+async function templateFileUrls(slug, relativePath) {
+    const urls = [];
+    const release = await resolveRelease();
+    if (release) urls.push(`${release.filesBaseUrl}/${slug}/${relativePath}`);
+    urls.push(`${rawBaseForCommit(PINNED_COMMIT)}/examples/${slug}/${relativePath}`);
+    return urls;
+}
 const CACHE_DIR = node_path.join(node_os.homedir(), ".cache", "extension-js");
 const CACHE_FILE = node_path.join(CACHE_DIR, "templates-meta.json");
 const CACHE_TTL_MS = 3600000;
-const TEMPLATES_META_URL = "https://github.com/extension-js/examples/releases/download/nightly/templates-meta.json";
 function isCacheValid() {
     try {
         const stat = node_fs.statSync(CACHE_FILE);
@@ -405,17 +481,22 @@ async function fetchTemplatesMeta() {
         const cached = JSON.parse(node_fs.readFileSync(CACHE_FILE, "utf8"));
         return cached;
     }
-    const response = await fetch(TEMPLATES_META_URL);
-    if (!response.ok) {
-        if (node_fs.existsSync(CACHE_FILE)) return JSON.parse(node_fs.readFileSync(CACHE_FILE, "utf8"));
-        throw new Error(`Failed to fetch templates-meta.json: ${response.status}`);
-    }
-    const data = await response.json();
-    node_fs.mkdirSync(CACHE_DIR, {
-        recursive: true
-    });
-    node_fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
-    return data;
+    let lastStatus = 0;
+    for (const url of (await templateMetaUrls()))try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            lastStatus = response.status;
+            continue;
+        }
+        const data = await response.json();
+        node_fs.mkdirSync(CACHE_DIR, {
+            recursive: true
+        });
+        node_fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+        return data;
+    } catch  {}
+    if (node_fs.existsSync(CACHE_FILE)) return JSON.parse(node_fs.readFileSync(CACHE_FILE, "utf8"));
+    throw new Error(`Failed to fetch templates-meta.json (${lastStatus || "network error"}).`);
 }
 async function listTemplates(filters) {
     const meta = await fetchTemplatesMeta();
@@ -883,6 +964,7 @@ function isGeckoFamily(browser) {
     return GECKO_FAMILY.has(browser);
 }
 const CARRIER_DIR_NAME = "extension-dev-live-preview";
+const CARRIER_EXTENSION_ID = "ibppeifnekhjjjmpjfiobccjlicbmgcb";
 const MARKER_FILE = "managed-by-extension-dev-mcp.json";
 function deriveCarrierId(source) {
     try {
@@ -1005,6 +1087,7 @@ function materializeCarrier(projectPath, browser) {
                 "Bridged calls run under the CARRIER's identity, not your extension's. The preview assumes a single active guest and does not namespace per-extension state, so storage, action/badge state, messaging delivery, offscreen documents and relative script paths belong to the carrier. Rows affected are badged carrier-scoped in the Trace tab.",
                 "Chromium-family only: Firefox has no externally_connectable channel for web pages."
             ],
+            graduation: "The carrier lane is the SHARED real lane: bridged calls run as the carrier, by design (see limitations). Your guest is already loaded as ITSELF in this same session, so for its own storage, identity, badge and messaging (the isolated real thing), drive the guest directly instead of the carrier bridge: extension_storage, extension_eval and extension_dom_inspect against this projectPath all operate on the guest as itself. Start (or replace) this session with allowControl: true (or allowEval: true) to unlock them. Use the carrier bridge for the shared real-lane TRACE; use the control verbs for the guest's OWN state.",
             ...carrierId ? {
                 bridgeProtocol: {
                     carrierExtensionId: carrierId,
@@ -1751,6 +1834,7 @@ async function dev_handler(args) {
     child.on("exit", ()=>removeSession(args.projectPath, browser));
     await new Promise((resolve)=>setTimeout(resolve, 3000));
     const earlyOutput = spawned.readOutput();
+    const cleanOutput = denoiseEarlyOutput(earlyOutput);
     if (null !== child.exitCode || null !== child.signalCode) {
         const code = child.exitCode;
         const signal = child.signalCode;
@@ -1763,12 +1847,12 @@ async function dev_handler(args) {
             exitCode: code,
             signal,
             error: `The dev server exited during startup (${signal ? `signal ${signal}` : `exit code ${code}`}). No session is running, so extension_logs/wait/eval and the control verbs have nothing to attach to.`,
-            output: denoiseEarlyOutput(earlyOutput).slice(0, 2000),
+            output: cleanOutput.slice(0, 2000),
             logPath,
             hint: "Read `output` above for the cause: a port already in use, a manifest the build rejects, or a missing browser binary are the common ones. Fix it and call extension_dev again; extension_doctor with this projectPath will also report what the last session recorded."
         });
     }
-    const compileFailed = /compiled with errors|✖✖✖|ERROR in |Module not found|NOT FOUND/i.test(earlyOutput);
+    const compileFailed = /compiled with errors|✖✖✖|ERROR in |Module not found|NOT FOUND/i.test(cleanOutput);
     if (compileFailed) return JSON.stringify({
         ok: false,
         status: "compile-failed",
@@ -1776,12 +1860,12 @@ async function dev_handler(args) {
         browser,
         pid,
         error: "The dev server started but the FIRST COMPILE FAILED, so the browser has nothing usable to load. The session is running; the extension is not.",
-        output: denoiseEarlyOutput(earlyOutput).slice(0, 2000),
+        output: cleanOutput.slice(0, 2000),
         logPath,
         hint: "Fix the compile error in `output` above and save: the dev server is still running and will recompile. Do not call extension_wait yet, it will report ready for a build that failed."
     });
     const exitStamp = args.noBrowser ? null : browserExitStamp(args.projectPath, browser, spawnedAt);
-    const profileLockHit = !args.noBrowser && /SingletonLock|ProcessSingleton|profile[^\n]*(in use|locked)|already (open|running)/i.test(earlyOutput);
+    const profileLockHit = !args.noBrowser && /SingletonLock|ProcessSingleton|profile[^\n]*(in use|locked)|already (open|running)/i.test(cleanOutput);
     if (exitStamp || profileLockHit) {
         const profileDir = node_path.join(args.projectPath, "dist", `extension-profile-${browser}`);
         return JSON.stringify({
@@ -1792,7 +1876,7 @@ async function dev_handler(args) {
             pid,
             ...exitStamp ?? {},
             error: `The dev server is running but the ${browser} browser it launched died during startup` + (profileLockHit ? " because its profile is locked by another browser instance." : "."),
-            output: denoiseEarlyOutput(earlyOutput).slice(0, 2000),
+            output: cleanOutput.slice(0, 2000),
             logPath,
             hint: `A locked profile means another session's browser still holds it: call extension_stop with this projectPath to kill that session, then start extension_dev again. If the lock survives a crash, remove ${profileDir} manually before retrying.`
         });
@@ -1840,7 +1924,7 @@ async function dev_handler(args) {
         } : {},
         capabilities,
         hint: args.noBrowser ? "Build-only session (noBrowser: true): no browser will launch, so no runtime will ever attach. extension_wait returns as soon as the first compile lands (compiled: true, browserAttached: false) instead of waiting out its budget; do not wait for a browser. The control verbs (storage/reload/open/dom_inspect/eval) need a live browser and will not work against this session. When you are done, call extension_stop to shut down the dev server." : "Use extension_wait to check when the extension is fully loaded, then extension_source_inspect to inspect the live state. " + (allowControl ? `Control channel is ON: extension_${controlVerbs.split(", ").join("/extension_")}${args.allowEval ? "/extension_eval" : ""} will work against this session.` : "Control channel is OFF: extension_storage/reload/open/dom_inspect need allowControl: true, and extension_eval needs allowEval: true (which also implies allowControl). To unlock them, call extension_dev again with the flag you need plus replace: true (it stops this session first); a plain second call is refused so the session does not fork.") + " When you are done, call extension_stop to shut down the dev server and browser.",
-        earlyOutput: denoiseEarlyOutput(earlyOutput).slice(0, 500),
+        earlyOutput: cleanOutput.slice(0, 500),
         logPath
     });
 }
@@ -1849,6 +1933,8 @@ function denoiseEarlyOutput(raw) {
         /^npm warn Unknown project config/i,
         /This will stop working in the next major version of npm/i,
         /^npm warn config/i,
+        /^npm warn exec/i,
+        /The following package(s)? (was|were) not found and will be installed/i,
         /V8: .*Invalid asm\.js/i,
         /^\(node:\d+\) V8:/i,
         /Use `node --trace-warnings/i,
@@ -2092,7 +2178,6 @@ async function preview_handler(args) {
         logPath
     });
 }
-const RAW_BASE = "https://raw.githubusercontent.com/extension-js/examples/main/examples";
 const get_template_source_schema = {
     name: "extension_get_template_source",
     description: "Read source files from a template in the extension.dev template catalog. Use this to learn implementation patterns before building something similar.",
@@ -2140,14 +2225,17 @@ async function get_template_source_handler(args) {
     const fileContents = {};
     const errors = [];
     await Promise.all(args.files.map(async (filePath)=>{
-        const url = `${RAW_BASE}/${args.slug}/${filePath}`;
-        try {
+        const urls = await templateFileUrls(args.slug, filePath);
+        let lastStatus = 0;
+        for (const url of urls)try {
             const response = await fetch(url);
-            if (response.ok) fileContents[filePath] = await response.text();
-            else errors.push(`${filePath}: ${response.status}`);
-        } catch (err) {
-            errors.push(`${filePath}: ${err instanceof Error ? err.message : "fetch failed"}`);
-        }
+            if (response.ok) {
+                fileContents[filePath] = await response.text();
+                return;
+            }
+            lastStatus = response.status;
+        } catch  {}
+        errors.push(`${filePath}: ${lastStatus || "fetch failed"}`);
     }));
     return JSON.stringify({
         ...meta,
@@ -5303,6 +5391,11 @@ const open_schema = {
         ]
     }
 };
+function sessionIsHeadless() {
+    if (/^(1|true)$/i.test(process.env.EXTENSION_HEADLESS ?? "")) return true;
+    return /(^|\s|=)-{1,2}headless\b/i.test(process.env.EXTENSION_BROWSER_FLAGS ?? "");
+}
+const HEADED_RELAUNCH = "start a headed session: extension_dev with replace: true, and in the environment set EXTENSION_HEADLESS=0 AND clear EXTENSION_BROWSER_FLAGS (it may carry --headless=new, which keeps the window hidden even with EXTENSION_HEADLESS=0)";
 async function open_handler(args) {
     const { browser } = resolveSessionBrowser(args.projectPath, args.browser);
     if (args.url) return navigateToUrl(args.projectPath, browser, args.url, args.timeout);
@@ -5347,7 +5440,7 @@ async function open_handler(args) {
     cli.push("--browser", browser);
     if (null != args.timeout) cli.push("--timeout", String(args.timeout));
     const raw = await runActVerb(cli, args.projectPath, args.timeout);
-    const headless = /^(1|true)$/i.test(process.env.EXTENSION_HEADLESS ?? "");
+    const headless = sessionIsHeadless();
     if (headless && [
         "popup",
         "action",
@@ -5361,12 +5454,12 @@ async function open_handler(args) {
                 try {
                     const parsedFallback = JSON.parse(fallback);
                     if (parsedFallback?.ok) {
-                        parsedFallback.note = "The dev browser is headless (EXTENSION_HEADLESS=1), and a real popup/sidebar window can only open in a headed session, so the surface was rendered as a tab instead. For the real window, start a headed session: extension_dev with replace: true, with EXTENSION_HEADLESS=0 (or unset) in the environment, then open the surface again without asTab.";
+                        parsedFallback.note = `The dev browser is headless, and a real popup/sidebar window can only open in a headed session, so the surface was rendered as a tab instead. For the real window, ${HEADED_RELAUNCH}, then open the surface again without asTab.`;
                         return JSON.stringify(parsedFallback);
                     }
                 } catch  {}
             }
-            if (!parsed.hint) parsed.hint = /user gesture/i.test(msg) ? "This surface can only open from a real user gesture, which headless automation cannot produce. Retry with asTab: true to render the surface document in a tab instead." : "The dev browser is running headless (EXTENSION_HEADLESS=1), and a popup/sidebar window needs a headed session. Retry with asTab: true to render the surface document in a tab, or start a headed session for the real window: extension_dev with replace: true, with EXTENSION_HEADLESS=0 (or unset) in the environment.";
+            if (!parsed.hint) parsed.hint = /user gesture/i.test(msg) ? "This surface can only open from a real user gesture, which headless automation cannot produce. Retry with asTab: true to render the surface document in a tab instead." : `The dev browser is running headless, and a popup/sidebar window needs a headed session. Retry with asTab: true to render the surface document in a tab, or for the real window, ${HEADED_RELAUNCH}.`;
             return JSON.stringify(parsed);
         }
     } catch  {}
@@ -5752,11 +5845,78 @@ function readValidCredentials(nowSeconds = Math.floor(Date.now() / 1000)) {
     if (creds.expiresAt && creds.expiresAt <= nowSeconds) return null;
     return creds;
 }
-const REGISTRY_BASE_DEFAULT = "https://registry.extension.land";
-const CONSOLE_BASE = "https://console.extension.dev";
+const PROD_ORIGINS = {
+    www: "https://www.extension.dev",
+    console: "https://console.extension.dev",
+    inspect: "https://inspect.extension.dev",
+    templates: "https://templates.extension.dev",
+    intelligence: "https://intelligence.extension.dev",
+    registry: "https://registry.extension.land",
+    media: "https://media.extension.land"
+};
+const DEV_LOCALHOST_ORIGINS = {
+    www: "http://localhost:3100",
+    console: "http://console.extension.localhost",
+    inspect: "http://inspect.extension.localhost",
+    templates: "http://templates.extension.localhost",
+    intelligence: "http://intelligence.extension.localhost",
+    registry: "https://registry.extension.land",
+    media: "https://media.extension.land"
+};
+function strip(value) {
+    return String(value ?? "").trim().replace(/\/+$/, "");
+}
+function isLocalOrigin(url) {
+    const raw = strip(url);
+    if (!raw) return false;
+    let host;
+    try {
+        host = new URL(raw).hostname;
+    } catch  {
+        return false;
+    }
+    return "localhost" === host || "127.0.0.1" === host || "::1" === host || "[::1]" === host || "extension.localhost" === host || host.endsWith(".extension.localhost");
+}
+function resolveOrigins(overrides = {}, opts = {}) {
+    const devLike = isLocalOrigin(overrides.www) || isLocalOrigin(overrides.console) || isLocalOrigin(opts.hint);
+    const base = devLike ? DEV_LOCALHOST_ORIGINS : PROD_ORIGINS;
+    const pick = (key)=>strip(overrides[key]) || base[key];
+    return {
+        www: pick("www"),
+        console: pick("console"),
+        inspect: pick("inspect"),
+        templates: pick("templates"),
+        intelligence: pick("intelligence"),
+        registry: pick("registry"),
+        media: pick("media")
+    };
+}
+const seg = (value)=>encodeURIComponent(String(value));
+function urls_paths_join(base, sub) {
+    if (!sub) return base;
+    return `${base}/${sub.replace(/^\/+/, "")}`;
+}
+function consoleProjectPath(ref, page = "") {
+    return urls_paths_join(`/${seg(ref.workspace)}/${seg(ref.project)}`, page);
+}
+PROD_ORIGINS.registry;
+function mcpOrigins(apiHint) {
+    const www = String(apiHint || process.env.EXTENSION_DEV_API_URL || "").trim() || void 0;
+    return resolveOrigins({
+        www,
+        console: process.env.EXTENSION_DEV_CONSOLE_URL,
+        inspect: process.env.EXTENSION_DEV_INSPECT_URL,
+        registry: process.env.EXTENSION_DEV_REGISTRY_URL,
+        media: process.env.EXTENSION_MEDIA_ORIGIN
+    }, {
+        hint: www
+    });
+}
+function consoleBase(apiHint) {
+    return mcpOrigins(apiHint).console;
+}
 function registryBase() {
-    const fromEnv = String(process.env.EXTENSION_DEV_REGISTRY_URL || "").trim();
-    return (fromEnv || REGISTRY_BASE_DEFAULT).replace(/\/+$/, "");
+    return mcpOrigins().registry;
 }
 function resolveProjectRef(overrides) {
     const workspace = String(overrides?.workspace || "").trim();
@@ -5777,9 +5937,10 @@ function resolveProjectRef(overrides) {
 function registryFileUrl(ref, file) {
     return `${registryBase()}/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.project)}/_extension-dev/${file}`;
 }
-function consoleProjectUrl(ref, page) {
-    if (!ref) return `${CONSOLE_BASE}`;
-    return `${CONSOLE_BASE}/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.project)}/${page}`;
+function consoleProjectUrl(ref, page, apiHint) {
+    const base = consoleBase(apiHint);
+    if (!ref) return base;
+    return `${base}${consoleProjectPath(ref, page)}`;
 }
 async function fetchRegistryJson(url, fetchImpl = fetch) {
     let res;
@@ -5855,12 +6016,12 @@ function parseBuildIndex(json) {
     }
     return out;
 }
-const DEFAULT_API = "https://www.extension.dev";
+const DEFAULT_API = PROD_ORIGINS.www;
 function tokenTtlNote(workspaceSlug, projectSlug) {
     const tokensUrl = workspaceSlug && projectSlug ? consoleProjectUrl({
         workspace: workspaceSlug,
         project: projectSlug
-    }, "settings/access-tokens") : CONSOLE_BASE;
+    }, "settings/access-tokens") : consoleBase();
     return `extension.dev CLI tokens live at most 7 days (server-enforced). CI pipelines must re-mint before expiry on the console's Access tokens page: ${tokensUrl}`;
 }
 function resolveApiBase(api) {
@@ -6101,7 +6262,6 @@ async function publish_handler(args) {
     }
     return JSON.stringify(data);
 }
-const release_promote_DEFAULT_API = "https://www.extension.dev";
 const release_promote_schema = {
     name: "extension_release_promote",
     description: "Promote a built extension to a release channel (e.g. stable, preview, beta) on extension.dev, headless. Auth-gated: uses your stored login (extension_login) or a release token in EXTENSION_DEV_TOKEN (mint and revoke it in the dashboard under project settings -> Access tokens; tokens live at most 7 days, so CI must re-mint before expiry). Posts to the platform's CLI release endpoint; the project is identified by the token. Cutting a version-bump PR is not available headlessly (it writes to your source repo and needs an interactive login).",
@@ -6161,7 +6321,7 @@ async function release_promote_handler(args) {
     const buildId = String(args.buildId || "").trim();
     const channel = String(args.channel || "").trim();
     if (!buildId || !channel) return release_promote_fail("ReleaseInputError", "buildId and channel are required.");
-    const apiCheck = safeApiBase(String(args.api || process.env.EXTENSION_DEV_API_URL || release_promote_DEFAULT_API));
+    const apiCheck = safeApiBase(resolveApiBase(args.api));
     if (!apiCheck.ok) return release_promote_fail("ReleaseConfigError", apiCheck.message);
     const url = `${apiCheck.base}/api/cli/release/promote`;
     const body = {
@@ -6199,7 +6359,7 @@ async function release_promote_handler(args) {
         const enrich = {};
         const ref = resolveProjectRef();
         if (404 === res.status || "UNKNOWN_BUILD" === code) {
-            enrich.buildsPageUrl = consoleProjectUrl(ref, "builds");
+            enrich.buildsPageUrl = consoleProjectUrl(ref, "builds", args.api);
             enrich.hint = "Run extension_release_list to see this project's channels, their promoted shas, and recent builds.";
             if (ref) {
                 const channelsUrl = registryFileUrl(ref, "channels.json");
@@ -6299,7 +6459,6 @@ async function release_list_handler(args) {
     if (!buildsRes.ok) result.buildsUnavailable = `builds/index.json unreadable: ${buildsRes.message}`;
     return JSON.stringify(result);
 }
-const deploy_DEFAULT_API = "https://www.extension.dev";
 function storeMdWarnings(browsers, cwd) {
     const wantsFirefox = browsers.includes("firefox");
     const wantsEdge = browsers.includes("edge");
@@ -6389,7 +6548,7 @@ async function deploy_handler(args) {
     if (0 === browsers.length) return deploy_fail("DeployInputError", 'browsers is required (e.g. ["chrome","firefox","edge","safari"]).');
     const buildSha = String(args.buildSha || "").trim();
     if (!buildSha) return deploy_fail("DeployInputError", "buildSha is required (the built commit to submit).");
-    const apiCheck = safeApiBase(String(args.api || process.env.EXTENSION_DEV_API_URL || deploy_DEFAULT_API));
+    const apiCheck = safeApiBase(resolveApiBase(args.api));
     if (!apiCheck.ok) return deploy_fail("DeployConfigError", apiCheck.message);
     const url = `${apiCheck.base}/api/cli/stores/submit`;
     const dryRun = false !== args.dryRun;
@@ -6434,7 +6593,7 @@ async function deploy_handler(args) {
     };
     if (dryRun) {
         const ref = resolveProjectRef();
-        const consoleStoresUrl = consoleProjectUrl(ref, "stores");
+        const consoleStoresUrl = consoleProjectUrl(ref, "stores", 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;
@@ -6710,6 +6869,63 @@ async function store_status_handler(args) {
     if (!submissionsRes.ok && 404 !== submissionsRes.status) result.submissionsUnavailable = `stores/submissions.json unreadable: ${submissionsRes.message}`;
     return JSON.stringify(result);
 }
+const ENGINE_COMPANION_IDS = new Set([
+    "kgdaecdpfkikjncaalnmmnjjfpofkcbl",
+    CARRIER_EXTENSION_ID
+]);
+const EXTENSION_URL = /^chrome-extension:\/\/([a-p]{32})\//i;
+async function verifyGuestLoaded(projectPath, browser, options) {
+    let cdpPort;
+    try {
+        const resolved = await resolveCdpPort(projectPath, browser, {
+            waitMs: options?.waitMs ?? 0
+        });
+        if (!resolved) return {
+            checked: false,
+            loaded: false,
+            guestTargets: [],
+            guestIds: [],
+            reason: "No CDP port in the session's ready contract, so the browser's target list could not be queried (a headless Chromium session still exposes one; a gecko/Firefox session does not)."
+        };
+        cdpPort = resolved.port;
+        const timeoutMs = options?.timeoutMs ?? 3000;
+        const targets = await Promise.race([
+            CDPClient.discoverTargets(cdpPort),
+            new Promise((_, reject)=>setTimeout(()=>reject(new Error(`CDP /json timed out after ${timeoutMs}ms`)), timeoutMs))
+        ]);
+        const guestTargets = [];
+        for (const t of targets){
+            const match = EXTENSION_URL.exec(String(t.url ?? ""));
+            if (!match) continue;
+            const id = match[1].toLowerCase();
+            if (!ENGINE_COMPANION_IDS.has(id)) guestTargets.push({
+                id,
+                type: String(t.type),
+                url: String(t.url)
+            });
+        }
+        const guestIds = [
+            ...new Set(guestTargets.map((t)=>t.id))
+        ];
+        return {
+            checked: true,
+            loaded: guestTargets.length > 0,
+            guestTargets,
+            guestIds,
+            cdpPort,
+            reason: guestTargets.length > 0 ? `The browser lists ${guestIds.length} extension target${1 === guestIds.length ? "" : "s"} that are not the engine companion (${guestIds.join(", ")}), so the guest is loaded.` : "The browser's target list has no chrome-extension:// target other than the engine's devtools companion. On Chrome this is the signature of a silently rejected --load-extension (extension.js BUGS_TO_FIX §83): the CLI and ready.json cannot see it."
+        };
+    } catch (err) {
+        return {
+            checked: false,
+            loaded: false,
+            guestTargets: [],
+            guestIds: [],
+            cdpPort,
+            reason: `Could not query the browser's target list${cdpPort ? ` on CDP port ${cdpPort}` : ""}: ${err?.message ?? String(err)}.`
+        };
+    }
+}
 function doctor_readReadyContract(projectPath, browser) {
     try {
         const raw = node_fs.readFileSync(node_path.resolve(projectPath, "dist", "extension-js", browser, "ready.json"), "utf8");
@@ -6905,7 +7121,7 @@ function wait_isAlive(pid) {
 }
 const wait_schema = {
     name: "extension_wait",
-    description: "Wait for a running dev or start session to be ready. Polls the ready.json contract file and returns structured status with two separate facts: compiled (the compiler finished) and browserAttached (the extension's runtime connected from a live browser). Every result reports budgetMs (this call's wait budget) and elapsedMs; on status:'timeout' call again to keep waiting (polling resumes on the same contract). In a noBrowser (build-only) session it returns as soon as the compile lands instead of waiting for a browser that will never attach. Ports in the result come from the ready contract, so they always match what the dev server actually bound.",
+    description: "Wait for a running dev or start session to be ready. Polls the ready.json contract file and returns structured status with these facts: compiled (the compiler finished), browserAttached (the engine's runtime executor connected), and for a browser session guestLoaded (the browser's OWN target list actually shows your extension). guestLoaded is the trustworthy load signal: it catches a silently rejected --load-extension that leaves ready.json stamped attached with empty logs (extension.js BUGS_TO_FIX §83); it is null when it could not be checked (no CDP port, e.g. a gecko session). Every result reports budgetMs (this call's wait budget) and elapsedMs; on status:'timeout' call again to keep waiting (polling resumes on the same contract). In a noBrowser (build-only) session it returns as soon as the compile lands instead of waiting for a browser that will never attach. Ports in the result come from the ready contract, so they always match what the dev server actually bound.",
     inputSchema: {
         type: "object",
         properties: {
@@ -6981,10 +7197,20 @@ async function wait_handler(args) {
                     continue;
                 }
                 const runtimeErrors = recentErrorLogs(args.projectPath, browser, 3);
+                const guestCheck = await verifyGuestLoaded(args.projectPath, browser);
+                const warnings = [];
+                if (runtimeErrors.length) warnings.push(`Compiled and attached, but the extension is throwing at runtime (${runtimeErrors.length} recent error event${1 === runtimeErrors.length ? "" : "s"} above). Check extension_logs (level: error) or extension_doctor before trusting this session.`);
+                if (guestCheck.checked && !guestCheck.loaded) warnings.push("The engine reports the runtime attached, but the browser's own target list shows no chrome-extension:// target for your extension, only the engine companion. This is the signature of a silently rejected --load-extension (extension.js BUGS_TO_FIX §83): the CLI and ready.json cannot see it, and the control verbs will fail against a guest that is not there. Check the manifest and extension_logs.");
                 return JSON.stringify({
                     status: "ready",
                     compiled: true,
                     browserAttached: true,
+                    guestLoaded: guestCheck.checked ? guestCheck.loaded : null,
+                    ...guestCheck.checked ? {
+                        guestIds: guestCheck.guestIds
+                    } : {
+                        guestLoadNote: guestCheck.reason
+                    },
                     command: contract.command,
                     browser: contract.browser,
                     port: contract.port,
@@ -6996,8 +7222,10 @@ async function wait_handler(args) {
                     budgetMs,
                     elapsedMs: Date.now() - start,
                     ...runtimeErrors.length ? {
-                        runtimeErrors,
-                        warning: `Compiled and attached, but the extension is throwing at runtime (${runtimeErrors.length} recent error event${1 === runtimeErrors.length ? "" : "s"} above). Check extension_logs (level: error) or extension_doctor before trusting this session.`
+                        runtimeErrors
+                    } : {},
+                    ...warnings.length ? {
+                        warning: warnings.join(" ")
                     } : {}
                 });
             }
@@ -7696,7 +7924,10 @@ const logout_schema = {
 };
 async function logout_handler() {
     const creds = readCredentials();
-    const revokeUrl = creds?.workspaceSlug && creds?.projectSlug ? `https://console.extension.dev/${creds.workspaceSlug}/${creds.projectSlug}/settings/access-tokens` : null;
+    const revokeUrl = creds?.workspaceSlug && creds?.projectSlug ? consoleProjectUrl({
+        workspace: creds.workspaceSlug,
+        project: creds.projectSlug
+    }, "settings/access-tokens") : null;
     const result = clearCredentials();
     return JSON.stringify({
         ok: true,

package/dist/src/lib/carrier.d.ts

@@ -7,6 +7,7 @@
  * localhost) can then watch the session's real-lane trace and pair with it.
  */
 export declare const CARRIER_DIR_NAME = "extension-dev-live-preview";
+export declare const CARRIER_EXTENSION_ID = "ibppeifnekhjjjmpjfiobccjlicbmgcb";
 /** Where the carrier lands inside a project. */
 export declare function carrierPath(projectPath: string): string;
 /** True only for a directory carrying our marker, i.e. ours to delete. */
@@ -49,6 +50,17 @@ export type CarrierMaterialization = {
      * was written down anywhere the caller would look.
      */
     limitations?: string[];
+    /**
+     * The graduation path, stated next to the shared-identity limitation so the
+     * caller is not left at a dead end. The carrier lane is the SHARED real lane
+     * (calls run as the carrier); but the guest is ALREADY loaded as itself in
+     * this same session, so its OWN storage, identity and messaging are reached by
+     * driving the guest directly with the control verbs, not the carrier bridge.
+     * This is the agent-lane twin of the inspect Trace tab's "load as your own
+     * extension" affordance: here the extension is already loaded, so graduating
+     * means targeting it, not launching it.
+     */
+    graduation?: string;
     /**
      * How to actually DRIVE the real lane. Seven personas reached a
      * permanently empty trace and concluded the feature was broken, because

package/dist/src/lib/guest-load-oracle.d.ts

@@ -0,0 +1,27 @@
+export type GuestTarget = {
+    id: string;
+    type: string;
+    url: string;
+};
+export type GuestLoadCheck = {
+    checked: boolean;
+    loaded: boolean;
+    guestTargets: GuestTarget[];
+    guestIds: string[];
+    cdpPort?: number;
+    reason: string;
+};
+/**
+ * The BUGS_TO_FIX §83 oracle: ask the BROWSER whether the guest actually loaded,
+ * instead of trusting the engine's ready.json. Chrome refusing --load-extension
+ * is invisible to every engine surface (ready.json stamps status:ready, empty
+ * logs), so the only trustworthy "did the guest load" signal is a
+ * chrome-extension:// target in the browser's own CDP /json list. The engine's
+ * devtools companion is always present and is not the guest; a NON-companion
+ * extension target is. Never throws: an unreachable endpoint returns
+ * checked:false so callers can degrade instead of failing.
+ */
+export declare function verifyGuestLoaded(projectPath: string, browser: string, options?: {
+    waitMs?: number;
+    timeoutMs?: number;
+}): Promise<GuestLoadCheck>;

package/dist/src/lib/registry.d.ts

@@ -1,5 +1,17 @@
-export declare const REGISTRY_BASE_DEFAULT = "https://registry.extension.land";
-export declare const CONSOLE_BASE = "https://console.extension.dev";
+import { type Origins } from "./urls-origins";
+export declare const REGISTRY_BASE_DEFAULT: string;
+/**
+ * Resolve the fleet origins from the MCP's env vars, once per call. Console,
+ * registry, and media all DERIVE from the platform base (`EXTENSION_DEV_API_URL`
+ * or a per-tool `api`): point that at a local stack and every dashboard link the
+ * MCP hands back follows to the dev host (`console.extension.localhost`) instead
+ * of silently pointing at prod. Explicit per-host env vars still win. Falls back
+ * to production when nothing is set. The dev-derivation lives in
+ * `@extensiondev/urls` so it stays identical to what the apps resolve.
+ */
+export declare function mcpOrigins(apiHint?: string): Origins;
+/** Base origin of the console dashboard, dev-aware (no trailing slash). */
+export declare function consoleBase(apiHint?: string): string;
 export declare function registryBase(): string;
 export interface ProjectRef {
     workspace: string;
@@ -17,8 +29,14 @@ export declare function resolveProjectRef(overrides?: {
 }): ProjectRef | null;
 /** URL of a file under the project's `_extension-dev/` registry directory. */
 export declare function registryFileUrl(ref: ProjectRef, file: string): string;
-/** Console page URL for the project (builds, releases/new, stores, ...). */
-export declare function consoleProjectUrl(ref: ProjectRef | null, page: string): string;
+/**
+ * Console page URL for the project (builds, releases/new, stores, ...). The
+ * origin is dev-aware; the path comes from the shared route contract so a
+ * console route rename is caught in one place. Pass `apiHint` (a tool's `api`
+ * arg) so the link matches that call's environment; otherwise it follows
+ * `EXTENSION_DEV_API_URL`/`EXTENSION_DEV_CONSOLE_URL`.
+ */
+export declare function consoleProjectUrl(ref: ProjectRef | null, page: string, apiHint?: string): string;
 export type RegistryFetchResult<T> = {
     ok: true;
     json: T;

package/dist/src/lib/template-artifact-source.d.ts

@@ -0,0 +1,2 @@
+export declare function templateMetaUrls(): Promise<string[]>;
+export declare function templateFileUrls(slug: string, relativePath: string): Promise<string[]>;

package/dist/src/lib/urls-origins.d.ts

@@ -0,0 +1,34 @@
+/** The set of app/service origins the fleet links between. */
+export interface Origins {
+    www: string;
+    console: string;
+    inspect: string;
+    templates: string;
+    intelligence: string;
+    /** Public release-state JSON host (registry.extension.land). */
+    registry: string;
+    /** Content-addressed template corpus host (media.extension.land). */
+    media: string;
+}
+/** Production origins. The prod fallback for every resolver in the fleet. */
+export declare const PROD_ORIGINS: Origins;
+export declare const DEV_LOCALHOST_ORIGINS: Origins;
+/**
+ * True for `localhost`, `127.0.0.1`, `[::1]`, or any `*.extension.localhost`
+ * host -- the shapes the dev proxy serves. Anything unparseable is treated as
+ * not-local so an odd value falls back to prod rather than leaking a dev host.
+ */
+export declare function isLocalOrigin(url: string | undefined | null): boolean;
+/**
+ * Resolve the full origin set from a caller's overrides.
+ *
+ * Precedence per origin: explicit override -> derived base (dev vs prod) ->
+ * prod. The base is chosen by whether the environment looks local: if any of
+ * `www`/`console`/`hint` points at a local host, unset origins derive from the
+ * Caddy dev map instead of prod. This is what lets an operator set only
+ * `EXTENSION_DEV_API_URL=http://localhost:3100` and still get a console link at
+ * `console.extension.localhost` rather than one that silently points at prod.
+ */
+export declare function resolveOrigins(overrides?: Partial<Origins>, opts?: {
+    hint?: string;
+}): Origins;

package/dist/src/lib/urls-paths.d.ts

@@ -0,0 +1,56 @@
+/** A project is addressed by its workspace slug + project slug across the fleet. */
+export interface ProjectRef {
+    workspace: string;
+    project: string;
+}
+/** `/:workspace` (or a sub-page like `settings` / `settings/:section`). */
+export declare function consoleWorkspacePath(workspace: string, page?: string): string;
+/**
+ * `/:workspace/:project/<page>`. Pass a page tail from `ConsoleProjectPage`
+ * (e.g. `ConsoleProjectPage.builds`) rather than hand-typing it, so a route
+ * rename is a one-line change here instead of a scattered string edit.
+ */
+export declare function consoleProjectPath(ref: ProjectRef, page?: string): string;
+/**
+ * Named project-page tails. Values are the exact segments under
+ * `/:username/:reponame/` in console's route table; deep pages take ids.
+ */
+export declare const ConsoleProjectPage: {
+    readonly overview: "";
+    readonly onboard: "onboard";
+    readonly activity: "activity";
+    readonly builds: "builds";
+    readonly build: (buildId: string, browser?: string) => string;
+    readonly releases: "releases";
+    readonly releasesNew: "releases/new";
+    readonly release: (releaseId: string) => string;
+    readonly stores: "stores";
+    readonly storesNew: "stores/new";
+    readonly store: (store: string) => string;
+    readonly storeSubmissions: (store: string) => string;
+    readonly storeSubmissionNew: (store: string) => string;
+    readonly storeSubmission: (store: string, submissionId: string) => string;
+    readonly projectSettings: "project-settings";
+    readonly projectSettingsSection: (section: string) => string;
+    /** Where CLI/MCP tokens are minted and revoked. */
+    readonly accessTokens: "settings/access-tokens";
+};
+export type QueryValue = string | number | boolean | null | undefined;
+/**
+ * `/new?...` -- project creation. The public deep-link contract: external
+ * READMEs use `extension.dev/new?template=<slug>`, which www normalizes to
+ * `/import` preserving every param. Do not change the `template` key.
+ */
+export declare function wwwNewPath(query?: Record<string, QueryValue>): string;
+/** `/import?...` -- the ported import/deploy flow templates' Deploy buttons target. */
+export declare function wwwImportPath(query?: Record<string, QueryValue>): string;
+/** `/device` -- CLI/MCP device-code consent. Lives on www, never console. */
+export declare function wwwDevicePath(): string;
+/** `/templates` and `/templates/:slug` -- externally linkable gallery entry on www. */
+export declare function wwwTemplatesPath(slug?: string): string;
+export type TemplateTab = "preview" | "instructions" | "source";
+/** `/:slug` for the default `preview` tab, else `/:slug/<tab>`. */
+export declare function templateTabPath(slug: string, tab?: TemplateTab): string;
+export type InspectTab = "preview" | "details" | "source" | "trace";
+/** `/` for the default `preview` tab, else `/details` / `/source` / `/trace`. */
+export declare function inspectTabPath(tab?: InspectTab): string;

package/dist/src/tools/open.d.ts

@@ -44,6 +44,7 @@ export declare const schema: {
         required: string[];
     };
 };
+export declare function sessionIsHeadless(): boolean;
 export declare function handler(args: ActArgs & {
     surface?: string;
     name?: string;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@extension.dev/mcp",
   "type": "module",
-  "version": "5.7.0",
+  "version": "6.0.0",
   "description": "MCP server that lets AI agents (Claude Code, Claude Desktop, Cursor, Copilot, Codex) build, run, inspect, and publish browser extensions. 33 tools for scaffolding, live DOM inspection, log streaming, and store-ready builds across Chrome, Edge, Firefox, Safari, and every Chromium- or Gecko-based browser (Brave, Opera, Vivaldi, Yandex, Waterfox, LibreWolf). Powered by extension.dev and Extension.js.",
   "mcpName": "io.github.extensiondev/mcp",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": {
     "name": "Cezar Augusto",
     "email": "hello@extension.dev",
@@ -42,7 +42,9 @@
     "server.json",
     "README.md",
     "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE",
+    "TRADEMARK.md"
   ],
   "scripts": {
     "clean": "rm -rf dist",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://extension.dev",
-  "version": "5.7.0",
+  "version": "6.0.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@extension.dev/mcp",
-      "version": "5.7.0",
+      "version": "6.0.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"