Publish AirGPT Hub H1.1

README.md

@@ -12,12 +12,17 @@ license: mit
 
 Vertical model discovery for embodied AI. The Space reads the public
 [`airgpt/embodied-model-index`](https://huggingface.co/datasets/airgpt/embodied-model-index)
-catalog and exposes a responsive browser plus a small read-only API.
+catalog and exposes a responsive browser plus a small API.
 
 The interface shows verified runtime revisions, VRAM guidance, model licenses, real
 validation previews, and copyable AirGPT Runtime commands. Asset provenance is recorded
 in [`ASSET_NOTICES.md`](ASSET_NOTICES.md).
 
+Catalog entries are enriched with cached public Hugging Face metadata, including revision
+drift, downloads, likes, gating, library, and pipeline information. The suggestion form
+validates public model repositories and generates an unverified candidate manifest. It
+does not store submissions or hold an organization token.
+
 ## Local development
 
 ```bash
@@ -30,9 +35,17 @@ Set `AIRGPT_CATALOG_URL` to use another catalog. If Hugging Face is unavailable,
 falls back to `data/index.json` bundled in the image.
 
 The organization Space uses the Docker SDK with FastAPI, a live five-minute catalog
-cache, and a read-only API. The synchronized `data/index.json` snapshot remains available
+and metadata cache. The synchronized `data/index.json` snapshot remains available
 when Hugging Face is temporarily unreachable.
 
+Maintainers can review a candidate locally. The command prints a merged preview unless
+`--publish` is explicitly supplied:
+
+```bash
+python scripts/review_candidate.py candidate.json
+HF_TOKEN=... python scripts/review_candidate.py candidate.json --publish
+```
+
 ## Publish
 
 ```bash

app.js

@@ -10,6 +10,7 @@ const state = { models: [], task: "all", verifiedOnly: true, query: "", sort: "v
 const $ = (id) => document.getElementById(id);
 const grid = $("modelGrid");
 const dialog = $("modelDialog");
+const submissionDialog = $("submissionDialog");
 
 function escapeHtml(value) {
   return String(value ?? "").replace(/[&<>'"]/g, (char) => ({
@@ -17,9 +18,22 @@ function escapeHtml(value) {
   })[char]);
 }
 
-async function api(path) {
-  const response = await fetch(path, { headers: { Accept: "application/json" } });
-  if (!response.ok) throw new Error(`Request failed (${response.status})`);
+async function api(path, options = {}) {
+  const response = await fetch(path, {
+    ...options,
+    headers: { Accept: "application/json", ...(options.headers || {}) },
+  });
+  if (!response.ok) {
+    let message = `Request failed (${response.status})`;
+    try {
+      const body = await response.json();
+      if (typeof body.detail === "string") message = body.detail;
+      else if (Array.isArray(body.detail)) message = body.detail.map((item) => item.msg).join("; ");
+    } catch (_) {
+      // Keep the status-based message when the response is not JSON.
+    }
+    throw new Error(message);
+  }
   return response.json();
 }
 
@@ -31,6 +45,10 @@ function badge(label, className = "") {
   return `<span class="badge ${className}">${escapeHtml(label)}</span>`;
 }
 
+function compactNumber(value) {
+  return new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value || 0);
+}
+
 function commandFor(model) {
   const path = `.cache/models/${model.slug}`;
   const dtype = model.runtime.dtype ? ` --dtype ${model.runtime.dtype}` : "";
@@ -112,15 +130,26 @@ function openModel(model, updateHistory = false) {
   $("detailTitle").textContent = model.display_name;
   $("detailSummary").textContent = model.summary;
   $("modelCardLink").href = `https://huggingface.co/${model.source.repo_id}`;
-  $("detailBadges").innerHTML = badge(model.verification.status, "verified") + badge(taskLabels[model.task], model.task === "world" ? "world" : "") + badge(model.source.license, "license");
-  $("detailSpecs").innerHTML = [
+  const upstream = model.upstream;
+  const updateBadge = upstream?.update_available ? badge("update available", "update") : "";
+  $("detailBadges").innerHTML = badge(model.verification.status, "verified") + badge(taskLabels[model.task], model.task === "world" ? "world" : "") + badge(model.source.license, "license") + updateBadge;
+  const specs = [
     spec("Recommended VRAM", `${model.hardware.recommended_vram_gb} GB`),
     spec("Minimum VRAM", `${model.hardware.minimum_vram_gb} GB`),
     spec("Backend", model.runtime.backend),
     spec("Adapter", model.runtime.adapter),
     spec("Revision", model.source.revision.slice(0, 12)),
     spec("Device", model.runtime.device),
-  ].join("");
+  ];
+  if (upstream) {
+    specs.push(
+      spec("Downloads", compactNumber(upstream.downloads)),
+      spec("Likes", compactNumber(upstream.likes)),
+      spec("Latest revision", upstream.latest_revision.slice(0, 12)),
+      spec("Upstream status", upstream.update_available ? "Update available" : "Pinned revision current"),
+    );
+  }
+  $("detailSpecs").innerHTML = specs.join("");
   $("commandOutput").textContent = commandFor(model);
   $("manifestOutput").textContent = JSON.stringify(model, null, 2);
   $("verificationPanel").innerHTML = `
@@ -159,6 +188,68 @@ function toast(message) {
   window.setTimeout(() => node.classList.remove("visible"), 1600);
 }
 
+function openSubmission() {
+  $("submissionForm").classList.remove("hidden");
+  $("submissionResult").classList.add("hidden");
+  $("submissionError").classList.add("hidden");
+  if (!submissionDialog.open) submissionDialog.showModal();
+}
+
+function closeSubmission() {
+  if (submissionDialog.open) submissionDialog.close();
+}
+
+function submissionPayload(form) {
+  const data = new FormData(form);
+  const optional = (name) => String(data.get(name) || "").trim() || null;
+  return {
+    repo_id: String(data.get("repo_id") || "").trim(),
+    slug: String(data.get("slug") || "").trim(),
+    display_name: optional("display_name"),
+    task: data.get("task"),
+    registry_model: String(data.get("registry_model") || "").trim(),
+    backend: String(data.get("backend") || "").trim(),
+    adapter: String(data.get("adapter") || "").trim(),
+    device: String(data.get("device") || "").trim(),
+    dtype: optional("dtype"),
+    minimum_vram_gb: Number(data.get("minimum_vram_gb")),
+    recommended_vram_gb: Number(data.get("recommended_vram_gb")),
+    summary: String(data.get("summary") || "").trim(),
+    tags: String(data.get("tags") || "").split(",").map((tag) => tag.trim()).filter(Boolean),
+  };
+}
+
+async function validateSubmission(event) {
+  event.preventDefault();
+  const form = event.currentTarget;
+  const submit = $("validateSubmission");
+  const error = $("submissionError");
+  error.classList.add("hidden");
+  submit.disabled = true;
+  submit.textContent = "Validating...";
+  try {
+    const result = await api("/api/submissions/validate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(submissionPayload(form)),
+    });
+    $("candidateOutput").textContent = JSON.stringify(result.candidate, null, 2);
+    $("submissionWarnings").innerHTML = result.warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join("");
+    $("submissionWarnings").classList.toggle("hidden", result.warnings.length === 0);
+    $("submissionStatus").textContent = result.warnings.length
+      ? `Validated with ${result.warnings.length} item${result.warnings.length === 1 ? "" : "s"} for maintainer review.`
+      : "Validated against the current Hugging Face revision.";
+    form.classList.add("hidden");
+    $("submissionResult").classList.remove("hidden");
+  } catch (requestError) {
+    error.textContent = requestError.message;
+    error.classList.remove("hidden");
+  } finally {
+    submit.disabled = false;
+    submit.textContent = "Validate candidate";
+  }
+}
+
 async function loadCatalog() {
   try {
     const body = await api("/api/catalog");
@@ -204,6 +295,18 @@ $("copyCommand").addEventListener("click", async () => {
   await navigator.clipboard.writeText(commandFor(state.current));
   toast("Command copied");
 });
+$("openSubmission").addEventListener("click", openSubmission);
+$("closeSubmission").addEventListener("click", closeSubmission);
+$("submissionForm").addEventListener("submit", validateSubmission);
+$("editSubmission").addEventListener("click", () => {
+  $("submissionResult").classList.add("hidden");
+  $("submissionForm").classList.remove("hidden");
+});
+$("copyCandidate").addEventListener("click", async () => {
+  await navigator.clipboard.writeText($("candidateOutput").textContent);
+  toast("Candidate copied");
+});
+submissionDialog.addEventListener("click", (event) => { if (event.target === submissionDialog) closeSubmission(); });
 window.addEventListener("popstate", () => {
   const slug = new URLSearchParams(location.search).get("model");
   const model = state.models.find((item) => item.slug === slug);

app/catalog.py

@@ -9,6 +9,8 @@ from typing import Literal
 import httpx
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from .huggingface import HuggingFaceClient, HuggingFaceError
+
 
 ROOT = Path(__file__).resolve().parents[1]
 DEFAULT_CATALOG_URL = (
@@ -56,6 +58,21 @@ class Verification(BaseModel):
     checks: list[str] = Field(default_factory=list)
 
 
+class UpstreamMetadata(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    latest_revision: str
+    revision_current: bool
+    update_available: bool
+    downloads: int = Field(ge=0)
+    likes: int = Field(ge=0)
+    last_modified: str | None = None
+    gated: bool
+    license: str
+    library: str | None = None
+    pipeline_tag: str | None = None
+
+
 class HubModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -68,6 +85,7 @@ class HubModel(BaseModel):
     runtime: Runtime
     hardware: Hardware
     verification: Verification
+    upstream: UpstreamMetadata | None = None
 
 
 class Catalog(BaseModel):
@@ -93,6 +111,8 @@ class CatalogService:
         fallback_path: Path = DEFAULT_FALLBACK_PATH,
         ttl_seconds: int = 300,
         timeout_seconds: float = 15.0,
+        hf_client: HuggingFaceClient | None = None,
+        enrich_metadata: bool = True,
     ):
         self.catalog_url = (
             catalog_url
@@ -102,6 +122,8 @@ class CatalogService:
         self.fallback_path = fallback_path
         self.ttl_seconds = ttl_seconds
         self.timeout_seconds = timeout_seconds
+        self.hf_client = hf_client or HuggingFaceClient(ttl_seconds=ttl_seconds)
+        self.enrich_metadata = enrich_metadata
         self.source = "not-loaded"
         self.error: str | None = None
         self._catalog: Catalog | None = None
@@ -123,6 +145,8 @@ class CatalogService:
             catalog = await self._load_remote() if self.catalog_url else None
             if catalog is None:
                 catalog = self._load_fallback()
+            if self.enrich_metadata:
+                catalog = await self._enrich(catalog)
             self._catalog = catalog
             self._loaded_at = time.monotonic()
             return catalog
@@ -151,6 +175,30 @@ class CatalogService:
         self.source = "bundled"
         return catalog
 
+    async def _enrich(self, catalog: Catalog) -> Catalog:
+        async def enrich_model(model: HubModel) -> HubModel:
+            try:
+                upstream = await self.hf_client.model(model.source.repo_id)
+            except (HuggingFaceError, ValueError):
+                return model
+            current = upstream.revision == model.source.revision
+            metadata = UpstreamMetadata(
+                latest_revision=upstream.revision,
+                revision_current=current,
+                update_available=not current,
+                downloads=upstream.downloads,
+                likes=upstream.likes,
+                last_modified=upstream.last_modified,
+                gated=upstream.gated,
+                license=upstream.license,
+                library=upstream.library,
+                pipeline_tag=upstream.pipeline_tag,
+            )
+            return model.model_copy(update={"upstream": metadata})
+
+        models = await asyncio.gather(*(enrich_model(model) for model in catalog.models))
+        return catalog.model_copy(update={"models": list(models)})
+
     async def model(self, slug: str) -> HubModel | None:
         catalog = await self.get()
         return next((model for model in catalog.models if model.slug == slug), None)

app/huggingface.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+from typing import Any
+
+import httpx
+from pydantic import BaseModel, ConfigDict, Field
+
+
+HF_API_URL = "https://huggingface.co/api/models"
+REPO_ID_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,95}/[A-Za-z0-9][A-Za-z0-9._-]{0,95}$")
+ROBOTICS_SIGNALS = {
+    "action",
+    "embodied",
+    "locomotion",
+    "manipulation",
+    "navigation",
+    "robot",
+    "robotics",
+    "state-space",
+    "vla",
+    "world-model",
+}
+
+
+class HuggingFaceError(RuntimeError):
+    pass
+
+
+class HuggingFaceModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    repo_id: str
+    revision: str
+    downloads: int = Field(default=0, ge=0)
+    likes: int = Field(default=0, ge=0)
+    last_modified: str | None = None
+    gated: bool = False
+    license: str = "other"
+    library: str | None = None
+    pipeline_tag: str | None = None
+    tags: list[str] = Field(default_factory=list)
+
+    def has_robotics_signal(self) -> bool:
+        values = {tag.casefold() for tag in self.tags}
+        if self.pipeline_tag:
+            values.add(self.pipeline_tag.casefold())
+        return bool(values & ROBOTICS_SIGNALS) or any(
+            signal in value for value in values for signal in ROBOTICS_SIGNALS
+        )
+
+
+def validate_repo_id(repo_id: str) -> str:
+    normalized = repo_id.strip()
+    if not REPO_ID_PATTERN.fullmatch(normalized):
+        raise ValueError("repo_id must use the owner/model format")
+    return normalized
+
+
+def _license_from(payload: dict[str, Any], tags: list[str]) -> str:
+    card_data = payload.get("cardData") or {}
+    license_name = card_data.get("license")
+    if isinstance(license_name, str) and license_name.strip():
+        return license_name.strip().casefold()
+    for tag in tags:
+        if tag.casefold().startswith("license:"):
+            return tag.split(":", 1)[1].strip().casefold() or "other"
+    return "other"
+
+
+def normalize_model(payload: dict[str, Any]) -> HuggingFaceModel:
+    repo_id = validate_repo_id(str(payload.get("id") or payload.get("modelId") or ""))
+    revision = str(payload.get("sha") or "").strip()
+    if not revision:
+        raise ValueError(f"Hugging Face did not return a revision for {repo_id}")
+    tags = [str(tag) for tag in payload.get("tags") or [] if isinstance(tag, str)]
+    gated_value = payload.get("gated", False)
+    return HuggingFaceModel(
+        repo_id=repo_id,
+        revision=revision,
+        downloads=max(int(payload.get("downloads") or 0), 0),
+        likes=max(int(payload.get("likes") or 0), 0),
+        last_modified=payload.get("lastModified"),
+        gated=gated_value is not False and gated_value is not None,
+        license=_license_from(payload, tags),
+        library=payload.get("library_name"),
+        pipeline_tag=payload.get("pipeline_tag"),
+        tags=tags,
+    )
+
+
+class HuggingFaceClient:
+    def __init__(
+        self,
+        *,
+        ttl_seconds: int = 300,
+        timeout_seconds: float = 12.0,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ):
+        self.ttl_seconds = ttl_seconds
+        self.timeout_seconds = timeout_seconds
+        self.transport = transport
+        self._cache: dict[str, tuple[float, Any]] = {}
+        self._lock = asyncio.Lock()
+
+    async def _get_json(self, url: str, *, params: dict[str, Any] | None = None) -> Any:
+        try:
+            async with httpx.AsyncClient(
+                timeout=self.timeout_seconds,
+                follow_redirects=True,
+                transport=self.transport,
+            ) as client:
+                response = await client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+        except (httpx.HTTPError, ValueError) as exc:
+            raise HuggingFaceError(str(exc)) from exc
+
+    async def _cached(self, key: str, loader) -> Any:
+        now = time.monotonic()
+        cached = self._cache.get(key)
+        if cached and now - cached[0] < self.ttl_seconds:
+            return cached[1]
+        async with self._lock:
+            now = time.monotonic()
+            cached = self._cache.get(key)
+            if cached and now - cached[0] < self.ttl_seconds:
+                return cached[1]
+            value = await loader()
+            self._cache[key] = (time.monotonic(), value)
+            return value
+
+    async def model(self, repo_id: str, *, refresh: bool = False) -> HuggingFaceModel:
+        repo_id = validate_repo_id(repo_id)
+        key = f"model:{repo_id.casefold()}"
+        if refresh:
+            self._cache.pop(key, None)
+
+        async def load() -> HuggingFaceModel:
+            payload = await self._get_json(f"{HF_API_URL}/{repo_id}")
+            try:
+                return normalize_model(payload)
+            except (TypeError, ValueError) as exc:
+                raise HuggingFaceError(str(exc)) from exc
+
+        return await self._cached(key, load)
+
+    async def discover(self, query: str, *, limit: int = 12) -> list[HuggingFaceModel]:
+        query = query.strip()
+        if not query:
+            return []
+        safe_limit = min(max(limit, 1), 30)
+        key = f"discover:{query.casefold()}:{safe_limit}"
+
+        async def load() -> list[HuggingFaceModel]:
+            payload = await self._get_json(
+                HF_API_URL,
+                params={"search": query, "limit": safe_limit, "full": "true"},
+            )
+            if not isinstance(payload, list):
+                raise HuggingFaceError("unexpected Hugging Face search response")
+            models = []
+            for item in payload:
+                try:
+                    model = normalize_model(item)
+                except (TypeError, ValueError):
+                    continue
+                if model.has_robotics_signal():
+                    models.append(model)
+            return models
+
+        return await self._cached(key, load)

app/main.py

@@ -8,13 +8,20 @@ from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
 from .catalog import ROOT, CatalogService
+from .huggingface import HuggingFaceClient, HuggingFaceError
+from .submissions import SubmissionRequest, SubmissionResult, SubmissionService
 
 
 ASSET_DIR = ROOT / "assets"
 
 
-def create_app(catalog_service: CatalogService | None = None) -> FastAPI:
-    service = catalog_service or CatalogService()
+def create_app(
+    catalog_service: CatalogService | None = None,
+    hf_client: HuggingFaceClient | None = None,
+) -> FastAPI:
+    shared_hf_client = hf_client or HuggingFaceClient()
+    service = catalog_service or CatalogService(hf_client=shared_hf_client)
+    submissions = SubmissionService(shared_hf_client)
 
     @asynccontextmanager
     async def lifespan(_: FastAPI):
@@ -23,12 +30,13 @@ def create_app(catalog_service: CatalogService | None = None) -> FastAPI:
 
     app = FastAPI(
         title="AirGPT Hub",
-        version="0.1.0",
+        version="0.1.1",
         docs_url="/api/docs",
         openapi_url="/api/openapi.json",
         lifespan=lifespan,
     )
     app.state.catalog = service
+    app.state.huggingface = shared_hf_client
     app.mount("/assets", StaticFiles(directory=ASSET_DIR), name="assets")
 
     @app.get("/", include_in_schema=False)
@@ -92,6 +100,29 @@ def create_app(catalog_service: CatalogService | None = None) -> FastAPI:
             "models": results,
         }
 
+    @app.get("/api/discover")
+    async def discover(q: str = Query(min_length=2, max_length=100)):
+        try:
+            models = await shared_hf_client.discover(q)
+        except HuggingFaceError as exc:
+            raise HTTPException(
+                status_code=502, detail=f"Hugging Face lookup failed: {exc}"
+            ) from exc
+        return {"query": q, "count": len(models), "models": models}
+
+    @app.post(
+        "/api/submissions/validate",
+        response_model=SubmissionResult,
+        response_model_exclude_none=True,
+    )
+    async def validate_submission(request: SubmissionRequest):
+        try:
+            return await submissions.validate(request)
+        except HuggingFaceError as exc:
+            raise HTTPException(
+                status_code=422, detail=f"Model repository could not be validated: {exc}"
+            ) from exc
+
     return app
 
 

app/submissions.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import re
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from .catalog import Hardware, HubModel, Runtime, Source, Verification
+from .huggingface import HuggingFaceClient, HuggingFaceModel, validate_repo_id
+
+
+SLUG_PATTERN = re.compile(r"^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$")
+ROBOTICS_TAGS = {"embodied", "manipulation", "navigation", "robot", "robotics", "vla"}
+
+
+class SubmissionRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
+
+    repo_id: str
+    slug: str
+    display_name: str | None = Field(default=None, min_length=2, max_length=100)
+    task: Literal["vla", "world", "state_world"]
+    registry_model: str = Field(min_length=1, max_length=100)
+    backend: str = Field(min_length=1, max_length=100)
+    adapter: str = Field(min_length=1, max_length=100)
+    device: str = Field(default="cuda:0", min_length=1, max_length=50)
+    dtype: str | None = Field(default=None, max_length=50)
+    minimum_vram_gb: int = Field(ge=0, le=1024)
+    recommended_vram_gb: int = Field(ge=0, le=1024)
+    summary: str = Field(min_length=20, max_length=400)
+    tags: list[str] = Field(default_factory=list, max_length=12)
+
+    @field_validator("repo_id")
+    @classmethod
+    def valid_repo_id(cls, value: str) -> str:
+        return validate_repo_id(value)
+
+    @field_validator("slug")
+    @classmethod
+    def valid_slug(cls, value: str) -> str:
+        if not SLUG_PATTERN.fullmatch(value):
+            raise ValueError("slug must contain lowercase letters, numbers, and internal hyphens")
+        return value
+
+    @field_validator("tags")
+    @classmethod
+    def normalize_tags(cls, values: list[str]) -> list[str]:
+        normalized = []
+        for value in values:
+            tag = value.strip().casefold()
+            if tag and tag not in normalized:
+                normalized.append(tag)
+        return normalized
+
+    @model_validator(mode="after")
+    def valid_vram_range(self):
+        if self.minimum_vram_gb > self.recommended_vram_gb:
+            raise ValueError("recommended_vram_gb must be at least minimum_vram_gb")
+        return self
+
+
+class SubmissionResult(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    candidate: HubModel
+    upstream: HuggingFaceModel
+    warnings: list[str]
+
+
+class SubmissionService:
+    def __init__(self, hf_client: HuggingFaceClient):
+        self.hf_client = hf_client
+
+    async def validate(self, request: SubmissionRequest) -> SubmissionResult:
+        upstream = await self.hf_client.model(request.repo_id, refresh=True)
+        warnings = []
+        if upstream.gated:
+            warnings.append("This model is gated; users must authenticate and accept its terms.")
+        if upstream.license in {"", "other", "unknown"}:
+            warnings.append("The upstream license needs manual review before publication.")
+        combined_tags = list(dict.fromkeys([*request.tags, *upstream.tags]))
+        if not upstream.has_robotics_signal() and not (set(request.tags) & ROBOTICS_TAGS):
+            warnings.append("No clear robotics or embodied-AI tag was found upstream.")
+        if not upstream.library:
+            warnings.append(
+                "The Hugging Face library is not declared; verify the runtime backend manually."
+            )
+
+        display_name = request.display_name or request.repo_id.split("/", 1)[1].replace("-", " ")
+        candidate = HubModel(
+            slug=request.slug,
+            display_name=display_name,
+            summary=request.summary,
+            task=request.task,
+            tags=combined_tags[:12],
+            source=Source(
+                provider="huggingface",
+                repo_id=upstream.repo_id,
+                revision=upstream.revision,
+                gated=upstream.gated,
+                license=upstream.license,
+                license_url=f"https://huggingface.co/{upstream.repo_id}",
+            ),
+            runtime=Runtime(
+                registry_model=request.registry_model,
+                backend=request.backend,
+                adapter=request.adapter,
+                device=request.device,
+                dtype=request.dtype,
+            ),
+            hardware=Hardware(
+                minimum_vram_gb=request.minimum_vram_gb,
+                recommended_vram_gb=request.recommended_vram_gb,
+                notes="Community suggestion; hardware guidance is not yet verified.",
+            ),
+            verification=Verification(status="unverified"),
+        )
+        return SubmissionResult(candidate=candidate, upstream=upstream, warnings=warnings)

index.html

@@ -47,10 +47,13 @@
             <button type="button" data-task="world" role="tab" aria-selected="false">World</button>
             <button type="button" data-task="state_world" role="tab" aria-selected="false">State space</button>
           </div>
-          <label class="verified-toggle">
-            <input id="verifiedOnly" type="checkbox" checked>
-            <span>Verified only</span>
-          </label>
+          <div class="toolbar-actions">
+            <label class="verified-toggle">
+              <input id="verifiedOnly" type="checkbox" checked>
+              <span>Verified only</span>
+            </label>
+            <button id="openSubmission" class="primary-button" type="button">Suggest model</button>
+          </div>
         </div>
       </section>
 
@@ -106,6 +109,53 @@
       </article>
     </dialog>
 
+    <dialog id="submissionDialog" class="submission-dialog">
+      <article>
+        <header class="dialog-header">
+          <div>
+            <p class="eyebrow">Community catalog</p>
+            <h2>Suggest a model</h2>
+          </div>
+          <button id="closeSubmission" class="close-button inline-close" type="button" aria-label="Close model suggestion">&times;</button>
+        </header>
+        <form id="submissionForm">
+          <div class="submission-fields">
+            <label class="wide-field">Hugging Face repository<input name="repo_id" placeholder="organization/model" required pattern="[A-Za-z0-9][A-Za-z0-9._\-]*\/[A-Za-z0-9][A-Za-z0-9._\-]*"></label>
+            <label>Display name<input name="display_name" placeholder="Optional"></label>
+            <label>Catalog slug<input name="slug" placeholder="model-name" required pattern="[a-z0-9][a-z0-9\-]{1,62}[a-z0-9]"></label>
+            <label>Task<select name="task" required><option value="vla">VLA</option><option value="world">World model</option><option value="state_world">State space</option></select></label>
+            <label>Runtime model<input name="registry_model" placeholder="openvla" required></label>
+            <label>Backend<input name="backend" value="transformers" required></label>
+            <label>Adapter<input name="adapter" placeholder="openvla" required></label>
+            <label>Device<input name="device" value="cuda:0" required></label>
+            <label>Dtype<input name="dtype" placeholder="bfloat16"></label>
+            <label>Minimum VRAM (GB)<input name="minimum_vram_gb" type="number" min="0" max="1024" value="16" required></label>
+            <label>Recommended VRAM (GB)<input name="recommended_vram_gb" type="number" min="0" max="1024" value="24" required></label>
+            <label class="wide-field">Tags<input name="tags" placeholder="robotics, manipulation, vla"></label>
+            <label class="wide-field">Summary<textarea name="summary" minlength="20" maxlength="400" placeholder="What this model does and which embodied task it supports" required></textarea></label>
+          </div>
+          <p class="submission-note">Validation reads public Hugging Face metadata and pins the current revision. Suggestions are not published automatically.</p>
+          <div id="submissionError" class="form-error hidden" role="alert"></div>
+          <div class="form-actions">
+            <a class="secondary-button" href="https://huggingface.co/datasets/airgpt/embodied-model-index/discussions" target="_blank" rel="noreferrer">Catalog discussions</a>
+            <button id="validateSubmission" class="primary-button" type="submit">Validate candidate</button>
+          </div>
+        </form>
+        <section id="submissionResult" class="submission-result hidden" aria-live="polite">
+          <div>
+            <h3>Candidate manifest</h3>
+            <p id="submissionStatus"></p>
+          </div>
+          <ul id="submissionWarnings" class="warning-list"></ul>
+          <pre id="candidateOutput" class="candidate-output"></pre>
+          <div class="form-actions">
+            <button id="editSubmission" class="secondary-action" type="button">Edit fields</button>
+            <button id="copyCandidate" class="primary-button" type="button">Copy candidate</button>
+          </div>
+        </section>
+      </article>
+    </dialog>
+
     <div id="toast" class="toast" role="status"></div>
     <script src="/app.js" defer></script>
   </body>

scripts/__init__.py

@@ -0,0 +1 @@
+"""Maintainer utilities for AirGPT Hub."""

scripts/publish_space.py

@@ -44,7 +44,7 @@ def main() -> int:
         repo_id=args.repo_id,
         repo_type="space",
         folder_path=str(ROOT),
-        commit_message="Publish AirGPT Hub H1",
+        commit_message="Publish AirGPT Hub H1.1",
         ignore_patterns=[
             ".git/**",
             ".pytest_cache/**",

scripts/review_candidate.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from app.catalog import Catalog, HubModel  # noqa: E402
+from app.huggingface import HuggingFaceClient  # noqa: E402
+
+
+CATALOG_URL = "https://huggingface.co/datasets/airgpt/embodied-model-index/resolve/main/index.json"
+
+
+def merge_candidate(catalog: Catalog, candidate: HubModel) -> Catalog:
+    if any(model.slug == candidate.slug for model in catalog.models):
+        raise ValueError(f"duplicate slug: {candidate.slug}")
+    if any(
+        model.source.repo_id.casefold() == candidate.source.repo_id.casefold()
+        for model in catalog.models
+    ):
+        raise ValueError(f"duplicate repository: {candidate.source.repo_id}")
+    if candidate.verification.status != "unverified":
+        raise ValueError("new candidates must have unverified status")
+    generated_at = datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+    return catalog.model_copy(
+        update={"generated_at": generated_at, "models": [*catalog.models, candidate]}
+    )
+
+
+def load_candidate(path: Path) -> HubModel:
+    payload: dict[str, Any] = json.loads(path.read_text(encoding="utf-8"))
+    if "candidate" in payload:
+        payload = payload["candidate"]
+    payload.pop("upstream", None)
+    return HubModel.model_validate(payload)
+
+
+async def build_preview(candidate_path: Path) -> Catalog:
+    candidate = load_candidate(candidate_path)
+    upstream = await HuggingFaceClient().model(candidate.source.repo_id, refresh=True)
+    if upstream.revision != candidate.source.revision:
+        raise ValueError(
+            "candidate revision is stale: "
+            f"expected {candidate.source.revision}, upstream is {upstream.revision}"
+        )
+    candidate = candidate.model_copy(
+        update={
+            "source": candidate.source.model_copy(
+                update={"gated": upstream.gated, "license": upstream.license}
+            )
+        }
+    )
+    async with httpx.AsyncClient(timeout=20, follow_redirects=True) as client:
+        response = await client.get(CATALOG_URL)
+        response.raise_for_status()
+    catalog = Catalog.model_validate(response.json())
+    return merge_candidate(catalog, candidate)
+
+
+def publish(catalog: Catalog, token: str) -> None:
+    try:
+        from huggingface_hub import HfApi
+    except ImportError as exc:
+        raise RuntimeError("install huggingface_hub before publishing") from exc
+    HfApi(token=token).upload_file(
+        path_or_fileobj=catalog.model_dump_json(indent=2).encode(),
+        path_in_repo="index.json",
+        repo_id="airgpt/embodied-model-index",
+        repo_type="dataset",
+        commit_message="Add reviewed AirGPT Hub candidate",
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="review an AirGPT Hub candidate manifest")
+    parser.add_argument("candidate", type=Path)
+    parser.add_argument("--publish", action="store_true", help="write the reviewed catalog to HF")
+    args = parser.parse_args()
+    catalog = asyncio.run(build_preview(args.candidate))
+    print(catalog.model_dump_json(indent=2))
+    if args.publish:
+        token = os.getenv("HF_TOKEN")
+        if not token:
+            parser.error("HF_TOKEN is required with --publish")
+        publish(catalog, token)
+    else:
+        print("\nPreview only. Re-run with --publish after manual review.", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

styles.css

@@ -29,7 +29,7 @@ body {
   color: var(--ink);
 }
 
-button, input, select { font: inherit; }
+button, input, select, textarea { font: inherit; }
 
 button, a { -webkit-tap-highlight-color: transparent; }
 
@@ -169,6 +169,22 @@ input[type="search"]:focus, select:focus { border-color: var(--green); box-shado
 
 .verified-toggle input { width: 17px; height: 17px; accent-color: var(--green); }
 
+.toolbar-actions { display: flex; align-items: center; gap: 18px; }
+
+.primary-button, .secondary-action {
+  min-height: 38px;
+  padding: 8px 13px;
+  border-radius: 6px;
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 750;
+}
+
+.primary-button { border: 1px solid var(--green); background: var(--green); color: white; }
+.primary-button:hover { background: var(--green-dark); border-color: var(--green-dark); }
+.primary-button:disabled { cursor: wait; opacity: 0.65; }
+.secondary-action { border: 1px solid var(--border-strong); background: var(--surface); color: #33413b; }
+
 .catalog-content { max-width: 1552px; margin: 0 auto; padding: 28px clamp(16px, 4vw, 56px) 52px; }
 
 .model-grid {
@@ -226,6 +242,7 @@ input[type="search"]:focus, select:focus { border-color: var(--green); box-shado
 .badge.verified { background: var(--green-soft); border-color: #afd9c8; color: var(--green-dark); }
 .badge.world { background: var(--blue-soft); border-color: #bfd0ed; color: var(--blue); }
 .badge.license { background: var(--amber-soft); border-color: #ead29a; color: var(--amber); }
+.badge.update { background: #fde8e7; border-color: #e8b8b4; color: #963c34; }
 
 .card-body { min-height: 268px; padding: 18px; display: flex; flex-direction: column; }
 .repo-name { margin: 0 0 5px; color: var(--muted); font: 12px/1.35 ui-monospace, SFMono-Regular, Menlo, monospace; overflow-wrap: anywhere; }
@@ -370,6 +387,47 @@ pre {
 }
 .toast.visible { opacity: 1; transform: translate(-50%, 0); }
 
+.submission-dialog {
+  width: min(760px, calc(100vw - 32px));
+  max-height: calc(100vh - 32px);
+  padding: 0;
+  overflow: hidden;
+  border: 0;
+  border-radius: 8px;
+  background: var(--surface);
+  box-shadow: var(--shadow);
+}
+
+.submission-dialog::backdrop { background: rgba(17, 28, 23, 0.6); }
+.submission-dialog article { max-height: calc(100vh - 32px); padding: 28px; overflow-y: auto; }
+.dialog-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; }
+.dialog-header h2 { margin: 3px 0 0; font-size: 25px; letter-spacing: 0; }
+.inline-close { position: static; flex: 0 0 auto; }
+.submission-fields { margin-top: 24px; display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 15px; }
+.submission-fields label { min-width: 0; color: #53615b; font-size: 12px; font-weight: 700; }
+.submission-fields .wide-field { grid-column: 1 / -1; }
+.submission-fields input, .submission-fields select, .submission-fields textarea {
+  width: 100%;
+  margin-top: 6px;
+  border: 1px solid var(--border-strong);
+  border-radius: 6px;
+  background: var(--surface);
+  color: var(--ink);
+  outline: none;
+}
+.submission-fields input, .submission-fields select { height: 42px; padding: 0 11px; }
+.submission-fields textarea { min-height: 88px; padding: 10px 11px; resize: vertical; line-height: 1.45; }
+.submission-fields input:focus, .submission-fields select:focus, .submission-fields textarea:focus { border-color: var(--green); box-shadow: 0 0 0 3px rgba(20, 120, 91, 0.12); }
+.submission-note { margin: 16px 0 0; color: var(--muted); font-size: 12px; line-height: 1.5; }
+.form-actions { margin-top: 18px; display: flex; align-items: center; justify-content: flex-end; gap: 10px; }
+.form-error { margin-top: 14px; padding: 10px 12px; border-left: 3px solid #a6463d; background: #fdeceb; color: #7f3029; font-size: 13px; }
+.submission-result { padding-top: 22px; }
+.submission-result h3 { margin: 0; font-size: 18px; letter-spacing: 0; }
+.submission-result p { margin: 6px 0 0; color: var(--muted); font-size: 13px; }
+.warning-list { margin: 16px 0 0; padding: 0; display: grid; gap: 7px; list-style: none; }
+.warning-list li { padding: 9px 11px; border-left: 3px solid var(--amber); background: var(--amber-soft); color: #684707; font-size: 13px; line-height: 1.45; }
+.candidate-output { max-height: 410px; }
+
 @media (max-width: 1050px) {
   .model-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
   .model-dialog article { grid-template-columns: minmax(240px, 34%) minmax(0, 1fr); }
@@ -391,6 +449,7 @@ pre {
   .segmented { width: 100%; grid-auto-flow: row; grid-template-columns: repeat(2, minmax(0, 1fr)); }
   .segmented button { padding: 0 9px; }
   .verified-toggle { min-height: 32px; }
+  .toolbar-actions { justify-content: space-between; }
   .catalog-content { padding: 18px 14px 36px; }
   .model-grid { grid-template-columns: 1fr; }
   .card-body { min-height: 0; }
@@ -408,6 +467,12 @@ pre {
   .detail-specs div:nth-child(even) { padding-left: 0; border-left: 0; }
   .detail-tabs { overflow-x: auto; }
   .detail-tabs button { white-space: nowrap; }
+  .submission-dialog { width: 100vw; height: 100vh; max-height: 100vh; border-radius: 0; }
+  .submission-dialog article { max-height: 100vh; padding: 22px 16px 30px; }
+  .submission-fields { grid-template-columns: 1fr; }
+  .submission-fields .wide-field { grid-column: auto; }
+  .form-actions { align-items: stretch; flex-direction: column-reverse; }
+  .form-actions .secondary-button, .form-actions button { width: 100%; text-align: center; }
 }
 
 @media (prefers-reduced-motion: reduce) {

tests/test_app.py

@@ -1,17 +1,48 @@
 from pathlib import Path
 
 from fastapi.testclient import TestClient
+import httpx
 
 from app.catalog import CatalogService
+from app.huggingface import HuggingFaceClient
 from app.main import create_app
 
 
 ROOT = Path(__file__).resolve().parents[1]
 
 
+def hf_payload(repo_id="openvla/openvla-7b"):
+    return {
+        "id": repo_id,
+        "sha": "a" * 40,
+        "downloads": 1200,
+        "likes": 45,
+        "lastModified": "2026-07-24T10:00:00.000Z",
+        "gated": False,
+        "tags": ["robotics", "vla", "license:apache-2.0"],
+        "pipeline_tag": "robotics",
+        "library_name": "transformers",
+    }
+
+
 def client():
-    service = CatalogService(catalog_url="", fallback_path=ROOT / "data" / "index.json")
-    return TestClient(create_app(service))
+    def handler(request: httpx.Request):
+        if request.url.path == "/api/models":
+            text_model = hf_payload("example/text-model")
+            text_model.update(
+                tags=["text-generation", "license:mit"],
+                pipeline_tag="text-generation",
+            )
+            return httpx.Response(200, json=[hf_payload(), text_model])
+        return httpx.Response(200, json=hf_payload(request.url.path.removeprefix("/api/models/")))
+
+    hf_client = HuggingFaceClient(transport=httpx.MockTransport(handler))
+    service = CatalogService(
+        catalog_url="",
+        fallback_path=ROOT / "data" / "index.json",
+        enrich_metadata=False,
+    )
+    return TestClient(create_app(service, hf_client))
 
 
 def test_catalog_ui_and_health():
@@ -49,3 +80,31 @@ def test_catalog_api_search_and_model_routes():
         assert test_client.get("/api/models/missing").status_code == 404
         assert test_client.get("/model/openvla-7b").status_code == 200
         assert test_client.get("/model/missing").status_code == 404
+
+
+def test_discovery_and_submission_validation_routes():
+    with client() as test_client:
+        discovery = test_client.get("/api/discover", params={"q": "openvla"}).json()
+        assert discovery["count"] == 1
+        assert discovery["models"][0]["repo_id"] == "openvla/openvla-7b"
+
+        response = test_client.post(
+            "/api/submissions/validate",
+            json={
+                "repo_id": "openvla/openvla-7b",
+                "slug": "openvla-community",
+                "task": "vla",
+                "registry_model": "openvla",
+                "backend": "transformers",
+                "adapter": "openvla",
+                "minimum_vram_gb": 24,
+                "recommended_vram_gb": 32,
+                "summary": "A community suggestion for an OpenVLA robot policy.",
+                "tags": ["robotics", "manipulation"],
+            },
+        )
+        assert response.status_code == 200
+        result = response.json()
+        assert result["candidate"]["source"]["revision"] == "a" * 40
+        assert result["candidate"]["verification"]["status"] == "unverified"
+        assert "upstream" not in result["candidate"]

tests/test_catalog.py

@@ -1,8 +1,10 @@
 from pathlib import Path
 
+import httpx
 import pytest
 
 from app.catalog import CatalogService
+from app.huggingface import HuggingFaceClient
 
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -10,7 +12,9 @@ ROOT = Path(__file__).resolve().parents[1]
 
 @pytest.mark.asyncio
 async def test_catalog_fallback_and_search():
-    service = CatalogService(catalog_url="", fallback_path=ROOT / "data" / "index.json")
+    service = CatalogService(
+        catalog_url="", fallback_path=ROOT / "data" / "index.json", enrich_metadata=False
+    )
     catalog = await service.get()
     assert service.source == "bundled"
     assert len(catalog.models) == 3
@@ -23,6 +27,38 @@ async def test_catalog_fallback_and_search():
 
 @pytest.mark.asyncio
 async def test_catalog_model_lookup():
-    service = CatalogService(catalog_url="", fallback_path=ROOT / "data" / "index.json")
+    service = CatalogService(
+        catalog_url="", fallback_path=ROOT / "data" / "index.json", enrich_metadata=False
+    )
     assert (await service.model("openvla-7b")).runtime.registry_model == "openvla"
     assert await service.model("missing") is None
+
+
+@pytest.mark.asyncio
+async def test_catalog_enriches_metadata_and_detects_revision_drift():
+    async def handler(request: httpx.Request):
+        repo_id = request.url.path.removeprefix("/api/models/")
+        return httpx.Response(
+            200,
+            json={
+                "id": repo_id,
+                "sha": "f" * 40,
+                "downloads": 99,
+                "likes": 7,
+                "gated": False,
+                "tags": ["robotics", "license:mit"],
+                "library_name": "transformers",
+                "pipeline_tag": "robotics",
+            },
+        )
+
+    service = CatalogService(
+        catalog_url="",
+        fallback_path=ROOT / "data" / "index.json",
+        hf_client=HuggingFaceClient(transport=httpx.MockTransport(handler)),
+    )
+    model = await service.model("openvla-7b")
+    assert model.upstream.latest_revision == "f" * 40
+    assert model.upstream.revision_current is False
+    assert model.upstream.update_available is True
+    assert model.upstream.downloads == 99

tests/test_huggingface.py

@@ -0,0 +1,69 @@
+import httpx
+import pytest
+
+from app.huggingface import HuggingFaceClient, normalize_model, validate_repo_id
+
+
+def payload(repo_id="owner/robot-model", **updates):
+    result = {
+        "id": repo_id,
+        "sha": "1" * 40,
+        "downloads": 42,
+        "likes": 3,
+        "lastModified": "2026-07-24T10:00:00.000Z",
+        "gated": "manual",
+        "tags": ["robotics", "license:apache-2.0"],
+        "pipeline_tag": "robotics",
+        "library_name": "transformers",
+    }
+    result.update(updates)
+    return result
+
+
+def test_metadata_normalization_and_repo_validation():
+    model = normalize_model(payload())
+    assert model.repo_id == "owner/robot-model"
+    assert model.gated is True
+    assert model.license == "apache-2.0"
+    assert model.has_robotics_signal() is True
+    with pytest.raises(ValueError):
+        validate_repo_id("https://example.com/model")
+    with pytest.raises(ValueError):
+        validate_repo_id("owner/model/extra")
+
+
+@pytest.mark.asyncio
+async def test_model_metadata_cache_and_refresh():
+    calls = 0
+
+    async def handler(_: httpx.Request):
+        nonlocal calls
+        calls += 1
+        return httpx.Response(200, json=payload())
+
+    client = HuggingFaceClient(transport=httpx.MockTransport(handler))
+    await client.model("owner/robot-model")
+    await client.model("owner/robot-model")
+    assert calls == 1
+    await client.model("owner/robot-model", refresh=True)
+    assert calls == 2
+
+
+@pytest.mark.asyncio
+async def test_discovery_filters_non_robotics_models():
+    async def handler(_: httpx.Request):
+        return httpx.Response(
+            200,
+            json=[
+                payload(),
+                payload(
+                    "owner/text-model",
+                    tags=["text-generation", "license:mit"],
+                    pipeline_tag="text-generation",
+                ),
+            ],
+        )
+
+    client = HuggingFaceClient(transport=httpx.MockTransport(handler))
+    results = await client.discover("robot")
+    assert [model.repo_id for model in results] == ["owner/robot-model"]

tests/test_review_candidate.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import pytest
+
+from app.catalog import Catalog, HubModel
+from scripts.review_candidate import load_candidate, merge_candidate
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_review_rejects_duplicate_slug_and_repository(tmp_path):
+    catalog = Catalog.model_validate_json((ROOT / "data" / "index.json").read_text())
+    candidate = catalog.models[0].model_copy(
+        update={
+            "verification": catalog.models[0].verification.model_copy(
+                update={"status": "unverified"}
+            )
+        }
+    )
+    with pytest.raises(ValueError, match="duplicate slug"):
+        merge_candidate(catalog, candidate)
+
+    different_slug = candidate.model_copy(update={"slug": "different-model"})
+    with pytest.raises(ValueError, match="duplicate repository"):
+        merge_candidate(catalog, different_slug)
+
+
+def test_load_candidate_accepts_validation_response(tmp_path):
+    model = Catalog.model_validate_json((ROOT / "data" / "index.json").read_text()).models[0]
+    candidate = model.model_copy(
+        update={"verification": model.verification.model_copy(update={"status": "unverified"})}
+    )
+    path = tmp_path / "candidate.json"
+    path.write_text(
+        '{"candidate": ' + candidate.model_dump_json() + ', "warnings": []}',
+        encoding="utf-8",
+    )
+    assert isinstance(load_candidate(path), HubModel)
+
+
+def test_review_appends_a_new_unverified_candidate():
+    catalog = Catalog.model_validate_json((ROOT / "data" / "index.json").read_text())
+    model = catalog.models[0]
+    candidate = model.model_copy(
+        update={
+            "slug": "new-community-policy",
+            "source": model.source.model_copy(
+                update={"repo_id": "example/new-community-policy", "revision": "c" * 40}
+            ),
+            "verification": model.verification.model_copy(update={"status": "unverified"}),
+        }
+    )
+    merged = merge_candidate(catalog, candidate)
+    assert len(merged.models) == len(catalog.models) + 1
+    assert merged.models[-1].slug == "new-community-policy"
+    assert merged.generated_at.endswith("Z")

tests/test_submissions.py

@@ -0,0 +1,55 @@
+import httpx
+import pytest
+
+from app.huggingface import HuggingFaceClient
+from app.submissions import SubmissionRequest, SubmissionService
+
+
+@pytest.mark.asyncio
+async def test_submission_candidate_is_pinned_and_warns_for_manual_review():
+    async def handler(_: httpx.Request):
+        return httpx.Response(
+            200,
+            json={
+                "id": "lab/custom-policy",
+                "sha": "b" * 40,
+                "downloads": 5,
+                "likes": 1,
+                "gated": "manual",
+                "tags": ["custom", "license:other"],
+            },
+        )
+
+    service = SubmissionService(HuggingFaceClient(transport=httpx.MockTransport(handler)))
+    result = await service.validate(
+        SubmissionRequest(
+            repo_id="lab/custom-policy",
+            slug="custom-policy",
+            task="vla",
+            registry_model="custom",
+            backend="transformers",
+            adapter="custom",
+            minimum_vram_gb=12,
+            recommended_vram_gb=16,
+            summary="A custom policy submitted for laboratory robot evaluation.",
+        )
+    )
+    assert result.candidate.source.revision == "b" * 40
+    assert result.candidate.source.gated is True
+    assert result.candidate.verification.status == "unverified"
+    assert len(result.warnings) == 4
+
+
+def test_submission_rejects_invalid_ranges_and_repository_urls():
+    with pytest.raises(ValueError):
+        SubmissionRequest(
+            repo_id="https://huggingface.co/lab/model",
+            slug="lab-model",
+            task="vla",
+            registry_model="lab",
+            backend="transformers",
+            adapter="lab",
+            minimum_vram_gb=32,
+            recommended_vram_gb=16,
+            summary="A long enough summary for validation to reach the range check.",
+        )