From a2f4ab0da110a469c0621b0e6af1da9c705400ad Mon Sep 17 00:00:00 2001
From: Cory Rylan <crylan@nvidia.com>
Date: Fri, 26 Jun 2026 14:38:43 -0500
Subject: [PATCH] fix(cli): version and updater checks

- Added support for versioning output files in the build process, ensuring that the correct version is written to bundled files.
- Introduced a new utility function to replace bundled constants in the output files, improving maintainability.
- Updated the installation script to utilize the embedded build SHA and version, enhancing the manifest generation.
- Refactored error handling in the update check to ensure proper feedback when the SHA is missing.

Signed-off-by: Cory Rylan <crylan@nvidia.com>
---
 .github/workflows/ci.yml                      |  51 ++++++-
 projects/cli/README.md                        |   2 +-
 projects/cli/package.json                     |   2 +-
 .../cli/scripts/write-install-manifest.mjs    |  18 ++-
 projects/cli/server.json                      |  31 ++++
 projects/cli/src/index.test.ts                |  55 +++++++
 projects/cli/src/index.ts                     |  72 ++++++----
 projects/cli/src/install.test.ts              |  64 ++++++++-
 projects/cli/src/install.ts                   |  11 +-
 projects/cli/src/update.test.ts               |  40 +++++-
 projects/cli/src/update.ts                    |   9 +-
 projects/cli/src/utils.test.ts                | 135 +++++++++++++++++-
 projects/cli/src/utils.ts                     |  73 ++++++++--
 projects/cli/vite.config.ts                   |  12 +-
 .../internals/tools/src/api/utils.test.ts     |  33 +++--
 projects/internals/tools/src/api/utils.ts     |   4 +-
 .../internals/tools/src/cli/utils.test.ts     |   9 ++
 projects/internals/tools/src/cli/utils.ts     |   2 +-
 .../tools/src/playground/utils.test.ts        |   2 +-
 .../internals/tools/src/playground/utils.ts   |   4 +-
 .../tools/src/project/health.test.ts          |  23 ++-
 .../internals/tools/src/project/health.ts     |  31 ++--
 projects/internals/vite/src/configs/build.js  |  10 +-
 .../internals/vite/src/configs/build.node.js  |  10 +-
 projects/internals/vite/src/configs/env.js    |  36 +++++
 projects/internals/vite/src/configs/test.js   |  10 +-
 .../internals/vite/src/configs/test.node.js   |  10 +-
 projects/site/src/_11ty/utils/env.js          |  22 ++-
 projects/site/src/_11ty/utils/env.test.ts     |  67 ---------
 projects/site/src/docs/cli/index.md           |   4 +-
 release.config.js                             |  29 +++-
 31 files changed, 667 insertions(+), 214 deletions(-)
 create mode 100644 projects/cli/server.json
 create mode 100644 projects/internals/vite/src/configs/env.js
 delete mode 100644 projects/site/src/_11ty/utils/env.test.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1fd5487fab..38b9e74be7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,7 +22,6 @@ jobs:
           # On main, checkout credentials must match the release token used by that dry-run.
           token: ${{ github.ref == 'refs/heads/main' && secrets.RELEASE_TOKEN || github.token }}
       - uses: ./.github/actions/setup-ci
-      # - uses: google/wireit@setup-github-actions-caching/v2
       - name: Run CI checks
         env:
           ELEMENTS_PAGES_BASE_URL: ${{vars.ELEMENTS_PAGES_BASE_URL}}
@@ -77,7 +76,6 @@ jobs:
           fetch-depth: 0
           lfs: true
       - uses: ./.github/actions/setup-ci
-      # - uses: google/wireit@setup-github-actions-caching/v2
       - name: Run Lighthouse tests
         run: WIREIT_FAILURES=kill pnpm run lighthouse && node ./projects/internals/ci/cache-validate.js lighthouse && node ./projects/internals/ci/metrics.lighthouse.js
       - name: Write lighthouse job summary
@@ -120,6 +118,51 @@ jobs:
           GITHUB_TOKEN: ${{secrets.RELEASE_TOKEN}}
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
         run: WIREIT_PARALLEL=1 WIREIT_LOGGER=metrics pnpm run release
+      - name: Upload MCP server manifest
+        uses: actions/upload-artifact@v7
+        with:
+          name: mcp-server
+          retention-days: 1
+          path: projects/cli/server.json
+
+  publish-mcp:
+    needs: release
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    concurrency: mcp-registry-publish
+    steps:
+      - name: Download MCP server manifest
+        uses: actions/download-artifact@v8
+        with:
+          name: mcp-server
+          path: projects/cli
+      - name: Check MCP Registry
+        id: registry
+        run: |
+          path=$(jq -r '[.name, .version] | map(@uri) | join("/versions/")' projects/cli/server.json)
+          status=$(curl --silent --show-error --output /dev/null --write-out '%{http_code}' \
+            --retry 3 --retry-all-errors --connect-timeout 10 --max-time 30 \
+            "https://registry.modelcontextprotocol.io/v0.1/servers/$path")
+
+          case "$status" in
+            200) publish=false ;;
+            404) publish=true ;;
+            *)
+              echo "Unexpected MCP Registry response: HTTP $status" >&2
+              exit 1
+              ;;
+          esac
+          echo "publish=$publish" >> "$GITHUB_OUTPUT"
+      - name: Publish to MCP Registry
+        if: steps.registry.outputs.publish == 'true'
+        run: |
+          curl --fail --location --show-error \
+            "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz" \
+            | tar xz mcp-publisher
+          ./mcp-publisher validate projects/cli/server.json
+          ./mcp-publisher login github-oidc
+          ./mcp-publisher publish projects/cli/server.json
 
   deploy-pages:
     needs: ci
@@ -131,9 +174,7 @@ jobs:
     environment:
       name: github-pages
       url: ${{steps.deployment.outputs.page_url}}
-    concurrency:
-      group: pages
-      cancel-in-progress: false
+    concurrency: pages
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
diff --git a/projects/cli/README.md b/projects/cli/README.md
index 706b5a8488..b1c59db4d3 100644
--- a/projects/cli/README.md
+++ b/projects/cli/README.md
@@ -52,7 +52,7 @@ npm install -g @nvidia-elements/cli
 | ---------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
 | `nve`                                                            | Show About and help output.                                                            |
 | `nve api.list [format]`                                          | Get a list of all available Elements (`nve-*`) APIs and components.                    |
-| `nve api.get <names> [format]`                                   | Get documentation for known components or attributes by name (`nve-*`).                |
+| `nve api.get <names..> [--format <format>]`                      | Get documentation for one to five known components or attributes (`nve-*`).            |
 | `nve api.template.validate <template>`                           | Check HTML templates using Elements APIs and components (`nve-*`).                     |
 | `nve api.imports.get <template>`                                 | Get ESM imports for an HTML template using Elements APIs (`nve-*`).                    |
 | `nve api.tokens.list [format] [query]`                           | Get available semantic CSS custom properties and design tokens for theming.            |
diff --git a/projects/cli/package.json b/projects/cli/package.json
index 24562ddacc..868c8a832e 100644
--- a/projects/cli/package.json
+++ b/projects/cli/package.json
@@ -35,7 +35,7 @@
     "dist/**/*.js"
   ],
   "scripts": {
-    "dev": "pnpm run nve:install && npx @modelcontextprotocol/inspector@0.22.0 node ./dist/index.js mcp",
+    "dev": "pnpm run cli:install && npx @modelcontextprotocol/inspector@0.22.0 node ./dist/index.js mcp",
     "ci": "wireit",
     "build": "wireit",
     "lint": "wireit",
diff --git a/projects/cli/scripts/write-install-manifest.mjs b/projects/cli/scripts/write-install-manifest.mjs
index 4f5a4274e6..a9e817013f 100644
--- a/projects/cli/scripts/write-install-manifest.mjs
+++ b/projects/cli/scripts/write-install-manifest.mjs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 const platformBinaries = [
@@ -14,9 +14,9 @@ const platformBinaries = [
 ];
 
 const manifestPath = resolve('dist/manifest.json');
-const existingManifest = existsSync(manifestPath) ? JSON.parse(readFileSync(manifestPath, 'utf-8')) : {};
-const indexContent = readFileSync(resolve('dist/index.js'));
-const sha = existingManifest.sha || createHash('sha256').update(indexContent).digest('hex').slice(0, 12);
+const indexContent = readFileSync(resolve('dist/index.js'), 'utf-8');
+const sha = getBundledConstant(indexContent, 'BUILD_SHA');
+const version = getBundledConstant(indexContent, 'VERSION');
 const platforms = Object.fromEntries(
   platformBinaries.map(({ key, filename, source }) => {
     const content = readFileSync(resolve('dist', source));
@@ -24,4 +24,12 @@ const platforms = Object.fromEntries(
   })
 );
 
-writeFileSync(manifestPath, `${JSON.stringify({ sha, platforms }, null, 2)}\n`);
+writeFileSync(manifestPath, `${JSON.stringify({ sha, version, platforms }, null, 2)}\n`);
+
+function getBundledConstant(content, name) {
+  const value = content.match(new RegExp(`(?:var|const|let)\\s+${name}\\s*=\\s*["']([^"']+)["']`))?.[1];
+  if (!value) {
+    throw new Error(`Missing bundled ${name} constant`);
+  }
+  return value;
+}
diff --git a/projects/cli/server.json b/projects/cli/server.json
new file mode 100644
index 0000000000..7b33cee666
--- /dev/null
+++ b/projects/cli/server.json
@@ -0,0 +1,31 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.nvidia/elements",
+  "title": "NVIDIA Elements",
+  "description": "NVIDIA Elements UI design system and agent tooling for AI/ML factories, robotics, and autonomous vehicles.",
+  "websiteUrl": "https://nvidia.github.io/elements/docs/mcp/",
+  "repository": {
+    "url": "https://github.com/NVIDIA/elements",
+    "source": "github",
+    "subfolder": "projects/cli"
+  },
+  "version": "2.1.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "@nvidia-elements/cli",
+      "version": "2.1.0",
+      "runtimeHint": "npx",
+      "packageArguments": [
+        {
+          "type": "positional",
+          "value": "mcp"
+        }
+      ],
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}
diff --git a/projects/cli/src/index.test.ts b/projects/cli/src/index.test.ts
index 5dec73b251..7f6895b81b 100644
--- a/projects/cli/src/index.test.ts
+++ b/projects/cli/src/index.test.ts
@@ -37,6 +37,11 @@ describe('index', () => {
     expect(output).toContain('nve examples.get <id> [format]');
   });
 
+  it('should provide api.get with variadic names', () => {
+    expect(output).toContain('nve api.get <names..>');
+    expect(output).not.toContain('nve api.get <names> [format]');
+  });
+
   it('should provide skills.list', () => {
     expect(output).toContain('nve skills.list [format]');
   });
@@ -120,6 +125,56 @@ describe('index', () => {
       expect(combined).toContain('nve-foo');
       expect(combined).toContain('nve-bar');
     });
+
+    it('should pass space-separated API names as one array argument', () => {
+      const result = spawnSync(process.execPath, ['dist/index.js', 'api.get', 'nve-card', 'nve-input'], {
+        timeout: 10000,
+        encoding: 'utf-8',
+        input: '',
+        env: { ...process.env, CI: 'true' }
+      });
+
+      expect(result.status).toBe(0);
+      expect(result.stderr).toBe('');
+      expect(result.stdout).toContain('nve-card');
+      expect(result.stdout).toContain('nve-input');
+    });
+
+    it('should accept an explicit format option after space-separated API names', () => {
+      const result = spawnSync(
+        process.execPath,
+        ['dist/index.js', 'api.get', 'nve-card', 'nve-input', '--format', 'json'],
+        {
+          timeout: 10000,
+          encoding: 'utf-8',
+          input: '',
+          env: { ...process.env, CI: 'true' }
+        }
+      );
+
+      expect(result.status).toBe(0);
+      expect(result.stderr).toBe('');
+      expect(JSON.parse(result.stdout)).toEqual([
+        expect.objectContaining({ name: 'nve-card' }),
+        expect.objectContaining({ name: 'nve-input' })
+      ]);
+    });
+
+    it('should reject array arguments that exceed the schema limit', () => {
+      const result = spawnSync(
+        process.execPath,
+        ['dist/index.js', 'api.get', 'nve-card', 'nve-input', 'nve-button', 'nve-badge', 'nve-alert', 'nve-link'],
+        {
+          timeout: 10000,
+          encoding: 'utf-8',
+          input: '',
+          env: { ...process.env, CI: 'true' }
+        }
+      );
+
+      expect(result.status).toBe(1);
+      expect(result.stderr).toContain('api.get accepts at most 5 names.');
+    });
   });
 
   describe('tool errors', () => {
diff --git a/projects/cli/src/index.ts b/projects/cli/src/index.ts
index 39e6c7d501..1fe47e16ac 100755
--- a/projects/cli/src/index.ts
+++ b/projects/cli/src/index.ts
@@ -9,9 +9,9 @@ process.env.ELEMENTS_ENV = 'cli';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { performance } from 'perf_hooks';
-import { type ManagedToolMethod, tools, ToolSupport, type Schema, isDebug, MAX_CONTEXT_TOKENS } from '@internals/tools';
+import { type ManagedToolMethod, tools, ToolSupport, type Schema } from '@internals/tools';
 import { installNve } from './install.js';
-import { banner, colors, getArgValue, progressBar, renderResult, runAsyncTool } from './utils.js';
+import { banner, colors, exitWithCompleteToolResult, exitWithToolError, getArgValue, runAsyncTool } from './utils.js';
 import { notifyIfUpdateAvailable } from './update.js';
 
 export const VERSION = '0.0.0';
@@ -46,11 +46,6 @@ yargsInstance.middleware(argv => {
   }
 });
 
-async function exitWithToolError(result: unknown, message: string | undefined): Promise<never> {
-  console.error(result === undefined ? colors.error(message ?? 'unknown error') : await renderResult(result));
-  process.exit(1);
-}
-
 yargsInstance.command(
   'install [source]',
   false,
@@ -73,10 +68,10 @@ yargsInstance.command(
   async () => {
     if (process.argv.includes('--upgrade')) {
       const upgradeTool = tools.find(tool => tool.metadata.command === 'cli.upgrade') as ManagedToolMethod<unknown>;
-      const { result, status, message } = await runAsyncTool({}, upgradeTool);
+      console.log(colors.info('Upgrading Elements CLI...'));
+      const { result, status, message } = await runAsyncTool({}, upgradeTool, { interactiveProgress: false });
       if (status === 'complete') {
-        await renderResult(result);
-        process.exit(0);
+        await exitWithCompleteToolResult({ result });
       } else {
         await exitWithToolError(result, message);
       }
@@ -100,9 +95,13 @@ tools
     const optionalArgs = Object.keys(properties ?? {}).filter(
       key => !required?.includes(key) || properties?.[key]?.default
     );
+    const hasVariadicArg = requiredArgs.some(key => properties?.[key]?.type === 'array');
+    const positionalArgs = requiredArgs.map(key => (properties?.[key]?.type === 'array' ? `<${key}..>` : `<${key}>`));
 
-    const command =
-      `${tool.metadata.command} ${[...requiredArgs.map(key => `<${key}>`), ...optionalArgs.map(key => `[${key}]`)].join(' ')}`.trim();
+    const command = `${tool.metadata.command} ${[
+      ...positionalArgs,
+      ...(hasVariadicArg ? [] : optionalArgs.map(key => `[${key}]`))
+    ].join(' ')}`.trim();
 
     yargsInstance.command(
       command,
@@ -113,7 +112,8 @@ tools
 
         const argOptions = (prop: Schema) => ({
           describe: prop.description,
-          type: prop.type as 'string' | 'number' | 'boolean',
+          type: (prop.type === 'array' ? 'string' : prop.type) as 'string' | 'number' | 'boolean',
+          ...(prop.type === 'array' ? { array: true } : {}),
           choices: prop.enum ?? undefined,
           default: prop.default
         });
@@ -128,17 +128,13 @@ tools
         const end = performance.now();
 
         if (status === 'complete') {
-          let formattedResult = await renderResult(result);
-          if (isDebug()) {
-            const tokens = formattedResult.length / 4;
-            const pct = (tokens / MAX_CONTEXT_TOKENS) * 100;
-            formattedResult += `[debug]\n[command]: ${tool.metadata.command}`;
-            formattedResult += `\n[execution time]: ${((end - start) / 1000).toFixed(2)} seconds`;
-            formattedResult += `\n[token usage]: ${progressBar(pct)} ${tokens.toLocaleString()} / ${MAX_CONTEXT_TOKENS.toLocaleString()} (${(100 - pct).toFixed(1)}% remaining)`;
-          }
-          console.log(formattedResult);
-          await notifyIfUpdateAvailable(BUILD_SHA);
-          process.exit(0);
+          await exitWithCompleteToolResult({
+            result,
+            tool,
+            start,
+            end,
+            notifyUpdate: () => notifyIfUpdateAvailable(BUILD_SHA)
+          });
         } else {
           await exitWithToolError(result, message);
         }
@@ -155,13 +151,31 @@ tools
               const propertySchema = properties?.[argName] ?? {};
               const v = await getArgValue(argName, propertySchema);
               argv[argName] = v;
-            } else if (properties?.[argName]?.type === 'array' && typeof argv[argName] === 'string') {
-              argv[argName] = (argv[argName] as string)
-                .split(',')
-                .map(s => s.trim())
-                .filter(Boolean);
             }
           }
+
+          Object.entries(properties ?? {})
+            .filter(([, property]) => property.type === 'array')
+            .forEach(([argName, property]) => {
+              if (argv[argName] === undefined) return;
+              const values = (Array.isArray(argv[argName]) ? argv[argName] : [argv[argName]])
+                .flatMap(value => (typeof value === 'string' ? value.split(',') : []))
+                .map(value => value.trim())
+                .filter(Boolean);
+              if (property.minItems !== undefined && values.length < property.minItems) {
+                console.error(
+                  colors.error(`${tool.metadata.command} accepts at least ${property.minItems} ${argName}.`)
+                );
+                process.exit(1);
+              }
+              if (property.maxItems !== undefined && values.length > property.maxItems) {
+                console.error(
+                  colors.error(`${tool.metadata.command} accepts at most ${property.maxItems} ${argName}.`)
+                );
+                process.exit(1);
+              }
+              argv[argName] = values;
+            });
         }
       ]
     );
diff --git a/projects/cli/src/install.test.ts b/projects/cli/src/install.test.ts
index d98e6a8297..eae268fc54 100644
--- a/projects/cli/src/install.test.ts
+++ b/projects/cli/src/install.test.ts
@@ -328,15 +328,25 @@ describe('installNve', () => {
     expect(await readFile(skillPath, 'utf-8')).toBe(getExpectedElementsSkillMarkdown());
   });
 
-  it('should overwrite the global Elements skill when accepted', async () => {
+  it('should overwrite the global Elements skill without prompting when it already exists', async () => {
     const context = await createInstallerContext();
     const source = await writeFakeNve(join(context.root, 'source-nve'));
     const skillPath = join(context.home, '.agents/skills/elements/SKILL.md');
+    let prompted = false;
     await mkdir(dirname(skillPath), { recursive: true });
     await writeFile(skillPath, 'stale skill');
 
-    await installNve({ env: createUnixEnv(context), log: () => {}, prompt: async () => 'y', source });
+    await installNve({
+      env: createUnixEnv(context),
+      log: () => {},
+      prompt: async () => {
+        prompted = true;
+        return 'N';
+      },
+      source
+    });
 
+    expect(prompted).toBe(false);
     expect(await readFile(skillPath, 'utf-8')).toBe(getExpectedElementsSkillMarkdown());
   });
 
@@ -393,6 +403,28 @@ describe('installNve', () => {
     expect(existsSync(join(context.home, '.agents/skills/elements/SKILL.md'))).toBe(false);
   });
 
+  it('should update an existing global Elements skill in CI without prompting', async () => {
+    const context = await createInstallerContext();
+    const source = await writeFakeNve(join(context.root, 'source-nve'));
+    const skillPath = join(context.home, '.agents/skills/elements/SKILL.md');
+    let prompted = false;
+    await mkdir(dirname(skillPath), { recursive: true });
+    await writeFile(skillPath, 'stale skill');
+
+    await installNve({
+      env: { ...createUnixEnv(context), CI: 'true' },
+      log: () => {},
+      prompt: async () => {
+        prompted = true;
+        return 'yes';
+      },
+      source
+    });
+
+    expect(prompted).toBe(false);
+    expect(await readFile(skillPath, 'utf-8')).toBe(getExpectedElementsSkillMarkdown());
+  });
+
   it('should keep the CLI install when global skill installation fails', async () => {
     const context = await createInstallerContext();
     const source = await writeFakeNve(join(context.root, 'source-nve'));
@@ -724,6 +756,30 @@ describe('write-install-manifest', () => {
 
     expect(source).toContain("{ key: 'windows-x64', filename: 'nve-windows-x64.exe', source: 'nve-windows-x64.exe' }");
   });
+
+  it('should use the embedded build sha and version', async () => {
+    const context = await createInstallerContext();
+    const dist = join(context.root, 'dist');
+    await mkdir(dist, { recursive: true });
+    await writeFile(join(dist, 'index.js'), 'var VERSION = "2.1.0";\nvar BUILD_SHA = "abc123def456";\n');
+    await Promise.all(
+      ['nve-macos-arm64', 'nve-macos-x64', 'nve-linux-x64', 'nve-linux-arm64', 'nve-windows-x64.exe'].map(
+        async filename => writeFile(join(dist, filename), filename)
+      )
+    );
+
+    const result = spawnSync(process.execPath, [writeInstallManifest], { cwd: context.root, encoding: 'utf-8' });
+    const manifest = JSON.parse(await readFile(join(dist, 'manifest.json'), 'utf-8')) as {
+      sha: string;
+      version: string;
+      platforms: { 'macos-arm64': { checksum: string } };
+    };
+
+    expect(result.status).toBe(0);
+    expect(manifest.sha).toBe('abc123def456');
+    expect(manifest.version).toBe('2.1.0');
+    expect(manifest.platforms['macos-arm64'].checksum).toBe(getContentChecksum('nve-macos-arm64'));
+  });
 });
 
 async function createInstallerContext(): Promise<InstallerContext> {
@@ -954,6 +1010,10 @@ function getFileChecksum(path: string): string {
   return createHash('sha256').update(readFileSync(path)).digest('hex');
 }
 
+function getContentChecksum(value: string): string {
+  return createHash('sha256').update(value).digest('hex');
+}
+
 function countOccurrences(value: string, search: string): number {
   return value.split(search).length - 1;
 }
diff --git a/projects/cli/src/install.ts b/projects/cli/src/install.ts
index b75244aa72..e14d8b3fcf 100644
--- a/projects/cli/src/install.ts
+++ b/projects/cli/src/install.ts
@@ -389,19 +389,20 @@ function getManifestPlatform(platform: NodeJS.Platform): string {
 }
 
 async function installGlobalElementsSkill(context: InstallContext): Promise<void> {
-  if (!(await shouldInstallGlobalElementsSkill(context))) {
-    return;
-  }
-
   const skillPath = getGlobalElementsSkillPath(context.env, context.platform);
   if (!skillPath) {
     context.warn('Could not install Elements agent skill. HOME is not set.');
     return;
   }
 
+  const hasExistingSkill = existsSync(skillPath);
+  if (!hasExistingSkill && !(await shouldInstallGlobalElementsSkill(context))) {
+    return;
+  }
+
   try {
     await writeGlobalElementsSkill(skillPath);
-    context.log(`Installed agent skill at ${skillPath}`);
+    context.log(`${hasExistingSkill ? 'Updated' : 'Installed'} agent skill at ${skillPath}`);
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
     context.warn(`Could not install Elements agent skill at ${skillPath}. ${message}`);
diff --git a/projects/cli/src/update.test.ts b/projects/cli/src/update.test.ts
index 8571018d9d..1c48caf69a 100644
--- a/projects/cli/src/update.test.ts
+++ b/projects/cli/src/update.test.ts
@@ -38,7 +38,7 @@ describe('update-check', () => {
       const result = await fetchLatestSha();
       expect(result).toBe('abc123def456');
       expect(fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/cli/manifest.json'),
+        'https://nvidia.github.io/elements/cli/manifest.json',
         expect.objectContaining({ signal: expect.any(AbortSignal) })
       );
     });
@@ -55,6 +55,18 @@ describe('update-check', () => {
       await expect(fetchLatestSha()).rejects.toThrow('Failed to fetch latest build info');
     });
 
+    it('should throw error when manifest is missing sha', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve({ version: '2.1.0' })
+        })
+      );
+
+      await expect(fetchLatestSha()).rejects.toThrow('Failed to fetch latest build info');
+    });
+
     it('should throw error on network failure', async () => {
       vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
 
@@ -92,6 +104,32 @@ describe('update-check', () => {
       expect(result).toBe(true);
     });
 
+    it('should return true when fetched sha differs even if version matches', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve({ sha: 'def456', version: '2.1.0' })
+        })
+      );
+
+      const result = await isUpdateAvailable('abc123');
+      expect(result).toBe(true);
+    });
+
+    it('should return false when fetched sha matches current even if version differs', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve({ sha: 'abc123', version: '2.1.0' })
+        })
+      );
+
+      const result = await isUpdateAvailable('abc123');
+      expect(result).toBe(false);
+    });
+
     it('should return false when fetched sha matches current', async () => {
       vi.stubGlobal(
         'fetch',
diff --git a/projects/cli/src/update.ts b/projects/cli/src/update.ts
index d249c6eca5..d71f5bcc8a 100644
--- a/projects/cli/src/update.ts
+++ b/projects/cli/src/update.ts
@@ -21,7 +21,11 @@ export async function fetchLatestSha(): Promise<string> {
     if (!res.ok) {
       throw new Error(`HTTP ${res.status}`);
     }
-    return ((await res.json()) as { sha: string }).sha;
+    const { sha } = (await res.json()) as { sha?: string };
+    if (typeof sha !== 'string') {
+      throw new Error('Missing sha');
+    }
+    return sha;
   } catch {
     throw new Error('Failed to fetch latest build info');
   }
@@ -50,8 +54,7 @@ export async function isUpdateAvailable(currentSha: string): Promise<boolean> {
 }
 
 /**
- * Shows update notification if a newer build is available.
- * Call after command execution with the promise from checkForUpdates().
+ * Shows update notification if the hosted CLI build differs.
  */
 export async function notifyIfUpdateAvailable(buildSha: string): Promise<void> {
   if (process.env.CI || !process.stdout.isTTY) {
diff --git a/projects/cli/src/utils.test.ts b/projects/cli/src/utils.test.ts
index c04a2cf2bf..dfc02f7e47 100644
--- a/projects/cli/src/utils.test.ts
+++ b/projects/cli/src/utils.test.ts
@@ -4,9 +4,13 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { marked } from 'marked';
 import ora, { type Ora } from 'ora';
+import type { ManagedToolMethod } from '@internals/tools';
 import {
   banner,
   colors,
+  exitCodeForResult,
+  exitWithCompleteToolResult,
+  exitWithToolError,
   getSpinnerProgressMessage,
   runAsyncTool,
   getArgValue,
@@ -140,6 +144,16 @@ describe('utils', () => {
       expect(ora).not.toHaveBeenCalled();
     });
 
+    it('should run function without spinner when interactive progress is disabled', async () => {
+      const args = {};
+      const result = await runAsyncTool(args, mockFn, { interactiveProgress: false });
+
+      expect(result).toBe('test result');
+      expect(mockFn).toHaveBeenCalledWith(args);
+      expect(args).not.toHaveProperty('onProgress');
+      expect(ora).not.toHaveBeenCalled();
+    });
+
     it('should run function with spinner in interactive mode', async () => {
       const args = {};
       const result = await runAsyncTool(args, mockFn);
@@ -162,6 +176,7 @@ describe('utils', () => {
 
       await expect(runAsyncTool(args, mockFn)).rejects.toThrow('Test error');
       expect(mockFn).toHaveBeenCalledWith(args);
+      expect(mockSpinner.stop).toHaveBeenCalled();
     });
 
     it('should append console and progress output to the spinner text', async () => {
@@ -459,6 +474,119 @@ describe('utils', () => {
     });
   });
 
+  describe('exitCodeForResult', () => {
+    it('should return 1 for danger reports', () => {
+      expect(
+        exitCodeForResult({
+          failedCheck: { status: 'danger', message: 'Failed' }
+        })
+      ).toBe(1);
+    });
+
+    it('should return 0 for non-danger reports and non-report results', () => {
+      expect(
+        exitCodeForResult({
+          warningCheck: { status: 'warning', message: 'Warning' }
+        })
+      ).toBe(0);
+      expect(exitCodeForResult('done')).toBe(0);
+    });
+  });
+
+  describe('exitWithToolError', () => {
+    it('should print fallback error messages and exit with code 1', async () => {
+      const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      await expect(exitWithToolError(undefined, 'failed')).rejects.toThrow('process.exit called');
+
+      expect(error).toHaveBeenCalledWith(colors.error('failed'));
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it('should render structured error results and exit with code 1', async () => {
+      const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      await expect(exitWithToolError({ message: 'failed' }, undefined)).rejects.toThrow('process.exit called');
+
+      expect(error).toHaveBeenCalledWith(JSON.stringify({ message: 'failed' }, null, 2));
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('exitWithCompleteToolResult', () => {
+    let originalElementsDebug: string | undefined;
+    let originalElementsEnv: string | undefined;
+
+    beforeEach(() => {
+      originalElementsDebug = process.env.ELEMENTS_DEBUG;
+      originalElementsEnv = process.env.ELEMENTS_ENV;
+      delete process.env.ELEMENTS_DEBUG;
+      delete process.env.ELEMENTS_ENV;
+      vi.mocked(marked.parse).mockImplementation(input => Promise.resolve(input));
+    });
+
+    afterEach(() => {
+      if (originalElementsDebug === undefined) {
+        delete process.env.ELEMENTS_DEBUG;
+      } else {
+        process.env.ELEMENTS_DEBUG = originalElementsDebug;
+      }
+
+      if (originalElementsEnv === undefined) {
+        delete process.env.ELEMENTS_ENV;
+      } else {
+        process.env.ELEMENTS_ENV = originalElementsEnv;
+      }
+    });
+
+    it('should print successful results, notify updates, and exit with code 0', async () => {
+      const notifyUpdate = vi.fn().mockResolvedValue(undefined);
+
+      await expect(exitWithCompleteToolResult({ result: { ok: true }, notifyUpdate })).rejects.toThrow(
+        'process.exit called'
+      );
+
+      expect(console.log).toHaveBeenCalledWith(JSON.stringify({ ok: true }, null, 2));
+      expect(notifyUpdate).toHaveBeenCalled();
+      expect(process.exit).toHaveBeenCalledWith(0);
+    });
+
+    it('should print danger reports without notifying updates and exit with code 1', async () => {
+      const notifyUpdate = vi.fn().mockResolvedValue(undefined);
+
+      await expect(
+        exitWithCompleteToolResult({
+          result: { failedCheck: { status: 'danger', message: 'Failed' } },
+          notifyUpdate
+        })
+      ).rejects.toThrow('process.exit called');
+
+      expect(console.log).toHaveBeenCalledWith('❌ (**failed check**): Failed');
+      expect(notifyUpdate).not.toHaveBeenCalled();
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it('should print debug metadata when debug output is enabled', async () => {
+      process.env.ELEMENTS_DEBUG = 'true';
+      process.env.ELEMENTS_ENV = 'cli';
+      const tool = { metadata: { command: 'api.list' } } as ManagedToolMethod<unknown>;
+
+      await expect(
+        exitWithCompleteToolResult({
+          result: { ok: true },
+          tool,
+          start: 1000,
+          end: 1500
+        })
+      ).rejects.toThrow('process.exit called');
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('[debug]\n[command]: api.list'));
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('[execution time]: 0.50 seconds'));
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('[token usage]:'));
+      expect(process.exit).toHaveBeenCalledWith(0);
+    });
+  });
+
   describe('renderReport', () => {
     beforeEach(() => {
       vi.mocked(marked.parse).mockImplementation(input => Promise.resolve(input));
@@ -476,12 +604,15 @@ describe('utils', () => {
       expect(process.exit).not.toHaveBeenCalled();
     });
 
-    it('should exit on failure', async () => {
+    it('should return formatted report and not exit on failure', async () => {
       const report = {
         failedTest: { status: 'danger' as const, message: 'Test failed' }
       };
 
-      await expect(() => renderReport(report)).rejects.toThrow('process.exit called');
+      const result = await renderReport(report);
+
+      expect(result).toBe('❌ (**failed test**): Test failed');
+      expect(process.exit).not.toHaveBeenCalled();
     });
 
     it('should format camelCase keys to readable labels', async () => {
diff --git a/projects/cli/src/utils.ts b/projects/cli/src/utils.ts
index 64e9b98017..60656cee66 100644
--- a/projects/cli/src/utils.ts
+++ b/projects/cli/src/utils.ts
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { select, input, confirm, editor } from '@inquirer/prompts';
-import { type ManagedToolMethod, type Report } from '@internals/tools';
+import { isDebug, MAX_CONTEXT_TOKENS, type ManagedToolMethod, type Report } from '@internals/tools';
 import ora, { type Ora } from 'ora';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
@@ -11,6 +11,10 @@ export const banner = `"░██████████ ░██
 
 type ArgInputType = 'string' | 'number' | 'boolean' | 'object' | 'array';
 
+interface RunAsyncToolOptions {
+  interactiveProgress?: boolean;
+}
+
 export const colors = {
   info: (value: string) => `\x1b[34m${value}\x1b[0m`,
   error: (value: string) => `\x1b[31m${value}\x1b[0m`,
@@ -40,8 +44,12 @@ export function getSpinnerProgressMessage() {
   return messages[Math.floor(Math.random() * messages.length)];
 }
 
-export async function runAsyncTool(args: Record<string, unknown>, fn: ManagedToolMethod<unknown>) {
-  const isInteractive = !args.start && !args.log && !process.env.CI;
+export async function runAsyncTool(
+  args: Record<string, unknown>,
+  fn: ManagedToolMethod<unknown>,
+  options: RunAsyncToolOptions = {}
+) {
+  const isInteractive = (options.interactiveProgress ?? true) && !args.start && !args.log && !process.env.CI;
   let spinner: Ora | undefined;
 
   const startTime = Date.now();
@@ -58,13 +66,14 @@ export async function runAsyncTool(args: Record<string, unknown>, fn: ManagedToo
     };
   }
 
-  const value = await fn(args);
-
-  if (isInteractive) {
-    spinner?.stop();
-    console.log = originalConsole;
+  try {
+    return await fn(args);
+  } finally {
+    if (isInteractive) {
+      spinner?.stop();
+      console.log = originalConsole;
+    }
   }
-  return value;
 }
 
 interface PropertySchema {
@@ -133,7 +142,7 @@ export const statusIcons = {
   undefined: ''
 };
 
-export function isReport(result: unknown) {
+export function isReport(result: unknown): result is Report {
   if (!isObjectLiteral(result)) return false;
   return Object.entries(result as Record<string, unknown>).every(([, value]) => {
     const entry = value as Record<string, unknown>;
@@ -145,6 +154,46 @@ export function reportHasFailures(result: Report) {
   return Object.values(result).some(value => value.status === 'danger');
 }
 
+export async function exitWithToolError(result: unknown, message: string | undefined): Promise<never> {
+  console.error(result === undefined ? colors.error(message ?? 'unknown error') : await renderResult(result));
+  process.exit(1);
+}
+
+export function exitCodeForResult(result: unknown) {
+  return isReport(result) && reportHasFailures(result) ? 1 : 0;
+}
+
+interface CompleteToolResultOptions {
+  result: unknown;
+  tool?: ManagedToolMethod<unknown>;
+  start?: number;
+  end?: number;
+  notifyUpdate?: () => Promise<void>;
+}
+
+export async function exitWithCompleteToolResult({
+  result,
+  tool,
+  start,
+  end,
+  notifyUpdate
+}: CompleteToolResultOptions): Promise<never> {
+  let formattedResult = await renderResult(result);
+  if (tool && start !== undefined && end !== undefined && isDebug()) {
+    const tokens = formattedResult.length / 4;
+    const pct = (tokens / MAX_CONTEXT_TOKENS) * 100;
+    formattedResult += `[debug]\n[command]: ${tool.metadata.command}`;
+    formattedResult += `\n[execution time]: ${((end - start) / 1000).toFixed(2)} seconds`;
+    formattedResult += `\n[token usage]: ${progressBar(pct)} ${tokens.toLocaleString()} / ${MAX_CONTEXT_TOKENS.toLocaleString()} (${(100 - pct).toFixed(1)}% remaining)`;
+  }
+  console.log(formattedResult);
+  const exitCode = exitCodeForResult(result);
+  if (exitCode === 0) {
+    await notifyUpdate?.();
+  }
+  process.exit(exitCode);
+}
+
 export async function renderReport(result: Report) {
   const reports = Object.entries(result).map(([key, value]) => {
     const label = key
@@ -156,10 +205,6 @@ export async function renderReport(result: Report) {
 
   const results = (await Promise.all(reports.map(report => marked.parse(report)))).map(r => r.trim()).join('\n');
 
-  if (reportHasFailures(result)) {
-    process.exit(1);
-  }
-
   return results;
 }
 
diff --git a/projects/cli/vite.config.ts b/projects/cli/vite.config.ts
index 478a2bbb0d..675ebf2889 100644
--- a/projects/cli/vite.config.ts
+++ b/projects/cli/vite.config.ts
@@ -12,6 +12,7 @@ const MCP_UI_SOURCE_DIR = resolve(import.meta.dirname, 'src/mcp/ui');
 const MCP_UI_OUTPUT_DIR = resolve(import.meta.dirname, 'dist/mcp/ui');
 const MCP_UI_ENTRYPOINTS = ['api-icons-list.html', 'api-tokens-list.html', 'examples-render.html'];
 const MCP_UI_INLINE_MODULE_ID = 'virtual:mcp-ui-inline';
+const PACKAGE_JSON_PATH = resolve(import.meta.dirname, 'package.json');
 
 export default defineConfig(async ({ command }) => {
   if (command === 'build') await buildMcpUiResources();
@@ -142,5 +143,14 @@ async function getNextReleaseVersion() {
     }
   );
 
-  return releaseResult ? releaseResult.nextRelease.version : '0.0.0';
+  return releaseResult?.nextRelease?.version ?? getPackageVersion();
+}
+
+function getPackageVersion() {
+  const packageJson: unknown = JSON.parse(readFileSync(PACKAGE_JSON_PATH, 'utf-8'));
+  if (!packageJson || typeof packageJson !== 'object' || !('version' in packageJson)) {
+    return '0.0.0';
+  }
+
+  return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
 }
diff --git a/projects/internals/tools/src/api/utils.test.ts b/projects/internals/tools/src/api/utils.test.ts
index e38708f8a7..beb87b6e04 100644
--- a/projects/internals/tools/src/api/utils.test.ts
+++ b/projects/internals/tools/src/api/utils.test.ts
@@ -151,17 +151,20 @@ describe('getLatestPublishedVersions', () => {
     await expect(getLatestPublishedVersions(projects)).rejects.toThrow(/Could not fetch latest versions from/);
   });
 
-  it('should return fallback version and warn when fetch fails and ELEMENTS_ENV is not mcp', async () => {
-    vi.stubEnv('ELEMENTS_ENV', 'dev');
-    vi.mocked(fetch).mockRejectedValue(new Error('Network error'));
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const { getLatestPublishedVersions } = await import('./utils.js');
-
-    const result = await getLatestPublishedVersions(projects);
-
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Could not fetch latest versions from'));
-    expect(result).toEqual({ '@nvidia-elements/core': '0.0.0' });
-  });
+  it.each(['cli', 'dev'])(
+    'should return a fallback version and warn when fetch fails in the %s environment',
+    async environment => {
+      vi.stubEnv('ELEMENTS_ENV', environment);
+      vi.mocked(fetch).mockRejectedValue(new Error('Network error'));
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const { getLatestPublishedVersions } = await import('./utils.js');
+
+      const result = await getLatestPublishedVersions(projects);
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Could not fetch latest versions from'));
+      expect(result).toEqual({ '@nvidia-elements/core': '0.0.0' });
+    }
+  );
 
   it('should fetch versions from the npm registry', async () => {
     vi.stubEnv('ELEMENTS_ENV', 'dev');
@@ -492,7 +495,7 @@ describe('attributeMetadataToMarkdown', () => {
       values: [
         { name: 'info' },
         { name: 'warning' },
-        { name: 'error|danger' }, // should be filtered
+        { name: 'error|danger' }, // filter this value
         { name: 'success' }
       ]
     };
@@ -511,9 +514,9 @@ describe('attributeMetadataToMarkdown', () => {
       markdown: '',
       values: [
         { name: 'active' },
-        { name: '@deprecated' }, // should be filtered
+        { name: '@deprecated' }, // filter this value
         { name: 'inactive' },
-        { name: 'user@email' } // should be filtered
+        { name: 'user@email' } // filter this value
       ]
     };
 
@@ -533,7 +536,7 @@ describe('attributeMetadataToMarkdown', () => {
       values: [
         { name: 'left' },
         { name: 'center' },
-        { name: 'left&right' }, // should be filtered
+        { name: 'left&right' }, // filter this value
         { name: 'right' }
       ]
     };
diff --git a/projects/internals/tools/src/api/utils.ts b/projects/internals/tools/src/api/utils.ts
index 01dd299d8c..65891f9186 100644
--- a/projects/internals/tools/src/api/utils.ts
+++ b/projects/internals/tools/src/api/utils.ts
@@ -15,6 +15,8 @@ import {
 
 export type { PartialAPIResult } from '../distill/apis.js';
 
+declare const __ELEMENTS_REGISTRY_URL__: string;
+
 export function getContextAPIs(
   format: 'markdown' | 'json',
   metadata: {
@@ -166,7 +168,7 @@ export interface ElementVersions {
   '@nvidia-elements/monaco': string;
 }
 
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const NPM_REGISTRY_URL = __ELEMENTS_REGISTRY_URL__;
 
 /* istanbul ignore next -- @preserve */
 let versions: ElementVersions | null = null;
diff --git a/projects/internals/tools/src/cli/utils.test.ts b/projects/internals/tools/src/cli/utils.test.ts
index 871869265b..5d7671611e 100644
--- a/projects/internals/tools/src/cli/utils.test.ts
+++ b/projects/internals/tools/src/cli/utils.test.ts
@@ -40,6 +40,15 @@ describe('cli/utils', () => {
     vi.restoreAllMocks();
   });
 
+  it('should fail the macos/linux pipeline when the installer download fails', () => {
+    expect(upgradeCommands['macos/linux']).toContain('pipefail');
+  });
+
+  it('should default upgrade commands to the public pages host', () => {
+    expect(upgradeCommands['macos/linux']).toContain('https://nvidia.github.io/elements/install.sh');
+    expect(upgradeCommands['windows-powershell']).toContain('https://nvidia.github.io/elements/install.ps1');
+  });
+
   describe('performUpgrade (sync path, no onProgress)', () => {
     it('should return success report when upgrade succeeds', async () => {
       const { execSync } = await import('node:child_process');
diff --git a/projects/internals/tools/src/cli/utils.ts b/projects/internals/tools/src/cli/utils.ts
index b6fcfb72c1..fa25efc4ca 100644
--- a/projects/internals/tools/src/cli/utils.ts
+++ b/projects/internals/tools/src/cli/utils.ts
@@ -9,7 +9,7 @@ declare const __ELEMENTS_PAGES_BASE_URL__: string;
 export type ProgressCallback = (message: string) => void;
 
 export const upgradeCommands = {
-  'macos/linux': `curl -fsSL ${__ELEMENTS_PAGES_BASE_URL__}/install.sh | bash`,
+  'macos/linux': `bash -o pipefail -c 'curl -fsSL ${__ELEMENTS_PAGES_BASE_URL__}/install.sh | bash'`,
   'windows-powershell': `powershell -NoProfile -ExecutionPolicy Bypass -Command "$script = Join-Path $env:TEMP 'nve-install.ps1'; Invoke-WebRequest -UseBasicParsing '${__ELEMENTS_PAGES_BASE_URL__}/install.ps1' -OutFile $script; & $script; Remove-Item $script -ErrorAction SilentlyContinue"`,
   nodejs: 'npm install -g @nvidia-elements/cli'
 };
diff --git a/projects/internals/tools/src/playground/utils.test.ts b/projects/internals/tools/src/playground/utils.test.ts
index 1e9f9ef753..95f90b8916 100644
--- a/projects/internals/tools/src/playground/utils.test.ts
+++ b/projects/internals/tools/src/playground/utils.test.ts
@@ -547,7 +547,7 @@ describe('createImportMap with different frameworks', () => {
   it('should include all NVE packages for all frameworks', () => {
     const files = createDefaultFiles('<nve-button></nve-button>', elements, {});
     const importmap = JSON.parse(files['importmap.json'].content);
-    expect(importmap.imports['@nvidia-elements/core']).toContain('/@nvidia-elements/core@latest');
+    expect(importmap.imports['@nvidia-elements/core']).toBe('https://esm.sh/@nvidia-elements/core@latest');
     expect(importmap.imports['@nvidia-elements/styles']).toContain('/@nvidia-elements/styles@latest');
     expect(importmap.imports['@nvidia-elements/themes']).toContain('/@nvidia-elements/themes@latest');
     expect(importmap.imports['@nvidia-elements/monaco']).toContain('/@nvidia-elements/monaco@latest');
diff --git a/projects/internals/tools/src/playground/utils.ts b/projects/internals/tools/src/playground/utils.ts
index 153245a241..3c07ade9e8 100644
--- a/projects/internals/tools/src/playground/utils.ts
+++ b/projects/internals/tools/src/playground/utils.ts
@@ -7,8 +7,10 @@ import type { Element } from '@internals/metadata';
 import { getElementImports } from '../internal/utils.js';
 import { validateTemplate } from '../internal/validate.js';
 
+declare const __ELEMENTS_ESM_CDN_BASE_URL__: string;
+
 const ELEMENTS_PLAYGROUND_BASE_URL = process.env.ELEMENTS_PLAYGROUND_BASE_URL ?? '';
-const ELEMENTS_ESM_CDN_BASE_URL = process.env.ELEMENTS_ESM_CDN_BASE_URL ?? '';
+const ELEMENTS_ESM_CDN_BASE_URL = __ELEMENTS_ESM_CDN_BASE_URL__;
 
 interface PlaygroundOptions {
   type?: PlaygroundType;
diff --git a/projects/internals/tools/src/project/health.test.ts b/projects/internals/tools/src/project/health.test.ts
index 5dcfa1b0bb..907e87c590 100644
--- a/projects/internals/tools/src/project/health.test.ts
+++ b/projects/internals/tools/src/project/health.test.ts
@@ -106,7 +106,7 @@ describe('getVersionStatus', () => {
   });
 
   it('should handle versions with missing minor or patch parts', () => {
-    // When minor is undefined, the comparison will fail and return 'success'
+    // A missing minor part makes the comparison fail and return 'success'
     expect(getVersionStatus('1', '1.10.0')).toEqual('success');
     expect(getVersionStatus('1.5', '1.10.0')).toEqual('success');
     expect(getVersionStatus('1.0.0', '1')).toEqual('success');
@@ -315,6 +315,23 @@ describe('checkDependencies', () => {
     expect(result.versions['@nvidia-elements/core'].status).toBe('danger');
   });
 
+  it('should return danger when the latest version cannot be verified', async () => {
+    const result = await checkDependencies(
+      {
+        devDependencies: {},
+        dependencies: { '@nvidia-elements/core': '1.0.0' },
+        peerDependencies: {}
+      },
+      { '@nvidia-elements/core': '0.0.0' } as ElementVersions
+    );
+
+    expect(result).toEqual({
+      versions: {},
+      status: 'danger',
+      message: 'Could not verify latest versions for @nvidia-elements/core'
+    });
+  });
+
   it('should return warning when packages are out of date (warning status)', async () => {
     const result = await checkDependencies(
       {
@@ -386,7 +403,7 @@ describe('checkDependencies', () => {
 describe('checkPublint (indirect testing)', () => {
   it('should handle publint checks with various status types', async () => {
     // This test verifies the behavior of checkPublint indirectly
-    // by testing the status mapping logic that would be used
+    // by testing the status mapping logic that checkPublint would use
     const statusOptions = {
       suggestion: 'warning',
       warning: 'warning',
@@ -399,7 +416,7 @@ describe('checkPublint (indirect testing)', () => {
   });
 
   it('should handle empty publint checks', async () => {
-    // This test verifies the behavior when no checks are returned
+    // This test verifies the behavior when publint returns no checks
     // The function should return a success message
     const emptyChecks: unknown[] = [];
     const results: Record<string, unknown> = {};
diff --git a/projects/internals/tools/src/project/health.ts b/projects/internals/tools/src/project/health.ts
index 773a6edf1f..1c3ed382e5 100644
--- a/projects/internals/tools/src/project/health.ts
+++ b/projects/internals/tools/src/project/health.ts
@@ -184,27 +184,42 @@ export function checkSemanticDependencies(packageJson: PackageData): ReportCheck
 }
 
 export async function checkDependencies(packageJson: PackageData, currentVersions: ElementVersions) {
-  const versions = await getVersionHealth(packageJson, currentVersions);
   const dependencies = Object.keys(packageJson.dependencies ?? {});
   const devDependencies = Object.keys(packageJson.devDependencies ?? {});
   const peerDependencies = Object.keys(packageJson.peerDependencies ?? {});
   const elementPackages = Object.keys(currentVersions);
   const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies];
-  let status: 'success' | 'danger' | 'warning' = 'success';
-  let message = '@nvidia-elements packages are up to date';
 
   if (!allDependencies.some(dependency => elementPackages.includes(dependency))) {
-    status = 'warning';
-    message = 'No @nvidia-elements packages found in the project';
+    return {
+      versions: {},
+      status: 'warning' as const,
+      message: 'No @nvidia-elements packages found in the project'
+    };
+  }
+
+  const unavailablePackages = Object.entries(currentVersions)
+    .filter(([packageName, version]) => allDependencies.includes(packageName) && version === '0.0.0')
+    .map(([packageName]) => packageName);
+  if (unavailablePackages.length > 0) {
+    return {
+      versions: {},
+      status: 'danger' as const,
+      message: `Could not verify latest versions for ${unavailablePackages.join(', ')}`
+    };
   }
 
+  const versions = await getVersionHealth(packageJson, currentVersions);
   if (
     Object.values(versions).some(version => version.status === 'danger') ||
     Object.values(versions).some(version => version.status === 'warning')
   ) {
-    status = 'warning'; // warning for either to ensure this does not trigger a CI runtime failure as this checks the latest version remotely
-    message = '@nvidia-elements packages are out of date';
+    return {
+      versions,
+      status: 'warning' as const,
+      message: '@nvidia-elements packages are out of date'
+    };
   }
 
-  return { versions, status, message };
+  return { versions, status: 'success' as const, message: '@nvidia-elements packages are up to date' };
 }
diff --git a/projects/internals/vite/src/configs/build.js b/projects/internals/vite/src/configs/build.js
index 51328e207e..7e5e6abc5b 100644
--- a/projects/internals/vite/src/configs/build.js
+++ b/projects/internals/vite/src/configs/build.js
@@ -12,6 +12,7 @@ import { bundle } from '../plugins/bundle.js';
 import { initial } from '../plugins/initial.js';
 import { examplesToJSON } from '../plugins/examples.js';
 import { writeIfChanged } from '../plugins/write-if-changed.js';
+import { getElementsEnv } from './env.js';
 
 const index = process.argv.findIndex(i => i === '--outDir') + 1;
 const dist = (p = '') => `${index ? process.argv[index] : './dist'}/${p}`;
@@ -26,14 +27,7 @@ const packageFile = JSON.parse(packageFilePath);
  */
 export const libraryBuildConfig = {
   plugins: [initial(), tsc(), dts(), bundle(), examplesToJSON(packageFile), cem(), snippets()],
-  define: {
-    __ELEMENTS_PLAYGROUND_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PLAYGROUND_BASE_URL || ''),
-    __ELEMENTS_REPO_BASE_URL__: JSON.stringify(process.env.ELEMENTS_REPO_BASE_URL || ''),
-    __ELEMENTS_PAGES_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PAGES_BASE_URL || ''),
-    __ELEMENTS_REGISTRY_URL__: JSON.stringify(process.env.ELEMENTS_REGISTRY_URL || ''),
-    __ELEMENTS_ESM_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_ESM_CDN_BASE_URL || ''),
-    __ELEMENTS_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_CDN_BASE_URL || '')
-  },
+  define: getElementsEnv(),
   build: {
     reportCompressedSize: false,
     cssMinify: prod ? 'esbuild' : false,
diff --git a/projects/internals/vite/src/configs/build.node.js b/projects/internals/vite/src/configs/build.node.js
index a7e1f788ea..cc63a2d313 100644
--- a/projects/internals/vite/src/configs/build.node.js
+++ b/projects/internals/vite/src/configs/build.node.js
@@ -8,6 +8,7 @@ import { dts } from '../plugins/dts.js';
 import { jsonDynamicImports } from '../plugins/json-dynamic-imports.js';
 import { transpileDecorators } from '../plugins/decorators.js';
 import { markdown } from '../plugins/markdown.js';
+import { getElementsEnv } from './env.js';
 
 const NODE_BUILT_IN_MODULES = builtinModules.filter(m => !m.startsWith('_'));
 NODE_BUILT_IN_MODULES.push(...NODE_BUILT_IN_MODULES.map(m => `node:${m}`));
@@ -27,14 +28,7 @@ export const libraryNodeBuildConfig = {
     exclude: NODE_BUILT_IN_MODULES
   },
   plugins: [tsc(), dts(), transpileDecorators(), markdown()],
-  define: {
-    __ELEMENTS_PLAYGROUND_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PLAYGROUND_BASE_URL || ''),
-    __ELEMENTS_REPO_BASE_URL__: JSON.stringify(process.env.ELEMENTS_REPO_BASE_URL || ''),
-    __ELEMENTS_PAGES_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PAGES_BASE_URL || ''),
-    __ELEMENTS_REGISTRY_URL__: JSON.stringify(process.env.ELEMENTS_REGISTRY_URL || ''),
-    __ELEMENTS_ESM_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_ESM_CDN_BASE_URL || ''),
-    __ELEMENTS_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_CDN_BASE_URL || '')
-  },
+  define: getElementsEnv(),
   build: {
     reportCompressedSize: false,
     watch: mode === 'watch' ? {} : undefined,
diff --git a/projects/internals/vite/src/configs/env.js b/projects/internals/vite/src/configs/env.js
new file mode 100644
index 0000000000..86f424f351
--- /dev/null
+++ b/projects/internals/vite/src/configs/env.js
@@ -0,0 +1,36 @@
+const DEFAULT_ELEMENTS_PAGES_BASE_URL = 'https://nvidia.github.io/elements';
+const DEFAULT_ELEMENTS_REPO_BASE_URL = 'https://github.com/NVIDIA/elements';
+const DEFAULT_ELEMENTS_REGISTRY_URL = 'https://registry.npmjs.org';
+const DEFAULT_ELEMENTS_CDN_BASE_URL = 'https://cdn.jsdelivr.net/npm';
+const DEFAULT_ELEMENTS_ESM_CDN_BASE_URL = 'https://esm.sh';
+const DEFAULT_ELEMENTS_SITE_URL = 'https://nvidia.github.io';
+
+function getEnvValue(name, fallback = '') {
+  return process.env[name]?.trim() || fallback;
+}
+
+export function getElementsEnvValues() {
+  return {
+    ELEMENTS_REPO_BASE_URL: getEnvValue('ELEMENTS_REPO_BASE_URL', DEFAULT_ELEMENTS_REPO_BASE_URL),
+    ELEMENTS_PAGES_BASE_URL: getEnvValue('ELEMENTS_PAGES_BASE_URL', DEFAULT_ELEMENTS_PAGES_BASE_URL),
+    ELEMENTS_REGISTRY_URL: getEnvValue('ELEMENTS_REGISTRY_URL', DEFAULT_ELEMENTS_REGISTRY_URL),
+    ELEMENTS_CDN_BASE_URL: getEnvValue('ELEMENTS_CDN_BASE_URL', DEFAULT_ELEMENTS_CDN_BASE_URL),
+    ELEMENTS_ESM_CDN_BASE_URL: getEnvValue('ELEMENTS_ESM_CDN_BASE_URL', DEFAULT_ELEMENTS_ESM_CDN_BASE_URL),
+    ELEMENTS_SITE_URL: getEnvValue('ELEMENTS_SITE_URL', DEFAULT_ELEMENTS_SITE_URL),
+    ELEMENTS_PLAYGROUND_BASE_URL: getEnvValue('ELEMENTS_PLAYGROUND_BASE_URL'),
+    ELEMENTS_ASSETS_CDN_BASE_URL: getEnvValue('ELEMENTS_ASSETS_CDN_BASE_URL')
+  };
+}
+
+export function getElementsEnv() {
+  const env = getElementsEnvValues();
+  return {
+    __ELEMENTS_REPO_BASE_URL__: JSON.stringify(env.ELEMENTS_REPO_BASE_URL),
+    __ELEMENTS_PAGES_BASE_URL__: JSON.stringify(env.ELEMENTS_PAGES_BASE_URL),
+    __ELEMENTS_REGISTRY_URL__: JSON.stringify(env.ELEMENTS_REGISTRY_URL),
+    __ELEMENTS_CDN_BASE_URL__: JSON.stringify(env.ELEMENTS_CDN_BASE_URL),
+    __ELEMENTS_ESM_CDN_BASE_URL__: JSON.stringify(env.ELEMENTS_ESM_CDN_BASE_URL),
+    __ELEMENTS_SITE_URL__: JSON.stringify(env.ELEMENTS_SITE_URL),
+    __ELEMENTS_PLAYGROUND_BASE_URL__: JSON.stringify(env.ELEMENTS_PLAYGROUND_BASE_URL)
+  };
+}
diff --git a/projects/internals/vite/src/configs/test.js b/projects/internals/vite/src/configs/test.js
index 4836eb24f3..3fa2bf6741 100644
--- a/projects/internals/vite/src/configs/test.js
+++ b/projects/internals/vite/src/configs/test.js
@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import process from 'process';
 import { playwright } from '@vitest/browser-playwright';
 import { hideExpectedTestConsoleMessage } from './console.js';
+import { getElementsEnv } from './env.js';
 
 const watch = process.argv.findIndex(i => i === '--watch') !== -1;
 const coverage = process.argv.findIndex(i => i === '--coverage') !== -1;
@@ -21,14 +22,7 @@ Object.defineProperty(browser, 'name', {
 export const libraryTestConfig = {
   testTimeout: 60_000,
   cacheDir: 'node_modules/.vite-unit',
-  define: {
-    __ELEMENTS_PLAYGROUND_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PLAYGROUND_BASE_URL || ''),
-    __ELEMENTS_REPO_BASE_URL__: JSON.stringify(process.env.ELEMENTS_REPO_BASE_URL || ''),
-    __ELEMENTS_PAGES_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PAGES_BASE_URL || ''),
-    __ELEMENTS_REGISTRY_URL__: JSON.stringify(process.env.ELEMENTS_REGISTRY_URL || ''),
-    __ELEMENTS_ESM_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_ESM_CDN_BASE_URL || ''),
-    __ELEMENTS_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_CDN_BASE_URL || '')
-  },
+  define: getElementsEnv(),
   build: {
     target: 'esnext',
     rolldownOptions: {
diff --git a/projects/internals/vite/src/configs/test.node.js b/projects/internals/vite/src/configs/test.node.js
index eac9e5c77d..8b8f8dc4d3 100644
--- a/projects/internals/vite/src/configs/test.node.js
+++ b/projects/internals/vite/src/configs/test.node.js
@@ -1,6 +1,7 @@
 import process from 'process';
 import { transpileDecorators } from '../plugins/decorators.js';
 import { markdown } from '../plugins/markdown.js';
+import { getElementsEnv } from './env.js';
 
 const watch = process.argv.findIndex(i => i === '--watch') !== -1;
 const coverage = process.argv.findIndex(i => i === '--coverage') !== -1;
@@ -14,14 +15,7 @@ export const libraryNodeTestConfig = {
       allow: [process.cwd(), '/']
     }
   },
-  define: {
-    __ELEMENTS_PLAYGROUND_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PLAYGROUND_BASE_URL || ''),
-    __ELEMENTS_REPO_BASE_URL__: JSON.stringify(process.env.ELEMENTS_REPO_BASE_URL || ''),
-    __ELEMENTS_PAGES_BASE_URL__: JSON.stringify(process.env.ELEMENTS_PAGES_BASE_URL || ''),
-    __ELEMENTS_REGISTRY_URL__: JSON.stringify(process.env.ELEMENTS_REGISTRY_URL || ''),
-    __ELEMENTS_ESM_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_ESM_CDN_BASE_URL || ''),
-    __ELEMENTS_CDN_BASE_URL__: JSON.stringify(process.env.ELEMENTS_CDN_BASE_URL || '')
-  },
+  define: getElementsEnv(),
   test: {
     retry: 1,
     isolate: coverage,
diff --git a/projects/site/src/_11ty/utils/env.js b/projects/site/src/_11ty/utils/env.js
index b6ccc34b58..53ad98c077 100644
--- a/projects/site/src/_11ty/utils/env.js
+++ b/projects/site/src/_11ty/utils/env.js
@@ -1,17 +1,15 @@
 /* eslint-env node */
 /* global process */
 
-function getEnvValue(name, fallback = '') {
-  const value = process.env[name]?.trim();
+import { getElementsEnvValues } from '@internals/vite/configs/env.js';
 
-  return value || fallback;
-}
+const elementsEnv = getElementsEnvValues();
 
-export const ELEMENTS_PAGES_BASE_URL = getEnvValue('ELEMENTS_PAGES_BASE_URL', 'https://nvidia.github.io/elements');
-export const ELEMENTS_REPO_BASE_URL = getEnvValue('ELEMENTS_REPO_BASE_URL', 'https://github.com/NVIDIA/elements');
-export const ELEMENTS_SITE_URL = getEnvValue('ELEMENTS_SITE_URL', 'https://nvidia.github.io');
-export const ELEMENTS_PLAYGROUND_BASE_URL = getEnvValue('ELEMENTS_PLAYGROUND_BASE_URL');
-export const ELEMENTS_REGISTRY_URL = getEnvValue('ELEMENTS_REGISTRY_URL');
-export const ELEMENTS_ASSETS_CDN_BASE_URL = getEnvValue('ELEMENTS_ASSETS_CDN_BASE_URL');
-export const ELEMENTS_ESM_CDN_BASE_URL = getEnvValue('ELEMENTS_ESM_CDN_BASE_URL');
-export const ELEMENTS_CDN_BASE_URL = getEnvValue('ELEMENTS_CDN_BASE_URL');
+export const ELEMENTS_PAGES_BASE_URL = elementsEnv.ELEMENTS_PAGES_BASE_URL;
+export const ELEMENTS_REPO_BASE_URL = elementsEnv.ELEMENTS_REPO_BASE_URL;
+export const ELEMENTS_PLAYGROUND_BASE_URL = elementsEnv.ELEMENTS_PLAYGROUND_BASE_URL;
+export const ELEMENTS_REGISTRY_URL = elementsEnv.ELEMENTS_REGISTRY_URL;
+export const ELEMENTS_ESM_CDN_BASE_URL = elementsEnv.ELEMENTS_ESM_CDN_BASE_URL;
+export const ELEMENTS_CDN_BASE_URL = elementsEnv.ELEMENTS_CDN_BASE_URL;
+export const ELEMENTS_SITE_URL = elementsEnv.ELEMENTS_SITE_URL;
+export const ELEMENTS_ASSETS_CDN_BASE_URL = elementsEnv.ELEMENTS_ASSETS_CDN_BASE_URL;
diff --git a/projects/site/src/_11ty/utils/env.test.ts b/projects/site/src/_11ty/utils/env.test.ts
deleted file mode 100644
index af8c33090a..0000000000
--- a/projects/site/src/_11ty/utils/env.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-async function importEnv() {
-  vi.resetModules();
-
-  return import('./env.js');
-}
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-});
-
-describe('env', () => {
-  it('should fall back when required url env vars are empty', async () => {
-    vi.stubEnv('ELEMENTS_PAGES_BASE_URL', '');
-    vi.stubEnv('ELEMENTS_REPO_BASE_URL', '');
-    vi.stubEnv('ELEMENTS_SITE_URL', '');
-
-    const env = await importEnv();
-
-    expect(env.ELEMENTS_PAGES_BASE_URL).toBe('https://nvidia.github.io/elements');
-    expect(env.ELEMENTS_REPO_BASE_URL).toBe('https://github.com/NVIDIA/elements');
-    expect(env.ELEMENTS_SITE_URL).toBe('https://nvidia.github.io');
-  });
-
-  it('should fall back when required url env vars are whitespace', async () => {
-    vi.stubEnv('ELEMENTS_PAGES_BASE_URL', '   ');
-    vi.stubEnv('ELEMENTS_REPO_BASE_URL', '   ');
-    vi.stubEnv('ELEMENTS_SITE_URL', '   ');
-
-    const env = await importEnv();
-
-    expect(env.ELEMENTS_PAGES_BASE_URL).toBe('https://nvidia.github.io/elements');
-    expect(env.ELEMENTS_REPO_BASE_URL).toBe('https://github.com/NVIDIA/elements');
-    expect(env.ELEMENTS_SITE_URL).toBe('https://nvidia.github.io');
-  });
-
-  it('should trim configured url env vars', async () => {
-    vi.stubEnv('ELEMENTS_PAGES_BASE_URL', ' https://docs.example.com/elements ');
-    vi.stubEnv('ELEMENTS_REPO_BASE_URL', ' https://github.example.com/NVIDIA/elements ');
-    vi.stubEnv('ELEMENTS_SITE_URL', ' https://docs.example.com ');
-    vi.stubEnv('ELEMENTS_PLAYGROUND_BASE_URL', ' https://playground.example.com ');
-
-    const env = await importEnv();
-
-    expect(env.ELEMENTS_PAGES_BASE_URL).toBe('https://docs.example.com/elements');
-    expect(env.ELEMENTS_REPO_BASE_URL).toBe('https://github.example.com/NVIDIA/elements');
-    expect(env.ELEMENTS_SITE_URL).toBe('https://docs.example.com');
-    expect(env.ELEMENTS_PLAYGROUND_BASE_URL).toBe('https://playground.example.com');
-  });
-
-  it('should keep optional env vars empty when empty', async () => {
-    vi.stubEnv('ELEMENTS_PLAYGROUND_BASE_URL', '');
-    vi.stubEnv('ELEMENTS_REGISTRY_URL', '');
-    vi.stubEnv('ELEMENTS_ASSETS_CDN_BASE_URL', '');
-    vi.stubEnv('ELEMENTS_ESM_CDN_BASE_URL', '');
-    vi.stubEnv('ELEMENTS_CDN_BASE_URL', '');
-
-    const env = await importEnv();
-
-    expect(env.ELEMENTS_PLAYGROUND_BASE_URL).toBe('');
-    expect(env.ELEMENTS_REGISTRY_URL).toBe('');
-    expect(env.ELEMENTS_ASSETS_CDN_BASE_URL).toBe('');
-    expect(env.ELEMENTS_ESM_CDN_BASE_URL).toBe('');
-    expect(env.ELEMENTS_CDN_BASE_URL).toBe('');
-  });
-});
diff --git a/projects/site/src/docs/cli/index.md b/projects/site/src/docs/cli/index.md
index 8eed830c5e..b9c3aa46f1 100644
--- a/projects/site/src/docs/cli/index.md
+++ b/projects/site/src/docs/cli/index.md
@@ -89,8 +89,8 @@ nve skills.get elements
     <nve-grid-cell>Search and retrieve a list of Elements (nve-*) components and APIs using keywords or natural language.</nve-grid-cell>
   </nve-grid-row>
   <nve-grid-row>
-    <nve-grid-cell><code nve-text="code">nve api.get &lt;names&gt; [format]</code></nve-grid-cell>
-    <nve-grid-cell>Get documentation known components or attributes by name (nve-*).</nve-grid-cell>
+    <nve-grid-cell><code nve-text="code">nve api.get &lt;names..&gt; [--format &lt;format&gt;]</code></nve-grid-cell>
+    <nve-grid-cell>Get documentation for one to five known components or attributes (nve-*).</nve-grid-cell>
   </nve-grid-row>
   <nve-grid-row>
     <nve-grid-cell><code nve-text="code">nve api.template.validate &lt;template&gt;</code></nve-grid-cell>
diff --git a/release.config.js b/release.config.js
index 445b9ad1dd..a046b52850 100644
--- a/release.config.js
+++ b/release.config.js
@@ -4,6 +4,7 @@ const DRY_RUN = process.env.DRY_RUN === 'true';
 const PLACEHOLDER_VERSION = '"0.0.0"';
 const packageFilePath = `${process.cwd()}/package.json`;
 const packageFile = JSON.parse(fs.readFileSync(packageFilePath));
+const mcpServerFilePath = packageFile.mcpName ? `${process.cwd()}/server.json` : undefined;
 const [_org, scope] = packageFile.name.split('/');
 
 /**
@@ -78,7 +79,25 @@ export default {
             from: PLACEHOLDER_VERSION,
             to: '"${nextRelease.version}"',
             allowEmptyPaths: true
-          }
+          },
+          ...(mcpServerFilePath
+            ? [
+                {
+                  files: [mcpServerFilePath],
+                  from: `"version": "${packageFile.version}"`,
+                  to: '"version": "${nextRelease.version}"',
+                  results: [
+                    {
+                      file: mcpServerFilePath,
+                      hasChanged: true,
+                      numMatches: 2,
+                      numReplacements: 2
+                    }
+                  ],
+                  countMatches: true
+                }
+              ]
+            : [])
         ]
       }
     ],
@@ -91,7 +110,13 @@ export default {
     [
       '@semantic-release/git',
       {
-        assets: ['CHANGELOG.md', 'package.json', 'projects/**/package.json', 'projects/**/CHANGELOG.md'],
+        assets: [
+          'CHANGELOG.md',
+          'package.json',
+          'projects/**/package.json',
+          'projects/**/CHANGELOG.md',
+          ...(mcpServerFilePath ? ['server.json'] : [])
+        ],
         message: `chore(release): ${packageFile.name}` + '-v${nextRelease.version} [skip ci]\n\n${nextRelease.notes}'
       }
     ],