@@ -388,3 +388,39 @@ jobs:
           path: mcpproxy-*-darwin-${{ matrix.goarch }}-installer.dmg
           retention-days: 14
           if-no-files-found: warn
+
+  # The release workflow's `release` job now depends on `build-docker`, so a
+  # Dockerfile that no longer builds blocks a whole release at tag time. Build
+  # (never push) the server image on every PR so breakage surfaces here instead.
+  # Single-platform amd64 — it runs natively on the runner, which keeps this a
+  # couple of minutes and lets us smoke-test the entrypoint.
+  docker-image:
+    name: Build Server Docker Image
+    needs: [prepare]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+
+      - name: Set up Buildx
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e  # v4.3.0
+
+      - name: Build image
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a  # v7.3.0
+        with:
+          context: .
+          push: false
+          load: true
+          platforms: linux/amd64
+          build-args: |
+            VERSION=${{ needs.prepare.outputs.version }}
+            COMMIT=${{ github.sha }}
+          tags: mcpproxy-server:pr
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Smoke-test the image
+        run: |
+          set -eo pipefail
+          docker run --rm --entrypoint mcpproxy mcpproxy-server:pr version | tee /tmp/version.txt
+          grep -q '(server)' /tmp/version.txt
@@ -1231,9 +1231,15 @@ jobs:
 
   build-docker:
     runs-on: ubuntu-latest
-    needs: [build]
-    # Disabled until server MVP is ready — uncomment to enable
-    if: false && startsWith(github.ref, 'refs/tags/v')
+    # `qa-gate` is load-bearing, not cosmetic: this job pushes to GHCR (including
+    # the `:latest` pointer), which is publishing to users. Without it in the
+    # closure a tag whose gate failed would still ship a container image — the
+    # exact hole cmd/release-gate's TestPublishJobsGatedOnQAGate exists to catch.
+    needs: [build, qa-gate]
+    # Stable releases only, matching `build`/`release` — release.yml fires on every
+    # `v*` tag, and an RC must never move `mcpproxy-server:latest`. prerelease.yml
+    # owns the RC channel and publishes no image.
+    if: startsWith(github.ref, 'refs/tags/v') && !contains(github.ref_name, '-')
     permissions:
       contents: read
       packages: write
@@ -1249,13 +1255,28 @@ jobs:
         with:
           context: .
           push: true
+          # linux/arm64 matters for Raspberry Pi / Graviton hosts, and the release
+          # already ships an arm64 Linux binary. The Dockerfile cross-compiles from
+          # $BUILDPLATFORM, so this costs a second native build, not QEMU emulation.
+          platforms: linux/amd64,linux/arm64
           build-args: |
             VERSION=${{ github.ref_name }}
             COMMIT=${{ github.sha }}
             BUILD_DATE=${{ github.event.head_commit.timestamp }}
           tags: |
             ghcr.io/smart-mcp-proxy/mcpproxy-server:${{ github.ref_name }}
             ghcr.io/smart-mcp-proxy/mcpproxy-server:latest
+          # image.source links the GHCR package back to this repo so it inherits the
+          # repo's README and shows up under the org's packages. It does NOT make the
+          # package public: a package first created by GITHUB_TOKEN is private, and
+          # visibility has to be flipped once by hand after the first push. Until that
+          # happens an anonymous `docker pull` gets `denied`.
+          labels: |
+            org.opencontainers.image.source=https://github.com/smart-mcp-proxy/mcpproxy-go
+            org.opencontainers.image.description=MCPProxy Server Edition — headless MCP proxy with tool discovery and quarantine
+            org.opencontainers.image.licenses=MIT
+            org.opencontainers.image.revision=${{ github.sha }}
+            org.opencontainers.image.version=${{ github.ref_name }}
 
   # Spec 081: release qualification gate. Runs the server-type matrix +
   # invariants + assembled suites and produces one pass/fail verdict. The
@@ -1271,7 +1292,7 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/v') && !contains(github.ref_name, '-')
 
   release:
-    needs: [build, sign-windows, generate-notes, qa-gate]  # add build-docker when server MVP is ready
+    needs: [build, build-docker, sign-windows, generate-notes, qa-gate]
     runs-on: ubuntu-latest
     environment: production
     # Explicit guard (belt-and-suspenders on top of the cascade from needs:) — RC tags
 
@@ -1,5 +1,7 @@
-# Build stage
-FROM golang:1.27-alpine AS builder
+# Build stage. Pinned to $BUILDPLATFORM and cross-compiled via $TARGETARCH so a
+# multi-arch build never needs QEMU emulation (the binary is CGO_ENABLED=0 and the
+# frontend is arch-independent).
+FROM --platform=$BUILDPLATFORM golang:1.27-alpine AS builder
 
 RUN apk add --no-cache git nodejs npm make
 
@@ -17,7 +19,9 @@ RUN mkdir -p web/frontend && cp -r frontend/dist web/frontend/
 ARG VERSION=dev
 ARG COMMIT=unknown
 ARG BUILD_DATE=unknown
-RUN CGO_ENABLED=0 go build \
+ARG TARGETOS
+ARG TARGETARCH
+RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH:-amd64} go build \
     -tags server \
     -ldflags "-X main.version=${VERSION} -X main.commit=${COMMIT} -X main.date=${BUILD_DATE} -X github.com/smart-mcp-proxy/mcpproxy-go/internal/httpapi.buildVersion=${VERSION} -X github.com/smart-mcp-proxy/mcpproxy-go/internal/updatecheck.buildChannel=docker -s -w" \
     -o /mcpproxy ./cmd/mcpproxy
 
@@ -365,6 +365,43 @@ You can then run `mcpproxy serve` directly, or wire up your own systemd unit mod
 
 The systemd unit launches mcpproxy with `--config=/etc/mcpproxy/mcp_config.json --data-dir=/var/lib/mcpproxy` and uses `NoNewPrivileges`, `ProtectSystem=strict`, `PrivateTmp`, and friends.
 
+## Docker (Server edition)
+
+The Server edition is published as a multi-arch image (`linux/amd64`, `linux/arm64`) on
+every stable release:
+
+```bash
+docker run -d --name mcpproxy \
+  -p 127.0.0.1:8080:8080 \
+  -e MCPPROXY_API_KEY="$(openssl rand -hex 32)" \
+  -v mcpproxy-data:/root/.mcpproxy \
+  ghcr.io/smart-mcp-proxy/mcpproxy-server:latest
+```
+
+- **Tags**: `ghcr.io/smart-mcp-proxy/mcpproxy-server:<version>` (e.g. `v0.64.0`) and `:latest`,
+  which always points at the newest stable release. RC builds publish no image.
+- **State survives restarts, not replacement**: `docker restart` keeps everything. Removing and
+  re-running the container, upgrading the tag, or rescheduling the pod destroys whatever is not
+  on the volume — so mount one before you configure anything.
+- **Don't use `MCPPROXY_DATA` or a bare `--data-dir` to relocate state.** The data-dir override is
+  applied after the config file is resolved, so the config in that directory is never read and is
+  overwritten with a fresh default (rotating the API key) on every boot. Mount the volume at the
+  default `/root/.mcpproxy` path instead. (`MCPPROXY_DATA_DIR`, referenced elsewhere in the docs,
+  is not implemented at all.)
+- **Port**: the entrypoint is `mcpproxy serve --listen 0.0.0.0:8080`, so the container listens on
+  `8080` inside the network namespace. The `-p 127.0.0.1:8080:8080` above keeps it reachable only
+  from the host; drop the `127.0.0.1:` prefix only if you deliberately want it on the network, and
+  read [Network exposure: localhost by default](#network-exposure-localhost-by-default) first.
+- **State**: config, the BBolt DB, and the search index live in `/root/.mcpproxy`. Mount a volume
+  there or every restart starts from an empty config.
+- **API key**: the REST API and Web UI require one. Set `MCPPROXY_API_KEY` explicitly and keep a
+  copy — the image is distroless (no shell), so reading an auto-generated key back out of the
+  container is awkward.
+- **Web UI**: `http://localhost:8080/ui/`.
+
+Note that this image ships the Server edition binary (`mcpproxy version` reports `(server)`); it is
+the headless core only, with no system tray.
+
 ## Verify Installation
 
 After installation, verify MCPProxy is working:
 
@@ -98,9 +98,9 @@ mcp-publisher status --status deleted \
 ## Registry Schema Notes
 
 - `version` must be a plain semantic version string (`0.33.1`) — no `v` prefix, no ranges.
-- `packages[]` is empty because none of the supported `registryType` values (`npm`, `pypi`, `oci`, `nuget`, `mcpb`) match MCPProxy's distribution channels (Homebrew tap, GitHub release tarballs, `.deb`/`.rpm`, `go install`). The Docker server-edition image at `ghcr.io/smart-mcp-proxy/mcpproxy-server` is not yet published to releases (gated behind `if: false` in the release workflow).
+- `packages[]` is empty because none of the supported `registryType` values (`npm`, `pypi`, `oci`, `nuget`, `mcpb`) match MCPProxy's distribution channels (Homebrew tap, GitHub release tarballs, `.deb`/`.rpm`, `go install`). The Docker server-edition image at `ghcr.io/smart-mcp-proxy/mcpproxy-server` *is* published on every stable tag, but the server edition speaks Streamable HTTP rather than stdio, so it is not a drop-in `oci` package entry either.
 - `remotes[]` is intentionally **omitted**. mcpproxy runs locally (`mcpproxy serve` exposes Streamable HTTP at `http://localhost:8080/mcp`), but the registry's semantic validation **rejects localhost/private remote URLs** (`invalid-remote-url`) — `remotes[]` is reserved for publicly reachable hosted endpoints. With no public remote and no installable package type, the entry is **discovery-only**: it lists the server, description, and repository link so clients can find it and follow the repo's install instructions.
-- If a Docker image for the server edition is published in a future release, add an `oci` entry to `packages[]` pointing at `ghcr.io/smart-mcp-proxy/mcpproxy-server:{version}` with `"transport": {"type": "stdio"}` and the appropriate `runtimeArguments` for `docker run`. That would upgrade the entry from discovery-only to one-click installable.
+- Adding an `oci` entry to `packages[]` for `ghcr.io/smart-mcp-proxy/mcpproxy-server:{version}` would upgrade the entry from discovery-only to one-click installable, but it needs a transport the registry accepts for a container that serves HTTP on a published port — not `"transport": {"type": "stdio"}`. Revisit once the registry's remote/container transport story covers it.
 
 ## References