Skip to content

HarnessRouter Community Edition: the self-hosted, Apache-2.0 edition of the unified interface for agent harnesses. Run Codex, Claude Code, Hermes, PI, DSH, and more through one API, with sessions, streaming, files, cancellation, and failure handling. Implements the Unified Harness Protocol (UHP), an open standard. Your keys, your infrastructure.

gateway: POST /v1/files lands on the local backing; X-09 exercises the upload form; API Keys in the self-hosted sidebar (#210)

github-actions[bot]52ff983cb75d
diff --git a/README.md b/README.md
index e8d3a35a..204da232 100644
--- a/README.md
+++ b/README.md
@@ -187,7 +187,7 @@ Run product tasks with built-in or custom harnesses as pluggable agent backends.
Once your harness runs successfully in the Console:
-1. Open `/keys` on the same CE instance ([default local address](http://localhost:3000/keys)) and choose **Create API key**. Open this URL directly if API keys is not visible in the sidebar.
+1. Open **API Keys** in the Console sidebar of the same CE instance ([default local address](http://localhost:3000/keys)) and choose **Create API key**.
2. Store the secret shown once as `HARNESSROUTER_API_KEY` in your product backend. Never expose it in browser code. This CE-issued key is separate from your Console password and provider key.
3. Call the API with the Harness ID shown in the Console and a model served by your connected provider.
diff --git a/docs/self-hosting-guide.md b/docs/self-hosting-guide.md
index cae24a3a..cd080dac 100644
--- a/docs/self-hosting-guide.md
+++ b/docs/self-hosting-guide.md
@@ -709,7 +709,7 @@ variables. It is a setup check, not a technical prerequisite for the API.
### Create a key on this CE instance for your backend
-1. Sign in to the Console of the CE instance your product will call, then open `/keys` on that same host and port ([default local address](http://localhost:3000/keys)). Community Edition currently hides this page from the sidebar, so use its URL directly.
+1. Sign in to the Console of the CE instance your product will call, then open **API Keys** in the sidebar ([default local address](http://localhost:3000/keys)).
2. Confirm the workspace containing the harness, then select **Create API key**. Give it a name and select **Create key**.
3. Copy the secret shown once. Store it in your product backend's secret store or environment. The examples call this variable `HARNESSROUTER_API_KEY`.
diff --git a/gateway/app.py b/gateway/app.py
index 3544c0e0..d2373c17 100644
--- a/gateway/app.py
+++ b/gateway/app.py
@@ -8461,16 +8461,27 @@ async def upload_file(request: Request, purpose: str = Form("user_data"), file:
raise HTTPException(413, f"file exceeds the {_UPLOAD_MAX_BYTES // (1024*1024)} MiB upload limit")
yield chunk
- h = _blob_headers("application/octet-stream")
- try:
- r = await _client().put(_blob_url(f"uploads/{fid}", RESP_BLOB_KB),
- headers=h, content=_pipe())
- except HTTPException:
- raise # the 413 from _pipe surfaces verbatim
- except httpx.HTTPError as e: # early server reject can surface as a WriteError, not a status
- raise HTTPException(502, "durable upload failed") from e
- if r.status_code >= 400:
- raise HTTPException(502, "durable upload failed")
+ if _blob_streaming():
+ h = _blob_headers("application/octet-stream")
+ try:
+ r = await _client().put(_blob_url(f"uploads/{fid}", RESP_BLOB_KB),
+ headers=h, content=_pipe())
+ except HTTPException:
+ raise # the 413 from _pipe surfaces verbatim
+ except httpx.HTTPError as e: # early server reject can surface as a WriteError, not a status
+ raise HTTPException(502, "durable upload failed") from e
+ if r.status_code >= 400:
+ raise HTTPException(502, "durable upload failed")
+ else:
+ # Local backing: the store has no HTTP surface to stream into (the VG-only _blob_url /
+ # _blob_headers above raised AttributeError here and every upload on a self-hosted
+ # instance answered 500, #198). Read the part through the same cap-enforcing pipe and
+ # hand the store the bytes; the cap bounds what is held, as it already bounds the turn body.
+ buf = bytearray()
+ async for chunk in _pipe():
+ buf += chunk
+ if not await BACKING.blob.put(RESP_BLOB_KB, f"uploads/{fid}", bytes(buf)):
+ raise HTTPException(502, "durable upload failed")
await _blob_put(f"uploads/{fid}.meta", json.dumps(
{"filename": file.filename, "media_type": file.content_type or "application/octet-stream"}).encode(),
kb=RESP_BLOB_KB)
diff --git a/gateway/tests/test_files_upload.py b/gateway/tests/test_files_upload.py
new file mode 100644
index 00000000..a26899cd
--- /dev/null
+++ b/gateway/tests/test_files_upload.py
@@ -0,0 +1,50 @@
+"""POST /v1/files on the local backing (#198, CE 0.17.3).
+
+The upload streamed into the blob plane through the VG-only URL/header helpers, unconditionally;
+the file-backed store has neither, so on every self-hosted instance the endpoint answered 500
+(`'FileBlobStore' object has no attribute 'headers'`) and the only way to attach a file was the
+inline `data:` form. The other relays (checkpoint, hydrate, workspace tar) already branch on the
+backing; this one did not. X-05 passes with the inline form, which is why the suite did not see it.
+"""
+import io
+import json
+import os
+
+from fastapi.testclient import TestClient
+
+os.environ.setdefault("HR_BACKING", "local")
+import app as gw # noqa: E402
+
+HEADERS = {"x-harness-internal": "test-internal-key", "x-harness-org": "local", "x-harness-member": "m"}
+
+
+def _upload(client, name: str, data: bytes, media: str = "text/plain"):
+ return client.post("/v1/files", headers=HEADERS, data={"purpose": "user_data"},
+ files={"file": (name, io.BytesIO(data), media)})
+
+
+def test_an_upload_lands_in_the_local_store_and_answers_the_file_object():
+ c = TestClient(gw.app)
+ r = _upload(c, "brief.txt", b"The secret token is uhp-198.\n")
+ assert r.status_code == 200, r.text
+ f = r.json()
+ assert f["object"] == "file" and f["id"].startswith("file_")
+ assert f["filename"] == "brief.txt" and f["bytes"] == 29 and f["purpose"] == "user_data"
+ assert isinstance(f["created_at"], int)
+ # the bytes and the sidecar the turn reads (the input_file resolver in create_response)
+ import asyncio
+ assert asyncio.run(gw._blob_get(f"uploads/{f['id']}", kb=gw.RESP_BLOB_KB)) == b"The secret token is uhp-198.\n"
+ meta = json.loads(asyncio.run(gw._blob_get(f"uploads/{f['id']}.meta", kb=gw.RESP_BLOB_KB)))
+ assert meta == {"filename": "brief.txt", "media_type": "text/plain"}
+
+
+def test_an_oversized_upload_is_refused_as_file_too_large_and_stores_nothing(monkeypatch):
+ monkeypatch.setattr(gw, "_UPLOAD_MAX_BYTES", 64)
+ c = TestClient(gw.app)
+ r = _upload(c, "big.bin", b"\x00" * 65)
+ assert r.status_code == 413, r.text
+ assert r.json()["error"]["code"] == "file_too_large"
+ import asyncio
+ listing = asyncio.run(gw.BACKING.blob.list(gw.RESP_BLOB_KB, "uploads/", limit=100))
+ names = json.dumps(listing)
+ assert "big.bin" not in names and names.count("file_") == names.count("file_") // 2 * 2 # only pairs (data + .meta) ever land
diff --git a/protocol/CHANGELOG.md b/protocol/CHANGELOG.md
index b587b381..8258007c 100644
--- a/protocol/CHANGELOG.md
+++ b/protocol/CHANGELOG.md
@@ -63,7 +63,14 @@ previous version stays published at its own address and a server SHOULD keep ser
survival of an unrelated edit, export that installs again without credentials, skipped
components recorded, `enabled: false` preserved, refusal of an unsupported manifest schema,
refusal of duplicate plugin names. Each is proven against a defect stub carrying one mistake at
- a time, the way the R-series is. The suite is now 74 checks.
+ a time, the way the R-series is. That made the suite 74 checks.
+
+- **X-09**, class Extended: a file uploaded through `POST /v1/files` is accepted and can be
+ sent as task input by id ([Files §1.2](versions/2026-09-12/files.md#12-by-upload)). X-05 sends
+ its file inline and never reaches the upload endpoint, so a server whose uploads all failed
+ passed the chapter (HarnessRouter CE 0.17.3, #198). Proven against a defect stub: an upload
+ that fails outright, one that answers without an id, and one that truncates each fail X-09
+ alone while X-05 stays green. The suite is now 75 checks.
## 2026-08-11, additive clarifications
diff --git a/protocol/conformance/README.md b/protocol/conformance/README.md
index 775a9f0e..bd71bb83 100644
--- a/protocol/conformance/README.md
+++ b/protocol/conformance/README.md
@@ -37,7 +37,7 @@ anything that only inspects a schema.
## What it checks
-74 checks across three classes.
+75 checks across three classes.
| Class | Checks | Covers |
|---|---|---|
@@ -64,6 +64,10 @@ A few of them are worth calling out, because they catch things a schema check ne
own origin.
- **X-08** — artifact ids do not traverse out of their container. Probes for `../` and its
percent-encoded form.
+- **X-09** — `POST /v1/files` itself. X-05 sends its file inline, so a server whose upload
+ endpoint fails outright still passed the files chapter: HarnessRouter CE 0.17.3 answered every
+ upload with 500 and was green. X-09 uploads, holds the file object to the schema and to the byte
+ count it was sent, and references the id from a task.
- **P-02/P-06** — a plugin package is derived, not copied, and a harness exports as a package
that installs again. P-02 fails a server whose own `mcpServers` absorb a plugin's servers, the
mistake that makes every read-then-write install them twice; P-06 fails an export that carries
diff --git a/protocol/conformance/tests/files_stub.py b/protocol/conformance/tests/files_stub.py
new file mode 100644
index 00000000..e5e81d65
--- /dev/null
+++ b/protocol/conformance/tests/files_stub.py
@@ -0,0 +1,136 @@
+"""A deliberately wrong UHP server for the files chapter, one toggleable defect at a time.
+
+X-05 sends its file inline and X-09 uploads it; a server whose `POST /v1/files` fails outright
+passes X-05, which is how HarnessRouter CE 0.17.3 shipped with every upload answering 500 (#198).
+This stub implements Files §1 in memory, correctly by default, and takes a DEFECT environment
+variable naming one thing to get wrong; test_files_checks.py asserts which check catches it.
+The "agent" here echoes the attached file's text, so a task that reaches it with the file shows
+the token and one that does not shows nothing.
+
+ DEFECT=upload_500 PORT=8933 python3 files_stub.py
+"""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+import uuid
+from email.parser import BytesParser
+from email.policy import default as _email_default
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlsplit
+
+DEFECT = os.environ.get("DEFECT", "none")
+PORT = int(os.environ.get("PORT", "8933"))
+KEY = "stub-key"
+VERSION = "2026-09-12"
+DEFECTS = {
+ "none",
+ "upload_500", # POST /v1/files raises: the endpoint exists and never works (#198)
+ "upload_no_id", # the file object comes back without an id, so nothing can reference it
+ "upload_truncates", # the object reports (and the store keeps) fewer bytes than were sent
+}
+assert DEFECT in DEFECTS, DEFECT
+
+FILES: dict[str, dict] = {}
+HARNESS = {"id": "h1", "object": "harness", "name": "stub", "base": "stub", "defaultModel": "stub-1"}
+
+
+def _error(status, code, message):
+ return status, {"error": {"type": "invalid_request_error" if status < 500 else "server_error",
+ "code": code, "message": message, "param": None, "detail": None}}
+
+
+def _parts(content_type: str, raw: bytes):
+ msg = BytesParser(policy=_email_default).parsebytes(
+ b"MIME-Version: 1.0\r\nContent-Type: " + content_type.encode() + b"\r\n\r\n" + raw)
+ for part in msg.iter_parts():
+ yield (part.get_param("name", header="content-disposition"), part.get_filename(),
+ part.get_payload(decode=True) or b"")
+
+
+def upload(content_type: str, raw: bytes):
+ if DEFECT == "upload_500":
+ return _error(500, "internal", "'FileBlobStore' object has no attribute 'headers'")
+ filename, data = "upload.bin", b""
+ for name, fn, payload in _parts(content_type, raw):
+ if name == "file":
+ filename, data = fn or filename, payload
+ if DEFECT == "upload_truncates":
+ data = data[: max(0, len(data) - 4)]
+ fid = f"file_{uuid.uuid4().hex[:12]}"
+ FILES[fid] = {"filename": filename, "data": data}
+ obj = {"id": fid, "object": "file", "filename": filename, "bytes": len(data),
+ "created_at": int(time.time())}
+ if DEFECT == "upload_no_id":
+ obj.pop("id")
+ return 200, obj
+
+
+def respond(body: dict):
+ texts = []
+ items = body.get("input")
+ if isinstance(items, str):
+ items = [{"role": "user", "content": [{"type": "input_text", "text": items}]}]
+ for item in items or []:
+ for part in item.get("content") or []:
+ if part.get("type") != "input_file":
+ continue
+ if part.get("file_data", "").startswith("data:"):
+ texts.append(base64.b64decode(part["file_data"].split(",", 1)[1]).decode("utf-8", "replace"))
+ elif part.get("file_id") in FILES:
+ texts.append(FILES[part["file_id"]]["data"].decode("utf-8", "replace"))
+ answer = " ".join(texts) if texts else "no file was attached"
+ return 200, {"id": f"resp_{uuid.uuid4().hex[:12]}", "object": "response", "created_at": int(time.time()),
+ "status": "completed", "model": "stub-1", "error": None,
+ "output": [{"id": f"msg_{uuid.uuid4().hex[:8]}", "type": "message", "role": "assistant",
+ "status": "completed",
+ "content": [{"type": "output_text", "text": answer, "annotations": []}]}],
+ "metadata": {"session_id": "sess_stub"}}
+
+
+class Handler(BaseHTTPRequestHandler):
+ def log_message(self, *a): # quiet
+ pass
+
+ def send(self, status: int, payload: dict):
+ data = json.dumps(payload).encode()
+ self.send_response(status)
+ self.send_header("content-type", "application/json")
+ self.send_header("content-length", str(len(data)))
+ self.end_headers()
+ self.wfile.write(data)
+
+ def route(self, method: str):
+ n = int(self.headers.get("content-length") or 0)
+ raw = self.rfile.read(n) if n else b""
+ p = [x for x in urlsplit(self.path).path.split("/") if x]
+ if method == "GET" and p == ["v1", "uhp"]:
+ return self.send(200, {"object": "uhp.discovery", "protocol": "uhp", "versions": [VERSION],
+ "default_version": VERSION, "conformance_class": "extended",
+ "capabilities": {"streaming": False, "sessions": True, "cancellation": False,
+ "files_input": True, "files_output": False}})
+ if (self.headers.get("authorization") or "").removeprefix("Bearer ").strip() != KEY:
+ return self.send(*_error(401, "missing_credential", "no credential"))
+ if method == "GET" and p == ["v1", "harnesses"]:
+ return self.send(200, {"harnesses": [HARNESS]})
+ if method == "POST" and p == ["v1", "files"]:
+ return self.send(*upload(self.headers.get("content-type") or "", raw))
+ if method == "POST" and p == ["v1", "responses"]:
+ try:
+ body = json.loads(raw or b"{}")
+ except Exception:
+ body = {}
+ return self.send(*respond(body))
+ return self.send(*_error(404, "not_found", "no such endpoint"))
+
+ def do_GET(self):
+ self.route("GET")
+
+ def do_POST(self):
+ self.route("POST")
+
+
+if __name__ == "__main__":
+ ThreadingHTTPServer(("127.0.0.1", PORT), Handler).serve_forever()
diff --git a/protocol/conformance/tests/test_files_checks.py b/protocol/conformance/tests/test_files_checks.py
new file mode 100644
index 00000000..2467893f
--- /dev/null
+++ b/protocol/conformance/tests/test_files_checks.py
@@ -0,0 +1,94 @@
+"""The files checks, tested by being shown to fail.
+
+X-05 sends its file inline and X-09 uploads it through `POST /v1/files`. A server whose upload
+endpoint fails outright must fail X-09 and still pass X-05 — that pair is the gap HarnessRouter
+CE 0.17.3 shipped through (#198: every upload answered 500, the inline form worked, the suite was
+green). Each defect in files_stub.py is caught by X-09, by no other files check, and a clean stub
+passes both. No real agent runs: the stub echoes the file it was handed.
+"""
+from __future__ import annotations
+
+import pathlib
+import socket
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+
+import pytest
+
+from uhp_conformance import checks # noqa: F401 — importing populates the registry
+from uhp_conformance.client import Client
+from uhp_conformance.context import Context
+from uhp_conformance.registry import REGISTRY, Outcome
+
+STUB = pathlib.Path(__file__).parent / "files_stub.py"
+FILE_CHECKS = ("X-05", "X-09")
+DEFECTS = ("upload_500", "upload_no_id", "upload_truncates")
+
+
+def _free_port() -> int:
+ with socket.socket() as s:
+ s.bind(("127.0.0.1", 0))
+ return s.getsockname()[1]
+
+
+def _run(defect: str) -> dict[str, tuple[Outcome, str]]:
+ port = _free_port()
+ srv = subprocess.Popen([sys.executable, str(STUB)],
+ env={"DEFECT": defect, "PORT": str(port), "PATH": "/usr/bin:/bin"})
+ try:
+ deadline = time.time() + 10
+ while time.time() < deadline:
+ try:
+ urllib.request.urlopen(f"http://127.0.0.1:{port}/v1/uhp", timeout=1).read()
+ break
+ except (urllib.error.URLError, OSError):
+ time.sleep(0.05)
+ else:
+ pytest.fail(f"the stub did not start for defect {defect!r}")
+ ctx = Context(client=Client(f"http://127.0.0.1:{port}", "stub-key"), task_timeout=30.0)
+ out = {}
+ for c in REGISTRY:
+ if c.id in FILE_CHECKS:
+ r = c.run(ctx)
+ out[c.id] = (r.outcome, r.detail)
+ return out
+ finally:
+ srv.terminate()
+ srv.wait(timeout=5)
+
+
+def test_x09_is_registered_at_extended_after_x08():
+ ids = [c.id for c in REGISTRY if c.id.startswith("X-")]
+ assert ids == [f"X-{i:02d}" for i in range(1, 10)]
+ assert next(c for c in REGISTRY if c.id == "X-09").cls == "extended"
+
+
+def test_a_conformant_server_passes_both_and_the_stub_echoes_the_token():
+ out = _run("none")
+ assert out["X-05"][0] is Outcome.PASS and out["X-09"][0] is Outcome.PASS, out
+ assert "echoed the token" in out["X-09"][1], out["X-09"]
+
+
+def test_an_upload_endpoint_that_fails_outright_fails_x09_and_passes_x05():
+ """The #198 shape: the inline form works, the upload form answers 500, and before X-09 the
+ files chapter was green."""
+ out = _run("upload_500")
+ assert out["X-05"][0] is Outcome.PASS, out["X-05"]
+ assert out["X-09"][0] is Outcome.FAIL, out["X-09"]
+ assert "HTTP 500" in out["X-09"][1] and "X-05" in out["X-09"][1], out["X-09"]
+
+
[email protected]("defect", DEFECTS)
+def test_each_defect_is_caught_by_x09_and_by_no_other_files_check(defect):
+ out = _run(defect)
+ assert out["X-09"][0] is Outcome.FAIL, f"{defect!r} was not caught: {out}"
+ assert out["X-05"][0] is Outcome.PASS, f"{defect!r} also failed X-05, which diagnoses one bug twice"
+
+
+def test_no_check_errors_on_any_defect():
+ for defect in ("none", *DEFECTS):
+ out = _run(defect)
+ assert Outcome.ERROR not in {o for o, _ in out.values()}, f"{defect}: {out}"
diff --git a/protocol/conformance/uhp_conformance/checks.py b/protocol/conformance/uhp_conformance/checks.py
index e96c589f..f2df56e9 100644
--- a/protocol/conformance/uhp_conformance/checks.py
+++ b/protocol/conformance/uhp_conformance/checks.py
@@ -669,6 +669,49 @@ def x08(ctx):
# Full — harness lifecycle
# ══════════════════════════════════════════════════════════════════════════════════════
+@check("X-09", "A file uploaded through POST /v1/files is accepted and can be sent as task input",
+ "extended", f"{SPEC}/files.md#12-by-upload")
+def x09(ctx):
+ """Files §1.2 is the other half of "a server MUST accept both forms". X-05 sends its file inline,
+ so it never reaches `POST /v1/files`: HarnessRouter CE 0.17.3 answered every upload with 500 and
+ passed the files chapter (#198). This check uploads, holds the file object to the schema, and
+ then references the id from a task the way a client would."""
+ d = ctx.state.get("discovery") or ctx.client.get("/v1/uhp", auth=False).json or {}
+ ctx.state["discovery"] = d
+ if (d.get("capabilities") or {}).get("files_input") is False:
+ raise Skip("this server reports files_input false, so Files §1 does not apply to it")
+ h = _harness(ctx)
+ token = f"uhp-{uuid.uuid4().hex[:8]}"
+ content = f"The secret token is {token}.\n".encode()
+ boundary = f"uhp{uuid.uuid4().hex}"
+ body = (f"--{boundary}\r\nContent-Disposition: form-data; name=\"purpose\"\r\n\r\nuser_data\r\n"
+ f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"token.txt\"\r\n"
+ f"Content-Type: text/plain\r\n\r\n").encode() + content + f"\r\n--{boundary}--\r\n".encode()
+ r = ctx.client.post("/v1/files", raw=body, content_type=f"multipart/form-data; boundary={boundary}")
+ assert r.status == 200, (f"POST /v1/files returned HTTP {r.status}: {r.body[:200]!r} "
+ f"(X-05 sends its file inline and never reaches this endpoint)")
+ f = r.json if isinstance(r.json, dict) else {}
+ ctx.validate(f, "File")
+ assert f.get("object") == "file", f"the upload answered object={f.get('object')!r}, not 'file'"
+ if "bytes" in f: # optional in the schema; when reported it must be the whole file — a short
+ assert f["bytes"] == len(content), ( # count is the silent truncation §1.2 forbids
+ f"the upload reports {f['bytes']!r} bytes for a {len(content)}-byte file")
+ task = {"input": [{"role": "user", "content": [
+ {"type": "input_text", "text": "Reply with only the secret token from the attached file."},
+ {"type": "input_file", "file_id": f["id"]}]}],
+ "metadata": {"harness_id": h["id"]}, "stream": False}
+ if ctx.model:
+ task["model"] = ctx.model
+ r2 = ctx.client.post("/v1/responses", body=task)
+ assert r2.status == 200, (f"a task referencing the uploaded file returned HTTP {r2.status}: "
+ f"{r2.body[:200]!r}")
+ ctx.validate(r2.json, "Response")
+ text = json.dumps(r2.json.get("output") or [])
+ return ("uploaded, referenced by id, and the harness echoed the token" if token in text
+ else "uploaded and accepted by id (the harness did not echo the token, which the protocol "
+ "does not require)")
+
+
@check("F-01", "A harness can be created, updated and deleted", "full",
f"{SPEC}/harnesses.md#4-managing-harnesses")
def f01(ctx):
diff --git a/protocol/conformance/uv.lock b/protocol/conformance/uv.lock
index c8a9fe51..46f96b82 100644
--- a/protocol/conformance/uv.lock
+++ b/protocol/conformance/uv.lock
@@ -320,7 +320,7 @@ wheels = [
[[package]]
name = "uhp-conformance"
-version = "2026.8.11.post1"
+version = "2026.9.12"
source = { editable = "." }
dependencies = [
{ name = "jsonschema" },
diff --git a/ui/src/lib/edition.ts b/ui/src/lib/edition.ts
index 1c81f3b1..d42e67de 100644
--- a/ui/src/lib/edition.ts
+++ b/ui/src/lib/edition.ts
@@ -27,8 +27,12 @@ export const LOCAL_MEMBER = 'local@localhost';
*
* Integrations is here because bring-your-own-key IS the self-hosted product: without it the
* box has no credentials and every turn fails. Hosted it stays a platform-admin surface, since
- * there the routing config is global. */
-export const SELF_HOSTED_NAV = ['/kits', '/harnesses', '/tasks', '/integrations'];
+ * there the routing config is global.
+ *
+ * API Keys is here because the box mints and serves them itself: /keys worked in every CE
+ * release and only the entry was missing, so the README sent people to the URL by hand. The
+ * key is how a product calls its own instance, which is the point of self-hosting. */
+export const SELF_HOSTED_NAV = ['/kits', '/harnesses', '/tasks', '/keys', '/integrations'];
/** Orgs allowed to see platform-admin surfaces (global model routing).
*