diff --git a/.gitignore b/.gitignore
index 7d0f326..add58ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -52,3 +52,5 @@ cscope.po.out
 
 
 # End of https://www.toptal.com/developers/gitignore/api/tags
+
+.DS_Store
diff --git a/web/src/modules/inferences/CatalogPage.tsx b/web/src/modules/inferences/CatalogPage.tsx
index bdefa40..66ff695 100644
--- a/web/src/modules/inferences/CatalogPage.tsx
+++ b/web/src/modules/inferences/CatalogPage.tsx
@@ -24,7 +24,7 @@ import {
 } from "@modelsphere/ui";
 import { Boxes, Library, MoreHorizontal, TriangleAlert } from "lucide-react";
 import { useModulePath } from "@/shell";
-import { api } from "@swiss/lib/api";
+import { api, type CatalogInfo } from "@swiss/lib/api";
 import { facetsOf, formatUplift, sorters, type Facets } from "@swiss/lib/catalog";
 import { useCatalogChoice } from "@swiss/components/CatalogChoice";
 import { useT } from "@/modules/inferences/i18n";
@@ -41,7 +41,7 @@ export function CatalogPage() {
     queryFn: () => api.catalog(choice.selected),
     enabled: !!choice.selected,
   });
-  const all = useMemo(() => catalog.data?.index.models.map(facetsOf) ?? [], [catalog.data]);
+  const all = useMemo(() => catalog.data?.models.map(facetsOf) ?? [], [catalog.data]);
   const options = useMemo(() => facetOptions(all), [all]);
   const f = filtersFrom(params);
   const set = (patch: Partial<CatalogFilters>) => setParams((prev) => withFilters(prev, patch), { replace: true });
@@ -70,11 +70,16 @@ export function CatalogPage() {
             {choice.several && (
               <FilterSelect
                 title={t("catalog.catalog")}
-                options={choice.catalogs.map((c) => ({ value: c.name, label: c.name }))}
+                options={choice.catalogs.map((c) => ({ value: c.name, label: c.name, description: c.schema === "v1" ? t("catalog.legacy") : undefined }))}
                 value={choice.selected}
                 onValueChange={(v) => v && choice.choose(v)}
               />
             )}
+            {catalog.data?.schema === "v1" && (
+              <Badge variant="warning" title={t("catalog.legacyHint")}>
+                {t("catalog.legacy")}
+              </Badge>
+            )}
             {facet("family")}
             {facet("engine")}
             {facet("hardware")}
@@ -181,7 +186,7 @@ function ModelCard({ x, catalog, to, onDeploy }: { x: Facets; catalog: string; t
         <span className="truncate" title={m.source.hf}>
           {m.source.hf}
         </span>
-        <span>v{m.latest}</span>
+        {x.version && <span>v{x.version}</span>}
         <span>{t("catalog.variants", { n: x.variants.length })}</span>
       </div>
 
@@ -207,7 +212,7 @@ function ModelCard({ x, catalog, to, onDeploy }: { x: Facets; catalog: string; t
   );
 }
 
-function NoCatalog({ catalogs, choose }: { catalogs: { name: string; source: string; default?: boolean }[]; choose: (name: string) => void }) {
+function NoCatalog({ catalogs, choose }: { catalogs: CatalogInfo[]; choose: (name: string) => void }) {
   const t = useT();
   const p = useModulePath();
   if (catalogs.length === 0) {
@@ -231,6 +236,11 @@ function NoCatalog({ catalogs, choose }: { catalogs: { name: string; source: str
         <button key={c.name} type="button" onClick={() => choose(c.name)} className="flex w-full items-center gap-3 rounded-lg border bg-card p-3 text-left hover:border-primary/40">
           <span className="font-medium">{c.name}</span>
           {c.default && <Badge variant="secondary">{t("catalog.default")}</Badge>}
+          {c.schema === "v1" && (
+            <Badge variant="warning" title={t("catalog.legacyHint")}>
+              {t("catalog.legacy")}
+            </Badge>
+          )}
           <span className="ms-auto truncate text-xs text-muted-foreground">{c.source}</span>
         </button>
       ))}
diff --git a/web/src/modules/inferences/ModelPage.tsx b/web/src/modules/inferences/ModelPage.tsx
index 40adeb4..8856dfc 100644
--- a/web/src/modules/inferences/ModelPage.tsx
+++ b/web/src/modules/inferences/ModelPage.tsx
@@ -6,7 +6,6 @@ import {
   AlertDescription,
   Badge,
   Button,
-  DataSelect,
   DetailHeader,
   Empty,
   EmptyHeader,
@@ -21,8 +20,8 @@ import {
 } from "@modelsphere/ui";
 import { TriangleAlert } from "lucide-react";
 import { useModulePath } from "@/shell";
-import { api, type Node, type Variant } from "@swiss/lib/api";
-import { comparison, formatUplift, httpLink, reportLink, variantKind, workloadSummary, type Kind } from "@swiss/lib/catalog";
+import { api, type ModelVariant, type Node } from "@swiss/lib/api";
+import { comparison, formatUplift, httpLink, reportLink, sharedVersion, variantKind, workloadSummary, type Kind } from "@swiss/lib/catalog";
 import { gpuModels, vendorLabel } from "@swiss/lib/gpu";
 import { useCatalogChoice } from "@swiss/components/CatalogChoice";
 import { useT } from "@/modules/inferences/i18n";
@@ -35,19 +34,19 @@ export function ModelPage() {
   const navigate = useNavigate();
   const { name = "" } = useParams();
   const [params, setParams] = useSearchParams();
-  const version = params.get("version") ?? undefined;
   const tab = params.get("tab") === "info" ? "info" : "variants";
   const choice = useCatalogChoice();
+  // The default variant resolved, for what only its file says: the served name.
   const model = useQuery({
-    queryKey: ["model", name, version, choice.selected],
-    queryFn: () => api.model(name, version, choice.selected),
+    queryKey: ["model", choice.selected, name, "", ""],
+    queryFn: () => api.model(name, { catalog: choice.selected }),
     enabled: !!choice.selected,
   });
   const index = useQuery({ queryKey: ["catalog", choice.selected], queryFn: () => api.catalog(choice.selected), enabled: !!choice.selected });
   const nodes = useQuery({ queryKey: ["nodes"], queryFn: api.nodes, retry: false });
   const cluster = useQuery({ queryKey: ["cluster"], queryFn: api.cluster });
   const [deploying, setDeploying] = useState<DeployTarget | null>(null);
-  const onDeploy = cluster.data?.allowDeploy ? (x: { model: string; catalog: string; version?: string; variant?: string }) => setDeploying({ kind: "deploy", ...x }) : undefined;
+  const onDeploy = cluster.data?.allowDeploy ? (x: { model: string; catalog: string; variant?: string }) => setDeploying({ kind: "deploy", ...x }) : undefined;
 
   const setParam = (k: string, v?: string) =>
     setParams((prev) => {
@@ -74,43 +73,41 @@ export function ModelPage() {
     );
   }
 
-  const e = model.data.entry;
-  const im = index.data?.index.models.find((m) => m.name === name);
-  const versions = im?.versions.map((v) => v.version) ?? [e.version];
-  const deprecated = im?.deprecated;
-  const cmp = comparison(e.variants, e.version, im?.tuning);
-  const site = index.data?.index.site;
-  const variants = [...e.variants].sort((a, b) => Number(!!b.default) - Number(!!a.default));
+  const { model: m, variant: resolved, schema } = model.data;
+  const deprecated = m.deprecated;
+  const cmp = comparison(m.variants, m.tuning);
+  const site = index.data?.site;
+  const variants = [...m.variants].sort((a, b) => Number(!!b.default) - Number(!!a.default));
+  // On v1 every variant is at its entry's version; on v2 each is at its own.
+  const shared = sharedVersion(variants);
+  const digest = shared ? variants[0].digest : undefined;
 
   return page(
     <Tabs value={tab} onValueChange={(v) => setParam("tab", v === "info" ? "info" : undefined)} className="flex-col gap-4">
       <DetailHeader
         onBack={back}
         backLabel={t("model.back")}
-        title={e.displayName || e.name}
-        subtitle={e.description}
+        title={m.displayName || m.name}
+        subtitle={m.description}
         notice={deprecated ? { tone: "warning", title: t("model.deprecated", { reason: typeof deprecated === "string" ? deprecated : "" }) } : undefined}
         actions={
           onDeploy
-            ? [{ key: "deploy", label: t("model.deploy"), onClick: () => onDeploy({ model: name, catalog: choice.selected, version }) }]
+            ? [{ key: "deploy", label: t("model.deploy"), onClick: () => onDeploy({ model: name, catalog: choice.selected }) }]
             : undefined
         }
         meta={[
-          { label: t("model.fields.family"), value: e.family || "-" },
-          { label: t("model.fields.source"), value: <span title={e.source.hf}>{e.source.hf}</span> },
-          { label: t("model.fields.license"), value: e.license || "-" },
+          { label: t("model.fields.family"), value: m.family || "-" },
+          { label: t("model.fields.source"), value: <span title={m.source.hf}>{m.source.hf}</span> },
+          { label: t("model.fields.version"), value: shared ?? t("model.perVariant") },
           {
-            label: t("model.fields.version"),
+            label: t("model.fields.schema"),
             value:
-              versions.length > 1 ? (
-                <DataSelect
-                  className="h-7 w-32"
-                  value={e.version}
-                  onValueChange={(v) => setParam("version", v === im?.latest ? undefined : v)}
-                  options={versions.map((v) => ({ value: v, label: v === im?.latest ? `${v} (${t("model.latest")})` : v }))}
-                />
+              schema === "v1" ? (
+                <Badge variant="warning" title={t("catalog.legacyHint")}>
+                  {t("catalog.legacy")}
+                </Badge>
               ) : (
-                e.version
+                schema
               ),
           },
         ]}
@@ -136,11 +133,12 @@ export function ModelPage() {
               <VariantCard
                 key={v.id}
                 v={v}
-                kind={variantKind(v, im?.tuning)}
+                kind={variantKind(v, m.tuning)}
+                version={shared ? undefined : v.version}
                 uplift={cmp && cmp.optimized === v.id ? cmp : null}
                 report={cmp && cmp.optimized === v.id ? reportLink(site, name, cmp.report) : undefined}
                 nodes={nodes.data?.nodes}
-                onDeploy={onDeploy ? () => onDeploy({ model: name, catalog: choice.selected, version, variant: v.id }) : undefined}
+                onDeploy={onDeploy ? () => onDeploy({ model: name, catalog: choice.selected, variant: v.id }) : undefined}
               />
             ))}
           </div>
@@ -153,13 +151,12 @@ export function ModelPage() {
             columns={1}
             labelClassName="w-28 shrink-0"
             items={[
-              { label: t("model.fields.source"), value: [e.source.hf, e.source.revision].filter(Boolean).join(" @ ") },
-              { label: t("model.fields.servedName"), value: e.servedName },
-              { label: t("model.fields.license"), value: e.license },
-              { label: t("model.fields.version"), value: e.version },
-              { label: t("model.fields.digest"), value: e.digest && <code className="font-mono text-xs break-all">{e.digest}</code> },
-              { label: t("model.fields.tags"), value: e.tags?.length ? e.tags.join(", ") : undefined },
-              { label: t("model.fields.sizeLabel"), value: e.source.sizeGiB ? t("model.fields.size", { n: e.source.sizeGiB }) : undefined },
+              { label: t("model.fields.source"), value: [m.source.hf, m.source.revision].filter(Boolean).join(" @ ") },
+              { label: t("model.fields.servedName"), value: resolved.servedName },
+              { label: t("model.fields.version"), value: shared },
+              { label: t("model.fields.digest"), value: digest && <code className="font-mono text-xs break-all">{digest}</code> },
+              { label: t("model.fields.tags"), value: m.tags?.length ? m.tags.join(", ") : undefined },
+              { label: t("model.fields.sizeLabel"), value: m.source.sizeGiB ? t("model.fields.size", { n: m.source.sizeGiB }) : undefined },
             ].filter((i) => i.value)}
           />
         </SectionCard>
@@ -172,13 +169,16 @@ export function ModelPage() {
 function VariantCard({
   v,
   kind,
+  version,
   uplift,
   report,
   nodes,
   onDeploy,
 }: {
-  v: Variant;
+  v: ModelVariant;
   kind: Kind;
+  // The variant's own version, when the model's variants are not all at one.
+  version?: string;
   uplift: ReturnType<typeof comparison>;
   report?: string;
   nodes?: Node[];
@@ -193,7 +193,13 @@ function VariantCard({
       title={
         <span className="inline-flex flex-wrap items-center gap-2">
           <span className="font-mono">{v.id}</span>
+          {version && <span className="text-xs text-muted-foreground">v{version}</span>}
           {v.default && <Badge variant="secondary">{t("model.default")}</Badge>}
+          {v.deprecated && (
+            <Badge variant="warning" title={typeof v.deprecated === "string" ? v.deprecated : undefined}>
+              {t("catalog.deprecated")}
+            </Badge>
+          )}
           {kind.optimized && <Badge variant="success">{t("model.optimized")}</Badge>}
           {kind.baseline && <Badge variant="outline">{t("model.baseline")}</Badge>}
           <Badge variant="outline">{v.engine}</Badge>
diff --git a/web/src/modules/inferences/SetupPage.tsx b/web/src/modules/inferences/SetupPage.tsx
index 545b9ef..e391a29 100644
--- a/web/src/modules/inferences/SetupPage.tsx
+++ b/web/src/modules/inferences/SetupPage.tsx
@@ -1,36 +1,31 @@
 import { useNavigate } from "react-router";
 import { useQuery } from "@tanstack/react-query";
-import { Alert, AlertDescription, PageBanner, Skeleton } from "@modelsphere/ui";
-import { Settings2, TriangleAlert } from "lucide-react";
+import { PageBanner, Skeleton } from "@modelsphere/ui";
+import { Settings2 } from "lucide-react";
 import { useModulePath } from "@/shell";
 import { api, type ProfileResponse } from "@swiss/lib/api";
 import { useT } from "@/modules/inferences/i18n";
 import { ProfileEditorBody, SaveButton, useProfileEditor } from "@/modules/inferences/components/ProfileEditor";
 
+// The first run only: the gate sends a site that has a profile to the site
+// profile page, so this always starts from swissd's default.
 export function SetupPage() {
   const t = useT();
-  const existing = useQuery({ queryKey: ["profile"], queryFn: api.profile, retry: false });
-  const template = useQuery({ queryKey: ["profile-template"], queryFn: api.profileTemplate, enabled: existing.isSuccess && !existing.data.profile });
-  const start = existing.data?.profile ? existing.data : template.data;
+  const template = useQuery({ queryKey: ["profile-template"], queryFn: api.profileTemplate });
   return (
     <div className="flex h-full flex-col">
       <PageBanner title={t("profile.setup.title")} description={t("profile.setup.description")} icon={<Settings2 className="size-5" />} />
       <div className="min-h-0 flex-1 overflow-auto bg-surface-page p-4">
         <div className="mx-auto max-w-4xl space-y-4">
-          {existing.data?.error && (
-            <Alert variant="destructive">
-              <TriangleAlert />
-              <AlertDescription>{t("profile.parseError", { error: existing.data.error })}</AlertDescription>
-            </Alert>
-          )}
-          {start?.profile ? <Setup start={start} saveLabel={t(existing.data?.profile ? "profile.setup.saveExisting" : "profile.setup.save")} /> : <Skeleton className="h-96 w-full" />}
+          {template.data?.profile ? <Setup start={template.data} /> : <Skeleton className="h-96 w-full" />}
         </div>
       </div>
     </div>
   );
 }
 
-function Setup({ start, saveLabel }: { start: ProfileResponse; saveLabel: string }) {
+function Setup({ start }: { start: ProfileResponse }) {
+  const t = useT();
   const p = useModulePath();
   const navigate = useNavigate();
   const editor = useProfileEditor(start.profile!, start.yaml ?? "", () => navigate(p(""), { replace: true }));
@@ -38,7 +33,7 @@ function Setup({ start, saveLabel }: { start: ProfileResponse; saveLabel: string
     <>
       <ProfileEditorBody editor={editor} />
       <div className="flex justify-end">
-        <SaveButton editor={editor} label={saveLabel} />
+        <SaveButton editor={editor} label={t("profile.setup.save")} />
       </div>
     </>
   );
diff --git a/web/src/modules/inferences/SiteProfilePage.tsx b/web/src/modules/inferences/SiteProfilePage.tsx
index 2bb69aa..8f01922 100644
--- a/web/src/modules/inferences/SiteProfilePage.tsx
+++ b/web/src/modules/inferences/SiteProfilePage.tsx
@@ -22,7 +22,7 @@ import {
 } from "@modelsphere/ui";
 import { SlidersHorizontal, TriangleAlert } from "lucide-react";
 import { useModulePath } from "@/shell";
-import { api, type ProfileResponse, type SiteProfile } from "@swiss/lib/api";
+import { api, type SiteProfile } from "@swiss/lib/api";
 import { toYaml } from "@swiss/lib/yaml";
 import { useT } from "@/modules/inferences/i18n";
 import { ProfileEditorBody, SaveButton, useProfileEditor } from "@/modules/inferences/components/ProfileEditor";
@@ -31,10 +31,15 @@ export function SiteProfilePage() {
   const t = useT();
   const p = useModulePath();
   const profile = useQuery({ queryKey: ["profile"], queryFn: api.profile });
+  // A stored profile that does not parse has nothing for the form to bind to:
+  // the form starts from the default, and the YAML tab holds the stored text,
+  // which is what has to be fixed.
+  const template = useQuery({ queryKey: ["profile-template"], queryFn: api.profileTemplate, enabled: !!profile.data && !profile.data.profile });
   const [editing, setEditing] = useState(false);
 
   if (profile.data && !profile.data.profile && !profile.data.error) return <Navigate to={p("setup")} replace />;
   const d = profile.data;
+  const start = d?.profile ?? template.data?.profile;
 
   return (
     <div className="flex h-full flex-col">
@@ -42,7 +47,7 @@ export function SiteProfilePage() {
         title={t("profile.title")}
         description={t("profile.description")}
         icon={<SlidersHorizontal className="size-5" />}
-        actions={d && <Button onClick={() => setEditing(true)}>{t("profile.edit")}</Button>}
+        actions={start && <Button onClick={() => setEditing(true)}>{t("profile.edit")}</Button>}
       />
       <div className="min-h-0 flex-1 space-y-4 overflow-auto bg-surface-page p-4">
         {profile.isPending ? (
@@ -57,7 +62,10 @@ export function SiteProfilePage() {
             {d?.error && (
               <Alert variant="destructive">
                 <TriangleAlert />
-                <AlertDescription>{t("profile.parseError", { error: d.error })}</AlertDescription>
+                <AlertDescription>
+                  <p>{t("profile.parseError", { error: d.error })}</p>
+                  <p>{t("profile.repairHint")}</p>
+                </AlertDescription>
               </Alert>
             )}
             {d?.source && <p className="text-xs text-muted-foreground">{t("profile.source", { source: d.source })}</p>}
@@ -65,7 +73,7 @@ export function SiteProfilePage() {
           </>
         )}
       </div>
-      {editing && d && <EditSheet data={d} onClose={() => setEditing(false)} />}
+      {editing && d && start && <EditSheet profile={start} yaml={d.yaml ?? ""} onClose={() => setEditing(false)} />}
     </div>
   );
 }
@@ -75,6 +83,23 @@ function ProfileView({ p }: { p: SiteProfile }) {
   const f = (k: string) => t(`profile.fields.${k}`);
   const v = (x: unknown) => (x === undefined || x === null || x === "" ? <span className="text-muted-foreground">{t("profile.unset")}</span> : String(x));
   const mono = (x?: string) => (x ? <code className="font-mono text-xs break-all">{x}</code> : v(x));
+  const aliases = (a?: Record<string, string[]>) =>
+    a && Object.keys(a).length ? (
+      <span className="flex flex-col gap-1">
+        {Object.entries(a).map(([product, sels]) => (
+          <span key={product} className="flex flex-wrap items-center gap-1">
+            <span className="font-medium">{product}</span>
+            {sels.map((sel) => (
+              <Badge key={sel} variant="secondary" className="font-mono font-normal">
+                {sel}
+              </Badge>
+            ))}
+          </span>
+        ))}
+      </span>
+    ) : (
+      v(undefined)
+    );
   const kv = (r?: Record<string, string>) => (r && Object.keys(r).length ? <span className="flex flex-wrap gap-1">{Object.entries(r).map(([k, x]) => <Badge key={k} variant="secondary" className="font-mono font-normal">{k}={x}</Badge>)}</span> : v(undefined));
   const card = (g: string, items: { label: string; value: React.ReactNode }[]) => (
     <SectionCard title={t(`profile.groups.${g}`)}>
@@ -89,6 +114,7 @@ function ProfileView({ p }: { p: SiteProfile }) {
         { label: f("scheduler"), value: v(p.schedule?.schedulerName) },
         { label: f("priorityClass"), value: v(p.schedule?.priorityClassName) },
         { label: f("gpusPerNode"), value: v(p.nodes?.gpusPerNode) },
+        { label: f("gpuAliases"), value: aliases(p.nodes?.gpuProductAliases) },
       ])}
       {card("catalog", [
         {
@@ -99,6 +125,13 @@ function ProfileView({ p }: { p: SiteProfile }) {
                 <span key={c.name} className="flex items-center gap-2">
                   <span className="font-medium">{c.name}</span>
                   {c.default && <Badge variant="secondary">{f("catalogDefault")}</Badge>}
+                  {c.schemaVersion === "v2" ? (
+                    <Badge variant="outline">v2</Badge>
+                  ) : (
+                    <Badge variant="warning" title={t("catalog.legacyHint")}>
+                      {t("catalog.legacy")}
+                    </Badge>
+                  )}
                   <code className="truncate font-mono text-xs text-muted-foreground">{c.url}</code>
                 </span>
               ))}
@@ -152,9 +185,9 @@ function ProfileView({ p }: { p: SiteProfile }) {
   );
 }
 
-function EditSheet({ data, onClose }: { data: ProfileResponse; onClose: () => void }) {
+function EditSheet({ profile, yaml, onClose }: { profile: SiteProfile; yaml: string; onClose: () => void }) {
   const t = useT();
-  const editor = useProfileEditor(data.profile!, data.yaml ?? "", onClose);
+  const editor = useProfileEditor(profile, yaml, onClose);
   return (
     <Sheet open onOpenChange={(o) => !o && onClose()} dirty={editor.dirty} onDiscard={onClose}>
       <SheetContent size="2xl" className="gap-0">
diff --git a/web/src/modules/inferences/catalog-lib.test.ts b/web/src/modules/inferences/catalog-lib.test.ts
index 454ae75..83c0814 100644
--- a/web/src/modules/inferences/catalog-lib.test.ts
+++ b/web/src/modules/inferences/catalog-lib.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import type { IndexModel, Node } from "@swiss/lib/api";
+import type { CatalogModel, Node } from "@swiss/lib/api";
 import { facetsOf } from "@swiss/lib/catalog";
 import {
   activeFilters,
@@ -13,22 +13,15 @@ import {
   withoutFilters,
 } from "@/modules/inferences/catalog-lib";
 
-const model = (over: Partial<IndexModel>): IndexModel => ({
+const model = (over: Partial<CatalogModel>): CatalogModel => ({
   name: "qwen3-8b",
   family: "qwen",
   tags: ["chat"],
   source: { hf: "Qwen/Qwen3-8B" },
-  latest: "1.0",
-  versions: [
-    {
-      version: "1.0",
-      path: "p",
-      digest: "d",
-      variants: [
-        { id: "h100x1", engine: "sglang", default: true, chart: { name: "sglang", version: "0.7.1" }, requires: { gpus: 1, gpuProduct: ["NVIDIA-H100-80GB-HBM3"] } },
-        { id: "v100x2", engine: "vllm", chart: { name: "vllm", version: "0.6.2" }, requires: { gpus: 2 } },
-      ],
-    },
+  defaultVariant: "h100x1",
+  variants: [
+    { id: "h100x1", version: "1.0", digest: "d", engine: "sglang", default: true, chart: { name: "sglang", version: "0.7.1" }, requires: { gpus: 1, gpuProduct: ["NVIDIA-H100-80GB-HBM3"] } },
+    { id: "v100x2", version: "1.0", digest: "d", engine: "vllm", chart: { name: "vllm", version: "0.6.2" }, requires: { gpus: 2 } },
   ],
   ...over,
 });
@@ -78,7 +71,7 @@ describe("facetOptions", () => {
 });
 
 describe("fitness", () => {
-  const v = model({}).versions[0]!.variants[0]!;
+  const v = model({}).variants[0]!;
   it("is unknown without the node list", () => {
     expect(fitness(v, undefined)).toBeNull();
   });
diff --git a/web/src/modules/inferences/catalog-lib.ts b/web/src/modules/inferences/catalog-lib.ts
index cd67aba..42ec5ab 100644
--- a/web/src/modules/inferences/catalog-lib.ts
+++ b/web/src/modules/inferences/catalog-lib.ts
@@ -1,4 +1,4 @@
-import type { IndexVariant, Node } from "@swiss/lib/api";
+import type { ModelVariant, Node } from "@swiss/lib/api";
 import type { Facets, SortKey } from "@swiss/lib/catalog";
 import { matchesVendor } from "@swiss/lib/gpu";
 
@@ -92,7 +92,7 @@ export interface Fit {
 
 // Whether the cluster has nodes a variant can land on right now: schedulable,
 // enough GPUs of the right vendor and product, as many as it spans.
-export function fitness(v: Pick<IndexVariant, "requires">, nodes?: Node[]): Fit | null {
+export function fitness(v: Pick<ModelVariant, "requires">, nodes?: Node[]): Fit | null {
   if (!nodes) return null;
   const matching = nodes.filter(
     (n) =>
diff --git a/web/src/modules/inferences/components/DeploySheet.tsx b/web/src/modules/inferences/components/DeploySheet.tsx
index 4d592e5..a4a4f42 100644
--- a/web/src/modules/inferences/components/DeploySheet.tsx
+++ b/web/src/modules/inferences/components/DeploySheet.tsx
@@ -24,19 +24,21 @@ import {
   useAnchorNav,
   useDirty,
 } from "@modelsphere/ui";
-import { ArrowRight, TriangleAlert } from "lucide-react";
+import { ArrowRight, FlaskConical, TriangleAlert } from "lucide-react";
 import { useModulePath } from "@/shell";
-import { api, deployApi, type ApplyResult, type DiffResult, type IndexModel, type Plan } from "@swiss/lib/api";
+import { api, deployApi, type ApplyResult, type ApplyWith, type CatalogModel, type DiffResult, type Plan } from "@swiss/lib/api";
 import { EMPTY, formFromPlan, imageOf, planRequest, type Form } from "@swiss/components/DeploySettings";
 import { releaseCatalog } from "@swiss/components/CatalogChoice";
 import { Provenance } from "@swiss/components/Provenance";
 import { DiffView } from "@swiss/components/DiffView";
 import { gpuShort } from "@swiss/lib/gpu";
 import { isChartRange, movableCatalogs } from "@swiss/lib/upgrade";
+import { installMethod, llmsvcBlock } from "@swiss/lib/applyWith";
 import { useT } from "@/modules/inferences/i18n";
 import { detailPath } from "@/modules/inferences/lib";
 import { SECTIONS, chartChoice, defaultServiceId, gpuOptions, pipelineState, serviceIdError, whatMoves, type Section } from "@/modules/inferences/deploy-lib";
 import { DeployForm } from "@/modules/inferences/components/DeployForm";
+import { ExperimentalBadge } from "@/modules/inferences/components/InstallMethodLabel";
 import { readRouteOptions } from "@/modules/inferences/api";
 
 export type DeployTarget =
@@ -76,25 +78,35 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
   const [variant, setVariant] = useState(upgrade ? "" : (target.variant ?? ""));
   const [moveTo, setMoveTo] = useState("");
   const [chartVersion, setChartVersion] = useState("");
+  const [picked, setPicked] = useState<ApplyWith>();
   const catalogName = moveTo || ownCatalog;
 
   const indexes = useQueries({
     queries: catalogs.map((c) => ({ queryKey: ["catalog", c.name], queryFn: () => api.catalog(c.name), enabled: upgrade || c.name === ownCatalog })),
   });
-  const modelIn = (name?: string): IndexModel | undefined =>
-    indexes[catalogs.findIndex((c) => c.name === name)]?.data?.index.models.find((m) => m.name === modelName);
+  const modelIn = (name?: string): CatalogModel | undefined =>
+    indexes[catalogs.findIndex((c) => c.name === name)]?.data?.models.find((m) => m.name === modelName);
   const { movable } = upgrade ? movableCatalogs(catalogs, recorded ?? {}, ownCatalog, (c) => modelIn(c)?.source.hf) : { movable: [] as string[] };
   const im = modelIn(catalogName);
-  const versions = im?.versions.map((v) => v.version) ?? [];
-  const listed = im?.versions.find((v) => v.version === (version || (upgrade ? recorded?.version : undefined) || im.latest))?.variants ?? [];
-  const keptVariant = variant || (upgrade ? recorded?.variant : listed.find((v) => v.default)?.id ?? listed[0]?.id) || "";
+  // The variants as listed now; a version is the chosen variant's, from its
+  // history: on v2 versions are per variant, on v1 the model's.
+  const listed = im?.variants ?? [];
+  const keptVariant = variant || (upgrade ? recorded?.variant : im?.defaultVariant ?? listed[0]?.id) || "";
+  const latest = listed.find((x) => x.id === keptVariant)?.version;
+  const history = useQuery({
+    queryKey: ["history", catalogName, modelName, keptVariant],
+    queryFn: () => api.history(modelName!, { catalog: catalogName, variant: keptVariant }),
+    enabled: !!modelName && !!catalogName && !!latest,
+    retry: false,
+  });
+  const versions = history.data?.revisions.map((r) => r.version) ?? (latest ? [latest] : []);
 
   const entry = useQuery({
-    queryKey: ["model", modelName, version, catalogName],
-    queryFn: () => api.model(modelName!, version || undefined, catalogName),
+    queryKey: ["model", catalogName, modelName, keptVariant, version],
+    queryFn: () => api.model(modelName!, { catalog: catalogName, variant: keptVariant || undefined, version: version || undefined }),
     enabled: !!modelName && !!catalogName,
   });
-  const v = entry.data?.entry.variants.find((x) => x.id === keptVariant) ?? entry.data?.entry.variants[0];
+  const v = entry.data?.variant;
   const chartRange = !!v && isChartRange(v.chart.version);
   const chartList = useQuery({
     queryKey: ["chart-versions", catalogName, modelName, version, keptVariant],
@@ -103,6 +115,9 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
     retry: false,
   });
   const chart = chartChoice(chartList, chartVersion, upgrade ? current.data?.chart : undefined);
+  const llm = cluster.data?.llmservice;
+  const block = llmsvcBlock(llm, entry.data?.schema);
+  const method = installMethod(picked, llm, entry.data?.schema);
 
   const initial = useMemo<Form>(() => (upgrade ? (current.data ? formFromPlan(current.data) : EMPTY) : { ...EMPTY, serviceId: defaultServiceId(target.model) }), [upgrade, current.data, target]);
   const [form, setForm] = useState<Form>(initial);
@@ -152,7 +167,7 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
   const dryRun = useMutation({ mutationFn: (pl: Plan) => deployApi.diff({ planHash: pl.hash }), onSuccess: setDiff });
   const state = pipelineState({ diff, exists: live.data?.exists, applied: !!applied });
   const apply = useMutation({
-    mutationFn: () => (state.action === "install" ? deployApi.install(plan!.hash, note.trim()) : deployApi.apply(plan!.hash, diff?.revision, note.trim(), force)),
+    mutationFn: () => (state.action === "install" ? deployApi.install(plan!.hash, note.trim(), method) : deployApi.apply(plan!.hash, diff?.revision, note.trim(), force)),
     onSuccess: (r) => {
       setApplied(r);
       for (const key of REFRESH) qc.invalidateQueries({ queryKey: key });
@@ -195,26 +210,17 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
       )}
       {!upgrade && (
         <FloatingField label={t("deploy.fields.model")} disabled>
-          <FieldInput value={entry.data?.entry.displayName || target.model} readOnly disabled />
+          <FieldInput value={entry.data?.model.displayName || target.model} readOnly disabled />
         </FloatingField>
       )}
       <div className="grid grid-cols-2 gap-3">
-        <FloatingField label={t("deploy.fields.version")}>
-          <FieldSelect
-            value={version || (upgrade ? KEEP : im?.latest ?? "")}
-            onValueChange={(x) => {
-              setVersion(x === KEEP || (!upgrade && x === im?.latest) ? "" : x);
-              setVariant("");
-              setChartVersion("");
-            }}
-            options={[...(upgrade ? [keepOption(t("deploy.fields.keep", { v: recorded?.version ?? "-" }))] : []), ...versions.map((x) => ({ value: x, label: x === im?.latest ? `${x} (${t("model.latest")})` : x }))]}
-          />
-        </FloatingField>
         <FloatingField label={t("deploy.fields.variant")}>
           <FieldSelect
             value={variant || (upgrade ? KEEP : keptVariant)}
             onValueChange={(x) => {
               setVariant(x === KEEP ? "" : x);
+              // On v2 another variant has versions of its own.
+              setVersion("");
               setChartVersion("");
             }}
             options={[
@@ -223,6 +229,28 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
             ]}
           />
         </FloatingField>
+        {/* Empty is the variant's latest, on an upgrade as on a deploy. */}
+        <FloatingField
+          label={t(entry.data?.schema === "v2" ? "deploy.fields.variantVersion" : "deploy.fields.version")}
+          hint={history.error ? t("deploy.fields.versionError", { error: history.error.message }) : undefined}
+        >
+          <FieldSelect
+            value={version || latest || ""}
+            onValueChange={(x) => {
+              setVersion(x === latest ? "" : x);
+              setChartVersion("");
+            }}
+            options={versions.map((x) => ({
+              value: x,
+              label:
+                x === latest
+                  ? `${x} (${t("model.latest")})`
+                  : upgrade && x === recorded?.version && keptVariant === recorded?.variant
+                    ? `${x} (${t("deploy.fields.deployed")})`
+                    : x,
+            }))}
+          />
+        </FloatingField>
       </div>
       {chartRange && (
         <FloatingField
@@ -251,6 +279,39 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
           )}
         </FloatingField>
       )}
+      {!upgrade && (
+        <FloatingField label={t("deploy.fields.applyWith")} hint={block ? t(`deploy.fields.applyWithBlocked.${block}`) : t("deploy.fields.applyWithHint")}>
+          <FieldSelect
+            value={method}
+            onValueChange={(x) => x && setPicked(x as ApplyWith)}
+            options={(["helm", "llmsvc"] as const).map((m) => {
+              const isDefault = m === installMethod(undefined, llm, "v2");
+              return {
+                value: m,
+                label: t(`deploy.fields.applyWithMethod.${m}`),
+                description: t(`deploy.fields.applyWithDesc.${m}`),
+                badge:
+                  m === "llmsvc" ? (
+                    <span className="inline-flex items-center gap-1.5">
+                      <ExperimentalBadge />
+                      {isDefault && t("deploy.fields.applyWithDefault")}
+                    </span>
+                  ) : isDefault ? (
+                    t("deploy.fields.applyWithDefault")
+                  ) : undefined,
+                disabled: m === "llmsvc" && !!block,
+              };
+            })}
+          />
+        </FloatingField>
+      )}
+      {/* The select shows only the label once closed, so the mark is repeated here. */}
+      {!upgrade && method === "llmsvc" && (
+        <p className="-mt-1 flex items-center gap-1.5 text-xs text-warning">
+          <FlaskConical className="size-3.5 shrink-0" />
+          {t("deploy.fields.applyWithExperimentalNote")}
+        </p>
+      )}
     </>
   );
 
@@ -326,6 +387,7 @@ function DeploySheetBody({ target, onClose }: { target: DeployTarget; onClose: (
               onNote={setNote}
               force={force}
               onForce={setForce}
+              method={state.action === "install" ? method : live.data?.backend}
             />
           )
         )}
@@ -369,6 +431,7 @@ export function Review({
   onNote,
   force,
   onForce,
+  method,
 }: {
   upgrade: boolean;
   rollback?: boolean;
@@ -383,6 +446,8 @@ export function Review({
   onNote: (v: string) => void;
   force: boolean;
   onForce: (v: boolean) => void;
+  // The install method: the one picked on an install, the release's own otherwise.
+  method?: ApplyWith;
 }) {
   const t = useT();
   const moves = current && (upgrade || rollback) ? whatMoves(current, plan, currentCatalog) : null;
@@ -429,6 +494,12 @@ export function Review({
           <Provenance plan={plan} />
         </SectionCard>
       )}
+      {method && (
+        <p className="flex flex-wrap items-center gap-1.5 text-sm text-muted-foreground">
+          {t(state.action === "install" ? "deploy.review.applyWith" : "deploy.review.applyWithKept", { method: t(`deploy.fields.applyWithMethod.${method}`) })}
+          {method === "llmsvc" && <ExperimentalBadge />}
+        </p>
+      )}
       <FloatingField label={t("deploy.review.note")} hint={t("deploy.review.noteHint")} multiline>
         <FieldTextarea value={note} onChange={(e) => onNote(e.target.value)} rows={3} />
       </FloatingField>
diff --git a/web/src/modules/inferences/components/InstallMethodLabel.tsx b/web/src/modules/inferences/components/InstallMethodLabel.tsx
new file mode 100644
index 0000000..b05a451
--- /dev/null
+++ b/web/src/modules/inferences/components/InstallMethodLabel.tsx
@@ -0,0 +1,19 @@
+import { Badge } from "@modelsphere/ui";
+import type { ApplyWith } from "@swiss/lib/api";
+import { useT } from "@/modules/inferences/i18n";
+
+export function ExperimentalBadge() {
+  const t = useT();
+  return <Badge variant="warning">{t("deploy.fields.applyWithExperimental")}</Badge>;
+}
+
+// The install method's name, marked when it is still experimental.
+export function InstallMethodLabel({ method }: { method: ApplyWith }) {
+  const t = useT();
+  return (
+    <span className="inline-flex items-center gap-1.5">
+      {t(`deploy.fields.applyWithMethod.${method}`)}
+      {method === "llmsvc" && <ExperimentalBadge />}
+    </span>
+  );
+}
diff --git a/web/src/modules/inferences/components/ProfileEditor.tsx b/web/src/modules/inferences/components/ProfileEditor.tsx
index ca942d6..89aa4e8 100644
--- a/web/src/modules/inferences/components/ProfileEditor.tsx
+++ b/web/src/modules/inferences/components/ProfileEditor.tsx
@@ -3,6 +3,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { Alert, AlertDescription, Button, FieldTextarea, FloatingField, Tabs, TabsList, TabsTrigger } from "@modelsphere/ui";
 import { TriangleAlert } from "lucide-react";
 import { api, type ProfileResponse, type SiteProfile } from "@swiss/lib/api";
+import { markSetUp } from "@swiss/components/Session";
 import { useT } from "@/modules/inferences/i18n";
 import { profileErrors } from "@/modules/inferences/profile-lib";
 import { ProfileForm } from "@/modules/inferences/components/ProfileForm";
@@ -18,7 +19,8 @@ export function useProfileEditor(profile: SiteProfile, yaml: string, onSaved: (r
   const save = useMutation({
     mutationFn: () => (mode === "form" ? api.saveProfile({ profile: form }) : api.saveProfile({ yaml: text })),
     onSuccess: (r) => {
-      for (const key of [["profile"], ["cluster"], ["catalog"], ["session"]]) qc.invalidateQueries({ queryKey: key });
+      markSetUp(qc);
+      for (const key of [["profile"], ["cluster"], ["catalog"]]) qc.invalidateQueries({ queryKey: key });
       onSaved(r);
     },
   });
diff --git a/web/src/modules/inferences/components/ProfileForm.tsx b/web/src/modules/inferences/components/ProfileForm.tsx
index 70dcff7..50123a7 100644
--- a/web/src/modules/inferences/components/ProfileForm.tsx
+++ b/web/src/modules/inferences/components/ProfileForm.tsx
@@ -1,9 +1,12 @@
 import { useState, type ReactNode } from "react";
-import { Button, Checkbox, FieldHint, FieldInput, FloatingField, FormSection, Input, Switch } from "@modelsphere/ui";
+import { Button, Checkbox, FieldHint, FieldInput, FieldSelect, FloatingField, FormSection, Input, Switch } from "@modelsphere/ui";
 import { Plus, X } from "lucide-react";
 import type { RouteAuth, SiteProfile } from "@swiss/lib/api";
 import { useT } from "@/modules/inferences/i18n";
-import { fromRows, markDefault, toRows, type Row } from "@/modules/inferences/profile-lib";
+import { fromRows, markDefault, toRows, withNodes, type Row } from "@/modules/inferences/profile-lib";
+import { aliasErrors, aliasMap, aliasRows, catalogErrors, type AliasError, type AliasRow, type CatalogError } from "@swiss/lib/profile";
+
+type CatalogRepo = NonNullable<SiteProfile["catalogs"]>[number];
 
 const GROUPS = ["placement", "catalog", "model", "routing", "auth", "scaler", "sites"] as const;
 
@@ -16,6 +19,8 @@ export function ProfileForm({ value: p, onChange, submitted, collapsible }: { va
   const auth = (patch: RouteAuth) => route({ auth: { ...p.route?.auth, ...patch } });
   const scaler = (patch: NonNullable<SiteProfile["scaler"]>) => set({ scaler: { ...p.scaler, ...patch } });
   const str = (v: string) => v || undefined;
+  const catalogs = p.catalogs ?? [];
+  const catalogErrs = catalogErrors(catalogs);
   const group = (g: (typeof GROUPS)[number], children: ReactNode) => (
     <FormSection
       title={t(`profile.groups.${g}`)}
@@ -43,7 +48,8 @@ export function ProfileForm({ value: p, onChange, submitted, collapsible }: { va
             {input(f("scheduler"), p.schedule?.schedulerName, (v) => set({ schedule: { ...p.schedule, schedulerName: str(v) } }), { placeholder: f("chartDefault") })}
             {input(f("priorityClass"), p.schedule?.priorityClassName, (v) => set({ schedule: { ...p.schedule, priorityClassName: str(v) } }), { placeholder: f("chartDefault") })}
           </div>
-          {input(f("gpusPerNode"), p.nodes?.gpusPerNode, (v) => set({ nodes: v.replace(/\D/g, "") ? { gpusPerNode: Number(v.replace(/\D/g, "")) } : undefined }), { hint: f("gpusPerNodeHint") })}
+          {input(f("gpusPerNode"), p.nodes?.gpusPerNode, (v) => set({ nodes: withNodes(p.nodes, { gpusPerNode: v.replace(/\D/g, "") ? Number(v.replace(/\D/g, "")) : undefined }) }), { hint: f("gpusPerNodeHint") })}
+          <GpuAliases value={p.nodes?.gpuProductAliases} submitted={submitted} onChange={(a) => set({ nodes: withNodes(p.nodes, { gpuProductAliases: a }) })} />
         </>,
       )}
 
@@ -51,18 +57,17 @@ export function ProfileForm({ value: p, onChange, submitted, collapsible }: { va
         "catalog",
         <>
           <Group label={f("catalogs")} hint={f("catalogsHint")}>
-            {(p.catalogs ?? []).map((c, i) => (
-              <div key={i} className="grid grid-cols-[10rem_1fr_auto_auto] items-center gap-2">
-                <Input value={c.name} onChange={(e) => set({ catalogs: p.catalogs!.map((x, j) => (j === i ? { ...x, name: e.target.value } : x)) })} placeholder={f("catalogName")} aria-label={f("catalogName")} />
-                <Input value={c.url} onChange={(e) => set({ catalogs: p.catalogs!.map((x, j) => (j === i ? { ...x, url: e.target.value } : x)) })} placeholder={f("catalogUrl")} aria-label={f("catalogUrl")} className="font-mono text-xs" />
-                <label className="flex items-center gap-1.5 text-sm whitespace-nowrap">
-                  <Checkbox checked={!!c.default} onCheckedChange={(on) => set({ catalogs: markDefault(p.catalogs!, i, !!on) })} />
-                  {f("catalogDefault")}
-                </label>
-                <Remove onClick={() => set({ catalogs: p.catalogs!.filter((_, j) => j !== i) })} />
-              </div>
+            {catalogs.map((c, i) => (
+              <CatalogRow
+                key={i}
+                value={c}
+                errors={submitted ? catalogErrs[i] : {}}
+                onChange={(patch) => set({ catalogs: catalogs.map((x, j) => (j === i ? { ...x, ...patch } : x)) })}
+                onDefault={(on) => set({ catalogs: markDefault(catalogs, i, on) })}
+                onRemove={() => set({ catalogs: catalogs.filter((_, j) => j !== i) })}
+              />
             ))}
-            <Add label={f("catalogAdd")} onClick={() => set({ catalogs: [...(p.catalogs ?? []), { name: "", url: "" }] })} />
+            <Add label={f("catalogAdd")} onClick={() => set({ catalogs: [...catalogs, { name: "", url: "", schemaVersion: "v2" }] })} />
           </Group>
           {input(f("chartRepo"), p.chartRepo, (v) => set({ chartRepo: str(v) }), { hint: f("chartRepoHint"), placeholder: "https://modelsphere.github.io/helm-charts", mono: true })}
           {input(f("chartPath"), p.chartPath, (v) => set({ chartPath: str(v) }), { placeholder: f("chartPathHint"), mono: true })}
@@ -155,6 +160,92 @@ export function ProfileForm({ value: p, onChange, submitted, collapsible }: { va
   );
 }
 
+function CatalogRow({
+  value: c,
+  errors,
+  onChange,
+  onDefault,
+  onRemove,
+}: {
+  value: CatalogRepo;
+  errors: { name?: CatalogError; url?: CatalogError };
+  onChange: (patch: Partial<CatalogRepo>) => void;
+  onDefault: (on: boolean) => void;
+  onRemove: () => void;
+}) {
+  const t = useT();
+  const f = (k: string) => t(`profile.fields.${k}`);
+  const err = (field: "name" | "url", e?: CatalogError) => e && t(`profile.errors.catalog.${field}.${e}`);
+  return (
+    <div className="grid gap-3 rounded-md border bg-surface-page p-3 sm:grid-cols-[minmax(0,14rem)_minmax(0,1fr)]">
+      <FloatingField label={f("catalogName")} required error={err("name", errors.name)}>
+        <FieldInput value={c.name} onChange={(e) => onChange({ name: e.target.value })} placeholder="public" />
+      </FloatingField>
+      <FloatingField label={f("catalogUrl")} required error={err("url", errors.url)}>
+        <FieldInput value={c.url} onChange={(e) => onChange({ url: e.target.value })} placeholder="https://modelsphere.github.io/model-catalog" className="font-mono text-xs" />
+      </FloatingField>
+      {/* Unset is v1, so v1 is written as unset. */}
+      <FloatingField label={f("catalogSchema")}>
+        <FieldSelect
+          value={c.schemaVersion === "v2" ? "v2" : "v1"}
+          onValueChange={(v) => v && onChange({ schemaVersion: v === "v2" ? "v2" : undefined })}
+          options={[
+            { value: "v2", label: f("catalogSchemaV2") },
+            { value: "v1", label: f("catalogSchemaV1") },
+          ]}
+        />
+      </FloatingField>
+      <div className="flex items-center gap-2 px-1">
+        <label className="flex items-center gap-1.5 text-sm whitespace-nowrap">
+          <Checkbox checked={!!c.default} onCheckedChange={(on) => onDefault(!!on)} />
+          {f("catalogDefault")}
+        </label>
+        <span className="ms-auto">
+          <Remove onClick={onRemove} />
+        </span>
+      </div>
+    </div>
+  );
+}
+
+function GpuAliases({ value, submitted, onChange }: { value?: Record<string, string[]>; submitted: boolean; onChange: (v?: Record<string, string[]>) => void }) {
+  const t = useT();
+  const f = (k: string) => t(`profile.fields.${k}`);
+  // Rows live here while typed; see aliasRows.
+  const [rows, setRows] = useState<AliasRow[]>(() => aliasRows(value));
+  const errs = aliasErrors(rows);
+  const err = (field: "product" | "selector", e?: AliasError) => (submitted && e ? t(`profile.errors.gpuAlias.${field}.${e}`) : undefined);
+  const update = (next: AliasRow[]) => {
+    setRows(next);
+    onChange(aliasMap(next));
+  };
+  const edit = (i: number, patch: Partial<AliasRow>) => update(rows.map((r, j) => (j === i ? { ...r, ...patch } : r)));
+  return (
+    <Group label={f("gpuAliases")} hint={f("gpuAliasesHint")}>
+      {/* An error line hangs below its field, so rows showing one need the room. */}
+      <div className={`flex flex-col gap-6 ${submitted && errs.some((e) => e.product || e.selector) ? "sm:gap-5" : "sm:gap-3"}`}>
+        {rows.map((r, i) => (
+          // Narrow, the remove button sits beside the product and the labels take the next line.
+          <div key={i} className="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-3 sm:grid-cols-[minmax(0,14rem)_minmax(0,1fr)_auto]">
+            <FloatingField label={f("gpuAliasProduct")} required error={err("product", errs[i].product)}>
+              <FieldInput value={r.product} onChange={(e) => edit(i, { product: e.target.value })} placeholder="Ascend-910B3" />
+            </FloatingField>
+            <span className="sm:order-last">
+              <Remove onClick={() => update(rows.filter((_, j) => j !== i))} />
+            </span>
+            <div className="col-span-2 sm:col-span-1">
+              <FloatingField label={f("gpuAliasSelector")} required error={err("selector", errs[i].selector)}>
+                <FieldInput value={r.selector} onChange={(e) => edit(i, { selector: e.target.value })} placeholder="accelerator=huawei-Ascend910" className="font-mono text-xs" />
+              </FloatingField>
+            </div>
+          </div>
+        ))}
+      </div>
+      <Add label={f("gpuAliasAdd")} onClick={() => setRows([...rows, { product: "", selector: "" }])} />
+    </Group>
+  );
+}
+
 function KV({ label, hint, value, onChange }: { label: string; hint?: string; value?: Record<string, string>; onChange: (v?: Record<string, string>) => void }) {
   const t = useT();
   // Rows live here while typed: a row with no key yet is not in the profile.
diff --git a/web/src/modules/inferences/dashboard-lib.test.ts b/web/src/modules/inferences/dashboard-lib.test.ts
index b9b9895..aabf526 100644
--- a/web/src/modules/inferences/dashboard-lib.test.ts
+++ b/web/src/modules/inferences/dashboard-lib.test.ts
@@ -19,54 +19,37 @@ const catalog: CatalogResponse = {
   name: "default",
   ref: "main",
   source: "https://catalog.example",
-  index: {
-    apiVersion: "catalog.swiss/v1",
-    count: 1,
-    models: [
-      {
-        name: "alpha",
-        source: { hf: "org/alpha" },
-        latest: "2",
-        versions: [
-          {
-            version: "1",
-            path: "alpha-1.yaml",
-            digest: "old",
-            variants: [{ id: "base", engine: "vllm", chart: { name: "vllm", version: "1" }, requires: { gpus: 1 } }],
-          },
-          {
-            version: "2",
-            path: "alpha-2.yaml",
-            digest: "new",
-            variants: [
-              { id: "base", engine: "vllm", chart: { name: "vllm", version: "2" }, requires: { gpus: 1 } },
-              { id: "tuned", engine: "sglang", chart: { name: "sglang", version: "2" }, requires: { gpus: 2 } },
-            ],
-          },
-        ],
-      },
-    ],
-  },
+  schema: "v2",
+  models: [
+    {
+      name: "alpha",
+      source: { hf: "org/alpha" },
+      defaultVariant: "base",
+      variants: [
+        { id: "base", version: "2", digest: "b2", engine: "vllm", chart: { name: "vllm", version: "2" }, requires: { gpus: 1 } },
+        { id: "tuned", version: "1", digest: "t1", engine: "sglang", chart: { name: "sglang", version: "2" }, requires: { gpus: 2 } },
+      ],
+    },
+  ],
 };
 
 describe("supported catalog totals", () => {
-  it("counts every supported version recipe, not a sample or only the latest", () =>
-    expect(supportedTotals([catalog])).toEqual({ models: 1, recipes: 3 }));
+  it("counts every variant at the pin its catalog lists now", () =>
+    expect(supportedTotals([catalog])).toEqual({ models: 1, recipes: 2 }));
   it("does not double-count mirrored catalog entries", () =>
-    expect(supportedTotals([catalog, { ...catalog, name: "mirror" }])).toEqual({ models: 1, recipes: 3 }));
+    expect(supportedTotals([catalog, { ...catalog, name: "mirror" }])).toEqual({ models: 1, recipes: 2 }));
   it("does not count deprecated models as current support", () => {
-    const old = {
-      ...catalog,
-      index: { ...catalog.index, models: catalog.index.models.map((m) => ({ ...m, deprecated: "retired" })) },
-    };
+    const old = { ...catalog, models: catalog.models.map((m) => ({ ...m, deprecated: "retired" })) };
     expect(supportedTotals([old])).toEqual({ models: 0, recipes: 0 });
   });
-  it("distinguishes different model sources and recipe revisions", () => {
-    const other = {
+  it("distinguishes different model sources and recipe pins", () => {
+    const other = { ...catalog, models: catalog.models.map((m) => ({ ...m, source: { hf: "other/alpha" } })) };
+    const moved = {
       ...catalog,
-      index: { ...catalog.index, models: catalog.index.models.map((m) => ({ ...m, source: { hf: "other/alpha" } })) },
+      models: catalog.models.map((m) => ({ ...m, variants: m.variants.map((v) => ({ ...v, version: "3", digest: "x" })) })),
     };
-    expect(supportedTotals([catalog, other])).toEqual({ models: 2, recipes: 6 });
+    expect(supportedTotals([catalog, other])).toEqual({ models: 2, recipes: 4 });
+    expect(supportedTotals([catalog, moved])).toEqual({ models: 1, recipes: 4 });
   });
 });
 
diff --git a/web/src/modules/inferences/dashboard-lib.ts b/web/src/modules/inferences/dashboard-lib.ts
index 203d531..e777f03 100644
--- a/web/src/modules/inferences/dashboard-lib.ts
+++ b/web/src/modules/inferences/dashboard-lib.ts
@@ -19,18 +19,19 @@ export interface DeploymentTimeline {
   complete: boolean;
 }
 
+// A recipe is a variant at the pin its catalog lists now. Older versions are
+// left out: a v2 index lists only current pins, and counting history would
+// cost a fetch per variant.
 export function supportedTotals(catalogs: CatalogResponse[]): { models: number; recipes: number } {
   const models = new Set<string>();
   const recipes = new Set<string>();
   for (const catalog of catalogs) {
-    for (const model of catalog.index.models) {
+    for (const model of catalog.models) {
       if (model.deprecated) continue;
       const identity = [model.name, model.source.hf, model.source.revision ?? ""];
       models.add(JSON.stringify(identity));
-      for (const version of model.versions) {
-        for (const variant of version.variants) {
-          recipes.add(JSON.stringify([...identity, version.version, version.digest, variant.id]));
-        }
+      for (const variant of model.variants) {
+        recipes.add(JSON.stringify([...identity, variant.id, variant.version, variant.digest]));
       }
     }
   }
diff --git a/web/src/modules/inferences/locales/en-US.json b/web/src/modules/inferences/locales/en-US.json
index 0bc65d6..5cffd27 100644
--- a/web/src/modules/inferences/locales/en-US.json
+++ b/web/src/modules/inferences/locales/en-US.json
@@ -278,6 +278,8 @@
     "noCatalog": "No model catalog is configured.",
     "noCatalogAction": "Add one in the site profile",
     "choose": "Several catalogs are configured. Pick one:",
+    "legacy": "v1 legacy",
+    "legacyHint": "Catalog schema v1 is the read-only legacy index, and what a catalog with no schemaVersion reads. Set schemaVersion: v2 on it in the site profile.",
     "default": "Default"
   },
   "model": {
@@ -293,12 +295,14 @@
       "license": "License",
       "version": "Version",
       "digest": "Digest",
+      "schema": "Schema",
       "tags": "Tags",
       "size": "{n} GiB",
       "sizeLabel": "Size"
     },
     "version": "Version",
     "latest": "latest",
+    "perVariant": "per variant",
     "default": "Default",
     "optimized": "Tuned",
     "baseline": "Baseline",
@@ -401,7 +405,28 @@
       "catalog": "Catalog",
       "version": "Model version",
       "variant": "Variant",
+      "variantVersion": "Variant version",
+      "versionError": "Could not list versions: {error}",
+      "deployed": "deployed",
       "chartVersion": "Chart version",
+      "applyWith": "Install method",
+      "applyWithHint": "Fixed at install: upgrades and rollbacks stay on it",
+      "applyWithDefault": "default",
+      "applyWithExperimental": "Experimental",
+      "applyWithExperimentalNote": "LLMService is experimental",
+      "applyWithMethod": {
+        "helm": "Plan ConfigMap",
+        "llmsvc": "LLMService"
+      },
+      "applyWithDesc": {
+        "helm": "swissd runs helm; the plan sits in a ConfigMap beside the release",
+        "llmsvc": "llm-operator runs helm from an LLMService swissd writes"
+      },
+      "applyWithBlocked": {
+        "unserved": "LLMService unavailable: the CRD is not served on this cluster",
+        "unavailable": "LLMService unavailable: swissd cannot use it here; see the cluster warnings",
+        "schema": "LLMService unavailable: it needs a catalog schema v2 model"
+      },
       "serviceId": "Service name",
       "serviceIdHint": "Names the helm release, the route, the scaler and the SLO",
       "serviceIdLocked": "Fixed on an upgrade: the route, the scaler and the SLO are named after it",
@@ -503,6 +528,8 @@
       "noteHint": "Why this is done; kept with the run and beside the release",
       "force": "Force conflicting fields",
       "forceHint": "Takes over fields helm sees owned by someone else, for this apply only",
+      "applyWith": "Installs with {method}",
+      "applyWithKept": "Stays on {method}: an existing release keeps its install method",
       "back": "Back to edit",
       "compose": "Compose plan",
       "composing": "Composing…",
@@ -618,6 +645,7 @@
     "saving": "Saving…",
     "unset": "Not set",
     "parseError": "The site profile does not parse: {error}",
+    "repairHint": "Open Edit and fix it in the YAML tab, which holds the stored document. The form starts from the default, and saving from it replaces the whole profile.",
     "groups": {
       "placement": "Placement",
       "catalog": "Catalogs, charts and images",
@@ -645,13 +673,21 @@
       "priorityClass": "Priority class",
       "gpusPerNode": "GPUs per node",
       "gpusPerNodeHint": "A full GPU node, used to derive cache.maxSlotsPerNode",
+      "gpuAliases": "GPU product aliases",
+      "gpuAliasesHint": "For nodes a vendor install does not label with the catalog GPU product name. Each row names a catalog product and a node label selector; every key=value must match. A node matching two products takes the one with more pairs",
+      "gpuAliasProduct": "Catalog GPU product",
+      "gpuAliasSelector": "Node labels",
+      "gpuAliasAdd": "Add alias",
       "chartDefault": "the chart's default",
       "catalogs": "Catalogs",
-      "catalogsHint": "Each an https base or an absolute path, under a name. With several, pages open in the default one. Set here they win over swissd's config file",
+      "catalogsHint": "Each an https base or an absolute path, under a name. With several, pages open in the default one. Set here they win over swissd's config file. Schema v2 is recommended; v1 is the read-only legacy index, and what a catalog with no schema set reads",
       "catalogName": "Name",
       "catalogUrl": "URL",
       "catalogDefault": "Default",
       "catalogAdd": "Add catalog",
+      "catalogSchema": "Schema",
+      "catalogSchemaV1": "v1 · legacy",
+      "catalogSchemaV2": "v2 · recommended",
       "chartRepo": "Chart repo",
       "chartRepoHint": "An https helm repo or oci:// registry, e.g. https://modelsphere.github.io/helm-charts; empty means a local chart path",
       "chartPath": "Chart path",
@@ -701,12 +737,33 @@
     "setup": {
       "title": "Set up this site",
       "description": "This swissd has no site profile yet. Describe the cluster first: the model catalog, the chart repo, the model paths. Deploying starts once it is saved.",
-      "save": "Save and start",
-      "saveExisting": "Save profile"
+      "save": "Save and start"
     },
     "errors": {
       "name": "The cluster name is required",
-      "pathTemplate": "The path template is required"
+      "pathTemplate": "The path template is required",
+      "catalog": {
+        "name": {
+          "required": "Name is required",
+          "format": "Only lowercase letters, digits, . - _",
+          "duplicate": "Another catalog has this name"
+        },
+        "url": {
+          "required": "URL is required",
+          "format": "An http:// or https:// URL, or an absolute path",
+          "duplicate": "Already listed with this schema"
+        }
+      },
+      "gpuAlias": {
+        "product": {
+          "required": "Product is required"
+        },
+        "selector": {
+          "required": "Labels are required",
+          "format": "key=value pairs, comma separated",
+          "conflict": "A node could match another product as well; add a label"
+        }
+      }
     }
   },
   "events": {
diff --git a/web/src/modules/inferences/locales/zh-CN.json b/web/src/modules/inferences/locales/zh-CN.json
index cab3e6e..b18876b 100644
--- a/web/src/modules/inferences/locales/zh-CN.json
+++ b/web/src/modules/inferences/locales/zh-CN.json
@@ -267,6 +267,8 @@
     "noCatalog": "还没有配置模型目录。",
     "noCatalogAction": "去站点配置添加",
     "choose": "已配置多个目录，请选择一个：",
+    "legacy": "v1 旧版",
+    "legacyHint": "目录 schema v1 是只读的旧版索引，未设置 schemaVersion 的目录按 v1 读取。请在站点配置里把它设为 schemaVersion: v2。",
     "default": "默认"
   },
   "model": {
@@ -282,12 +284,14 @@
       "license": "许可证",
       "version": "版本",
       "digest": "Digest",
+      "schema": "Schema",
       "tags": "标签",
       "size": "{n} GiB",
       "sizeLabel": "大小"
     },
     "version": "版本",
     "latest": "最新",
+    "perVariant": "按变体",
     "default": "默认",
     "optimized": "调优",
     "baseline": "基线",
@@ -390,7 +394,28 @@
       "catalog": "目录",
       "version": "模型版本",
       "variant": "变体",
+      "variantVersion": "变体版本",
+      "versionError": "无法列出版本：{error}",
+      "deployed": "已部署",
       "chartVersion": "Chart 版本",
+      "applyWith": "安装方式",
+      "applyWithHint": "安装时确定：之后的升级和回滚都沿用",
+      "applyWithDefault": "默认",
+      "applyWithExperimental": "实验性",
+      "applyWithExperimentalNote": "LLMService 为实验性功能",
+      "applyWithMethod": {
+        "helm": "Plan ConfigMap",
+        "llmsvc": "LLMService"
+      },
+      "applyWithDesc": {
+        "helm": "swissd 执行 helm，计划存放在 release 旁的 ConfigMap",
+        "llmsvc": "swissd 写入 LLMService，由 llm-operator 执行 helm"
+      },
+      "applyWithBlocked": {
+        "unserved": "LLMService 不可用：集群未提供该 CRD",
+        "unavailable": "LLMService 不可用：swissd 无法使用，见集群告警",
+        "schema": "LLMService 不可用：需要 v2 schema 目录中的模型"
+      },
       "serviceId": "服务名",
       "serviceIdHint": "作为 helm release、路由、伸缩器和 SLO 的名字",
       "serviceIdLocked": "升级时不能改：路由、伸缩器和 SLO 都以它命名",
@@ -492,6 +517,8 @@
       "noteHint": "为什么做这次变更；会记入操作记录并写在 release 旁",
       "force": "强制接管冲突字段",
       "forceHint": "helm 字段归属冲突时强制覆盖，只对这一次生效",
+      "applyWith": "安装方式：{method}",
+      "applyWithKept": "沿用 {method}：已有 release 不改变安装方式",
       "back": "返回修改",
       "compose": "生成计划",
       "composing": "生成中…",
@@ -607,6 +634,7 @@
     "saving": "保存中…",
     "unset": "未设置",
     "parseError": "站点配置解析失败：{error}",
+    "repairHint": "点击编辑，在 YAML 标签页中修正已存储的文档。表单从默认配置开始，从表单保存会替换整个配置。",
     "groups": {
       "placement": "调度",
       "catalog": "目录、Chart 与镜像",
@@ -634,13 +662,21 @@
       "priorityClass": "优先级类",
       "gpusPerNode": "每节点 GPU 数",
       "gpusPerNodeHint": "一个满配 GPU 节点的卡数，用来推算 cache.maxSlotsPerNode",
+      "gpuAliases": "GPU 型号别名",
+      "gpuAliasesHint": "用于厂商安装未按模型库 GPU 型号名打标签的节点。每行填写一个模型库 GPU 型号和一个节点标签选择器，所有 key=value 都须匹配。同时匹配两个型号的节点取匹配对数更多的那个",
+      "gpuAliasProduct": "模型库 GPU 型号",
+      "gpuAliasSelector": "节点标签",
+      "gpuAliasAdd": "添加别名",
       "chartDefault": "chart 默认值",
       "catalogs": "模型目录",
-      "catalogsHint": "每项是 https 地址或绝对路径，以名字区分。配置多个时页面默认打开标记为默认的那个；这里的设置优先于 swissd 的配置文件",
+      "catalogsHint": "每项是 https 地址或绝对路径，以名字区分。配置多个时页面默认打开标记为默认的那个；这里的设置优先于 swissd 的配置文件。推荐 schema v2；v1 是只读的旧版索引，未设置 schema 时按 v1 读取",
       "catalogName": "名称",
       "catalogUrl": "地址",
       "catalogDefault": "默认",
       "catalogAdd": "添加目录",
+      "catalogSchema": "Schema",
+      "catalogSchemaV1": "v1 · 旧版",
+      "catalogSchemaV2": "v2 · 推荐",
       "chartRepo": "Chart 仓库",
       "chartRepoHint": "https 的 helm 仓库或 oci:// 仓库，例如 https://modelsphere.github.io/helm-charts；留空表示使用本地 chart 路径",
       "chartPath": "Chart 路径",
@@ -690,12 +726,33 @@
     "setup": {
       "title": "初始化站点",
       "description": "这个 swissd 还没有站点配置。先说明这个集群的情况：模型目录、chart 仓库、模型路径。保存后就可以开始部署。",
-      "save": "保存并开始",
-      "saveExisting": "保存配置"
+      "save": "保存并开始"
     },
     "errors": {
       "name": "集群名必填",
-      "pathTemplate": "路径模板必填"
+      "pathTemplate": "路径模板必填",
+      "catalog": {
+        "name": {
+          "required": "名称必填",
+          "format": "仅限小写字母、数字和 . - _",
+          "duplicate": "名称与其他目录重复"
+        },
+        "url": {
+          "required": "地址必填",
+          "format": "http:// 或 https:// 地址，或绝对路径",
+          "duplicate": "相同 schema 下已有此地址"
+        }
+      },
+      "gpuAlias": {
+        "product": {
+          "required": "请填写型号"
+        },
+        "selector": {
+          "required": "请填写标签",
+          "format": "逗号分隔的 key=value",
+          "conflict": "节点可能同时匹配另一个型号，请再加一个标签"
+        }
+      }
     }
   },
   "events": {
diff --git a/web/src/modules/inferences/profile-lib.test.ts b/web/src/modules/inferences/profile-lib.test.ts
index 996da2f..9ca21a1 100644
--- a/web/src/modules/inferences/profile-lib.test.ts
+++ b/web/src/modules/inferences/profile-lib.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { SiteProfile } from "@swiss/lib/api";
-import { fromRows, markDefault, profileErrors, toRows } from "@/modules/inferences/profile-lib";
+import { fromRows, markDefault, profileErrors, toRows, withNodes } from "@/modules/inferences/profile-lib";
 
 describe("key-value rows", () => {
   it("round-trips a table and drops rows without a key", () => {
@@ -25,3 +25,28 @@ describe("markDefault", () => {
     expect(markDefault(cs, 0, false).map((c) => c.default)).toEqual([false, undefined]);
   });
 });
+
+describe("profileErrors with catalogs", () => {
+  it("blocks the save on a bad catalog row", () => {
+    expect(profileErrors({ name: "x", model: { pathTemplate: "/m" }, catalogs: [{ name: "", url: "/c" }] } as SiteProfile)).toEqual(["catalogs"]);
+  });
+});
+
+describe("nodes", () => {
+  const aliases = { "Ascend-910B3": ["accelerator=huawei-Ascend910"] };
+
+  it("keeps the aliases when GPUs per node is edited, and the reverse", () => {
+    expect(withNodes({ gpusPerNode: 8, gpuProductAliases: aliases }, { gpusPerNode: 16 })).toEqual({ gpusPerNode: 16, gpuProductAliases: aliases });
+    expect(withNodes({ gpusPerNode: 8, gpuProductAliases: aliases }, { gpusPerNode: undefined })).toMatchObject({ gpuProductAliases: aliases });
+    expect(withNodes({ gpusPerNode: 8 }, { gpuProductAliases: aliases })).toEqual({ gpusPerNode: 8, gpuProductAliases: aliases });
+    expect(withNodes({ gpusPerNode: 8 }, { gpusPerNode: undefined })).toBeUndefined();
+  });
+
+  it("blocks the save on a bad alias", () => {
+    const p: SiteProfile = { name: "c", model: { pathTemplate: "/m" } };
+    expect(profileErrors({ ...p, nodes: { gpuProductAliases: aliases } })).toEqual([]);
+    expect(profileErrors({ ...p, nodes: { gpuProductAliases: { A: ["accelerator"] } } })).toEqual(["gpuAliases"]);
+    expect(profileErrors({ ...p, nodes: { gpuProductAliases: { A: ["a=1"], B: ["b=1"] } } })).toEqual(["gpuAliases"]);
+  });
+});
+
diff --git a/web/src/modules/inferences/profile-lib.ts b/web/src/modules/inferences/profile-lib.ts
index 94dddb9..daef887 100644
--- a/web/src/modules/inferences/profile-lib.ts
+++ b/web/src/modules/inferences/profile-lib.ts
@@ -1,4 +1,5 @@
 import type { SiteProfile } from "@swiss/lib/api";
+import { aliasErrors, aliasRows, catalogErrors } from "@swiss/lib/profile";
 
 export interface Row {
   key: string;
@@ -16,13 +17,22 @@ export function fromRows(rows: Row[]): Record<string, string> | undefined {
   return kept.length ? Object.fromEntries(kept.map((r) => [r.key.trim(), r.value])) : undefined;
 }
 
-export function profileErrors(p: SiteProfile): ("name" | "pathTemplate")[] {
-  const errs: ("name" | "pathTemplate")[] = [];
+export function profileErrors(p: SiteProfile): ("name" | "pathTemplate" | "catalogs" | "gpuAliases")[] {
+  const errs: ("name" | "pathTemplate" | "catalogs" | "gpuAliases")[] = [];
   if (!p.name?.trim()) errs.push("name");
   if (!p.model?.pathTemplate?.trim()) errs.push("pathTemplate");
+  if (catalogErrors(p.catalogs).some((e) => e.name || e.url)) errs.push("catalogs");
+  if (aliasErrors(aliasRows(p.nodes?.gpuProductAliases)).some((e) => e.product || e.selector)) errs.push("gpuAliases");
   return errs;
 }
 
+// nodes with one field replaced: the others ride along, and nothing set is no
+// nodes section at all.
+export function withNodes(nodes: SiteProfile["nodes"], patch: NonNullable<SiteProfile["nodes"]>): SiteProfile["nodes"] {
+  const next = { ...nodes, ...patch };
+  return next.gpusPerNode === undefined && !next.gpuProductAliases ? undefined : next;
+}
+
 // One catalog marked default at most: marking one clears the others.
 export function markDefault(catalogs: NonNullable<SiteProfile["catalogs"]>, index: number, on: boolean) {
   return catalogs.map((c, i) => ({ ...c, default: i === index ? on : on ? false : c.default }));
diff --git a/web/src/modules/inferences/tabs/Overview.tsx b/web/src/modules/inferences/tabs/Overview.tsx
index d8556fa..c13cbd2 100644
--- a/web/src/modules/inferences/tabs/Overview.tsx
+++ b/web/src/modules/inferences/tabs/Overview.tsx
@@ -18,6 +18,7 @@ import { AccessPoint } from "@swiss/components/Endpoint";
 import { useT } from "@/modules/inferences/i18n";
 import { installSteps, modelLine, releaseState, type Step, type StepState } from "@/modules/inferences/lib";
 import { StatusDot } from "@/modules/inferences/components/StatusDot";
+import { InstallMethodLabel } from "@/modules/inferences/components/InstallMethodLabel";
 import { LoadHint } from "@/modules/inferences/components/LoadHint";
 import { EventRow, useReleaseEvents } from "@/modules/inferences/tabs/Events";
 
@@ -87,6 +88,7 @@ export function Overview({
               { label: t("detail.fields.catalog"), value: catalog },
               { label: t("detail.fields.chart"), value: plan && `${plan.chart.name}-${plan.chart.version}` },
               { label: t("detail.fields.revision"), value: s.exists ? String(s.revision) : undefined },
+              { label: t("deploy.fields.applyWith"), value: s.backend && <InstallMethodLabel method={s.backend} /> },
               { label: t("detail.fields.route"), value: s.route && <code className="font-mono text-xs">/{s.route}/</code> },
               { label: t("detail.fields.namespace"), value: namespace },
               { label: t("detail.fields.updated"), value: updated && formatDateTime(updated) },
diff --git a/web/src/modules/swiss/components/CatalogChoice.tsx b/web/src/modules/swiss/components/CatalogChoice.tsx
index 4c4175e..ec63b17 100644
--- a/web/src/modules/swiss/components/CatalogChoice.tsx
+++ b/web/src/modules/swiss/components/CatalogChoice.tsx
@@ -1,7 +1,7 @@
 import { Link, useSearchParams } from "@swiss/lib/host";
 import { useQuery } from "@tanstack/react-query";
 import { Library } from "lucide-react";
-import { api, type CatalogInfo } from "@swiss/lib/api";
+import { api, type CatalogInfo, type CatalogSchema } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
 import { Empty } from "@swiss/components/States";
 
@@ -101,6 +101,7 @@ export function CatalogGate({
               <span className="flex items-center gap-2 font-semibold">
                 {c.name}
                 {c.default && <Badge variant="muted">default</Badge>}
+                <SchemaBadge schema={c.schema} />
               </span>
               <span className="mt-0.5 block font-mono text-xs break-all text-muted-foreground">{c.url}</span>
               {!c.ref && <span className="mt-1 block text-xs text-warning">could not be read right now</span>}
@@ -134,7 +135,9 @@ export function CatalogSwitch({
       >
         {catalogs.map((c) => (
           <option key={c.name} value={c.name}>
-            {c.default ? `${c.name} (default)` : c.name}
+            {c.name}
+            {c.default ? " (default)" : ""}
+            {c.schema === "v1" ? " · v1 legacy" : ""}
           </option>
         ))}
       </select>
@@ -154,3 +157,17 @@ export function CatalogBadge({ name, show }: { name: string; show: boolean }) {
     </Badge>
   );
 }
+
+// v1 is marked: the legacy schema, read-only. v2 is what a catalog should be
+// set to, so it needs no badge.
+export function SchemaBadge({ schema }: { schema?: CatalogSchema }) {
+  if (schema !== "v1") return null;
+  return (
+    <Badge
+      variant="warning"
+      title="Catalog schema v1 is the read-only legacy index, and what a catalog with no schemaVersion reads. Set schemaVersion: v2 on it in the site profile."
+    >
+      v1 legacy
+    </Badge>
+  );
+}
diff --git a/web/src/modules/swiss/components/CatalogModelDiff.test.ts b/web/src/modules/swiss/components/CatalogModelDiff.test.ts
index ae7dddb..8f4ca1f 100644
--- a/web/src/modules/swiss/components/CatalogModelDiff.test.ts
+++ b/web/src/modules/swiss/components/CatalogModelDiff.test.ts
@@ -1,37 +1,27 @@
 import { describe, expect, it } from "vitest";
-import type { Entry } from "@swiss/lib/api";
+import type { Variant } from "@swiss/lib/api";
 import { catalogValues, lineDiff, modelText } from "./CatalogModelDiff";
 
-const entry = {
-  apiVersion: "catalog.swiss/v1",
-  name: "m",
+const variant = {
+  id: "v",
   version: "1.0.0",
+  digest: "sha256:def",
   servedName: "served",
-  source: { hf: "org/m" },
-  variants: [
-    {
-      id: "v",
-      engine: "sglang",
-      chart: { name: "sglang", version: "0.8.0" },
-      requires: { gpus: 2 },
-      image: { repository: "repo", tag: "t", digest: "sha256:abc" },
-      values: { extraArgs: ["--tp-size=2"], model: { name: "from-values" } },
-    },
-  ],
-} as Entry;
+  engine: "sglang",
+  chart: { name: "sglang", version: "0.8.0" },
+  requires: { gpus: 2 },
+  image: { repository: "repo", tag: "t", digest: "sha256:abc" },
+  values: { extraArgs: ["--tp-size=2"], model: { name: "from-values" } },
+} as Variant;
 
 describe("catalogValues", () => {
-  it("projects a variant the way the catalog layer does", () => {
-    expect(catalogValues(entry, "v").tree).toEqual({
+  it("projects a variant the way the catalog layer does, image digest left out", () => {
+    expect(catalogValues(variant).tree).toEqual({
       extraArgs: ["--tp-size=2"],
       model: { name: "served", gpus: "2" },
-      image: { repository: "repo", tag: "t", digest: "sha256:abc" },
+      image: { repository: "repo", tag: "t" },
     });
   });
-
-  it("is empty when the variant is no longer listed", () => {
-    expect(catalogValues(entry, "missing")).toEqual({});
-  });
 });
 
 describe("modelText", () => {
diff --git a/web/src/modules/swiss/components/CatalogModelDiff.tsx b/web/src/modules/swiss/components/CatalogModelDiff.tsx
index a8519df..b8210e4 100644
--- a/web/src/modules/swiss/components/CatalogModelDiff.tsx
+++ b/web/src/modules/swiss/components/CatalogModelDiff.tsx
@@ -1,5 +1,5 @@
 import { useQuery } from "@tanstack/react-query";
-import { api, type Entry } from "@swiss/lib/api";
+import { api, type Variant } from "@swiss/lib/api";
 import { toYaml } from "@swiss/lib/yaml";
 import { Badge } from "@swiss/components/ui/badge";
 import { Dialog } from "@swiss/components/ui/dialog";
@@ -34,15 +34,15 @@ export function CatalogModelDiff({
 }) {
   const ready = !!model && !!version && !!variant;
   const entry = useQuery({
-    queryKey: ["catalog-model", catalog, model, version],
-    queryFn: () => api.model(model!, version, catalog),
+    queryKey: ["catalog-model", catalog, model, variant, version],
+    queryFn: () => api.model(model!, { catalog, variant, version }),
     enabled: open && ready,
     retry: false,
     staleTime: Infinity,
   });
 
-  const published = entry.data ? catalogValues(entry.data.entry, variant!) : undefined;
-  const publishedVariant = entry.data?.entry.variants.find((item) => item.id === variant);
+  const publishedVariant = entry.data?.variant;
+  const published = publishedVariant ? catalogValues(publishedVariant) : undefined;
   const diff =
     published?.tree && publishedVariant
       ? lineDiff(
@@ -71,10 +71,6 @@ export function CatalogModelDiff({
         <ErrorState what="the catalog model" error={entry.error} />
       ) : published?.error ? (
         <p className="text-sm text-muted-foreground">{published.error}</p>
-      ) : published && !published.tree ? (
-        <p className="text-sm text-muted-foreground">
-          The catalog no longer lists variant {variant} on version {version}.
-        </p>
       ) : (
         <div className="space-y-3">
           <div className="flex flex-wrap items-center gap-2 text-sm">
@@ -97,14 +93,11 @@ export function CatalogModelDiff({
   );
 }
 
-export function catalogValues(
-  entry: Entry,
-  variantId: string,
-): { tree?: Record<string, unknown>; error?: string } {
-  const variant = entry.variants.find((item) => item.id === variantId);
-  if (!variant) return {};
+// The catalog layer compose writes for a variant. A variant's image.digest stays
+// out, as it does there: the charts' schema rejects it.
+export function catalogValues(variant: Variant): { tree?: Record<string, unknown>; error?: string } {
   const tree: Record<string, unknown> = structuredClone(variant.values ?? {});
-  const name = setPath(tree, "model.name", entry.servedName || entry.name);
+  const name = setPath(tree, "model.name", variant.servedName);
   if (name) return { error: name };
   const gpus = setPath(tree, "model.gpus", String(variant.requires.gpus));
   if (gpus) return { error: gpus };
@@ -112,7 +105,6 @@ export function catalogValues(
     for (const [key, value] of [
       ["image.repository", variant.image.repository],
       ["image.tag", variant.image.tag],
-      ["image.digest", variant.image.digest],
     ] as const) {
       if (!value) continue;
       const err = setPath(tree, key, value);
diff --git a/web/src/modules/swiss/components/DeploySettings.tsx b/web/src/modules/swiss/components/DeploySettings.tsx
index 489e6b8..915f1b7 100644
--- a/web/src/modules/swiss/components/DeploySettings.tsx
+++ b/web/src/modules/swiss/components/DeploySettings.tsx
@@ -1,7 +1,8 @@
 import { useState } from "react";
-import { ChevronDown, Plus, X } from "lucide-react";
+import { ChevronDown, Plus, TriangleAlert, X } from "lucide-react";
 import type { ClusterInfo, Plan, PlanRequest, Variant } from "@swiss/lib/api";
 import { cn } from "@swiss/lib/utils";
+import { productChoices, unlistedProducts } from "@swiss/lib/gpu";
 import {
   DIRECTIVES,
   DIRECTIVES_BY_KEY,
@@ -137,8 +138,9 @@ export function DeploySettings({
   image?: { catalog: string; site: string };
   lockIdentity?: boolean;
   readOnly?: boolean;
-  // Products the chosen variant declares, and those a node in this cluster
-  // actually reports. The intersection is what is worth offering.
+  // Products the chosen variant declares, and those this cluster reports on
+  // nodes of the variant's vendor. Every one of the second is offered; one the
+  // first does not name is marked, and selecting it is a forced deploy.
   supportedGPUs?: string[];
   clusterGPUs?: string[];
 }) {
@@ -621,7 +623,8 @@ export function DeploySettings({
             <Products
               selected={form.gpuProducts}
               onChange={(v) => onChange({ gpuProducts: v })}
-              options={gpuOptions(supportedGPUs, clusterGPUs)}
+              options={productChoices(supportedGPUs, clusterGPUs, form.gpuProducts)}
+              listed={supportedGPUs}
             />
           </Row>
           <Row label="Tolerations" note="lets this deploy land on tainted GPU nodes">
@@ -726,9 +729,6 @@ function Row({
   );
 }
 
-// The products worth offering are those the variant declares and a node in
-// this cluster reports. Either list alone is a guess: the catalog does not know
-// what is racked here, and the cluster does not know what the model supports.
 function tolerationsOf(o: Record<string, unknown>): Toleration[] {
   if (!Array.isArray(o.tolerations)) return [];
   return o.tolerations.flatMap((t): Toleration[] => {
@@ -775,13 +775,6 @@ function gpuProductsOf(o: Record<string, unknown>): string[] {
   return [];
 }
 
-function gpuOptions(supported?: string[], present?: string[]): string[] {
-  const has = new Set(present?.filter(Boolean) ?? []);
-  if (!supported?.length) return [...has].sort();
-  const both = supported.filter((p) => has.has(p));
-  return (both.length ? both : supported).slice().sort();
-}
-
 // Tab fills an empty field with the default it is showing, the way a shell
 // completes: the field is no longer empty afterwards, so the next Tab moves on.
 function accept(
@@ -1000,14 +993,19 @@ function Select({
   );
 }
 
+// Products offers every card of the variant's vendor on this cluster, the ones
+// the catalog lists first and the rest after an "untested" mark: the catalog
+// does not know what is racked here.
 function Products({
   selected,
   onChange,
   options,
+  listed,
 }: {
   selected: string[];
   onChange: (v: string[]) => void;
   options: string[];
+  listed?: string[];
 }) {
   if (options.length === 0) {
     return (
@@ -1016,32 +1014,53 @@ function Products({
       </span>
     );
   }
+  const untested = (o: string) => unlistedProducts(listed, [o]).length > 0;
+  const supported = options.filter((o) => !untested(o));
+  const others = options.filter(untested);
+  const forced = unlistedProducts(listed, selected);
+  const chip = (o: string) => {
+    const active = selected.includes(o);
+    const off = untested(o);
+    return (
+      <button
+        key={o}
+        type="button"
+        aria-pressed={active}
+        title={off ? "untested with this variant" : undefined}
+        onClick={() => onChange(active ? selected.filter((p) => p !== o) : [...selected, o])}
+        className={cn(
+          "inline-flex items-center gap-1 rounded-full border px-2.5 py-1 text-xs transition-colors",
+          !active && "bg-background text-muted-foreground hover:border-foreground/30 hover:text-foreground",
+          active && !off && "border-success/40 bg-success/15 font-medium text-success",
+          active && off && "border-warning/50 bg-warning/15 font-medium text-warning",
+        )}
+      >
+        {active && off && <TriangleAlert className="size-3" />}
+        {o}
+      </button>
+    );
+  };
   return (
-    <div className="flex w-full flex-wrap gap-1.5">
-      {options.map((o) => {
-        const active = selected.includes(o);
-        return (
-          <button
-            key={o}
-            type="button"
-            aria-pressed={active}
-            onClick={() =>
-              onChange(active ? selected.filter((p) => p !== o) : [...selected, o])
-            }
-            className={
-              active
-                ? "rounded-full border border-success/40 bg-success/15 px-2.5 py-1 text-xs font-medium text-success"
-                : "rounded-full border bg-background px-2.5 py-1 text-xs text-muted-foreground hover:border-foreground/30 hover:text-foreground"
-            }
-          >
-            {o}
-          </button>
-        );
-      })}
-      {selected.length === 0 && (
-        <span className="self-center text-xs text-muted-foreground">
-          none selected — any product the variant supports
-        </span>
+    <div className="w-full space-y-1.5">
+      {/* Two units, so a wrap moves the label with its chips. */}
+      <div className="flex flex-wrap items-center gap-x-3 gap-y-1.5">
+        {supported.length > 0 && (
+          <span className="inline-flex flex-wrap items-center gap-1.5">{supported.map(chip)}</span>
+        )}
+        {others.length > 0 && (
+          <span className="inline-flex flex-wrap items-center gap-1.5">
+            <span className="text-[11px] text-muted-foreground">untested</span>
+            {others.map(chip)}
+          </span>
+        )}
+      </div>
+      {forced.length > 0 ? (
+        <p className="flex items-center gap-1.5 text-xs text-warning">
+          <TriangleAlert className="size-3.5 shrink-0" />
+          {forced.join(", ")} untested with this variant, deployed as forced
+        </p>
+      ) : (
+        selected.length === 0 && <p className="text-xs text-muted-foreground">none selected: any supported product</p>
       )}
     </div>
   );
@@ -1327,6 +1346,9 @@ export function planRequest(
     fromRelease?: string;
     catalog?: string;
     chartVersion?: string;
+    // Accept gpuProducts the variant does not list; swissd still requires each
+    // on this cluster under the variant's vendor.
+    forceGpuProducts?: boolean;
   },
 ): PlanRequest {
   const overrides: Record<string, unknown> = {};
@@ -1428,6 +1450,7 @@ export function planRequest(
     version: opts.version || undefined,
     editsYAML: f.edits.trim() || undefined,
     gpuProducts: f.gpuProducts.length ? f.gpuProducts : undefined,
+    forceGpuProducts: f.gpuProducts.length > 0 && opts.forceGpuProducts ? true : undefined,
     variant: opts.variant || undefined,
     release: f.serviceId.trim() || undefined,
     namespace: f.namespace.trim() || undefined,
diff --git a/web/src/modules/swiss/components/InstallMethod.tsx b/web/src/modules/swiss/components/InstallMethod.tsx
new file mode 100644
index 0000000..0796972
--- /dev/null
+++ b/web/src/modules/swiss/components/InstallMethod.tsx
@@ -0,0 +1,64 @@
+import type { ApplyWith } from "@swiss/lib/api";
+import type { LLMSVCBlock } from "@swiss/lib/applyWith";
+import { Badge } from "@swiss/components/ui/badge";
+import { cn } from "@swiss/lib/utils";
+
+export const METHODS: Record<ApplyWith, { label: string; hint: string }> = {
+  helm: { label: "Plan ConfigMap", hint: "swissd runs helm and keeps the plan in a ConfigMap beside the release." },
+  llmsvc: { label: "LLMService", hint: "swissd writes an LLMService and llm-operator runs helm from it." },
+};
+
+const BLOCKED: Record<LLMSVCBlock, string> = {
+  unserved: "the LLMService CRD is not served on this cluster",
+  unavailable: "swissd cannot use LLMServices here; see the cluster warnings",
+  schema: "LLMService installs need a catalog schema v2 model",
+};
+
+export function InstallMethodChoice({
+  value,
+  onChange,
+  blocked,
+  fallback,
+}: {
+  value: ApplyWith;
+  onChange: (m: ApplyWith) => void;
+  blocked?: LLMSVCBlock;
+  // What an install naming none gets: the site profile's applyWith.
+  fallback: ApplyWith;
+}) {
+  return (
+    <div role="radiogroup" aria-label="install method" className="grid gap-2 sm:grid-cols-2">
+      {(["helm", "llmsvc"] as const).map((m) => {
+        const disabled = m === "llmsvc" && !!blocked;
+        return (
+          <label
+            key={m}
+            className={cn(
+              "flex items-start gap-2 rounded-md border p-3 text-sm",
+              value === m && "border-primary",
+              disabled ? "cursor-not-allowed opacity-60" : "cursor-pointer",
+            )}
+          >
+            <input
+              type="radio"
+              name="applyWith"
+              className="mt-1"
+              checked={value === m}
+              disabled={disabled}
+              onChange={() => onChange(m)}
+            />
+            <span className="space-y-0.5">
+              <span className="flex items-center gap-2 font-medium">
+                {METHODS[m].label}
+                {m === fallback && <Badge variant="muted">default</Badge>}
+              </span>
+              <span className="block text-xs text-muted-foreground">
+                {disabled ? `Unavailable: ${BLOCKED[blocked!]}.` : METHODS[m].hint}
+              </span>
+            </span>
+          </label>
+        );
+      })}
+    </div>
+  );
+}
diff --git a/web/src/modules/swiss/components/Pipeline.tsx b/web/src/modules/swiss/components/Pipeline.tsx
index f6e0dc3..5a8a256 100644
--- a/web/src/modules/swiss/components/Pipeline.tsx
+++ b/web/src/modules/swiss/components/Pipeline.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { CircleCheck, FlaskConical, Layers, Loader2, Rocket, TriangleAlert, Undo2 } from "lucide-react";
-import { api, deployApi, type ApplyResult, type DiffResult, type Plan } from "@swiss/lib/api";
+import { api, deployApi, type ApplyResult, type ApplyWith, type DiffResult, type Plan } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
 import { Button } from "@swiss/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@swiss/components/ui/card";
@@ -14,6 +14,7 @@ import { DiffView } from "@swiss/components/DiffView";
 import { Provenance } from "@swiss/components/Provenance";
 import { ReleaseStatus } from "@swiss/components/ReleaseStatus";
 import { Empty, ErrorState } from "@swiss/components/States";
+import { METHODS } from "@swiss/components/InstallMethod";
 
 // Pipeline is compose -> dry run -> apply -> status, shared by Deploy, Upgrade
 // and rollback.
@@ -43,6 +44,7 @@ export function Pipeline({
   onDiff,
   onApplied,
   rollbackTo,
+  applyWith,
   children,
 }: {
   namespace: string;
@@ -62,6 +64,8 @@ export function Pipeline({
   // re-applied. There is nothing to compose -- the plan came out of the
   // cluster exactly as it ran -- so the button opens the dialog directly.
   rollbackTo?: number;
+  // How an install stores the release. An existing release keeps its own.
+  applyWith?: ApplyWith;
   // Rendered on the Plan tab above the composed plan: what moves, on upgrade.
   children?: React.ReactNode;
 }) {
@@ -117,6 +121,7 @@ export function Pipeline({
   });
   const exists = diff?.exists ?? live.data?.exists;
   const install = exists === false;
+  const method = install ? applyWith : live.data?.backend;
 
   const applyM = useMutation({
     mutationFn: () =>
@@ -132,7 +137,7 @@ export function Pipeline({
             note.trim(),
           )
         : install
-          ? deployApi.install(plan!.hash, note.trim())
+          ? deployApi.install(plan!.hash, note.trim(), applyWith)
           : // expectRevision is the optimistic lock the dry run computed. It
             // always exists here: nothing reaches this call without one.
             deployApi.apply(plan!.hash, diff?.revision, note.trim(), force),
@@ -239,6 +244,11 @@ export function Pipeline({
                 chart {plan.chart.name}-{plan.chart.version}
               </span>
               <span className="font-mono text-xs break-all">{plan.hash}</span>
+              {method && (
+                <Badge variant="muted" title={install ? "install method" : "installed with this; it does not change"}>
+                  {METHODS[method].label}
+                </Badge>
+              )}
             </span>
           )
         }
@@ -249,6 +259,7 @@ export function Pipeline({
               known={known}
               rollbackTo={rollbackTo}
               install={install}
+              method={method}
               diff={diff}
               applied={applied}
               note={note}
@@ -298,6 +309,17 @@ export function Pipeline({
         {tab === "plan" && plan && (
           <div className="space-y-4">
             {children}
+            {/* What compose accepted but a person should see; kept with the release. */}
+            {!!plan.warnings?.length && (
+              <div className="space-y-1 rounded-md border border-warning/40 bg-warning/10 p-3 text-sm text-warning">
+                {plan.warnings.map((w) => (
+                  <p key={w} className="flex items-start gap-2">
+                    <TriangleAlert className="mt-0.5 size-4 shrink-0" />
+                    {w}
+                  </p>
+                ))}
+              </div>
+            )}
             <Card>
               <CardHeader>
                 <CardTitle className="text-base">Composed plan</CardTitle>
@@ -366,6 +388,7 @@ function Action({
   known,
   rollbackTo,
   install,
+  method,
   diff,
   applied,
   note,
@@ -384,6 +407,7 @@ function Action({
   known: boolean;
   rollbackTo?: number;
   install: boolean;
+  method?: ApplyWith;
   diff: DiffResult | null;
   applied: ApplyResult | null;
   note: string;
@@ -415,8 +439,9 @@ function Action({
       }.`
     : canApply && diff
       ? (diff.exists
-          ? `Asserting the release is still at revision ${diff.revision}.`
-          : "The release does not exist; this creates it.") +
+          ? `Asserting the release is still at revision ${diff.revision}.` +
+            (method ? ` Install method stays ${METHODS[method].label}.` : "")
+          : `The release does not exist; this creates it${method ? ` with ${METHODS[method].label}` : ""}.`) +
         (force ? " Fields a hand edit left kubectl owning will be overwritten." : "")
       : "";
 
diff --git a/web/src/modules/swiss/components/ProfileEditor.tsx b/web/src/modules/swiss/components/ProfileEditor.tsx
index 3750a09..ff1c105 100644
--- a/web/src/modules/swiss/components/ProfileEditor.tsx
+++ b/web/src/modules/swiss/components/ProfileEditor.tsx
@@ -5,6 +5,7 @@ import { api, type SiteProfile } from "@swiss/lib/api";
 import { Button } from "@swiss/components/ui/button";
 import { ErrorState } from "@swiss/components/States";
 import { ProfileForm } from "@swiss/components/ProfileForm";
+import { markSetUp } from "@swiss/components/Session";
 
 type Mode = "form" | "yaml";
 
@@ -39,7 +40,7 @@ export function ProfileEditor({
     mutationFn: () => (mode === "form" ? api.saveProfile({ profile: form }) : api.saveProfile({ yaml })),
     onSuccess: (saved) => {
       qc.setQueryData(["profile"], saved);
-      qc.invalidateQueries({ queryKey: ["session"] });
+      markSetUp(qc);
       qc.invalidateQueries({ queryKey: ["cluster"] });
       // Whichever half was not edited is now stale. A save that came back
       // without a profile did not parse, which the server refuses -- so this is
diff --git a/web/src/modules/swiss/components/ProfileForm.tsx b/web/src/modules/swiss/components/ProfileForm.tsx
index fd6f96d..e81ae75 100644
--- a/web/src/modules/swiss/components/ProfileForm.tsx
+++ b/web/src/modules/swiss/components/ProfileForm.tsx
@@ -5,6 +5,8 @@ import { api, type Site, type SiteProfile } from "@swiss/lib/api";
 import { Button } from "@swiss/components/ui/button";
 import { Field, Input } from "@swiss/components/ui/input";
 import { Switch } from "@swiss/components/ui/switch";
+import { aliasErrors, aliasMap, aliasRows, catalogErrors, type AliasRow } from "@swiss/lib/profile";
+import { cn } from "@swiss/lib/utils";
 
 // ProfileForm edits the site profile field by field, which is how it is
 // normally edited: the document is a fixed set of cluster facts, not free-form
@@ -76,18 +78,37 @@ export function ProfileForm({
             onChange={(e) => setIn("nodes", { gpusPerNode: num(e.target.value) })}
           />
         </Field>
+        {/* Not a Field: that is a <label>, and these rows hold several controls. */}
+        <div className="space-y-1 sm:col-span-2">
+          <span className="text-sm font-medium">GPU product aliases</span>
+          <GpuAliases
+            value={value.nodes?.gpuProductAliases}
+            onChange={(gpuProductAliases) => setIn("nodes", { gpuProductAliases })}
+          />
+          <p className="text-xs text-muted-foreground">
+            For nodes a vendor install does not label with the catalog's GPU product name. Each row names a
+            catalog product and a node label selector, every key=value of which must match. A node matching two
+            products takes the one with more pairs. The GPU view then reports the catalog's name, and a deploy
+            restricted to that product may land on the node.
+          </p>
+        </div>
       </Group>
 
       <Group
         title="Catalog, charts and images"
         hint="Where the models come from, and the registries the catalog deliberately does not name."
       >
-        <Field
-          label="Catalogs"
-          hint="Each an https base or an absolute path, under the name the pages select it by. With several, pages open in the one marked default, or ask which one first when none is. Set here they win over swissd's config file, so catalogs change without a helm upgrade."
-        >
+        {/* Not a Field: that is a <label>, and these rows hold several controls. */}
+        <div className="space-y-1 sm:col-span-2">
+          <span className="text-sm font-medium">Catalogs</span>
           <Catalogs value={catalogs} onChange={setCatalogs} configured={configuredCatalog} />
-        </Field>
+          <p className="text-xs text-muted-foreground">
+            Each an https base or an absolute path, under the name the pages select it by. With several, pages
+            open in the one marked default, or ask which one first when none is. Set here they win over
+            swissd's config file, so catalogs change without a helm upgrade. Schema v2 is recommended; v1 is
+            the read-only legacy index, and what a catalog with no schema set reads.
+          </p>
+        </div>
         <Field label="Chart repo" hint="An https helm repo or oci:// registry, e.g. https://modelsphere.github.io/helm-charts. Empty means a local chart path.">
           <Input
             value={value.chartRepo ?? ""}
@@ -291,7 +312,7 @@ export function ProfileForm({
   );
 }
 
-type CatalogRepo = { name: string; url: string; default?: boolean };
+type CatalogRepo = NonNullable<SiteProfile["catalogs"]>[number];
 
 // Catalogs is the list a page selects from. swissd refuses the profile over a
 // row without a name or url, a name that is not lowercase, a name or url listed
@@ -307,17 +328,9 @@ function Catalogs({
 }) {
   const patch = (i: number, p: Partial<CatalogRepo>) =>
     onChange(value.map((c, j) => (i === j ? { ...c, ...p } : c)));
-  const names = value.map((c) => c.name.trim());
-  const urls = value.map((c) => c.url.trim());
-  const problem = value.some(
-    (_, i) =>
-      !names[i] ||
-      !urls[i] ||
-      !/^[a-z0-9][a-z0-9._-]*$/.test(names[i]) ||
-      names.indexOf(names[i]) !== i ||
-      urls.indexOf(urls[i]) !== i ||
-      !/^(https?:\/\/|\/)/.test(urls[i]),
-  );
+  const errs = catalogErrors(value);
+  const problem = errs.some((e) => e.name || e.url);
+  const bad = "border-destructive";
 
   return (
     <div className="space-y-2">
@@ -335,21 +348,33 @@ function Catalogs({
       {value.map((c, i) => (
         <div key={i} className="flex flex-wrap items-center gap-2">
           <Input
-            className="w-40"
+            className={cn("w-40", errs[i].name && bad)}
+            aria-invalid={!!errs[i].name}
             value={c.name}
             onChange={(e) => patch(i, { name: e.target.value })}
             placeholder="name"
             aria-label="catalog name"
           />
           <Input
-            className="min-w-0 flex-1 font-mono text-xs"
+            className={cn("min-w-64 flex-1 font-mono text-xs", errs[i].url && bad)}
+            aria-invalid={!!errs[i].url}
             value={c.url}
             onChange={(e) => patch(i, { url: e.target.value })}
             placeholder="https://modelsphere.github.io/model-catalog/"
             aria-label="catalog url"
           />
+          {/* Unset is v1, so v1 is written as unset. */}
+          <select
+            className="h-9 w-44 rounded-md border bg-background px-3 text-sm"
+            value={c.schemaVersion === "v2" ? "v2" : ""}
+            onChange={(e) => patch(i, { schemaVersion: e.target.value === "v2" ? "v2" : undefined })}
+            aria-label={`schema of ${c.name || "catalog"}`}
+          >
+            <option value="">v1 · legacy</option>
+            <option value="v2">v2 · recommended</option>
+          </select>
           {/* At most one default: checking one clears the others. */}
-          <label className="inline-flex items-center gap-1.5 text-xs text-muted-foreground">
+          <label className="inline-flex items-center gap-1.5 text-sm text-muted-foreground">
             <input
               type="checkbox"
               checked={!!c.default}
@@ -371,15 +396,16 @@ function Catalogs({
       ))}
       {problem && (
         <p className="text-xs text-warning">
-          Every catalog needs a unique lowercase name and a unique url starting with http://, https:// or
-          /; swissd will refuse the profile otherwise.
+          Every catalog needs a unique lowercase name (letters, digits, . - _), and a url starting with
+          http://, https:// or / that is not listed twice under one schema; swissd will refuse the profile
+          otherwise.
         </p>
       )}
       <Button
         type="button"
         size="sm"
         variant="outline"
-        onClick={() => onChange([...value, { name: "", url: "" }])}
+        onClick={() => onChange([...value, { name: "", url: "", schemaVersion: "v2" }])}
       >
         <Plus className="size-4" /> Add catalog
       </Button>
@@ -387,6 +413,70 @@ function Catalogs({
   );
 }
 
+// GpuAliases names catalog GPU products by node labels. swissd refuses a row
+// missing either half, a selector that is not key=value pairs, and two products
+// one node could match with as many pairs -- flagged here so the save is not
+// the first to say.
+function GpuAliases({
+  value,
+  onChange,
+}: {
+  value?: Record<string, string[]>;
+  onChange: (v: Record<string, string[]> | undefined) => void;
+}) {
+  // Rows live here while typed; see aliasRows.
+  const [rows, setRows] = useState<AliasRow[]>(() => aliasRows(value));
+  const errs = aliasErrors(rows);
+  const push = (next: AliasRow[]) => {
+    setRows(next);
+    onChange(aliasMap(next));
+  };
+  const patch = (i: number, p: Partial<AliasRow>) => push(rows.map((r, j) => (i === j ? { ...r, ...p } : r)));
+  const bad = "border-destructive";
+
+  return (
+    <div className="space-y-2">
+      {rows.map((r, i) => (
+        <div key={i} className="flex flex-wrap items-center gap-2">
+          <Input
+            className={cn("w-48", errs[i].product && bad)}
+            aria-invalid={!!errs[i].product}
+            value={r.product}
+            onChange={(e) => patch(i, { product: e.target.value })}
+            placeholder="catalog GPU product"
+            aria-label="GPU product"
+          />
+          <Input
+            className={cn("min-w-64 flex-1 font-mono text-xs", errs[i].selector && bad)}
+            aria-invalid={!!errs[i].selector}
+            value={r.selector}
+            onChange={(e) => patch(i, { selector: e.target.value })}
+            placeholder="accelerator=huawei-Ascend910"
+            aria-label="node labels"
+          />
+          <button
+            type="button"
+            onClick={() => push(rows.filter((_, j) => j !== i))}
+            aria-label={`remove ${r.product || "alias"}`}
+            className="rounded-md p-1 text-muted-foreground hover:bg-muted hover:text-foreground"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+      ))}
+      {errs.some((e) => e.product || e.selector) && (
+        <p className="text-xs text-warning">
+          Every alias needs a product and key=value labels, comma separated, and no node may match two products
+          with as many labels; swissd will refuse the profile otherwise.
+        </p>
+      )}
+      <Button type="button" size="sm" variant="outline" onClick={() => setRows([...rows, { product: "", selector: "" }])}>
+        <Plus className="size-4" /> Add alias
+      </Button>
+    </div>
+  );
+}
+
 // Sites is the switcher's list: a name to show and an address to go to. Both
 // are required -- a row missing either is a dead entry in a dropdown -- and
 // swissd refuses the profile rather than rendering one, so the empty state is
diff --git a/web/src/modules/swiss/components/Session.tsx b/web/src/modules/swiss/components/Session.tsx
index cdeb24d..38c2cac 100644
--- a/web/src/modules/swiss/components/Session.tsx
+++ b/web/src/modules/swiss/components/Session.tsx
@@ -1,7 +1,8 @@
 import { createContext, use, useEffect } from "react";
 import { loginPath, Navigate, useLocation } from "@swiss/lib/host";
-import { useQuery, useQueryClient, type UseQueryResult } from "@tanstack/react-query";
+import { useQuery, useQueryClient, type QueryClient, type UseQueryResult } from "@tanstack/react-query";
 import { api, onUnauthorized, type Session } from "@swiss/lib/api";
+import { setupRedirect } from "@swiss/lib/setup";
 import { ErrorState, Loading } from "@swiss/components/States";
 
 // The session is asked for once, at the root, and read from everywhere else.
@@ -25,9 +26,19 @@ export function useSessionQuery(): UseQueryResult<Session> {
   });
 }
 
+// markSetUp follows a profile save. What was just stored parses -- swissd
+// refuses one that does not -- so the site is set up. Said before the session
+// is re-asked, or the gate acts on the old answer and sends the next page back
+// to setup.
+export function markSetUp(qc: QueryClient) {
+  qc.setQueryData<Session>(["session"], (s) => s && { ...s, initialized: true, setUp: true });
+  qc.invalidateQueries({ queryKey: ["session"] });
+}
+
 // Gate is what every page is rendered inside: not logged in goes to the login,
 // and a site with no profile yet goes to the setup page before anything else --
 // there is nothing to show until swissd knows what this cluster looks like.
+// setupRedirect says which pages setup is for.
 export function Gate({ children }: { children: React.ReactNode }) {
   const session = useSessionQuery();
   const { pathname } = useLocation();
@@ -48,8 +59,7 @@ export function Gate({ children }: { children: React.ReactNode }) {
     if (loginPath) return <Navigate to={loginPath} replace state={{ from: pathname }} />;
     return <ErrorState what="swissd" error={new Error("swissd did not accept console; give console swissd's proxyKey (swiss chart auth.proxyKey)")} />;
   }
-  if (!session.data.initialized && !pathname.endsWith("/setup")) {
-    return <Navigate to="/setup" replace />;
-  }
+  const to = setupRedirect(session.data, pathname);
+  if (to) return <Navigate to={to} replace />;
   return <SessionContext value={session.data}>{children}</SessionContext>;
 }
diff --git a/web/src/modules/swiss/components/VariantCard.tsx b/web/src/modules/swiss/components/VariantCard.tsx
index 89b403b..7b75387 100644
--- a/web/src/modules/swiss/components/VariantCard.tsx
+++ b/web/src/modules/swiss/components/VariantCard.tsx
@@ -1,5 +1,5 @@
 import { ChartColumn, ExternalLink } from "lucide-react";
-import type { IndexVariant, Node } from "@swiss/lib/api";
+import type { ModelVariant, Node } from "@swiss/lib/api";
 import { type Kind, httpLink, UPLIFT_HELP } from "@swiss/lib/catalog";
 import { gpuCount, matchesVendor, vendorLabel } from "@swiss/lib/gpu";
 import { Badge } from "@swiss/components/ui/badge";
@@ -25,7 +25,7 @@ export function VariantCard({
   disabled,
   action,
 }: {
-  v: IndexVariant;
+  v: CardVariant;
   kind: Kind;
   // The headline, "+58%", with "on v1.0.0" when measured on another version.
   uplift?: string;
@@ -56,6 +56,11 @@ export function VariantCard({
             {v.id}
             {tags}
             {v.default && <Badge variant="muted">default</Badge>}
+            {v.deprecated && (
+              <Badge variant="destructive" title={typeof v.deprecated === "string" ? v.deprecated : undefined}>
+                deprecated
+              </Badge>
+            )}
             {kind.optimized && (
               <Badge variant="success" title={upliftTitle ? `${upliftTitle}. ${UPLIFT_HELP}` : UPLIFT_HELP}>
                 optimized{uplift && ` ${uplift}`}
@@ -132,7 +137,9 @@ export function VariantCard({
   );
 }
 
-function fitness(v: IndexVariant, nodes?: Node[]): { ok: boolean; text: string } | null {
+type CardVariant = Pick<ModelVariant, "id" | "engine" | "default" | "description" | "link" | "chart" | "requires" | "deprecated">;
+
+function fitness(v: CardVariant, nodes?: Node[]): { ok: boolean; text: string } | null {
   if (!nodes) return null;
   const matching = nodes.filter(
     (n) =>
diff --git a/web/src/modules/swiss/lib/api.ts b/web/src/modules/swiss/lib/api.ts
index 6473472..5639b09 100644
--- a/web/src/modules/swiss/lib/api.ts
+++ b/web/src/modules/swiss/lib/api.ts
@@ -25,6 +25,22 @@ export interface ClusterInfo {
   // The other swissd instances this site knows about, from its profile.
   sites?: Site[];
   warnings?: string[];
+  // Absent from a swissd that predates the LLMService backend.
+  llmservice?: LLMServiceInfo;
+}
+
+// How a release is stored: helm keeps the plan in a ConfigMap beside a release
+// swissd installs; llmsvc is an LLMService that llm-operator installs.
+export type ApplyWith = "helm" | "llmsvc";
+
+export interface LLMServiceInfo {
+  // The CRD is served (discovery, not operator readiness).
+  served: boolean;
+  // An install may name llmsvc: served, and swissd is not known to lack the grant.
+  available?: boolean;
+  // The site profile's applyWith, and what an install naming none gets.
+  applyWith: ApplyWith;
+  newInstalls: ApplyWith;
 }
 
 // One selectable catalog. source is its location as a plan records it, which
@@ -37,6 +53,9 @@ export interface CatalogInfo {
   ref?: string;
   // The catalog a page opens in when none is named.
   default?: boolean;
+  // The index's schema, else the profile's schemaVersion. Absent when neither
+  // says, and from a swissd that predates it.
+  schema?: CatalogSchema;
 }
 
 // One other swissd, by name and address. The url is where a browser goes; no
@@ -65,6 +84,9 @@ export interface Deployment {
   // The path the entrypoint publishes this release on. Absent when the plan
   // names no route.
   route?: string;
+  backend?: ApplyWith;
+  // An LLMService swiss did not write.
+  external?: boolean;
 }
 
 export interface DeploymentsResponse {
@@ -95,24 +117,50 @@ export interface Requires {
   rdma?: boolean;
 }
 
-export interface IndexVariant {
+// v1 is the legacy schema: read-only, and still what a catalog with no
+// schemaVersion reads. v2 is the one new catalogs publish.
+export type CatalogSchema = "v1" | "v2";
+
+// One variant as its catalog lists it now, at its pin: on v2 each variant file
+// has its own version and digest, on v1 every variant shares its entry's.
+export interface ModelVariant {
   id: string;
+  version: string;
+  digest: string;
   engine: string;
   default?: boolean;
   description?: string;
   link?: string;
   chart: Chart;
   requires: Requires;
+  // v2 only.
+  servedName?: string;
+  deprecated?: boolean | string;
+  replaces?: string;
 }
 
-export interface IndexVersion {
-  version: string;
-  path: string;
-  digest: string;
-  variants: IndexVariant[];
+// A variant at a version. Version is absent when the catalog recorded none.
+export interface VariantRef {
+  id: string;
+  version?: string;
 }
 
-export interface IndexModel {
+// A measured result from metadata.yaml: a tuned variant against a baseline,
+// each at the version it was measured at. Display only, and not checked by
+// swissd -- ids may dangle.
+export interface Tuning {
+  baseline: VariantRef;
+  optimized: VariantRef;
+  // The headline: percent gained on the tuning benchmark, 44 meaning +44%.
+  uplift?: number;
+  // Every workload the benchmark ran, when it ran more than one.
+  workloads?: { name: string; uplift: number }[];
+  // A file beside metadata.yaml in the catalog, such as an AutoTune report.
+  report?: string;
+}
+
+// A model as its index lists it now, the same for either schema.
+export interface CatalogModel {
   name: string;
   displayName?: string;
   description?: string;
@@ -120,52 +168,61 @@ export interface IndexModel {
   tags?: string[];
   // true, or the reason as a string. Existing deploys still resolve it.
   deprecated?: boolean | string;
-  tuning?: Tuning[];
   source: { hf: string; revision?: string; sizeGiB?: number };
-  latest: string;
-  versions: IndexVersion[];
-}
-
-// A measured result from metadata.yaml: a tuned variant against a baseline, in
-// one version. Display only, and not checked by swissd -- ids may dangle.
-export interface Tuning {
-  version: string;
-  baseline: string;
-  optimized: string;
-  // The headline: percent gained on the tuning benchmark, 44 meaning +44%.
-  uplift?: number;
-  // Every workload the benchmark ran, when it ran more than one.
-  workloads?: { name: string; uplift: number }[];
-  // A file beside metadata.yaml in the catalog, such as an AutoTune report.
-  report?: string;
+  defaultVariant: string;
+  variants: ModelVariant[];
+  tuning?: Tuning[];
 }
 
 export interface CatalogResponse {
   name: string;
   ref: string;
   source: string;
-  // site is where the catalog's own site is published, perf reports included.
-  index: { apiVersion: string; site?: string; count: number; models: IndexModel[] };
+  schema: CatalogSchema;
+  // Where the catalog's own site is published, perf reports included.
+  site?: string;
+  models: CatalogModel[];
 }
 
-export interface Variant extends IndexVariant {
+// A variant as a deploy composes it, values and image included, at the pin it
+// is composed at.
+export interface Variant extends Omit<ModelVariant, "servedName" | "deprecated" | "replaces"> {
+  servedName: string;
   image?: { repository: string; tag: string; digest?: string };
   values?: Record<string, unknown>;
 }
 
-export interface Entry {
-  apiVersion: string;
-  name: string;
+export interface ModelResponse {
+  ref: string;
+  schema: CatalogSchema;
+  model: CatalogModel;
+  variant: Variant;
+  // What the site's template resolves to for this model, so a form can show
+  // the real default rather than describe the template.
+  localPath?: string;
+  pathTemplate?: string;
+  // Each variant's image after the site's mirror rewrite, by variant id, so the
+  // form can offer that rewrite as a choice.
+  imageRepository?: Record<string, string>;
+}
+
+// One published version of a variant. Commit, releaseDate and subject are v2's.
+export interface CatalogRevision {
   version: string;
-  digest?: string;
-  servedName?: string;
-  displayName?: string;
-  description?: string;
-  family?: string;
-  license?: string;
-  tags?: string[];
-  source: { hf: string; revision?: string; sizeGiB?: number };
-  variants: Variant[];
+  digest: string;
+  releaseDate?: string;
+  commit?: string;
+  subject?: string;
+  // The one the index lists now.
+  current?: boolean;
+}
+
+export interface HistoryResponse {
+  ref: string;
+  schema: CatalogSchema;
+  model: string;
+  variant: string;
+  revisions: CatalogRevision[];
 }
 
 export interface Run {
@@ -221,7 +278,8 @@ export interface SiteProfile {
   namespace?: string;
   // The catalogs this site deploys from. Set here they win over swissd's config
   // file; empty falls back to it.
-  catalogs?: { name: string; url: string; default?: boolean }[];
+  // schemaVersion unset reads v1.
+  catalogs?: { name: string; url: string; schemaVersion?: CatalogSchema; default?: boolean }[];
   // The single-catalog spelling from before the list, read as one catalog
   // named "default". The form rewrites it as catalogs.
   catalog?: string;
@@ -249,7 +307,12 @@ export interface SiteProfile {
     auth?: RouteAuth;
   };
   schedule?: { priorityClassName?: string; schedulerName?: string };
-  nodes?: { gpusPerNode?: number };
+  nodes?: {
+    gpusPerNode?: number;
+    // Catalog GPU product -> node label selectors ("key=value[,key=value]"),
+    // for nodes a vendor install does not label with the catalog's name.
+    gpuProductAliases?: Record<string, string[]>;
+  };
   sites?: Site[];
   extra?: Record<string, unknown>;
 }
@@ -357,9 +420,13 @@ export interface Session {
   authenticated: boolean;
   user?: string;
   expiresAt?: string;
-  // Absent until authenticated: whether the site profile has been written yet.
-  // A fresh install has none, and the first login lands on the setup page.
+  // Absent until authenticated: whether the site profile is stored and parses,
+  // so swissd can compose against it.
   initialized?: boolean;
+  // Whether setup has run: a profile is stored, parsing or not. False only when
+  // swissd found none, which is the one state the setup page is for. Absent
+  // from a swissd older than the field.
+  setUp?: boolean;
   // This swissd runs with no login at all.
   authDisabled?: boolean;
 }
@@ -381,18 +448,13 @@ export const api = {
   // may be left out.
   catalog: (catalog?: string) =>
     get<CatalogResponse>("/api/catalog" + (catalog ? `?catalog=${encodeURIComponent(catalog)}` : "")),
-  model: (name: string, version?: string, catalog?: string) =>
-    // localPath is what the site's template resolves to for this model, so a
-    // form can show the real default rather than describe the template.
-    // imageRepository is each variant's image after the site's mirror rewrite,
-    // by variant id, so the form can offer that rewrite as a choice.
-    get<{
-      ref: string;
-      entry: Entry;
-      localPath?: string;
-      pathTemplate?: string;
-      imageRepository?: Record<string, string>;
-    }>(`/api/catalog/${encodeURIComponent(name)}` + query({ version, catalog })),
+  // A model and one variant of it resolved: the default unless one is named,
+  // at its current version unless one is named.
+  model: (name: string, opts: { catalog?: string; variant?: string; version?: string } = {}) =>
+    get<ModelResponse>(`/api/catalog/${encodeURIComponent(name)}` + query(opts)),
+  // A variant's published versions, newest first; the default's unless one is named.
+  history: (name: string, opts: { catalog?: string; variant?: string } = {}) =>
+    get<HistoryResponse>(`/api/catalog/${encodeURIComponent(name)}/history` + query(opts)),
   // The chart versions a variant's chart.version allows, newest first. A pinned
   // variant has its one; a range lists the chart repository, which can fail.
   chartVersions: (name: string, opts: { catalog?: string; version?: string; variant?: string }) =>
@@ -470,6 +532,9 @@ export interface Plan {
     version?: string;
     digest?: string;
     variant: string;
+    // "v2" when composed from a v2 catalog, whose version and digest pin one
+    // variant file. Absent on v1.
+    schema?: CatalogSchema;
   };
   chart: { name: string; version: string; repo?: string; path?: string };
   engine: string;
@@ -482,6 +547,8 @@ export interface Plan {
   layers: Record<string, Record<string, unknown>>;
   helmfile?: string;
   hash: string;
+  // What compose accepted but a person should see, such as a forced GPU product.
+  warnings?: string[];
 }
 
 export interface DiffResult {
@@ -514,6 +581,9 @@ export interface PlanRequest {
   serviceId?: string;
   localPath?: string;
   gpuProducts?: string[];
+  // Accepts gpuProducts the variant does not list, provided each is on this
+  // cluster under the variant's vendor. The plan then carries a warning.
+  forceGpuProducts?: boolean;
   overrides?: Record<string, unknown>;
   overridesYAML?: string;
   editsYAML?: string;
@@ -573,6 +643,8 @@ export interface ReleaseStatus {
   // Written beside the release on every apply. The only thing that can say an
   // apply was started and never finished -- helm reports the last one that did.
   planStatus?: PlanStatus;
+  // Set when swiss manages the release; it never changes after install.
+  backend?: ApplyWith;
 }
 
 export interface ObjectRef {
@@ -837,8 +909,8 @@ export const deployApi = {
   // decision about this one upgrade rather than about the release.
   apply: (planHash: string, expectRevision?: number, note?: string, forceConflicts?: boolean) =>
     post<ApplyResult>("/api/apply", { planHash, expectRevision, note, forceConflicts }),
-  install: (planHash: string, note?: string) =>
-    post<ApplyResult>("/api/install", { planHash, note }),
+  install: (planHash: string, note?: string, applyWith?: ApplyWith) =>
+    post<ApplyResult>("/api/install", { planHash, note, applyWith }),
   probe: (ns: string, release: string, auth: EntrypointAuth = {}) =>
     post<ProbeResult>(
       `/api/releases/${encodeURIComponent(ns)}/${encodeURIComponent(release)}/probe`,
diff --git a/web/src/modules/swiss/lib/applyWith.test.ts b/web/src/modules/swiss/lib/applyWith.test.ts
new file mode 100644
index 0000000..d67ec77
--- /dev/null
+++ b/web/src/modules/swiss/lib/applyWith.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import type { LLMServiceInfo } from "@swiss/lib/api";
+import { installMethod, llmsvcBlock } from "./applyWith";
+
+const ready: LLMServiceInfo = { served: true, available: true, applyWith: "helm", newInstalls: "helm" };
+
+describe("llmsvcBlock", () => {
+  it("says why llmsvc cannot take an install", () => {
+    expect(llmsvcBlock(undefined, "v2")).toBe("unserved");
+    expect(llmsvcBlock({ ...ready, served: false, available: false }, "v2")).toBe("unserved");
+    expect(llmsvcBlock({ ...ready, available: false }, "v2")).toBe("unavailable");
+    expect(llmsvcBlock({ served: true, applyWith: "helm", newInstalls: "helm" }, "v2")).toBe("unavailable");
+    expect(llmsvcBlock(ready, "v1")).toBe("schema");
+    expect(llmsvcBlock(ready, undefined)).toBe("schema");
+    expect(llmsvcBlock(ready, "v2")).toBeUndefined();
+  });
+});
+
+describe("installMethod", () => {
+  it("defaults to the plan ConfigMap", () => {
+    expect(installMethod(undefined, ready, "v2")).toBe("helm");
+  });
+  it("follows a site profile set to llmsvc", () => {
+    expect(installMethod(undefined, { ...ready, applyWith: "llmsvc", newInstalls: "llmsvc" }, "v2")).toBe("llmsvc");
+  });
+  it("takes the pick over the profile", () => {
+    expect(installMethod("llmsvc", ready, "v2")).toBe("llmsvc");
+    expect(installMethod("helm", { ...ready, applyWith: "llmsvc", newInstalls: "llmsvc" }, "v2")).toBe("helm");
+  });
+  it("falls back to helm when llmsvc is blocked", () => {
+    expect(installMethod("llmsvc", ready, "v1")).toBe("helm");
+    expect(installMethod("llmsvc", { ...ready, available: false }, "v2")).toBe("helm");
+  });
+});
diff --git a/web/src/modules/swiss/lib/applyWith.ts b/web/src/modules/swiss/lib/applyWith.ts
new file mode 100644
index 0000000..db8eaa9
--- /dev/null
+++ b/web/src/modules/swiss/lib/applyWith.ts
@@ -0,0 +1,17 @@
+import type { ApplyWith, CatalogSchema, LLMServiceInfo } from "@swiss/lib/api";
+
+// Why an install cannot use llmsvc: the CRD is not served, swissd cannot use
+// it, or the catalog is not v2 (swissd refuses an LLMService for a v1 plan).
+export type LLMSVCBlock = "unserved" | "unavailable" | "schema";
+
+export function llmsvcBlock(info: LLMServiceInfo | undefined, schema: CatalogSchema | undefined): LLMSVCBlock | undefined {
+  if (!info?.served) return "unserved";
+  if (!info.available) return "unavailable";
+  if (schema !== "v2") return "schema";
+}
+
+// The picked method, else the site profile's; helm whenever llmsvc cannot take it.
+export function installMethod(picked: ApplyWith | undefined, info: LLMServiceInfo | undefined, schema: CatalogSchema | undefined): ApplyWith {
+  if (llmsvcBlock(info, schema)) return "helm";
+  return picked ?? (info?.newInstalls === "llmsvc" ? "llmsvc" : "helm");
+}
diff --git a/web/src/modules/swiss/lib/catalog.ts b/web/src/modules/swiss/lib/catalog.ts
index 9a2d06d..57001cc 100644
--- a/web/src/modules/swiss/lib/catalog.ts
+++ b/web/src/modules/swiss/lib/catalog.ts
@@ -1,4 +1,4 @@
-import type { IndexModel, IndexVariant, Tuning } from "@swiss/lib/api";
+import type { CatalogModel, ModelVariant, Tuning } from "@swiss/lib/api";
 import { gpuModels } from "@swiss/lib/gpu";
 
 export interface Kind {
@@ -12,7 +12,7 @@ export interface Kind {
 // hack/build-site.js used before the field existed.
 // TODO: delete the fallback (guessKind, upliftOf) once every tuned model in the
 // catalog records `tuning`.
-function guessKind(v: Pick<IndexVariant, "id" | "description">): Kind {
+function guessKind(v: Pick<ModelVariant, "id" | "description">): Kind {
   const id = v.id.toLowerCase();
   const desc = (v.description ?? "").toLowerCase();
   const optimized = /optimi[sz]ed/.test(id) || /\b(optimi[sz]ed|tuned by)\b/.test(desc);
@@ -30,10 +30,10 @@ function upliftOf(description?: string): number | null {
 
 // A model that records any tuning is read from it alone: mixing in the guess
 // would label variants the catalog deliberately left unlabelled.
-export function variantKind(v: Pick<IndexVariant, "id" | "description">, tuning?: Tuning[]): Kind {
+export function variantKind(v: Pick<ModelVariant, "id" | "description">, tuning?: Tuning[]): Kind {
   if (!tuning?.length) return guessKind(v);
-  const optimized = tuning.some((t) => t.optimized === v.id);
-  return { optimized, baseline: !optimized && tuning.some((t) => t.baseline === v.id) };
+  const optimized = tuning.some((t) => t.optimized.id === v.id);
+  return { optimized, baseline: !optimized && tuning.some((t) => t.baseline.id === v.id) };
 }
 
 export function formatUplift(pct: number): string {
@@ -44,38 +44,54 @@ export interface Comparison {
   baseline: string;
   optimized: string;
   uplift: number | null;
-  // The version the number was measured on. It can be older than the one
-  // shown, when a later version kept the variants without re-measuring.
+  // The tuned variant's version the number was measured on, and whether that
+  // is another than the one shown: a variant can move on without re-measuring.
   version: string;
+  older: boolean;
   report?: string;
   workloads: { name: string; uplift: number }[];
 }
 
-// The pair shown for one version's variants. A recorded pair must name
-// variants this version has; among those, one measured on this version wins,
-// then one whose tuned variant is the default.
-export function comparison(variants: IndexVariant[], version: string, tuning?: Tuning[]): Comparison | null {
+// The pair shown for a model's variants, each at the version shown. A recorded
+// pair must name variants listed; among those, one measured on the tuned
+// variant's shown version wins, then one whose tuned variant is the default.
+export function comparison(
+  variants: Pick<ModelVariant, "id" | "version" | "default" | "description">[],
+  tuning?: Tuning[],
+): Comparison | null {
+  const shown = new Map(variants.map((v) => [v.id, v.version]));
   if (tuning?.length) {
-    const ids = new Set(variants.map((v) => v.id));
-    const fits = tuning.filter((t) => ids.has(t.baseline) && ids.has(t.optimized));
+    const fits = tuning.filter((t) => shown.has(t.baseline.id) && shown.has(t.optimized.id));
     const def = variants.find((v) => v.default)?.id;
-    const t = fits.find((t) => t.version === version) ?? fits.find((t) => t.optimized === def) ?? fits[0];
-    return t
-      ? {
-          baseline: t.baseline,
-          optimized: t.optimized,
-          uplift: t.uplift ?? null,
-          version: t.version,
-          report: t.report,
-          workloads: t.workloads ?? [],
-        }
-      : null;
+    const t =
+      fits.find((t) => t.optimized.version === shown.get(t.optimized.id)) ??
+      fits.find((t) => t.optimized.id === def) ??
+      fits[0];
+    if (!t) return null;
+    const current = shown.get(t.optimized.id) ?? "";
+    const version = t.optimized.version || current;
+    return {
+      baseline: t.baseline.id,
+      optimized: t.optimized.id,
+      uplift: t.uplift ?? null,
+      version,
+      older: version !== current,
+      report: t.report,
+      workloads: t.workloads ?? [],
+    };
   }
   const base = variants.find((v) => guessKind(v).baseline);
   const tuned = variants.filter((v) => guessKind(v).optimized);
   const opt = tuned.find((v) => v.default) ?? tuned[0];
   if (!base || !opt) return null;
-  return { baseline: base.id, optimized: opt.id, uplift: upliftOf(opt.description), version, workloads: [] };
+  return {
+    baseline: base.id,
+    optimized: opt.id,
+    uplift: upliftOf(opt.description),
+    version: opt.version,
+    older: false,
+    workloads: [],
+  };
 }
 
 // What an uplift number means, for tooltips. Workload names are the report's:
@@ -149,15 +165,20 @@ export function reportLink(site: string | undefined, model: string, report?: str
   }
 }
 
-export function latestVersion(m: IndexModel) {
-  return m.versions.find((v) => v.version === m.latest) ?? m.versions[0];
+// The version every variant is at, as on a v1 catalog where they share their
+// entry's. Undefined when they differ, as v2 variants may.
+export function sharedVersion(variants: Pick<ModelVariant, "version">[]): string | undefined {
+  const first = variants[0]?.version;
+  return first && variants.every((v) => v.version === first) ? first : undefined;
 }
 
 // What the page filters, sorts and summarizes on, one per model.
 export interface Facets {
-  model: IndexModel;
-  // The latest version's, default first.
-  variants: IndexVariant[];
+  model: CatalogModel;
+  // As listed now, default first.
+  variants: ModelVariant[];
+  // The one version they all share, else undefined.
+  version?: string;
   // One per variant, so a summary can count variants per engine.
   engines: string[];
   hardware: string[];
@@ -168,8 +189,8 @@ export interface Facets {
   text: string;
 }
 
-export function facetsOf(m: IndexModel): Facets {
-  const variants = latestVersion(m).variants
+export function facetsOf(m: CatalogModel): Facets {
+  const variants = m.variants
     .slice()
     .sort((a, b) => Number(!!b.default) - Number(!!a.default));
   const hardware = Array.from(new Set(variants.flatMap((v) => gpuModels(v.requires)))).sort();
@@ -189,10 +210,11 @@ export function facetsOf(m: IndexModel): Facets {
   return {
     model: m,
     variants,
+    version: sharedVersion(variants),
     engines: variants.map((v) => v.engine),
     hardware,
     kinds: Object.fromEntries(variants.map((v) => [v.id, variantKind(v, m.tuning)])),
-    cmp: comparison(variants, m.latest, m.tuning),
+    cmp: comparison(variants, m.tuning),
     deprecated: !!m.deprecated,
     text,
   };
diff --git a/web/src/modules/swiss/lib/gpu.test.ts b/web/src/modules/swiss/lib/gpu.test.ts
new file mode 100644
index 0000000..033aa63
--- /dev/null
+++ b/web/src/modules/swiss/lib/gpu.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { productChoices, unlistedProducts, vendorProducts } from "@swiss/lib/gpu";
+
+const nodes = [
+  { GPUProduct: "NVIDIA-H100-80GB-HBM3", GPUResource: "nvidia.com/gpu" },
+  { GPUProduct: "NVIDIA-H20", GPUResource: "nvidia.com/gpu" },
+  { GPUProduct: "NVIDIA-H20", GPUResource: "nvidia.com/gpu" },
+  { GPUProduct: "Ascend-910B3", GPUResource: "huawei.com/Ascend910" },
+  { GPUProduct: "", GPUResource: "" },
+];
+
+describe("vendorProducts", () => {
+  it("is every product on the vendor's nodes, once", () => {
+    expect(vendorProducts(nodes, undefined)).toEqual(["NVIDIA-H100-80GB-HBM3", "NVIDIA-H20"]);
+    expect(vendorProducts(nodes, "ascend")).toEqual(["Ascend-910B3"]);
+    expect(vendorProducts(undefined, "nvidia")).toEqual([]);
+  });
+
+  it("keeps a node whose resource is unknown, as swissd does", () => {
+    expect(vendorProducts([{ GPUProduct: "X" }], "ascend")).toEqual(["X"]);
+  });
+});
+
+describe("unlistedProducts", () => {
+  it("is what the variant does not list, and nothing when it lists none", () => {
+    expect(unlistedProducts(["A"], ["A", "B"])).toEqual(["B"]);
+    expect(unlistedProducts([], ["A", "B"])).toEqual([]);
+    expect(unlistedProducts(undefined, ["A"])).toEqual([]);
+  });
+});
+
+describe("productChoices", () => {
+  it("offers every product the cluster has for the vendor, listed first", () => {
+    expect(productChoices(["NVIDIA-H20"], ["NVIDIA-H100-80GB-HBM3", "NVIDIA-H20"], [])).toEqual(["NVIDIA-H20", "NVIDIA-H100-80GB-HBM3"]);
+  });
+
+  it("falls back to the variant's list without inventory", () => {
+    expect(productChoices(["B", "A"], [], [])).toEqual(["A", "B"]);
+    expect(productChoices(["B", "A"], undefined, [])).toEqual(["A", "B"]);
+  });
+
+  it("keeps a selection the cluster no longer reports, so it can be cleared", () => {
+    expect(productChoices(["A"], ["A"], ["Gone"])).toEqual(["A", "Gone"]);
+  });
+});
diff --git a/web/src/modules/swiss/lib/gpu.ts b/web/src/modules/swiss/lib/gpu.ts
index 614ba21..deec512 100644
--- a/web/src/modules/swiss/lib/gpu.ts
+++ b/web/src/modules/swiss/lib/gpu.ts
@@ -66,3 +66,35 @@ export function matchesVendor(
   }
   return node.GPUResource === expected;
 }
+
+// The products this cluster reports on a vendor's nodes: what a variant of that
+// vendor can be scheduled onto, whether the catalog lists them or not. swissd
+// accepts the same set when a deploy forces a product the variant does not list.
+export function vendorProducts(
+  nodes: { GPUProduct?: string; GPUResource?: string }[] | undefined,
+  vendor: string | undefined,
+): string[] {
+  const out = new Set<string>();
+  for (const n of nodes ?? []) if (n.GPUProduct && matchesVendor(vendor, n)) out.add(n.GPUProduct);
+  return [...out].sort();
+}
+
+// The selected products a variant does not list. A variant naming none accepts
+// any card of its vendor, so for it nothing is unlisted.
+export function unlistedProducts(listed: string[] | undefined, selected: string[]): string[] {
+  return listed?.length ? selected.filter((p) => !listed.includes(p)) : [];
+}
+
+// What the product picker offers: every product of the variant's vendor this
+// cluster reports, the listed ones first. With no inventory -- nothing reported,
+// or the nodes not read -- the variant's own list stands in. A product already
+// selected is always offered, so it can be cleared.
+export function productChoices(
+  listed: string[] | undefined,
+  present: string[] | undefined,
+  selected: string[],
+): string[] {
+  const base = present?.length ? present : (listed ?? []);
+  const off = (p: string) => (unlistedProducts(listed, [p]).length ? 1 : 0);
+  return [...new Set([...base, ...selected])].sort((a, b) => off(a) - off(b) || a.localeCompare(b));
+}
diff --git a/web/src/modules/swiss/lib/profile.test.ts b/web/src/modules/swiss/lib/profile.test.ts
new file mode 100644
index 0000000..da28903
--- /dev/null
+++ b/web/src/modules/swiss/lib/profile.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { aliasErrors, aliasMap, aliasRows, catalogErrors } from "./profile";
+
+describe("catalogErrors", () => {
+  it("applies swissd's name and url rules", () => {
+    expect(
+      catalogErrors([
+        { name: "", url: "" },
+        { name: "Public", url: "ftp://x" },
+        { name: "public", url: "https://c" },
+        { name: "public", url: "https://c" },
+      ]),
+    ).toEqual([{ name: "required", url: "required" }, { name: "format", url: "format" }, {}, { name: "duplicate", url: "duplicate" }]);
+  });
+  it("allows one url under both schemas", () => {
+    expect(catalogErrors([{ name: "old", url: "/c" }, { name: "next", url: "/c", schemaVersion: "v2" }])).toEqual([{}, {}]);
+  });
+});
+
+describe("gpu product aliases", () => {
+  it("round-trips the stored map, one row per selector", () => {
+    const stored = { "Ascend-910B3": ["accelerator=huawei-Ascend910", "vendor=huawei,model=910b"], H20: ["gpu=h20"] };
+    expect(aliasRows(stored)).toHaveLength(3);
+    expect(aliasMap(aliasRows(stored))).toEqual(stored);
+  });
+
+  it("leaves out a row just added, and keeps a half-filled one to be refused", () => {
+    expect(aliasMap([{ product: "", selector: "" }])).toBeUndefined();
+    expect(aliasMap([{ product: " A ", selector: "" }, { product: "", selector: "x=1" }])).toEqual({ A: [""], "": ["x=1"] });
+  });
+
+  it("applies swissd's selector rules", () => {
+    expect(
+      aliasErrors([
+        { product: "", selector: "" },
+        { product: "", selector: "a=1" },
+        { product: "A", selector: "" },
+        { product: "A", selector: "accelerator" },
+        { product: "A", selector: "a=1,a=2" },
+        { product: "A", selector: "a=1, b = 2" },
+      ]),
+    ).toEqual([{}, { product: "required" }, { selector: "required" }, { selector: "format" }, { selector: "format" }, {}]);
+  });
+
+  it("refuses two products one node could match with as many pairs", () => {
+    expect(aliasErrors([{ product: "A", selector: "a=1" }, { product: "B", selector: "b=1" }])).toEqual([{ selector: "conflict" }, { selector: "conflict" }]);
+    // More pairs wins, values that differ cannot both match, and one product may repeat itself.
+    expect(aliasErrors([{ product: "A", selector: "a=1" }, { product: "B", selector: "a=1,b=1" }])).toEqual([{}, {}]);
+    expect(aliasErrors([{ product: "A", selector: "a=1" }, { product: "B", selector: "a=2" }])).toEqual([{}, {}]);
+    expect(aliasErrors([{ product: "A", selector: "a=1" }, { product: "A", selector: "b=1" }])).toEqual([{}, {}]);
+  });
+});
diff --git a/web/src/modules/swiss/lib/profile.ts b/web/src/modules/swiss/lib/profile.ts
new file mode 100644
index 0000000..8d8a29a
--- /dev/null
+++ b/web/src/modules/swiss/lib/profile.ts
@@ -0,0 +1,87 @@
+import type { SiteProfile } from "@swiss/lib/api";
+
+export type CatalogError = "required" | "format" | "duplicate";
+
+// swissd's rules for catalogs, so a bad row is flagged before the save is
+// refused. One url may be listed twice under the two schemas.
+export function catalogErrors(catalogs: SiteProfile["catalogs"] = []): { name?: CatalogError; url?: CatalogError }[] {
+  const names = new Set<string>();
+  const keys = new Set<string>();
+  return catalogs.map((c) => {
+    const name = c.name.trim();
+    const url = c.url.trim();
+    const key = `${c.schemaVersion === "v2" ? "v2" : "v1"} ${url}`;
+    const e: { name?: CatalogError; url?: CatalogError } = {};
+    if (!name) e.name = "required";
+    else if (!/^[a-z0-9][a-z0-9._-]{0,62}$/.test(name)) e.name = "format";
+    else if (names.has(name)) e.name = "duplicate";
+    if (!url) e.url = "required";
+    else if (!/^(https?:\/\/|\/)/.test(url)) e.url = "format";
+    else if (keys.has(key)) e.url = "duplicate";
+    names.add(name);
+    keys.add(key);
+    return e;
+  });
+}
+
+// nodes.gpuProductAliases is product -> node label selectors. It is edited as
+// one row per selector: a map keyed by what is being typed loses the row the
+// moment a product name is briefly empty or matches another.
+export interface AliasRow {
+  product: string;
+  selector: string;
+}
+
+export type AliasError = "required" | "format" | "conflict";
+
+export function aliasRows(aliases?: Record<string, string[]>): AliasRow[] {
+  return Object.entries(aliases ?? {}).flatMap(([product, sels]) => sels.map((selector) => ({ product, selector })));
+}
+
+// Back to the stored shape. A row with neither field is one just added and is
+// left out. Any other row is kept as typed, so a half-filled one is refused at
+// save rather than silently dropped.
+export function aliasMap(rows: AliasRow[]): Record<string, string[]> | undefined {
+  const out: Record<string, string[]> = {};
+  for (const r of rows) {
+    const product = r.product.trim();
+    const selector = r.selector.trim();
+    if (!product && !selector) continue;
+    (out[product] ??= []).push(selector);
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+// A selector is key=value pairs joined by commas, every one required.
+function parseSelector(sel: string): Record<string, string> | undefined {
+  const labels: Record<string, string> = {};
+  for (const pair of sel.split(",")) {
+    const at = pair.indexOf("=");
+    const k = pair.slice(0, at).trim();
+    const v = pair.slice(at + 1).trim();
+    if (at < 0 || !k || !v || (k in labels && labels[k] !== v)) return undefined;
+    labels[k] = v;
+  }
+  return labels;
+}
+
+// swissd's rules for aliases. A node matching two products takes the one with
+// more pairs, so two selectors of one size that a single node could satisfy
+// are refused: both rows are flagged.
+export function aliasErrors(rows: AliasRow[]): { product?: AliasError; selector?: AliasError }[] {
+  const parsed = rows.map((r) => (r.selector.trim() ? parseSelector(r.selector) : undefined));
+  const overlap = (a: Record<string, string>, b: Record<string, string>) =>
+    Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v]) => !(k in b) || b[k] === v);
+  return rows.map((r, i) => {
+    const product = r.product.trim();
+    const selector = r.selector.trim();
+    const e: { product?: AliasError; selector?: AliasError } = {};
+    if (!product && !selector) return e;
+    if (!product) e.product = "required";
+    const mine = parsed[i];
+    if (!selector) e.selector = "required";
+    else if (!mine) e.selector = "format";
+    else if (rows.some((o, j) => parsed[j] && o.product.trim() !== product && overlap(mine, parsed[j]!))) e.selector = "conflict";
+    return e;
+  });
+}
diff --git a/web/src/modules/swiss/lib/setup.test.ts b/web/src/modules/swiss/lib/setup.test.ts
new file mode 100644
index 0000000..993e36f
--- /dev/null
+++ b/web/src/modules/swiss/lib/setup.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { setupRedirect } from "@swiss/lib/setup";
+
+const session = (initialized: boolean, setUp?: boolean) => ({ authenticated: true, initialized, setUp });
+
+describe("setupRedirect", () => {
+  it("sends a site with nothing stored to setup, and keeps it there", () => {
+    expect(setupRedirect(session(false, false), "/")).toBe("/setup");
+    expect(setupRedirect(session(false, false), "/site-profile")).toBe("/setup");
+    expect(setupRedirect(session(false, false), "/setup")).toBeNull();
+  });
+
+  it("never opens setup on a site that is set up", () => {
+    expect(setupRedirect(session(true, true), "/setup")).toBe("/site-profile");
+    expect(setupRedirect(session(true, true), "/inferences/setup")).toBe("/site-profile");
+    expect(setupRedirect(session(true, true), "/")).toBeNull();
+    expect(setupRedirect(session(true, true), "/catalog")).toBeNull();
+  });
+
+  it("sends a stored profile that does not parse to the profile page, not setup", () => {
+    expect(setupRedirect(session(false, true), "/")).toBe("/site-profile");
+    expect(setupRedirect(session(false, true), "/setup")).toBe("/site-profile");
+    expect(setupRedirect(session(false, true), "/site-profile")).toBeNull();
+    expect(setupRedirect(session(false, true), "/inferences/site-profile")).toBeNull();
+  });
+
+  it("reads an older swissd's initialized as setUp", () => {
+    expect(setupRedirect(session(false), "/")).toBe("/setup");
+    expect(setupRedirect(session(false), "/setup")).toBeNull();
+    expect(setupRedirect(session(true), "/setup")).toBe("/site-profile");
+  });
+});
diff --git a/web/src/modules/swiss/lib/setup.ts b/web/src/modules/swiss/lib/setup.ts
new file mode 100644
index 0000000..61206d8
--- /dev/null
+++ b/web/src/modules/swiss/lib/setup.ts
@@ -0,0 +1,18 @@
+import type { Session } from "@swiss/lib/api";
+
+// setupRedirect is where the gate sends a logged-in page, or null to render it.
+//
+// Setup is the first run and nothing else. It writes over whatever is stored,
+// so a site that has a profile never lands there, typed URL included: it goes
+// to the site profile page, where that profile is edited. So does a profile
+// that does not parse, or could not be read -- that page opens on the stored
+// document, or says why it could not.
+export function setupRedirect(s: Session, pathname: string): string | null {
+  // A swissd older than setUp only says initialized, and sent every profile it
+  // could not use to setup.
+  const setUp = s.setUp ?? s.initialized;
+  const onSetup = pathname.endsWith("/setup");
+  if (!setUp) return onSetup ? null : "/setup";
+  if (onSetup || (!s.initialized && !pathname.endsWith("/site-profile"))) return "/site-profile";
+  return null;
+}
diff --git a/web/src/modules/swiss/routes/Catalog.tsx b/web/src/modules/swiss/routes/Catalog.tsx
index 650443c..b33088a 100644
--- a/web/src/modules/swiss/routes/Catalog.tsx
+++ b/web/src/modules/swiss/routes/Catalog.tsx
@@ -2,7 +2,7 @@ import { Fragment, createContext, useContext, useMemo, useState } from "react";
 import { Link, useSearchParams } from "@swiss/lib/host";
 import { useQuery } from "@tanstack/react-query";
 import { ArrowDown, ArrowUp, ChartColumn, ExternalLink, Eye, LayoutGrid, Rocket, RotateCcw, Search, Table2 } from "lucide-react";
-import { api, type IndexVariant } from "@swiss/lib/api";
+import { api, type ModelVariant } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
 import { Button, buttonVariants } from "@swiss/components/ui/button";
 import { Card } from "@swiss/components/ui/card";
@@ -11,7 +11,7 @@ import { Input } from "@swiss/components/ui/input";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@swiss/components/ui/table";
 import { Empty, ErrorState, Loading } from "@swiss/components/States";
 import { WorkloadList } from "@swiss/components/Uplift";
-import { CatalogGate, CatalogSwitch, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
+import { CatalogGate, CatalogSwitch, SchemaBadge, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
 import {
   type Comparison,
   type Facets,
@@ -150,7 +150,7 @@ export function Catalog() {
     enabled: !!choice.selected,
   });
   const { filters: f, set, reset } = useFilters();
-  const all = useMemo(() => data?.index.models.map(facetsOf) ?? [], [data]);
+  const all = useMemo(() => data?.models.map(facetsOf) ?? [], [data]);
 
   if (choice.isPending) return <Loading what="catalogs" />;
   if (choice.error) return <ErrorState what="catalogs" error={choice.error} />;
@@ -164,11 +164,12 @@ export function Catalog() {
 
   return (
     <CatalogName.Provider value={choice.selected}>
-    <CatalogSite.Provider value={data.index.site}>
+    <CatalogSite.Provider value={data.site}>
     <div className="space-y-4">
       <div className="flex flex-wrap items-center gap-x-3 gap-y-2">
         <h1 className="text-lg font-semibold">Catalog</h1>
         <CatalogSwitch catalogs={choice.catalogs} selected={choice.selected} choose={choice.choose} />
+        <SchemaBadge schema={data.schema} />
         <span className="text-sm text-muted-foreground">{data.source}</span>
         <code className="ml-auto text-xs text-muted-foreground">{data.ref.slice(0, 19)}</code>
       </div>
@@ -447,7 +448,7 @@ function CatalogTable({ rows, sort, set }: { rows: Facets[]; sort: SortKey; set:
           <TableRow className="hover:bg-transparent">
             {head("name", "Model")}
             {head("family", "Family")}
-            <TableHead>Variants (latest)</TableHead>
+            <TableHead>Variants</TableHead>
             {head("uplift", "Uplift vs baseline", "h-auto py-2 text-right", UPLIFT_HELP, "per workload · in + out tokens")}
             <TableHead>
               <span className="sr-only">Actions</span>
@@ -460,8 +461,8 @@ function CatalogTable({ rows, sort, set }: { rows: Facets[]; sort: SortKey; set:
               <TableCell className="min-w-48 align-top">
                 <ModelName f={x} />
                 <div className="mt-0.5 text-xs text-muted-foreground">
-                  <code>{x.model.name}</code> · v{x.model.latest}
-                  {x.model.versions.length > 1 && ` · ${x.model.versions.length} versions`}
+                  <code>{x.model.name}</code>
+                  {x.version && ` · v${x.version}`}
                 </div>
               </TableCell>
               <TableCell className="align-top">
@@ -474,13 +475,13 @@ function CatalogTable({ rows, sort, set }: { rows: Facets[]; sort: SortKey; set:
               <TableCell className="align-top">
                 <div className="space-y-1.5">
                   {x.variants.map((v) => (
-                    <VariantLine key={v.id} v={v} kind={x.kinds[v.id]} />
+                    <VariantLine key={v.id} v={v} kind={x.kinds[v.id]} version={!x.version} />
                   ))}
                 </div>
               </TableCell>
               <TableCell className="align-top text-right">
                 {x.cmp ? (
-                  <UpliftCell cmp={x.cmp} latest={x.model.latest} model={x.model.name} />
+                  <UpliftCell cmp={x.cmp} model={x.model.name} />
                 ) : (
                   <span className="text-muted-foreground">—</span>
                 )}
@@ -506,8 +507,7 @@ function ModelCard({ f, set }: { f: Facets; set: Update }) {
         <div className="min-w-0 space-y-1.5">
           <ModelName f={f} className="text-base" />
           <div className="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground">
-            <Badge variant="muted">v{m.latest}</Badge>
-            {m.versions.length > 1 && <span>{m.versions.length} versions</span>}
+            {f.version && <Badge variant="muted">v{f.version}</Badge>}
             {m.family && <Chip onClick={() => set({ family: m.family ?? "" })}>{m.family}</Chip>}
           </div>
         </div>
@@ -515,7 +515,7 @@ function ModelCard({ f, set }: { f: Facets; set: Update }) {
           <div className="shrink-0 text-right">
             <UpliftBadge cmp={f.cmp} />
             <div className="mt-1 text-xs text-muted-foreground">
-              vs baseline{f.cmp.version !== m.latest && ` · v${f.cmp.version}`}
+              vs baseline{f.cmp.older && ` · v${f.cmp.version}`}
             </div>
           </div>
         )}
@@ -544,7 +544,7 @@ function ModelCard({ f, set }: { f: Facets; set: Update }) {
       <ul className="divide-y rounded-md border">
         {f.variants.map((v) => (
           <li key={v.id} className="px-3 py-2">
-            <VariantLine v={v} kind={f.kinds[v.id]} wrap />
+            <VariantLine v={v} kind={f.kinds[v.id]} version={!f.version} wrap />
             {/* Cards are narrow, so the hardware leads the description line
                 rather than wrapping onto a line of its own. */}
             <p className="mt-1 line-clamp-2 text-xs text-muted-foreground" title={v.description}>
@@ -604,13 +604,30 @@ function ModelName({ f, className }: { f: Facets; className?: string }) {
   );
 }
 
-// id, badges, and (unless the caller places it) the hardware on one line.
-function VariantLine({ v, kind, wrap = false }: { v: IndexVariant; kind: Kind; wrap?: boolean }) {
+// id, badges, and (unless the caller places it) the hardware on one line. The
+// version is the variant's own when the model's variants are not all at one.
+function VariantLine({
+  v,
+  kind,
+  version = false,
+  wrap = false,
+}: {
+  v: ModelVariant;
+  kind: Kind;
+  version?: boolean;
+  wrap?: boolean;
+}) {
   const link = httpLink(v.link);
   return (
     <div className={cn("flex items-center gap-1.5", wrap ? "flex-wrap" : "whitespace-nowrap")}>
       <code className="text-xs">{v.id}</code>
+      {version && <span className="text-xs text-muted-foreground">v{v.version}</span>}
       {v.default && <Badge variant="muted">default</Badge>}
+      {v.deprecated && (
+        <Badge variant="destructive" title={typeof v.deprecated === "string" ? v.deprecated : undefined}>
+          deprecated
+        </Badge>
+      )}
       {kind.optimized && <Badge variant="success">optimized</Badge>}
       {kind.baseline && <Badge variant="outline">baseline</Badge>}
       {link && (
@@ -658,7 +675,7 @@ function UpliftBadge({ cmp, className }: { cmp: Comparison; className?: string }
 // in the column header.
 //   50k + 1.5k  [+64.2%]
 //      8k + 1k    +7.6%
-function UpliftCell({ cmp, latest, model }: { cmp: Comparison; latest: string; model: string }) {
+function UpliftCell({ cmp, model }: { cmp: Comparison; model: string }) {
   const report = reportLink(useContext(CatalogSite), model, cmp.report);
   const head = headlineWorkload(cmp);
   const label = "text-left font-mono text-xs whitespace-nowrap text-muted-foreground";
@@ -674,7 +691,7 @@ function UpliftCell({ cmp, latest, model }: { cmp: Comparison; latest: string; m
           </Badge>
         </Fragment>
       ))}
-      {cmp.version !== latest && (
+      {cmp.older && (
         <span className="col-span-2 text-right text-xs text-muted-foreground">measured on v{cmp.version}</span>
       )}
       {report && (
@@ -760,7 +777,7 @@ function DeployButton({ f }: { f: Facets }) {
         open={choosing}
         onClose={() => setChoosing(false)}
         title={`Deploy ${m.displayName ?? m.name}`}
-        subtitle={`v${m.latest} — ${f.variants.length} variants. Each is a different accelerator and parallelism shape; pick the one this cluster runs.`}
+        subtitle={`${f.version ? `v${f.version} — ` : ""}${f.variants.length} variants. Each is a different accelerator and parallelism shape; pick the one this cluster runs.`}
       >
         <div className="space-y-2.5 text-left">
           {f.variants.map((v) => {
@@ -771,6 +788,7 @@ function DeployButton({ f }: { f: Facets }) {
                 <div className="flex flex-wrap items-center justify-between gap-2">
                   <div className="flex flex-wrap items-center gap-2">
                     <span className="text-sm font-semibold">{v.id}</span>
+                    {!f.version && <span className="text-xs text-muted-foreground">v{v.version}</span>}
                     {v.default && <Badge variant="muted">default</Badge>}
                     {kind.optimized && <Badge variant="success">optimized</Badge>}
                     {kind.baseline && <Badge variant="outline">baseline</Badge>}
diff --git a/web/src/modules/swiss/routes/Deploy.tsx b/web/src/modules/swiss/routes/Deploy.tsx
index 62a9ba3..dedb905 100644
--- a/web/src/modules/swiss/routes/Deploy.tsx
+++ b/web/src/modules/swiss/routes/Deploy.tsx
@@ -1,20 +1,23 @@
 import { useEffect, useState } from "react";
 import { Link, useParams, useSearchParams } from "@swiss/lib/host";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
 import { ChevronLeft, TriangleAlert } from "lucide-react";
-import { api, deployApi, type ApplyResult, type DiffResult, type Plan } from "@swiss/lib/api";
+import { api, deployApi, type ApplyResult, type ApplyWith, type DiffResult, type Plan } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@swiss/components/ui/card";
 import { DeploySettings, EMPTY, imageOf, planRequest, type Form } from "@swiss/components/DeploySettings";
 import { Pipeline } from "@swiss/components/Pipeline";
 import { ErrorState, Loading } from "@swiss/components/States";
-import { CatalogBadge, CatalogGate, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
-import { chartVersionChoice, TargetRow } from "@swiss/components/ChartVersion";
+import { CatalogBadge, CatalogGate, SchemaBadge, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
+import { chartVersionChoice, Select, TargetRow } from "@swiss/components/ChartVersion";
 import { isChartRange } from "@swiss/lib/upgrade";
+import { unlistedProducts, vendorProducts } from "@swiss/lib/gpu";
+import { installMethod, llmsvcBlock } from "@swiss/lib/applyWith";
+import { InstallMethodChoice } from "@swiss/components/InstallMethod";
 
 export function Deploy() {
   const { name = "" } = useParams();
-  const [params] = useSearchParams();
+  const [params, setParams] = useSearchParams();
   const variantId = params.get("variant") ?? "";
   const version = params.get("version") ?? "";
   // The catalog is chosen before anything is composed: the same model name in
@@ -22,14 +25,24 @@ export function Deploy() {
   const choice = useCatalogChoice();
   const catalog = choice.selected;
 
+  // The variant resolved at the version picked, its current one by default:
+  // on v2 a version is the variant's own, on v1 its entry's.
   const model = useQuery({
-    queryKey: ["model", catalog, name, version],
-    queryFn: () => api.model(name, version || undefined, catalog),
+    queryKey: ["model", catalog, name, variantId, version],
+    queryFn: () => api.model(name, { catalog, variant: variantId || undefined, version: version || undefined }),
     enabled: !!catalog,
+    // Picking another version keeps the page, and the form, while it resolves.
+    placeholderData: keepPreviousData,
+  });
+  const history = useQuery({
+    queryKey: ["history", catalog, name, variantId],
+    queryFn: () => api.history(name, { catalog, variant: variantId || undefined }),
+    enabled: !!catalog,
+    retry: false,
   });
   const cluster = useQuery({ queryKey: ["cluster"], queryFn: api.cluster });
   const nodes = useQuery({ queryKey: ["nodes"], queryFn: api.nodes });
-  const chartVariant = model.data?.entry.variants.find((v) => v.id === variantId) ?? model.data?.entry.variants[0];
+  const chartVariant = model.data?.variant;
   const chartRange = !!chartVariant && isChartRange(chartVariant.chart.version);
   const chartVersions = useQuery({
     queryKey: ["chart-versions", catalog, name, version, chartVariant?.id],
@@ -37,8 +50,18 @@ export function Deploy() {
     enabled: chartRange,
     retry: false,
   });
+  const pickVersion = (v: string) => {
+    setParams((prev) => {
+      const next = new URLSearchParams(prev);
+      if (v) next.set("version", v);
+      else next.delete("version");
+      return next;
+    });
+    update({});
+  };
   const [chartVersion, setChartVersion] = useState("");
   useEffect(() => setChartVersion(""), [catalog, name, version, variantId]);
+  const [picked, setPicked] = useState<ApplyWith>();
 
   const [form, setForm] = useState<Form>({ ...EMPTY, serviceId: name });
   // serviceId is the identity everything else is named after: the helm release,
@@ -64,7 +87,14 @@ export function Deploy() {
   const planM = useMutation({
     mutationFn: () =>
       deployApi.plan(
-        planRequest(form, { model: name, version, variant: variantId, catalog, chartVersion: chartVersion || undefined }),
+        planRequest(form, {
+          model: name,
+          version,
+          variant: variantId,
+          catalog,
+          chartVersion: chartVersion || undefined,
+          forceGpuProducts: unlistedProducts(model.data?.variant.requires.gpuProduct, form.gpuProducts).length > 0,
+        }),
       ),
     // The previous plan is superseded the moment a recompose starts. Dropping
     // it here rather than on the way back means a failed compose leaves
@@ -86,7 +116,10 @@ export function Deploy() {
   if (model.isPending || cluster.isPending) return <Loading what="the model" />;
   if (model.error) return <ErrorState what={name} error={model.error} />;
 
-  const entry = model.data.entry;
+  const { model: m, variant, schema } = model.data;
+  const current = m.variants.find((v) => v.id === variant.id)?.version;
+  const llm = cluster.data?.llmservice;
+  const method = installMethod(picked, llm, schema);
   const chart = chartVersionChoice({
     list: chartVersions,
     value: chartVersion,
@@ -95,7 +128,6 @@ export function Deploy() {
       update({});
     },
   });
-  const variant = entry.variants.find((v) => v.id === variantId) ?? entry.variants[0];
 
   if (!cluster.data?.allowDeploy) {
     return (
@@ -112,12 +144,13 @@ export function Deploy() {
 
       <div>
         <h1 className="flex flex-wrap items-center gap-2 text-xl font-semibold">
-          Deploy {entry.displayName ?? entry.name}
+          Deploy {m.displayName ?? m.name}
           <CatalogBadge name={catalog} show={choice.several} />
+          <SchemaBadge schema={schema} />
         </h1>
         <p className="mt-1 text-sm text-muted-foreground">
           <Badge variant="outline">{variant.id}</Badge>{" "}
-          <Badge variant="muted">v{entry.version}</Badge>{" "}
+          <Badge variant="muted">v{variant.version}</Badge>{" "}
           {variant.engine} · {variant.requires.gpus} GPU
           {variant.requires.nodes && variant.requires.nodes > 1
             ? ` × ${variant.requires.nodes} nodes`
@@ -129,16 +162,37 @@ export function Deploy() {
 
       {planM.error && <ErrorState what="the request" error={planM.error} />}
 
-      {chartRange && (
-        <Card>
-          <CardHeader>
-            <CardTitle className="text-base">Chart version</CardTitle>
-            <p className="text-sm text-muted-foreground">
-              This model's catalog allows a range of {variant.chart.name} charts. The plan records the
-              exact version installed, and later upgrades keep it until asked to move.
-            </p>
-          </CardHeader>
-          <CardContent className="divide-y pt-0">
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Version</CardTitle>
+          <p className="text-sm text-muted-foreground">
+            The plan records the version and its digest
+            {chartRange && `, and the exact ${variant.chart.name} chart installed from the range the catalog allows`}.
+            Later upgrades keep both until asked to move.
+          </p>
+        </CardHeader>
+        <CardContent className="divide-y pt-0">
+          <TargetRow
+            label={schema === "v2" ? "Variant version" : "Model version"}
+            hint={
+              schema === "v2"
+                ? "Each variant of a v2 catalog has its own versions."
+                : "A v1 version is the model's: every variant of it moves together."
+            }
+            changing={!!version && version !== current}
+            caption={history.error ? `Could not list versions: ${history.error.message}` : undefined}
+            tone={history.error ? "destructive" : "muted"}
+          >
+            <Select
+              value={version}
+              onChange={pickVersion}
+              options={(history.data?.revisions ?? [])
+                .filter((r) => r.version !== current)
+                .map((r) => ({ value: r.version, label: r.releaseDate ? `${r.version} · ${r.releaseDate}` : r.version }))}
+              emptyLabel={current ? `latest (${current})` : "latest"}
+            />
+          </TargetRow>
+          {chartRange && (
             <TargetRow
               label="Chart version"
               hint="Left on the default, the newest version the catalog allows is installed."
@@ -148,9 +202,27 @@ export function Deploy() {
             >
               {chart.control}
             </TargetRow>
-          </CardContent>
-        </Card>
-      )}
+          )}
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Install method</CardTitle>
+          <p className="text-sm text-muted-foreground">
+            How a new release is stored. It is fixed at install: upgrades and rollbacks stay on it,
+            and an existing release keeps its own.
+          </p>
+        </CardHeader>
+        <CardContent className="pt-0">
+          <InstallMethodChoice
+            value={method}
+            onChange={setPicked}
+            blocked={llmsvcBlock(llm, schema)}
+            fallback={installMethod(undefined, llm, "v2")}
+          />
+        </CardContent>
+      </Card>
 
       {/* The settings are the page. Plan, diff and apply are what is done with
           them, so they sit below as tabs rather than holding the form inside
@@ -164,7 +236,7 @@ export function Deploy() {
         localPathPlaceholder={model.data.pathTemplate}
         image={imageOf(variant, model.data.imageRepository)}
         supportedGPUs={variant?.requires.gpuProduct}
-        clusterGPUs={nodes.data?.nodes.map((n) => n.GPUProduct)}
+        clusterGPUs={vendorProducts(nodes.data?.nodes, variant?.requires.vendor)}
       />
 
       <Pipeline
@@ -178,6 +250,7 @@ export function Deploy() {
         onCompose={() => planM.mutate()}
         composing={planM.isPending}
         composeDisabled={!form.serviceId}
+        applyWith={method}
         onDiff={setDiff}
         onApplied={setApplied}
       />
diff --git a/web/src/modules/swiss/routes/DeploymentDetail.tsx b/web/src/modules/swiss/routes/DeploymentDetail.tsx
index 6536bea..2af79f6 100644
--- a/web/src/modules/swiss/routes/DeploymentDetail.tsx
+++ b/web/src/modules/swiss/routes/DeploymentDetail.tsx
@@ -37,6 +37,7 @@ import { AccessPoint } from "@swiss/components/Endpoint";
 import { ReleaseStatus } from "@swiss/components/ReleaseStatus";
 import { SLODialog } from "@swiss/components/SLOCard";
 import { ErrorState, Loading } from "@swiss/components/States";
+import { METHODS } from "@swiss/components/InstallMethod";
 import { cn, timeAgo } from "@swiss/lib/utils";
 
 export function DeploymentDetail() {
@@ -232,6 +233,11 @@ function InstallStatus({ status, objects }: { status: Status; objects?: ObjectRe
         <div className="flex flex-wrap items-center gap-1.5">
           {p && <PhaseBadge phase={p.phase} />}
           {status.helmStatus && <Badge variant="outline">helm {status.helmStatus}</Badge>}
+          {status.backend && (
+            <Badge variant="muted" title={`install method: ${METHODS[status.backend].hint}`}>
+              {METHODS[status.backend].label}
+            </Badge>
+          )}
         </div>
       </CardHeader>
       <CardContent className="space-y-4">
diff --git a/web/src/modules/swiss/routes/Model.tsx b/web/src/modules/swiss/routes/Model.tsx
index 5824db4..611da00 100644
--- a/web/src/modules/swiss/routes/Model.tsx
+++ b/web/src/modules/swiss/routes/Model.tsx
@@ -1,23 +1,23 @@
-import { Link, useParams, useSearchParams } from "@swiss/lib/host";
+import { Link, useParams } from "@swiss/lib/host";
 import { useQuery } from "@tanstack/react-query";
 import { ChevronLeft, Rocket } from "lucide-react";
 import { api } from "@swiss/lib/api";
-import { comparison, formatUplift, reportLink, variantKind, workloadSummary } from "@swiss/lib/catalog";
+import { comparison, formatUplift, reportLink, sharedVersion, variantKind, workloadSummary } from "@swiss/lib/catalog";
+import { Badge } from "@swiss/components/ui/badge";
 import { Button } from "@swiss/components/ui/button";
 import { ErrorState, Loading } from "@swiss/components/States";
 import { VariantCard } from "@swiss/components/VariantCard";
-import { CatalogBadge, CatalogGate, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
+import { CatalogBadge, CatalogGate, SchemaBadge, useCatalogChoice, withCatalog } from "@swiss/components/CatalogChoice";
 
 export function Model() {
   const { name = "" } = useParams();
-  const [params, setParams] = useSearchParams();
-  const version = params.get("version") ?? "";
   // A model belongs to one catalog: the same name in another is another model.
   const choice = useCatalogChoice();
   const selected = choice.selected;
+  // The default variant resolved, for what only its file says: the served name.
   const model = useQuery({
-    queryKey: ["model", selected, name, version],
-    queryFn: () => api.model(name, version || undefined, selected),
+    queryKey: ["model", selected, name, "", ""],
+    queryFn: () => api.model(name, { catalog: selected }),
     enabled: !!selected,
   });
   const catalog = useQuery({
@@ -36,13 +36,11 @@ export function Model() {
   if (model.isPending) return <Loading what={name} />;
   if (model.error) return <ErrorState what={name} error={model.error} />;
 
-  const e = model.data.entry;
-  const indexed = catalog.data?.index.models.find((m) => m.name === name);
-  // Roles and the uplift come from the model's recorded tuning, via the index.
-  // The entry itself carries none: it is metadata, not part of the version.
-  const tuning = indexed?.tuning;
-  const cmp = comparison(e.variants, e.version, tuning);
-  const report = cmp ? reportLink(catalog.data?.index.site, e.name, cmp.report) : undefined;
+  const m = model.data.model;
+  // On v1 every variant is at its entry's version; on v2 each is at its own.
+  const shared = sharedVersion(m.variants);
+  const cmp = comparison(m.variants, m.tuning);
+  const report = cmp ? reportLink(catalog.data?.site, m.name, cmp.report) : undefined;
   return (
     <div className="space-y-5">
       <Link
@@ -54,47 +52,32 @@ export function Model() {
 
       <div>
         <h1 className="flex flex-wrap items-center gap-2 text-xl font-semibold">
-          {e.displayName ?? e.name}
+          {m.displayName ?? m.name}
           <CatalogBadge name={selected} show={choice.several} />
+          <SchemaBadge schema={model.data.schema} />
         </h1>
-        {e.description && <p className="mt-1 max-w-3xl text-sm text-muted-foreground">{e.description}</p>}
+        {m.description && <p className="mt-1 max-w-3xl text-sm text-muted-foreground">{m.description}</p>}
       </div>
 
       <dl className="grid gap-x-8 gap-y-2 text-sm sm:grid-cols-2">
-        <Field label="Weights" value={`${e.source.hf}${e.source.sizeGiB ? ` · ${e.source.sizeGiB} GiB` : ""}`} />
-        <Field label="Served as" value={e.servedName ?? e.name} />
-        {e.license && <Field label="License" value={e.license} />}
-        <Field label="Version" value={e.version} />
-        {e.digest && <Field label="Digest" value={e.digest.slice(0, 19)} />}
+        <Field label="Weights" value={`${m.source.hf}${m.source.sizeGiB ? ` · ${m.source.sizeGiB} GiB` : ""}`} />
+        <Field label="Served as" value={model.data.variant.servedName} />
+        <Field label="Version" value={shared ?? "per variant"} />
+        {shared && <Field label="Digest" value={m.variants[0].digest.slice(0, 19)} />}
       </dl>
 
-      <VersionPicker
-        name={name}
-        current={e.version}
-        versions={
-          indexed?.versions.map((v) => v.version) ?? []
-        }
-        onPick={(v) =>
-          setParams((prev) => {
-            const next = new URLSearchParams(prev);
-            if (v) next.set("version", v);
-            else next.delete("version");
-            return next;
-          })
-        }
-      />
-
       <div>
         <h2 className="mb-2 text-sm font-medium">Variants</h2>
         <div className="grid gap-3 md:grid-cols-2">
-          {e.variants.map((v) => (
+          {m.variants.map((v) => (
             <VariantCard
               key={v.id}
               v={v}
-              kind={variantKind(v, tuning)}
+              kind={variantKind(v, m.tuning)}
+              tags={!shared && <Badge variant="muted">v{v.version}</Badge>}
               uplift={
                 cmp?.optimized === v.id && cmp.uplift != null
-                  ? formatUplift(cmp.uplift) + (cmp.version !== e.version ? ` on v${cmp.version}` : "")
+                  ? formatUplift(cmp.uplift) + (cmp.older ? ` on v${cmp.version}` : "")
                   : undefined
               }
               upliftTitle={cmp?.optimized === v.id && cmp.workloads.length ? workloadSummary(cmp) : undefined}
@@ -102,13 +85,7 @@ export function Model() {
               workloads={cmp?.optimized === v.id && cmp.workloads.length ? cmp.workloads : undefined}
               nodes={nodes.data?.nodes}
               action={
-                <Link
-                  to={withCatalog(
-                    `/deploy/${encodeURIComponent(e.name)}?variant=${encodeURIComponent(v.id)}` +
-                      (version ? `&version=${encodeURIComponent(version)}` : ""),
-                    selected,
-                  )}
-                >
+                <Link to={withCatalog(`/deploy/${encodeURIComponent(m.name)}?variant=${encodeURIComponent(v.id)}`, selected)}>
                   <Button size="sm">
                     <Rocket className="size-4" /> Deploy
                   </Button>
@@ -117,45 +94,14 @@ export function Model() {
             />
           ))}
         </div>
+        <p className="mt-2 text-xs text-muted-foreground">
+          Each variant deploys at its current version; an older one is chosen on the deploy page.
+        </p>
       </div>
     </div>
   );
 }
 
-function VersionPicker({
-  name,
-  current,
-  versions,
-  onPick,
-}: {
-  name: string;
-  current: string;
-  versions: string[];
-  onPick: (v: string) => void;
-}) {
-  if (versions.length < 2) return null;
-  return (
-    <div className="flex items-center gap-2 text-sm">
-      <span className="text-muted-foreground">Version</span>
-      <select
-        className="rounded-md border bg-background px-2 py-1 text-sm"
-        value={current}
-        onChange={(e) => onPick(e.target.value)}
-        aria-label={`version of ${name}`}
-      >
-        {versions.map((v) => (
-          <option key={v} value={v}>
-            {v}
-          </option>
-        ))}
-      </select>
-      <span className="text-xs text-muted-foreground">
-        a deploy records the version and its digest
-      </span>
-    </div>
-  );
-}
-
 function Field({ label, value }: { label: string; value: string }) {
   return (
     <div className="flex gap-2">
diff --git a/web/src/modules/swiss/routes/Setup.tsx b/web/src/modules/swiss/routes/Setup.tsx
index 828abd0..c23b192 100644
--- a/web/src/modules/swiss/routes/Setup.tsx
+++ b/web/src/modules/swiss/routes/Setup.tsx
@@ -4,7 +4,6 @@ import { api } from "@swiss/lib/api";
 import { Card, CardContent, CardHeader, CardTitle } from "@swiss/components/ui/card";
 import { ErrorState, Loading } from "@swiss/components/States";
 import { ProfileEditor } from "@swiss/components/ProfileEditor";
-import { useSessionQuery } from "@swiss/components/Session";
 
 // Setup is the first run: swissd owns the site profile, the chart writes none,
 // so a fresh install has nothing to compose against until this is filled in.
@@ -12,11 +11,12 @@ import { useSessionQuery } from "@swiss/components/Session";
 // Pre-filled from the server's own default rather than from a blank page: the
 // answer to "what goes in here" is most of the work, and the default is a
 // working profile with the reasoning beside each field.
+//
+// Only a site with nothing stored gets here -- the gate sends every other one to
+// the site profile page -- so there is no stored document to start from.
 export function Setup() {
   const navigate = useNavigate();
-  const session = useSessionQuery();
   const template = useQuery({ queryKey: ["profileTemplate"], queryFn: api.profileTemplate });
-  const existing = useQuery({ queryKey: ["profile"], queryFn: api.profile, retry: false });
 
   // Not logged in is the gate's business; this page is always rendered inside
   // it. Navigating from a render body here would be a second answer to one
@@ -24,21 +24,9 @@ export function Setup() {
   if (template.isPending) return <Loading what="the setup" />;
   if (template.error) return <ErrorState what="the setup" error={template.error} />;
 
-  const configured = !!session.data?.initialized;
-  // An install that got half-way through keeps what it saved; everything else
-  // starts from the server's own default.
-  //
-  // The two halves are chosen separately on purpose. A stored document that
-  // does not parse has no profile to seed the form with -- that falls back to
-  // the default -- but its text is exactly what has to be edited, so the YAML
-  // tab opens on it rather than on a template that would discard the whole
-  // profile to fix one line.
-  const startProfile = existing.data?.profile ?? template.data.profile;
-  const startYaml = existing.data?.yaml ?? template.data.yaml ?? "";
-
   // The server's own default failing to parse is a bug in swissd, not something
   // this page can seed around.
-  if (!startProfile) {
+  if (!template.data.profile) {
     return <ErrorState what="the setup" error={new Error("the default profile does not parse")} />;
   }
 
@@ -54,24 +42,6 @@ export function Setup() {
         </p>
       </div>
 
-      {existing.data?.error && (
-        <Card>
-          <CardContent className="p-4 text-sm">
-            <div className="font-medium text-warning">
-              The stored profile does not parse, so swissd has nothing to compose against.
-            </div>
-            <pre className="mt-2 overflow-x-auto font-mono text-xs text-muted-foreground">
-              {existing.data.error}
-            </pre>
-            <p className="mt-2 text-muted-foreground">
-              The YAML tab below opens on the stored document — fix the line it names and
-              save. The form tab starts from the default instead, and saving from it would
-              replace the whole profile.
-            </p>
-          </CardContent>
-        </Card>
-      )}
-
       <Card>
         <CardHeader>
           <CardTitle className="text-base">Site profile</CardTitle>
@@ -82,9 +52,9 @@ export function Setup() {
         </CardHeader>
         <CardContent>
           <ProfileEditor
-            profile={startProfile}
-            yaml={startYaml}
-            submitLabel={configured ? "Save profile" : "Save and start"}
+            profile={template.data.profile}
+            yaml={template.data.yaml ?? ""}
+            submitLabel="Save and start"
             onSaved={() => navigate("/", { replace: true })}
           />
         </CardContent>
diff --git a/web/src/modules/swiss/routes/SiteProfile.tsx b/web/src/modules/swiss/routes/SiteProfile.tsx
index 68694c9..a2427c5 100644
--- a/web/src/modules/swiss/routes/SiteProfile.tsx
+++ b/web/src/modules/swiss/routes/SiteProfile.tsx
@@ -1,8 +1,7 @@
 import { useState } from "react";
-import { Navigate } from "@swiss/lib/host";
 import { useQuery } from "@tanstack/react-query";
 import { Check, Pencil } from "lucide-react";
-import { api } from "@swiss/lib/api";
+import { api, type ProfileResponse } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
 import { Button } from "@swiss/components/ui/button";
 import { ProfileEditor } from "@swiss/components/ProfileEditor";
@@ -22,9 +21,9 @@ export function SiteProfile() {
   if (error) return <ErrorState what="the site profile" error={error} />;
 
   // The stored document does not parse, so there is nothing to show as parsed.
-  // Setup is where it gets fixed -- it opens on the same text -- and the site
-  // reports itself uninitialised anyway, which is the state this is.
-  if (!data.profile) return <Navigate to="/setup" replace />;
+  // It is fixed here rather than at setup: setup is for a site with nothing
+  // stored, and starting over from the default would lose the whole profile.
+  if (!data.profile) return <Repair data={data} />;
 
   const p = data.profile;
   const auth = p.route?.auth;
@@ -87,6 +86,9 @@ export function SiteProfile() {
           >
             <Row label="Namespace" value={p.namespace} fallback="the chart's default" />
             <Row label="GPUs per node" value={p.nodes?.gpusPerNode} />
+            {Object.entries(p.nodes?.gpuProductAliases ?? {}).map(([product, sels]) => (
+              <Row key={product} label={`${product} (GPU alias)`} value={sels.join(" or ")} mono />
+            ))}
             <Row
               label="Scheduler"
               value={p.schedule?.schedulerName}
@@ -238,6 +240,46 @@ export function SiteProfile() {
   );
 }
 
+// Repair opens on a stored profile that does not parse. The two halves of the
+// editor start differently on purpose: the YAML tab holds the stored text,
+// which is exactly what has to be edited, and the form -- which binds to a
+// parsed profile and has none -- starts from the server's default.
+function Repair({ data }: { data: ProfileResponse }) {
+  const template = useQuery({ queryKey: ["profileTemplate"], queryFn: api.profileTemplate });
+  if (template.isPending) return <Loading what="the site profile" />;
+  if (template.error) return <ErrorState what="the site profile" error={template.error} />;
+  if (!template.data.profile) {
+    return <ErrorState what="the site profile" error={new Error("the default profile does not parse")} />;
+  }
+
+  return (
+    <div className="space-y-5">
+      <div>
+        <h1 className="text-xl font-semibold">Site profile</h1>
+        <p className="mt-1 font-mono text-xs text-muted-foreground">{data.source}</p>
+      </div>
+      <Card>
+        <CardContent className="p-4 text-sm">
+          <div className="font-medium text-warning">
+            The stored profile does not parse, so swissd has nothing to compose against.
+          </div>
+          <pre className="mt-2 overflow-x-auto font-mono text-xs text-muted-foreground">{data.error}</pre>
+          <p className="mt-2 text-muted-foreground">
+            The YAML tab below opens on the stored document — fix the line it names and save.
+            The form tab starts from the default instead, and saving from it would replace the
+            whole profile.
+          </p>
+        </CardContent>
+      </Card>
+      <Card>
+        <CardContent className="p-4">
+          <ProfileEditor profile={template.data.profile} yaml={data.yaml ?? ""} submitLabel="Save profile" />
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
 function Section({
   title,
   hint,
diff --git a/web/src/modules/swiss/routes/Upgrade.test.tsx b/web/src/modules/swiss/routes/Upgrade.test.tsx
index 7e0e059..26e319b 100644
--- a/web/src/modules/swiss/routes/Upgrade.test.tsx
+++ b/web/src/modules/swiss/routes/Upgrade.test.tsx
@@ -2,24 +2,22 @@ import { describe, expect, it } from "vitest";
 import { renderToString } from "react-dom/server";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { MemoryRouter, Route, Routes } from "react-router";
-import { Upgrade, VariantChoices } from "./Upgrade";
+import { republishWarning, Upgrade, VariantChoices } from "./Upgrade";
 import type { Plan } from "@swiss/lib/api";
 import { ModuleProvider } from "@/shell/module";
 
 const variant = (id: string, engine: string, extra = {}) => ({
-  id, engine, chart: { name: engine, version: ">=0.7.1" }, requires: { gpus: 2, gpuProduct: ["H100"] }, ...extra,
+  id, engine, version: "1.1.0", digest: "d", chart: { name: engine, version: ">=0.7.1" }, requires: { gpus: 2, gpuProduct: ["H100"] }, ...extra,
 });
-const index = (hf: string) => ({
-  name: "x", ref: "r", source: "s",
-  index: { apiVersion: "v1", site: "https://site.example/", count: 1, models: [{
-    name: "m", source: { hf }, latest: "1.1.0",
-    tuning: [{ version: "1.1.0", baseline: "a", optimized: "c", uplift: 40, report: "perf.html" }],
-    versions: [
-      { version: "1.1.0", path: "p", digest: "d", variants: [
-        variant("a", "sglang", { default: true, description: "TP2 on H100", link: "https://docs.example/a" }),
-        variant("b", "vllm"), variant("c", "sglang", { description: "tuned" })] },
-      { version: "1.0.0", path: "p", digest: "d", variants: [variant("a", "sglang")] },
-    ] }] },
+const listing = (hf: string) => ({
+  name: "x", ref: "r", source: "s", schema: "v1", site: "https://site.example/",
+  models: [{
+    name: "m", source: { hf }, defaultVariant: "a",
+    tuning: [{ baseline: { id: "a", version: "1.1.0" }, optimized: { id: "c", version: "1.1.0" }, uplift: 40, report: "perf.html" }],
+    variants: [
+      variant("a", "sglang", { default: true, description: "TP2 on H100", link: "https://docs.example/a" }),
+      variant("b", "vllm"), variant("c", "sglang", { description: "tuned" })],
+  }],
 });
 
 const deployed = {
@@ -29,18 +27,17 @@ const deployed = {
 } as Plan;
 
 const cards = (moving: boolean, selected: string) => {
-  const m = index("org/m").index.models[0];
+  const m = listing("org/m").models[0];
   const html = renderToString(
     <ModuleProvider module={{ id: "swiss", title: "s", basePath: "/swiss", pages: [] }}>
       <MemoryRouter>
         <VariantChoices
-          variants={m.versions[0].variants}
+          variants={m.variants}
           current={deployed}
           moving={moving}
           selected={selected}
           onPick={() => {}}
           tuning={m.tuning}
-          version="1.1.0"
           report="https://site.example/models/m/perf.html"
           nodes={[{ Name: "n1", GPUProduct: "H100", GPUs: 8, Schedulable: true } as never]}
         />
@@ -78,8 +75,10 @@ describe("Upgrade page", () => {
     qc.setQueryData(["cluster"], { allowDeploy: true, namespace: "models", catalogs: [
       { name: "public", url: "u1", source: "s1", ref: "r", default: true }, { name: "internal", url: "u2", source: "s2", ref: "r" }] });
     qc.setQueryData(["nodes"], { nodes: [{ Name: "n1", GPUProduct: "H100", GPUs: 8, Schedulable: true }] });
-    qc.setQueryData(["catalog", "public"], index("org/m"));
-    qc.setQueryData(["catalog", "internal"], index("org/m"));
+    qc.setQueryData(["catalog", "public"], listing("org/m"));
+    qc.setQueryData(["catalog", "internal"], listing("org/m"));
+    qc.setQueryData(["history", "public", "m", "a"], { ref: "r", schema: "v1", model: "m", variant: "a", revisions: [
+      { version: "1.1.0", digest: "d", current: true }, { version: "1.0.0", digest: "sha256:0123456789abcdef0123" }] });
     qc.setQueryData(["chart-versions", "public", "m", "", "a"], { chart: "sglang", range: ">=0.7.1", variant: "a", versions: ["0.8.6", "0.7.1"] });
     const html = renderToString(
       <QueryClientProvider client={qc}>
@@ -99,3 +98,23 @@ describe("Upgrade page", () => {
     expect(text).not.toContain("Choose a variant");
   });
 });
+
+describe("republishWarning", () => {
+  const source = (version: string, digest: string, schema?: "v2") =>
+    ({ ...deployed.source, version, digest, schema }) as Plan["source"];
+  const revisions = [{ version: "1.1.0", digest: "d2" }, { version: "1.0.0", digest: "d1" }];
+  const changed = "version 1.0.0 variant a: upstream digest changed since this was deployed";
+
+  it("warns only while the target stays on the deployed version and variant", () => {
+    expect(republishWarning(source("1.0.0", "d1"), "v1", revisions, "1.0.0", "a")).toBeUndefined();
+    expect(republishWarning(source("1.0.0", "old"), "v1", revisions, "1.0.0", "a")).toBe(changed);
+    expect(republishWarning(source("1.0.0", "old"), "v1", revisions, "1.1.0", "a")).toBeUndefined();
+    expect(republishWarning(source("1.0.0", "old"), "v1", revisions, "1.0.0", "b")).toBeUndefined();
+  });
+
+  it("compares within the schema the plan was composed from", () => {
+    expect(republishWarning(source("1.0.0", "old", "v2"), "v2", revisions, "1.0.0", "a")).toBe(changed);
+    // A v1 plan against its catalog switched to v2 is a migration, not a rewrite.
+    expect(republishWarning(source("1.0.0", "old"), "v2", revisions, "1.0.0", "a")).toBeUndefined();
+  });
+});
diff --git a/web/src/modules/swiss/routes/Upgrade.tsx b/web/src/modules/swiss/routes/Upgrade.tsx
index 46e3293..299e535 100644
--- a/web/src/modules/swiss/routes/Upgrade.tsx
+++ b/web/src/modules/swiss/routes/Upgrade.tsx
@@ -6,10 +6,12 @@ import {
   api,
   deployApi,
   type ApplyResult,
+  type CatalogSchema,
   type DiffResult,
-  type IndexVariant,
+  type ModelVariant,
   type Node,
   type Plan,
+  type CatalogRevision,
   type Tuning,
 } from "@swiss/lib/api";
 import { Badge } from "@swiss/components/ui/badge";
@@ -24,15 +26,15 @@ import {
 } from "@swiss/components/DeploySettings";
 import { Pipeline } from "@swiss/components/Pipeline";
 import { ErrorState, Loading } from "@swiss/components/States";
-import { CatalogBadge, releaseCatalog as catalogOfRelease } from "@swiss/components/CatalogChoice";
+import { CatalogBadge, SchemaBadge, releaseCatalog as catalogOfRelease } from "@swiss/components/CatalogChoice";
 import { movableCatalogs } from "@swiss/lib/upgrade";
 import { chartVersionChoice, Select, TargetRow } from "@swiss/components/ChartVersion";
 import { CatalogModelDiff } from "@swiss/components/CatalogModelDiff";
 import { VariantCard } from "@swiss/components/VariantCard";
 import { Dialog } from "@swiss/components/ui/dialog";
-import { gpuCount } from "@swiss/lib/gpu";
+import { gpuCount, unlistedProducts, vendorProducts } from "@swiss/lib/gpu";
 import { Button } from "@swiss/components/ui/button";
-import { comparison, formatUplift, reportLink, variantKind, workloadSummary } from "@swiss/lib/catalog";
+import { comparison, formatUplift, reportLink, sharedVersion, variantKind, workloadSummary } from "@swiss/lib/catalog";
 
 export function Upgrade() {
   const { namespace = "", release = "" } = useParams();
@@ -78,23 +80,31 @@ export function Upgrade() {
       enabled: !rollbackTo,
     })),
   });
-  const modelIn = (name?: string) =>
-    indexes[catalogs.findIndex((c) => c.name === name)]?.data?.index.models.find(
-      (m) => m.name === recorded?.model,
-    );
+  const listing = (name?: string) => indexes[catalogs.findIndex((c) => c.name === name)]?.data;
+  const modelIn = (name?: string) => listing(name)?.models.find((m) => m.name === recorded?.model);
   const { hf, movable } = movableCatalogs(catalogs, recorded ?? {}, releaseCatalog, (c) => modelIn(c)?.source.hf);
+  const model = modelIn(catalogName);
+  const schema = listing(catalogName)?.schema;
+  // The variants as listed now. A version is chosen for the kept variant from
+  // its own history: on v2 versions are per variant, on v1 the model's.
+  const variants = model?.variants ?? [];
+  const keptVariant = variant || recorded?.variant || "";
+  const keptPin = variants.find((v) => v.id === keptVariant);
+  const variantMissing = !!model && !keptPin;
+  const history = useQuery({
+    queryKey: ["history", catalogName, recorded?.model, keptVariant],
+    queryFn: () => api.history(recorded!.model, { catalog: catalogName, variant: keptVariant }),
+    enabled: !!recorded && !!catalogName && !variantMissing && !rollbackTo,
+    retry: false,
+  });
+  const versions = history.data?.revisions.map((r) => r.version) ?? [];
   // For the model path default, which is the site's template resolved against
-  // this model's hf -- the same value the deploy page shows.
+  // this model's hf -- the same value the deploy page shows -- and the image.
   const entry = useQuery({
-    queryKey: ["model", catalogName, current.data?.source.model ?? "", version],
-    queryFn: () => api.model(current.data!.source.model, version || undefined, catalogName),
-    enabled: !!current.data && !!catalogName,
+    queryKey: ["model", catalogName, recorded?.model ?? "", keptVariant, version],
+    queryFn: () => api.model(recorded!.model, { catalog: catalogName, variant: keptVariant, version: version || undefined }),
+    enabled: !!recorded && !!catalogName && !variantMissing,
   });
-  const model = modelIn(catalogName);
-  const versions = model?.versions.map((v) => v.version) ?? [];
-  const variants = model?.versions.find((v) => v.version === (version || model.latest))?.variants ?? [];
-  const keptVariant = variant || recorded?.variant || "";
-  const variantMissing = !!model && !variants.some((v) => v.id === keptVariant);
   const chartVersions = useQuery({
     queryKey: ["chart-versions", catalogName, recorded?.model, version, keptVariant],
     queryFn: () =>
@@ -139,6 +149,7 @@ export function Upgrade() {
           variant: variant || undefined,
           catalog: moving ? targetCatalog : undefined,
           chartVersion: chartVersion || undefined,
+          forceGpuProducts: unlistedProducts(keptPin?.requires.gpuProduct, form.gpuProducts).length > 0,
           // The server carries forward anything the form does not cover, so a
           // value set once from a flag survives the upgrade instead of being
           // dropped by a form that never knew about it.
@@ -168,17 +179,17 @@ export function Upgrade() {
   }
 
   const cur = current.data;
-  const targetVersion = version || model?.latest;
+  const targetVersion = version || keptPin?.version;
   // A move is a different catalog's entry, not a republish of this one.
   const digestWarn = moving
     ? undefined
-    : republishWarning(cur.source, model?.versions, targetVersion, variant || cur.source.variant);
-  const site = indexes[catalogs.findIndex((c) => c.name === catalogName)]?.data?.index.site;
-  const optimized = targetVersion ? comparison(variants, targetVersion, model?.tuning) : null;
-  const report = optimized && model ? reportLink(site, model.name, optimized.report) : undefined;
-  const keptInfo = variants.find((v) => v.id === keptVariant);
+    : republishWarning(cur.source, schema, history.data?.revisions, targetVersion, keptVariant);
+  const optimized = comparison(variants, model?.tuning);
+  const report = optimized && model ? reportLink(listing(catalogName)?.site, model.name, optimized.report) : undefined;
   const pickVariant = (id: string) => {
     setVariant(id === cur.source.variant ? "" : id);
+    // On v2 another variant has versions of its own.
+    setVersion("");
     setChartVersion("");
     setPicking(false);
     reset();
@@ -220,7 +231,8 @@ export function Upgrade() {
         </h1>
         <p className="mt-1 flex flex-wrap items-center gap-1 text-sm text-muted-foreground">
           <Badge variant="outline">{namespace}</Badge>
-          <CatalogBadge name={releaseCatalog ?? ""} show={catalogs.length > 1} /> {cur.source.model}
+          <CatalogBadge name={releaseCatalog ?? ""} show={catalogs.length > 1} />
+          <SchemaBadge schema={catalogs.find((c) => c.name === releaseCatalog)?.schema} /> {cur.source.model}
           {cur.source.version && ` v${cur.source.version}`} · {cur.source.variant} · chart{" "}
           {cur.chart.name}-{cur.chart.version}
         </p>
@@ -298,7 +310,12 @@ export function Upgrade() {
               </TargetRow>
             )}
             <TargetRow
-              label="Model version"
+              label={schema === "v2" ? "Variant version" : "Model version"}
+              hint={
+                schema === "v2"
+                  ? "Each variant of a v2 catalog has its own versions; another variant starts on its latest."
+                  : "A v1 version is the model's: every variant of it moves together."
+              }
               from={cur.source.version ?? "unpinned"}
               changing={!!targetVersion && targetVersion !== cur.source.version}
               caption={digestWarn}
@@ -312,8 +329,8 @@ export function Upgrade() {
                   setChartVersion("");
                   reset();
                 }}
-                options={versions}
-                emptyLabel={model?.latest ? `latest (${model.latest})` : "latest"}
+                options={versions.filter((v) => v !== keptPin?.version)}
+                emptyLabel={keptPin ? `latest (${keptPin.version})` : "latest"}
               />
             </TargetRow>
             <TargetRow
@@ -321,7 +338,7 @@ export function Upgrade() {
               hint="Parallelism and hardware. Moving to another catalog keeps the engine, so variants on another one are disabled."
               from={cur.source.variant}
               changing={!!variant && variant !== cur.source.variant}
-              caption={variantMissing ? `${catalogName} has no ${keptVariant} in this version: choose another.` : undefined}
+              caption={variantMissing ? `${catalogName} no longer lists ${keptVariant}: choose another.` : undefined}
               tone="warning"
             >
               <button
@@ -332,9 +349,9 @@ export function Upgrade() {
                 className="flex h-9 w-full items-center gap-2 rounded-md border bg-background px-3 text-left text-sm hover:bg-muted/40 focus-visible:outline-2 focus-visible:outline-offset-1 disabled:cursor-not-allowed disabled:opacity-60"
               >
                 <span className="truncate font-mono">{keptVariant}</span>
-                {keptInfo && (
+                {keptPin && (
                   <span className="hidden truncate text-xs text-muted-foreground sm:inline">
-                    {keptInfo.engine} · {gpuCount(keptInfo.requires)}
+                    {keptPin.engine} · {gpuCount(keptPin.requires)}
                   </span>
                 )}
                 {!variant && <Badge variant="muted">kept</Badge>}
@@ -374,7 +391,7 @@ export function Upgrade() {
           subtitle={
             <>
               {cur.source.model}
-              {targetVersion && ` v${targetVersion}`}
+              {sharedVersion(variants) && ` v${sharedVersion(variants)}`}
               {catalogs.length > 1 && catalogName && ` · ${catalogName}`}
               {moving && ` · a catalog move keeps ${cur.engine}`}
             </>
@@ -394,7 +411,6 @@ export function Upgrade() {
             selected={keptVariant}
             onPick={pickVariant}
             tuning={model?.tuning}
-            version={targetVersion}
             report={report}
             nodes={nodes.data?.nodes}
           />
@@ -413,14 +429,11 @@ export function Upgrade() {
         form={form}
         onChange={update}
         cluster={cluster.data}
-        supportedGPUs={variants.find((v) => v.id === (variant || cur.source.variant))?.requires.gpuProduct}
-        clusterGPUs={nodes.data?.nodes.map((n) => n.GPUProduct)}
+        supportedGPUs={keptPin?.requires.gpuProduct}
+        clusterGPUs={vendorProducts(nodes.data?.nodes, keptPin?.requires.vendor)}
         localPathDefault={entry.data?.localPath}
         localPathPlaceholder={entry.data?.pathTemplate}
-        image={imageOf(
-          entry.data?.entry.variants.find((v) => v.id === (variant || cur.source.variant)),
-          entry.data?.imageRepository,
-        )}
+        image={imageOf(entry.data?.variant, entry.data?.imageRepository)}
         lockIdentity
         readOnly={rollbackTo > 0}
       />
@@ -453,23 +466,23 @@ export function Upgrade() {
   );
 }
 
-// The catalog republished the version this release is on. Only while the
-// target stays on that version and variant: picking another version is a
-// different upgrade, and the index already carries the digest to compare.
-function republishWarning(
+// The catalog republished the version this release is on: the same variant at
+// the same version, under another digest. Only while the target stays on that
+// version and variant, and only against a catalog of the schema the plan was
+// composed from -- a v1 digest is of a version file, a v2 one of a variant file.
+export function republishWarning(
   source: Plan["source"],
-  versions: { version: string; digest: string; variants: { id: string }[] }[] | undefined,
+  schema: CatalogSchema | undefined,
+  revisions: Pick<CatalogRevision, "version" | "digest">[] | undefined,
   targetVersion: string | undefined,
   variant: string,
 ): string | undefined {
-  if (!source.digest || !source.version || !targetVersion || targetVersion !== source.version || !versions) {
-    return;
-  }
-  const published = versions.find((v) => v.version === targetVersion);
-  if (!published || published.digest === source.digest || !published.variants.some((v) => v.id === variant)) {
-    return;
-  }
-  return `version ${targetVersion} variant ${variant}: upstream digest changed since this was deployed`;
+  if (!source.digest || !source.version || !revisions) return;
+  if (targetVersion !== source.version || variant !== source.variant) return;
+  if ((source.schema ?? "v1") !== (schema ?? "v1")) return;
+  const published = revisions.find((r) => r.version === source.version);
+  if (!published || published.digest === source.digest) return;
+  return `version ${source.version} variant ${variant}: upstream digest changed since this was deployed`;
 }
 
 // The cards the model page shows, as an upgrade's choice: the deployed one
@@ -482,21 +495,20 @@ export function VariantChoices({
   selected,
   onPick,
   tuning,
-  version,
   report,
   nodes,
 }: {
-  variants: IndexVariant[];
+  variants: ModelVariant[];
   current: Plan;
   moving: boolean;
   selected: string;
   onPick: (id: string) => void;
   tuning?: Tuning[];
-  version?: string;
   report?: string;
   nodes?: Node[];
 }) {
-  const cmp = version ? comparison(variants, version, tuning) : null;
+  const cmp = comparison(variants, tuning);
+  const shared = sharedVersion(variants);
   return (
     <div className="grid gap-3 md:grid-cols-2">
       {variants.map((v) => {
@@ -509,14 +521,19 @@ export function VariantChoices({
             kind={variantKind(v, tuning)}
             uplift={
               optimized && cmp.uplift != null
-                ? formatUplift(cmp.uplift) + (cmp.version !== version ? ` on v${cmp.version}` : "")
+                ? formatUplift(cmp.uplift) + (cmp.older ? ` on v${cmp.version}` : "")
                 : undefined
             }
             upliftTitle={optimized && cmp.workloads.length ? workloadSummary(cmp) : undefined}
             report={optimized ? report : undefined}
             workloads={optimized && cmp.workloads.length ? cmp.workloads : undefined}
             nodes={nodes}
-            tags={!moving && v.id === current.source.variant && <Badge variant="outline">deployed</Badge>}
+            tags={
+              <>
+                {!shared && <Badge variant="muted">v{v.version}</Badge>}
+                {!moving && v.id === current.source.variant && <Badge variant="outline">deployed</Badge>}
+              </>
+            }
             selected={v.id === selected}
             disabled={otherEngine ? `Runs on ${v.engine}; a catalog move keeps ${current.engine}` : undefined}
             action={
@@ -561,14 +578,14 @@ function WhatMoves({
       </CardHeader>
       <CardContent className="space-y-2">
         <Change label="Catalog" from={currentCatalog} to={proposed.source.catalogName ?? currentCatalog} />
-        <Change label="Model version" from={current.source.version} to={proposed.source.version} />
+        <Change label="Version" from={current.source.version} to={proposed.source.version} />
         <Change
           label="Chart"
           from={`${current.chart.name}-${current.chart.version}`}
           to={`${proposed.chart.name}-${proposed.chart.version}`}
         />
         <Change
-          label="Entry digest"
+          label="Digest"
           from={current.source.digest?.slice(7, 19)}
           to={proposed.source.digest?.slice(7, 19)}
         />
diff --git a/web/src/modules/swiss/standalone/Login.tsx b/web/src/modules/swiss/standalone/Login.tsx
index 8896aef..8357bce 100644
--- a/web/src/modules/swiss/standalone/Login.tsx
+++ b/web/src/modules/swiss/standalone/Login.tsx
@@ -35,7 +35,9 @@ export function Login() {
       qc.setQueryData(["session"], s);
       qc.invalidateQueries({ queryKey: ["session"] });
       const from = (location.state as { from?: string } | null)?.from;
-      navigate(s.initialized ? (from ?? "/") : "/setup", { replace: true });
+      // Only a site with no profile stored goes to setup; the gate sends one
+      // whose profile does not parse to the profile page.
+      navigate((s.setUp ?? s.initialized) ? (from ?? "/") : "/setup", { replace: true });
     },
   });
 
diff --git a/web/src/modules/swiss/standalone/PreviewDeploySettings.tsx b/web/src/modules/swiss/standalone/PreviewDeploySettings.tsx
index c447b0b..81b661e 100644
--- a/web/src/modules/swiss/standalone/PreviewDeploySettings.tsx
+++ b/web/src/modules/swiss/standalone/PreviewDeploySettings.tsx
@@ -39,7 +39,8 @@ export function PreviewDeploySettings() {
           site: "ghcr.io/modelsphere/sglang:latest",
         }}
         supportedGPUs={["NVIDIA-H100-80GB-HBM3", "NVIDIA-B300-SXM6-AC"]}
-        clusterGPUs={["NVIDIA-H100-80GB-HBM3", "NVIDIA-B300-SXM6-AC"]}
+        // H20 is racked here but not listed by the variant: offered dashed, and a forced deploy when picked.
+        clusterGPUs={["NVIDIA-H100-80GB-HBM3", "NVIDIA-B300-SXM6-AC", "NVIDIA-H20"]}
       />
     </div>
   );
diff --git a/web/src/shell/pages/Home.health.test.tsx b/web/src/shell/pages/Home.health.test.tsx
index ba71363..f96e530 100644
--- a/web/src/shell/pages/Home.health.test.tsx
+++ b/web/src/shell/pages/Home.health.test.tsx
@@ -18,7 +18,7 @@ const row = (release: string): Deployment => ({ release, namespace: "models", re
 const status = (release: string, ready: number, total: number, extra: Partial<ReleaseStatus> = {}): ReleaseStatus => ({ release, namespace: "models", exists: true, revision: 1, pods: [], ready, total, ...extra });
 const nodes: NodesResponse = { cluster: "c", nodes: [], summary: { nodes: 1, gpus: 1, gpusUsed: 0 } };
 const cluster: ClusterInfo = { name: "c", profile: "p", catalog: "u", version: "0", allowDeploy: true, catalogs: [{ name: "default", url: "u", source: "u", default: true }] };
-const catalog: CatalogResponse = { name: "default", ref: "r", source: "u", index: { apiVersion: "catalog.swiss/v1", count: 0, models: [] } };
+const catalog: CatalogResponse = { name: "default", ref: "r", source: "u", schema: "v2", models: [] };
 
 function client() {
   return new QueryClient({ defaultOptions: { queries: { retry: false, retryOnMount: false } } });
diff --git a/web/src/shell/pages/Home.test.tsx b/web/src/shell/pages/Home.test.tsx
index f32cc8a..956232e 100644
--- a/web/src/shell/pages/Home.test.tsx
+++ b/web/src/shell/pages/Home.test.tsx
@@ -75,35 +75,19 @@ const catalog: CatalogResponse = {
   name: "default",
   ref: "main",
   source: "https://catalog.example",
-  index: {
-    apiVersion: "catalog.swiss/v1",
-    count: 1,
-    models: [
-      {
-        name: "alpha",
-        displayName: "Alpha Model",
-        source: { hf: "org/alpha" },
-        latest: "2",
-        versions: [
-          {
-            version: "1",
-            path: "alpha-1.yaml",
-            digest: "old",
-            variants: [{ id: "base", engine: "vllm", chart: { name: "vllm", version: "1" }, requires: { gpus: 1 } }],
-          },
-          {
-            version: "2",
-            path: "alpha-2.yaml",
-            digest: "new",
-            variants: [
-              { id: "base", engine: "vllm", chart: { name: "vllm", version: "2" }, requires: { gpus: 1 } },
-              { id: "tuned", engine: "sglang", chart: { name: "sglang", version: "2" }, requires: { gpus: 2 } },
-            ],
-          },
-        ],
-      },
-    ],
-  },
+  schema: "v2",
+  models: [
+    {
+      name: "alpha",
+      displayName: "Alpha Model",
+      source: { hf: "org/alpha" },
+      defaultVariant: "base",
+      variants: [
+        { id: "base", version: "2", digest: "b2", engine: "vllm", chart: { name: "vllm", version: "2" }, requires: { gpus: 1 } },
+        { id: "tuned", version: "2", digest: "t2", engine: "sglang", chart: { name: "sglang", version: "2" }, requires: { gpus: 2 } },
+      ],
+    },
+  ],
 };
 const history = recordedTimeline([], "2026-10-10T12:15:00Z", "2026-10-11T12:15:00Z", true);
 
@@ -170,7 +154,7 @@ describe("model operations dashboard", () => {
     seed(c);
     const html = render(c);
     expect(html).toContain('aria-label="支持模型: 1"');
-    expect(html).toContain('aria-label="配方总数: 3"');
+    expect(html).toContain('aria-label="配方总数: 2"');
     expect(html).not.toContain("Alpha Model");
     expect(html).not.toContain("模型展示");
     expect(html).not.toContain("max-w-[1600px]");
@@ -188,14 +172,11 @@ describe("model operations dashboard", () => {
     c.setQueryData(["catalog", "first"], catalog);
     c.setQueryData(["catalog", "second"], {
       ...catalog,
-      index: {
-        ...catalog.index,
-        models: catalog.index.models.map((m) => ({ ...m, name: "beta", source: { hf: "org/beta" } })),
-      },
+      models: catalog.models.map((m) => ({ ...m, name: "beta", source: { hf: "org/beta" } })),
     });
     const html = render(c);
     expect(html).toContain('aria-label="支持模型: 2"');
-    expect(html).toContain('aria-label="配方总数: 6"');
+    expect(html).toContain('aria-label="配方总数: 4"');
   });
   it("does not present partial catalog results as a complete capability total", () => {
     const c = client();
diff --git a/web/vite.config.ts b/web/vite.config.ts
index 33cfc48..26220f7 100644
--- a/web/vite.config.ts
+++ b/web/vite.config.ts
@@ -26,27 +26,30 @@ function keepDistEmbeddable(): Plugin {
 //
 // | mode             | entry                        | @swiss/lib/host | @swiss/components/ui | /api goes to            | out          |
 // |------------------|------------------------------|-----------------|----------------------|-------------------------|--------------|
-// | (default)        | index.html, console shell    | console.ts      | rise                 | console, :8080          | dist/        |
+// | (default)        | index.html, console shell    | console.ts      | rise                 | console, $CONSOLE       | dist/        |
 // | `--mode swiss`   | modules/swiss/standalone     | standalone.ts   | shadcn               | swissd, $SWISSD         | dist-swiss/  |
 const src = path.resolve(import.meta.dirname, "src");
 const swissDir = path.join(src, "modules/swiss");
 
 const egressProxy = process.env.http_proxy ?? process.env.HTTP_PROXY;
-// The swissd that `npm run dev:swiss` talks to: SWISSD=http://<host>:<port> npm run dev:swiss
+// What the dev server proxies to:
+//   CONSOLE=http://<host>:<port> npm run dev        a console; default the local `go run` on :8080
+//   SWISSD=http://<host>:<port> npm run dev:swiss   a swissd
+const consoleTarget = process.env.CONSOLE ?? "http://localhost:8080";
 const remote = process.env.SWISSD ?? "http://127.0.0.1:8080";
 
+// Through the egress proxy, except to this machine, which the proxy cannot reach.
+function via(target: string): ProxyOptions {
+  const local = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/.test(target);
+  return { target, changeOrigin: true, agent: egressProxy && !local ? new HttpProxyAgent(egressProxy) : undefined };
+}
+
 export default defineConfig(({ mode }) => {
   const swiss = mode === "swiss";
   const proxy: Record<string, string | ProxyOptions> = swiss
     ? // swissd's own login: its session cookie is host-only and plain-http here, so it rides the proxy.
-      {
-        "/api": {
-          target: remote,
-          changeOrigin: true,
-          agent: egressProxy ? new HttpProxyAgent(egressProxy) : undefined,
-        },
-      }
-    : { "/api": "http://localhost:8080", "/oauth": "http://localhost:8080" };
+      { "/api": via(remote) }
+    : { "/api": via(consoleTarget), "/oauth": via(consoleTarget) };
   return {
     root: swiss ? path.join(swissDir, "standalone") : undefined,
     plugins: [react(), tailwindcss(), ...(swiss ? [] : [keepDistEmbeddable()])],