@@ -85,18 +85,26 @@ jobs:
       # Archive layout/name live in the ONE canonical script the local
       # artifact-flow smoke lane also runs (venue-parity contract).
       - name: Archive release binary (canonical package-release.sh)
+        env:
+          VERSION: ${{ inputs.version }}
         run: scripts/package-release.sh ${{ matrix.goos }} ${{ matrix.goarch }}
 
       - name: Attest release binary provenance
         if: ${{ inputs.attest }}
         uses: actions/attest-build-provenance@0f67c3f4856b2e3261c31976d6725780e5e4c373 # v4.1.1
         with:
-          subject-path: codebase-memory-mcp-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz
+          # *.mcpb matches nothing on the glibc-dynamic linux targets — the
+          # canonical packager builds bundles only where static/one-click holds.
+          subject-path: |
+            codebase-memory-mcp-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz
+            *.mcpb
 
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: "*.tar.gz"
+          path: |
+            *.tar.gz
+            *.mcpb
 
   build-windows:
     runs-on: windows-latest
@@ -133,18 +141,24 @@ jobs:
       # artifact-flow smoke lane also runs (venue-parity contract).
       - name: Archive release binary (canonical package-release.sh)
         shell: msys2 {0}
+        env:
+          VERSION: ${{ inputs.version }}
         run: scripts/package-release.sh windows amd64 CC=clang CXX=clang++
 
       - name: Attest release binary provenance
         if: ${{ inputs.attest }}
         uses: actions/attest-build-provenance@0f67c3f4856b2e3261c31976d6725780e5e4c373 # v4.1.1
         with:
-          subject-path: codebase-memory-mcp-windows-amd64.zip
+          subject-path: |
+            codebase-memory-mcp-windows-amd64.zip
+            *.mcpb
 
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: binaries-windows-amd64
-          path: "*.zip"
+          path: |
+            *.zip
+            *.mcpb
 
   build-windows-arm64:
     # Native ARM64 Windows binary via the CLANGARM64 toolchain on the
@@ -183,18 +197,24 @@ jobs:
 
       - name: Archive release binary (canonical package-release.sh)
         shell: msys2 {0}
+        env:
+          VERSION: ${{ inputs.version }}
         run: scripts/package-release.sh windows arm64 CC=clang CXX=clang++
 
       - name: Attest release binary provenance
         if: ${{ inputs.attest }}
         uses: actions/attest-build-provenance@0f67c3f4856b2e3261c31976d6725780e5e4c373 # v4.1.1
         with:
-          subject-path: codebase-memory-mcp-windows-arm64.zip
+          subject-path: |
+            codebase-memory-mcp-windows-arm64.zip
+            *.mcpb
 
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: binaries-windows-arm64
-          path: "*.zip"
+          path: |
+            *.zip
+            *.mcpb
 
   build-linux-portable:
     # Fully static Linux binaries (gcc -static on Ubuntu).
@@ -235,15 +255,21 @@ jobs:
           ldd build/c/codebase-memory-mcp 2>&1 | grep -q "not a dynamic executable" || ldd build/c/codebase-memory-mcp 2>&1 | grep -q "statically linked"
 
       - name: Archive release binary (canonical package-release.sh)
+        env:
+          VERSION: ${{ inputs.version }}
         run: scripts/package-release.sh linux ${{ matrix.arch }}-portable
 
       - name: Attest release binary provenance
         if: ${{ inputs.attest }}
         uses: actions/attest-build-provenance@0f67c3f4856b2e3261c31976d6725780e5e4c373 # v4.1.1
         with:
-          subject-path: codebase-memory-mcp-linux-${{ matrix.arch }}-portable.tar.gz
+          subject-path: |
+            codebase-memory-mcp-linux-${{ matrix.arch }}-portable.tar.gz
+            *.mcpb
 
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: binaries-linux-${{ matrix.arch }}-portable
-          path: "*.tar.gz"
+          path: |
+            *.tar.gz
+            *.mcpb
@@ -129,16 +129,25 @@ jobs:
           merge-multiple: true
 
       - name: List artifacts
-        run: ls -la *.tar.gz *.zip
+        run: ls -la *.tar.gz *.zip *.mcpb
 
       - name: Generate checksums
-        run: sha256sum *.tar.gz *.zip > checksums.txt
+        run: sha256sum *.tar.gz *.zip *.mcpb > checksums.txt
 
       - name: Attest checksum provenance
         uses: actions/attest-build-provenance@0f67c3f4856b2e3261c31976d6725780e5e4c373 # v4.1.1
         with:
           subject-path: checksums.txt
 
+      # publish-mcp-registry reads the *.mcpb sha256 lines from here — a
+      # same-run workflow artifact, not a draft-release download, so that
+      # job keeps contents: read and no gh dependency.
+      - name: Preserve checksums for the registry job
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: release-checksums
+          path: checksums.txt
+
       # SBOM content lives in the canonical scripts/ci entry, not inline YAML
       # (venue-parity contract): vendored versions are reviewable there.
       - name: Generate SBOM
@@ -155,7 +164,7 @@ jobs:
 
       - name: Sign artifacts
         run: |
-          for f in *.tar.gz *.zip checksums.txt; do
+          for f in *.tar.gz *.zip *.mcpb checksums.txt; do
             cosign sign-blob --yes --bundle "${f}.bundle" "$f"
           done
 
@@ -187,6 +196,7 @@ jobs:
           files: |
             *.tar.gz
             *.zip
+            *.mcpb
             checksums.txt
             sbom.json
             *.bundle
@@ -214,11 +224,14 @@ jobs:
         run: |
           ARCHIVE_DIR="$RUNNER_TEMP/release-archives"
           mkdir -p "$ARCHIVE_DIR" binaries
-          gh release download "$VERSION" --dir "$ARCHIVE_DIR" --repo "$GITHUB_REPOSITORY" --pattern '*.tar.gz' --pattern '*.zip'
+          gh release download "$VERSION" --dir "$ARCHIVE_DIR" --repo "$GITHUB_REPOSITORY" --pattern '*.tar.gz' --pattern '*.zip' --pattern '*.mcpb'
+          # 14 = 8 archives + 6 MCPB bundles; runtime 42 = 8×3 archive
+          # sidecars + 6×3 bundle members (manifest.json, LICENSE, notices).
+          # The bundle binaries dedupe to the archive objects byte-for-byte.
           scripts/ci/extract-release-archives.sh "$ARCHIVE_DIR" binaries \
-            --expect-archives=8 \
-            --expect-binaries=8 \
-            --expect-runtime-files=24
+            --expect-archives=14 \
+            --expect-binaries=14 \
+            --expect-runtime-files=42
 
       - name: Security audits on all unique extracted release objects
         run: |
@@ -418,6 +431,20 @@ jobs:
           jq --arg v "$VERSION" '.version = $v | (.packages[].version) = $v' \
             server.json > server.tmp && mv server.tmp server.json
           echo "server.json pinned to $VERSION"
+
+      # The MCPB entries need each bundle's sha256; checksums.txt comes from
+      # the release-draft job as a same-run artifact (not a draft-release
+      # download — that would need contents beyond read plus gh).
+      - name: Fetch release checksums
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: release-checksums
+
+      - name: Append MCPB package entries to server.json
+        env:
+          RELEASE_VERSION: ${{ inputs.version }}
+        run: |
+          scripts/ci/gen-mcpb-registry-entries.sh server.json checksums.txt "$RELEASE_VERSION"
           cat server.json
 
       - name: Install mcp-publisher
 
@@ -33,6 +33,7 @@ from __future__ import annotations
 
 import csv
 import hashlib
+import json
 import os
 import pathlib
 import re
@@ -71,9 +72,20 @@ UNIX_TARGETS = (
     "linux-arm64-portable",
 )
 WINDOWS_TARGETS = ("windows-amd64", "windows-arm64")
+# MCPB bundles exist for darwin/windows and the STATIC linux builds only —
+# the same eligibility rule scripts/package-release.sh encodes.
+MCPB_TARGETS = (
+    "darwin-amd64",
+    "darwin-arm64",
+    "linux-amd64-portable",
+    "linux-arm64-portable",
+    "windows-amd64",
+    "windows-arm64",
+)
 CANONICAL_ARCHIVES = frozenset(
     [f"codebase-memory-mcp-{target}.tar.gz" for target in UNIX_TARGETS]
     + [f"codebase-memory-mcp-{target}.zip" for target in WINDOWS_TARGETS]
+    + [f"codebase-memory-mcp-{target}.mcpb" for target in MCPB_TARGETS]
 )
 # One composition ships; the association column is retained so the schema stays
 # stable for the gate and release-notes consumers.
@@ -308,27 +320,70 @@ def validate_namespace(archive_name: str, names: Iterable[str]) -> Dict[str, str
     if len(names_list) != len(set(names_list)):
         duplicate = next(name for name in names_list if names_list.count(name) > 1)
         raise ContractError(f"duplicate archive member in {archive_name}: {duplicate}")
-    windows = archive_name.endswith(".zip")
-    binary = "codebase-memory-mcp.exe" if windows else "codebase-memory-mcp"
-    installer = "install.ps1" if windows else "install.sh"
-    fixed = {
-        binary: "binary",
-        "LICENSE": "runtime",
-        installer: "runtime",
-        "THIRD_PARTY_NOTICES.md": "runtime",
-    }
+    # The archive name is already validated against CANONICAL_ARCHIVES, so
+    # platform detection by name is sound for every container kind.
+    windows = "-windows-" in archive_name
+    if archive_name.endswith(".mcpb"):
+        binary = "server/codebase-memory-mcp.exe" if windows else "server/codebase-memory-mcp"
+        fixed = {
+            "manifest.json": "runtime",
+            binary: "binary",
+            "server/LICENSE": "runtime",
+            "server/THIRD_PARTY_NOTICES.md": "runtime",
+        }
+    else:
+        binary = "codebase-memory-mcp.exe" if windows else "codebase-memory-mcp"
+        installer = "install.ps1" if windows else "install.sh"
+        fixed = {
+            binary: "binary",
+            "LICENSE": "runtime",
+            installer: "runtime",
+            "THIRD_PARTY_NOTICES.md": "runtime",
+        }
     name_set = set(names_list)
     extras = name_set - set(fixed)
     if extras:
         raise ContractError(f"unexpected archive member in {archive_name}: {sorted(extras)[0]}")
     if name_set != set(fixed):
         missing = sorted(set(fixed) - name_set)
         raise ContractError(
-            f"member namespace mismatch in {archive_name}: expected exactly 4 root files; missing={missing}"
+            f"member namespace mismatch in {archive_name}: expected exactly 4 members; missing={missing}"
         )
     return fixed
 
 
+def validate_mcpb_manifest(path: pathlib.Path, *, archive_name: str) -> None:
+    """A structurally broken bundle must fail the matrix, not ship.
+
+    The namespace check above proves manifest.json EXISTS; this proves it
+    actually describes the binary the bundle carries. Full schema validation
+    belongs to MCPB hosts — the gate pins only what a wrong build would break.
+    """
+    with zipfile.ZipFile(path, "r") as archive:
+        try:
+            manifest = json.loads(archive.read("manifest.json"))
+        except (json.JSONDecodeError, UnicodeDecodeError) as error:
+            raise ContractError(f"manifest.json in {archive_name} is not valid JSON: {error}")
+        if not isinstance(manifest, dict):
+            raise ContractError(f"manifest.json in {archive_name} must be a JSON object")
+        if not manifest.get("version"):
+            raise ContractError(f"manifest.json in {archive_name} lacks a version")
+        server = manifest.get("server")
+        if not isinstance(server, dict) or server.get("type") != "binary":
+            raise ContractError(f"manifest.json in {archive_name} must declare a binary server")
+        entry = server.get("entry_point")
+        if entry not in set(archive.namelist()):
+            raise ContractError(
+                f"manifest entry_point is not a member of {archive_name}: {entry}"
+            )
+        mcp_config = server.get("mcp_config")
+        command = mcp_config.get("command") if isinstance(mcp_config, dict) else None
+        if not isinstance(command, str) or not command.endswith(entry):
+            raise ContractError(
+                f"manifest mcp_config.command does not target the entry_point in {archive_name}"
+            )
+
+
 def add_association(
     rows: List[Dict[str, object]],
     scan_object: ScanObject,
@@ -582,6 +637,8 @@ def main(argv: Sequence[str]) -> None:
             total_members += member_total
             if total_members > MAX_TOTAL_MEMBER_BYTES:
                 raise ContractError("release matrix exceeds total uncompressed byte ceiling")
+            if archive_name.endswith(".mcpb"):
+                validate_mcpb_manifest(archive_object.path, archive_name=archive_name)
             counts["archives"] += 1
             counts["binaries"] += sum(kind == "binary" for kind in kinds.values())
             counts["runtime_files"] += sum(kind == "runtime" for kind in kinds.values())
 
@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# gen-mcpb-registry-entries.sh — append MCPB package entries to server.json.
+#
+# The npm/PyPI entries are static repo content, but MCPB entries carry a
+# per-release fileSha256, so they can only exist at publish time. This script
+# derives them from the same checksums.txt the draft release ships (and
+# attests), never by re-hashing anything itself: one checksum authority.
+#
+# Usage: gen-mcpb-registry-entries.sh <server.json> <checksums.txt> <release-tag>
+#
+#   release-tag   the GitHub release tag, v-prefixed (v0.11.0); it forms the
+#                 download URL. The package version field drops the prefix.
+#
+# Idempotent: existing mcpb entries are replaced, never duplicated, so a
+# re-run of the registry job cannot grow the manifest. A checksums file
+# without a single .mcpb line is a hard failure — publishing a manifest that
+# silently un-lists the bundles would hide a broken artifact chain
+# (the #1522 silent-empty-results lesson).
+set -euo pipefail
+
+if [ "$#" -ne 3 ]; then
+    echo "Usage: $0 <server.json> <checksums.txt> <release-tag>" >&2
+    exit 2
+fi
+
+command -v python3 >/dev/null 2>&1 || {
+    echo "FAIL: python3 is required to generate MCPB registry entries" >&2
+    exit 1
+}
+
+python3 - "$@" <<'PY'
+import json
+import pathlib
+import re
+import sys
+
+server_json = pathlib.Path(sys.argv[1])
+checksums = pathlib.Path(sys.argv[2])
+tag = sys.argv[3]
+
+if not tag:
+    print("FAIL: empty release tag", file=sys.stderr)
+    raise SystemExit(1)
+for path in (server_json, checksums):
+    if not path.is_file():
+        print(f"FAIL: missing {path}", file=sys.stderr)
+        raise SystemExit(1)
+
+manifest = json.loads(server_json.read_text(encoding="utf-8"))
+repo_url = (manifest.get("repository") or {}).get("url")
+if not repo_url:
+    print(f"FAIL: {server_json} has no repository.url to build download URLs from",
+          file=sys.stderr)
+    raise SystemExit(1)
+repo_url = repo_url.rstrip("/")
+version = tag[1:] if tag.startswith("v") else tag
+
+entries = []
+for line in checksums.read_text(encoding="utf-8").splitlines():
+    parts = line.split()
+    if len(parts) != 2 or not parts[1].endswith(".mcpb"):
+        continue
+    sha, name = parts
+    if not re.fullmatch(r"[0-9a-f]{64}", sha):
+        print(f"FAIL: malformed sha256 for {name} in {checksums}", file=sys.stderr)
+        raise SystemExit(1)
+    entries.append((name, sha))
+
+if not entries:
+    print(f"FAIL: no .mcpb lines in {checksums}", file=sys.stderr)
+    raise SystemExit(1)
+
+packages = [package for package in manifest.get("packages", [])
+            if package.get("registryType") != "mcpb"]
+for name, sha in sorted(entries):
+    packages.append({
+        "registryType": "mcpb",
+        "identifier": f"{repo_url}/releases/download/{tag}/{name}",
+        "version": version,
+        "fileSha256": sha,
+        "transport": {"type": "stdio"},
+    })
+    print(f"mcpb entry: {name} ({sha})")
+manifest["packages"] = packages
+
+server_json.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+print(f"appended {len(entries)} mcpb package entries to {server_json} for {tag}")
+PY