refactor(decision): use direct serving mode without legacy aliases

Signed-off-by: Xunzhuo <Xunzhuo@users.noreply.huggingface.co>

DEPLOYMENT.md

@@ -1,47 +1,45 @@
 # Decision Gateway deployment
 
-## Direct `drun` mode
+## Direct serving mode
 
-`DECISION_BACKEND=drun` is the production direct-routing mode. The Space keeps no model weights: it validates the public request, resolves its exact canonical Hugging Face model ID, and sends it to that model's private `vllm-sr decision serve` origin. Both public inference routes keep the same path end to end:
+`DECISION_BACKEND=direct` is the production direct-routing mode. The Space keeps no model weights: it validates the public request, resolves its exact canonical Hugging Face model ID, and sends it to that model's private `vllm-sr decision serve` origin. Both public inference routes keep the same path end to end:
 
 - `POST /v1/systemone`
 - `POST /v1/systemone/batches`
 
 Public requests must include one exact canonical model ID advertised by `/v1/models`. The Studio-only `/api/evaluate` route requires a configured short wire ID or canonical ID; the Gateway converts it to the canonical ID before forwarding and returns the strict backend response unchanged. Direct mode advertises no default model in `/v1/models`; the Studio editor chooses its model locally and sends it explicitly. There is no default-model inference and no fallback to another model, the legacy native engine, or a queue worker.
 
-Set the backend, the pinned `DECISION_MODEL_REGISTRY_V2`, and a server-only JSON map whose keys cover that registry exactly. Every direct-mode registry entry must include the full immutable 40-character Hub `revision` and 64-character `manifest_sha256`; it may also pin the runtime's 64-character `content_sha256`. These values come from each released artifact and may change through deployment configuration without a Gateway source release. This same-host-process example works only when the Gateway and every `drun` listener share the host network namespace:
+Set the backend, the pinned `DECISION_MODEL_REGISTRY_V2`, and a server-only JSON map whose keys cover that registry exactly. Every direct-mode registry entry must include the full immutable 40-character Hub `revision` and 64-character `manifest_sha256`; it may also pin the runtime's 64-character `content_sha256`. These values come from each released artifact and may change through deployment configuration without a Gateway source release. The loopback example below works only when the Gateway and every Decision runtime listener share the host network namespace:
 
-`/v1/models` reads presentation dates from the validated `MODEL_RELEASES.json` metadata shipped with the Gateway image. Its top-level `release` is the default date; a model row can set its own ISO `release_date`. A date is published only when that row's canonical ID, revision, and manifest digest match the active registry. An artifact with newer deployment pins still serves normally when the presentation file has not caught up; its date is omitted rather than reported incorrectly. If the file is missing or invalid, `/v1/models` still lists every configured model but omits all release dates; direct serving is unaffected. Operators can call `load_model_releases()` explicitly to fail on invalid metadata. Update the JSON metadata and rebuild the Gateway image when the public date should change. This file does not allowlist model files or decide which artifacts `drun` may load.
+`/v1/models` reads presentation dates from the validated `MODEL_RELEASES.json` metadata shipped with the Gateway image. Its top-level `release` is the default date; a model row can set its own ISO `release_date`. A date is published only when that row's canonical ID, revision, and manifest digest match the active registry. An artifact with newer deployment pins still serves normally when the presentation file has not caught up; its date is omitted rather than reported incorrectly. If the file is missing or invalid, `/v1/models` still lists every configured model but omits all release dates; direct serving is unaffected. Operators can call `load_model_releases()` explicitly to fail on invalid metadata. Update the JSON metadata and rebuild the Gateway image when the public date should change. This file does not allowlist model files or decide which artifacts the Decision runtime may load.
 
 ```text
-DECISION_BACKEND=drun
-DECISION_DRUN_ENDPOINTS={"llm-semantic-router/Decision-1.0-Kai-0.6B":"http://127.0.0.1:8101","llm-semantic-router/Decision-1.0-Lux-9B":"http://127.0.0.1:8106"}
-DECISION_DRUN_TIMEOUT_SECONDS=45
+DECISION_BACKEND=direct
+DECISION_DIRECT_ENDPOINTS={"llm-semantic-router/Decision-1.0-Kai-0.6B":"http://127.0.0.1:8101","llm-semantic-router/Decision-1.0-Lux-9B":"http://127.0.0.1:8106"}
+DECISION_DIRECT_TIMEOUT_SECONDS=45
 ```
 
-The example assumes a two-model registry; the endpoint map must include every model in the active registry, and every model must have a distinct origin. A `drun` instance binds to host loopback by default. `127.0.0.1` inside a separate Gateway or Tetris container is that container itself, **not** the model host, so loopback endpoints do not work across ordinary container namespaces. Use one of these explicit deployment boundaries:
+The example assumes a two-model registry; the endpoint map must include every model in the active registry, and every model must have a distinct origin. A Decision runtime instance binds to host loopback by default. `127.0.0.1` inside a separate Gateway or Tetris container is that container itself, **not** the model host, so loopback endpoints do not work across ordinary container namespaces. Use one of these explicit deployment boundaries:
 
-- Run the Gateway with host networking on the same trusted Linux host, keep every `drun` listener on host loopback, and retain the loopback map above.
-- Attach the Gateway and model containers to a dedicated private network, bind each `drun` listener intentionally to its assigned private interface, and admit only the Gateway with host firewall/container-network policy. Never publish those ports on a public interface.
+- Run the Gateway with host networking on the same trusted Linux host, keep every Decision runtime listener on host loopback, and retain the loopback map above.
+- Attach the Gateway and model containers to a dedicated private network, bind each Decision runtime listener intentionally to its assigned private interface, and admit only the Gateway with host firewall/container-network policy. Never publish those ports on a public interface.
 - For a remote Space, establish an authenticated private overlay or tunnel first and use its private IP literals. Direct mode is not ready if the Space can reach the models only through public origins.
 
-A private-network staging map therefore looks like this (replace the documentation-only subnet with addresses assigned by the private deployment, and configure the active registry with the same two models):
+For a private-network deployment, keep the same JSON map structure and replace
+each loopback origin with the private IP origin assigned to that model in your
+environment. Configure the active registry with the same model IDs. Store the
+map only in the server-side secret setting; no private-network addresses belong
+in this repository.
 
-```text
-DECISION_BACKEND=drun
-DECISION_DRUN_ENDPOINTS={"llm-semantic-router/Decision-1.0-Kai-0.6B":"http://10.90.0.11:8101","llm-semantic-router/Decision-1.0-Lux-9B":"http://10.90.0.12:8106"}
-DECISION_DRUN_TIMEOUT_SECONDS=45
-```
-
-Store `DECISION_DRUN_ENDPOINTS` as a private Space secret or equivalent server-only setting because it describes private topology. Values must be bare `http` or `https` origins with an explicit port and a literal loopback, RFC 1918, or IPv6 unique-local address. DNS names, public addresses, link-local addresses, URL credentials, paths, queries, and fragments fail startup. `DECISION_DRUN_TIMEOUT_SECONDS` is bounded to 0.1–300 seconds.
+Store `DECISION_DIRECT_ENDPOINTS` as a private Space secret or equivalent server-only setting because it describes private topology. Values must be bare `http` or `https` origins with an explicit port and a literal loopback, RFC 1918, or IPv6 unique-local address. DNS names, public addresses, link-local addresses, URL credentials, paths, queries, and fragments fail startup. `DECISION_DIRECT_TIMEOUT_SECONDS` is bounded to 0.1–300 seconds.
 
-The direct transport ignores ambient proxy variables, does not follow redirects, requests identity encoding, reuses private keep-alive connections, bounds single requests at 256 KiB, batch requests at 2 MiB, and inference responses at 8 MiB. Bind each `drun` service to loopback or enforce a network policy that admits only the Gateway; direct mode intentionally does not forward browser authorization. Neither backend origins nor private configuration are returned by `/api/status`, `/v1/models`, error responses, or browser configuration.
+The direct transport ignores ambient proxy variables, does not follow redirects, requests identity encoding, reuses private keep-alive connections, bounds single requests at 256 KiB, batch requests at 2 MiB, and inference responses at 8 MiB. Bind each Decision runtime service to loopback or enforce a network policy that admits only the Gateway; direct mode intentionally does not forward browser authorization. Neither backend origins nor private configuration are returned by `/api/status`, `/v1/models`, error responses, or browser configuration.
 
-Each successful private inference response carries `X-Decision-Artifact-Model`, `X-Decision-Artifact-Revision`, `X-Decision-Artifact-Manifest-Sha256`, and `X-Decision-Artifact-Content-Sha256` headers from the resident `drun` process. The Gateway requires exactly one well-formed value for each, matches the canonical model, pinned Hub revision and manifest digest, and matches the content digest when configured. Missing, duplicate, malformed, or mismatched identity discards that response. It also verifies the exact requested model, strict official JSON field set, answer IDs and types, state order, probability distributions, Choice winner, Score legend/value, type-aware Decision confidence, and batch usage aggregation. Confidence is accepted only from the validated `drun` response and is never replaced with `max(probabilities)`. Explicit `/api/status?model=<wire-id>` probes report readiness plus the configured and live artifact digests without disclosing private origins. A Gateway using response attestation requires the matching `drun` version; older runtimes fail closed.
+Each successful private inference response carries `X-Decision-Artifact-Model`, `X-Decision-Artifact-Revision`, `X-Decision-Artifact-Manifest-Sha256`, and `X-Decision-Artifact-Content-Sha256` headers from the resident Decision runtime process. The Gateway requires exactly one well-formed value for each, matches the canonical model, pinned Hub revision and manifest digest, and matches the content digest when configured. Missing, duplicate, malformed, or mismatched identity discards that response. It also verifies the exact requested model, strict official JSON field set, answer IDs and types, state order, probability distributions, Choice winner, Score legend/value, type-aware Decision confidence, and batch usage aggregation. Confidence is accepted only from the validated runtime response and is never replaced with `max(probabilities)`. Explicit `/api/status?model=<wire-id>` probes report readiness plus the configured and live artifact digests without disclosing private origins. A Gateway using response attestation requires the matching Decision runtime version; older runtimes fail closed.
 
 `GET /api/ready` probes every configured model and returns HTTP 200 only when all are loaded with the pinned artifact; otherwise it returns HTTP 503 with public model IDs and Boolean readiness, never private origins. The Docker health check uses this aggregate route in direct mode, while legacy queue deployments keep their existing `/api/status` health check. The Studio menu reports an unavailable model distinctly from one still loading. Tetris configuration probes live Decision readiness before offering a local competitor, and a race start rechecks each selected local model so a disconnected instance returns 503 before the runners start. These control probes occur at page load and race admission, not on every game turn.
 
-For rollout, start and warm every pinned `drun` instance first, verify reachability **from the Gateway network namespace**, and verify that each private origin's live artifact report matches its assigned model and deployment pins. Then switch the Space to `DECISION_BACKEND=drun`. Keep the prior queue workers and their exact settings available but inactive until direct-mode probes and representative single/batch calls pass. A response identity mismatch is a deployment failure, never a reason to replay against another backend.
+For rollout, start and warm every pinned Decision runtime instance first, verify reachability **from the Gateway network namespace**, and verify that each private origin's live artifact report matches its assigned model and deployment pins. Then switch the Space to `DECISION_BACKEND=direct`. Keep the prior queue workers and their exact settings available but inactive until direct-mode probes and representative single/batch calls pass. A response identity mismatch is a deployment failure, never a reason to replay against another backend.
 
 The public reverse proxy must route `/tetris/` and `/api/tetris/*` to the same pinned Gateway release. Preserve the `/tetris` path when forwarding: the new Gateway serves the page at `/tetris/`, while an older standalone Tetris service used a stripped prefix. Keep `/v1/systemone` bounded at 256 KiB and admit up to 2 MiB at `/v1/systemone/batches`; a site-wide 256 KiB body limit would reject valid batch traffic before it reaches this application. Align the proxy's response-header timeout with the selected synchronous runtime timeout. Validate the proxy configuration before reload, retain its exact prior version, and test both paths before retiring the old page.
 
@@ -108,7 +106,7 @@ Public single-state request bodies remain bounded at 256 KiB; public batch bodie
 
 `/tetris/` is a passive SSE client for server-authoritative races. Starting a race creates two independent asynchronous runners immediately; connecting, reconnecting, or slowing the event stream does not pause either model. A disconnect starts a bounded reconnection lease, after which an abandoned race is cancelled. Only the seeded tetromino sequence is shared. The server retains separate board snapshots, request states, model actions, and traces at `/api/tetris/races/{id}/trace`. The browser paints each side from its own bounded step queue; a short 40-step burst keeps every step, while a longer burst may skip intermediate visual frames without changing the server race, final board, or result. The server records side completion order in the SSE result and snapshot so recovery preserves the real finishing order. An illegal model choice ends that side and is never replaced by a heuristic choice or another model.
 
-All endpoints and credentials are server-only Space variables or secrets. In `DECISION_BACKEND=drun` mode, Tetris selects local models from the same private `DECISION_DRUN_ENDPOINTS` map and sends each turn through the Gateway's attested direct client. It ignores legacy `TETRIS_LOCAL_*_API_URL` and local bearer variables. In the legacy modes, configure the shared Decision gateway with `TETRIS_LOCAL_API_URL` pointing to its `/v1/systemone` route, or configure per-model `TETRIS_LOCAL_LUX_API_URL`, `TETRIS_LOCAL_NOX_API_URL`, `TETRIS_LOCAL_SOL_API_URL`, `TETRIS_LOCAL_EOS_API_URL`, `TETRIS_LOCAL_KAI_API_URL`, and `TETRIS_LOCAL_LEX_API_URL`; optional local bearer secrets use the corresponding `_API_KEY` name or the shared `TETRIS_LOCAL_API_KEY`. A Decision response must return the exact Hugging Face canonical model ID selected by the player, such as `llm-semantic-router/Decision-1.0-Lux-9B`; a different or missing identity ends that side instead of being displayed under the wrong model name. This strict response identity is a deployment prerequisite. Legacy wire IDs such as `decision-lux` are not compatibility aliases here and deliberately fail closed during integration with an outdated Gateway.
+All endpoints and credentials are server-only Space variables or secrets. In `DECISION_BACKEND=direct` mode, Tetris selects local models from the same private `DECISION_DIRECT_ENDPOINTS` map and sends each turn through the Gateway's attested direct client. It ignores legacy `TETRIS_LOCAL_*_API_URL` and local bearer variables. In the legacy modes, configure the shared Decision gateway with `TETRIS_LOCAL_API_URL` pointing to its `/v1/systemone` route, or configure per-model `TETRIS_LOCAL_LUX_API_URL`, `TETRIS_LOCAL_NOX_API_URL`, `TETRIS_LOCAL_SOL_API_URL`, `TETRIS_LOCAL_EOS_API_URL`, `TETRIS_LOCAL_KAI_API_URL`, and `TETRIS_LOCAL_LEX_API_URL`; optional local bearer secrets use the corresponding `_API_KEY` name or the shared `TETRIS_LOCAL_API_KEY`. A Decision response must return the exact Hugging Face canonical model ID selected by the player, such as `llm-semantic-router/Decision-1.0-Lux-9B`; a different or missing identity ends that side instead of being displayed under the wrong model name. This strict response identity is a deployment prerequisite. Legacy wire IDs such as `decision-lux` are not compatibility aliases here and deliberately fail closed during integration with an outdated Gateway.
 
 Configure Jev Cloud with `TETRIS_JEV_API_URL`, the `TETRIS_JEV_API_KEY` secret, and optional `TETRIS_JEV_MODEL`. Configure the alternate SystemOne provider with `TETRIS_SYSTEMONE_API_URL`, the `TETRIS_SYSTEMONE_API_KEY` secret, and optional `TETRIS_SYSTEMONE_MODEL`. Existing `JEV_API_*`, `JEV_MIRROR_API_*`, and `LOCAL_API_URL` variables remain accepted while the deployment migrates. The `jev-latest` alias accepts only itself or a versioned `jev-x.y.z` response; an explicitly pinned Jev model must match exactly. `/api/tetris/config` exposes only readiness and display metadata; it never returns endpoint URLs or credentials.
 
@@ -116,6 +114,6 @@ Step races accept 1 through `TETRIS_MAX_STEPS` pieces. The default server limit
 
 Paid Cloud competitors additionally share one process-wide call budget across all clients. `TETRIS_CLOUD_CALLS_PER_WINDOW` defaults to 480 attempted calls, with a `TETRIS_CLOUD_CALL_WINDOW_SECONDS` default of 600 seconds. Admission reserves one call per possible step for each selected Cloud side (two for Cloud-vs-Cloud); a completed, failed, or cancelled race settles unused calls back to the budget. A race that cannot reserve its full possible Cloud cost receives HTTP 429 before any provider call. A local-vs-local race reserves no paid Cloud calls, including at the 2,000-step limit. Keep the default 120-step ceiling for public Cloud races unless the paid-provider budget is deliberately raised. The ledger is in memory and protects only this one Gateway process: deployments with multiple replicas or processes need a shared atomic budget store or an upstream account-level rate limit before claiming a fleet-wide cap.
 
-`TETRIS_RACE_TIMEOUT_SECONDS` sets a 1–3,600 second whole-race deadline (default 900); raise it deliberately for slow long runs. `TETRIS_STREAM_GRACE_SECONDS` sets the 1–300 second reconnection lease after the last event stream disconnects (default 30); reconnecting resumes retained SSE events, and the browser can recover the latest board and terminal result from the race snapshot. An abandoned race is cancelled. `TETRIS_COMPLETED_TTL_SECONDS` controls completed-race retention from 30–3,600 seconds (default 300). Shutdown cancels and awaits every active race before closing the provider transport. A failed, timed-out, or otherwise incomplete race does not award a score winner. The speed percentage is available only when both sides complete the same step target; it compares the sums of complete server-observed adapter calls. For an owned `drun` model, that includes its inference POST, response attestation, and response validation. Cloud competitors include the provider POST, response read, and response validation. Local `inference_ms`, when returned, is retained per turn in the trace for diagnosis and never enters that comparison. Whole-run durations remain in the race summary as diagnostics; browser rendering delay does not enter the speed percentage.
+`TETRIS_RACE_TIMEOUT_SECONDS` sets a 1–3,600 second whole-race deadline (default 900); raise it deliberately for slow long runs. `TETRIS_STREAM_GRACE_SECONDS` sets the 1–300 second reconnection lease after the last event stream disconnects (default 30); reconnecting resumes retained SSE events, and the browser can recover the latest board and terminal result from the race snapshot. An abandoned race is cancelled. `TETRIS_COMPLETED_TTL_SECONDS` controls completed-race retention from 30–3,600 seconds (default 300). Shutdown cancels and awaits every active race before closing the provider transport. A failed, timed-out, or otherwise incomplete race does not award a score winner. The speed percentage is available only when both sides complete the same step target; it compares the sums of complete server-observed adapter calls. For a private Decision runtime, that includes its inference POST, response attestation, and response validation. Cloud competitors include the provider POST, response read, and response validation. Local `inference_ms`, when returned, is retained per turn in the trace for diagnosis and never enters that comparison. Whole-run durations remain in the race summary as diagnostics; browser rendering delay does not enter the speed percentage.
 
 `TETRIS_REQUEST_TIMEOUT_SECONDS` bounds each server-to-provider call to 0.1–300 seconds (default 45). The adapter sends optional bearer credentials only from server configuration, rejects redirects, ignores ambient proxy settings, bounds response bytes, and never returns provider URLs or credentials to the browser. Validate each configured endpoint with its selected canonical model and expected response identity before enabling that competitor; publishing a Space commit rebuilds the live Space.

Dockerfile

@@ -6,10 +6,10 @@ RUN useradd --create-home --uid 1000 studio
 WORKDIR /app
 COPY requirements.txt /app/requirements.txt
 RUN pip install -r /app/requirements.txt
-COPY --chown=studio:studio app.py systemone_api.py contract.py engine.py relay.py model_registry.py drun_contract.py drun_gateway.py tetris_arena.py examples.json MODEL_RELEASES.json LICENSE /app/
+COPY --chown=studio:studio app.py systemone_api.py contract.py engine.py relay.py model_registry.py direct_contract.py direct_gateway.py tetris_arena.py examples.json MODEL_RELEASES.json LICENSE /app/
 COPY --chown=studio:studio static /app/static
 USER studio
 EXPOSE 7860
-HEALTHCHECK --interval=30s --timeout=5s --start-period=20s CMD python -c "import os, urllib.request; path = '/api/ready' if os.getenv('DECISION_BACKEND') == 'drun' else '/api/status'; urllib.request.urlopen('http://127.0.0.1:7860' + path, timeout=3).close()"
+HEALTHCHECK --interval=30s --timeout=5s --start-period=20s CMD python -c "import os, urllib.request; path = '/api/ready' if os.getenv('DECISION_BACKEND') == 'direct' else '/api/status'; urllib.request.urlopen('http://127.0.0.1:7860' + path, timeout=3).close()"
 # One process preserves the legacy in-memory queue/lease rollback mode.
 CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1", "--no-access-log"]

README.md

@@ -40,4 +40,4 @@ Complete input includes context, instructions, candidates and special tokens. No
 
 The editor runs on this CPU Space. Production direct mode maps each canonical model ID to its own private `vllm-sr decision serve` instance; the authenticated pull-queue deployment remains an explicit rollback mode. Switching clears old results, and an unavailable or misidentified model never silently falls back to another. Requests and results are not application-logged.
 
-[Historical presentation metadata](MODEL_RELEASES.json) · [Request contract](SYSTEM_ONE_MAPPING.md) · [Deployment](DEPLOYMENT.md). Active revision and manifest pins come from the deployment registry and are checked against each live `drun` service; the presentation file is not a serving allowlist. Studio code is MIT licensed. Models have their own Apache-2.0 project licenses and retained third-party notices. This repository contains no model weights or worker credentials.
+[Historical presentation metadata](MODEL_RELEASES.json) · [Request contract](SYSTEM_ONE_MAPPING.md) · [Deployment](DEPLOYMENT.md). Active revision and manifest pins come from the deployment registry and are checked against each live Decision runtime service; the presentation file is not a serving allowlist. Studio code is MIT licensed. Models have their own Apache-2.0 project licenses and retained third-party notices. This repository contains no model weights or worker credentials.

SYSTEMONE_API.md

@@ -87,7 +87,7 @@ with TypeSafeClient(
     print(result.scores["urgency"].score)
 ```
 
-Select any exact Hugging Face repository ID returned as `id` by `/v1/models`. The model is required on public inference requests; short names, wire aliases, and case variants are rejected. The response repeats the selected canonical ID. The Studio editor uses a same-origin endpoint; in direct `drun` mode it receives the same strict response envelope, while legacy modes retain their internal queue/diagnostic contracts.
+Select any exact Hugging Face repository ID returned as `id` by `/v1/models`. The model is required on public inference requests; short names, wire aliases, and case variants are rejected. The response repeats the selected canonical ID. The Studio editor uses a same-origin endpoint; in direct serving mode it receives the same strict response envelope, while legacy modes retain their internal queue/diagnostic contracts.
 
 Direct mode does not advertise a default model. The Studio editor selects a model locally and includes it explicitly in every `/api/evaluate` request; a missing model receives HTTP 422. Legacy rollback modes may retain their previous discovery default.
 
@@ -107,9 +107,9 @@ Direct mode does not advertise a default model. The Studio editor selects a mode
 - Noul returns P(true); Choice returns its winning label and probabilities; Score returns the expected ordinal level and its distribution.
 - Choice `confidence` is the top-two probability margin; Score `confidence` is the ordinal concentration around its expected level, normalized against uniform variance. These are versioned Decision-owned statistics, not calibrated probabilities of correctness or a claim of equivalence to TypeSafe's undisclosed calculation. The direct Gateway validates and forwards the runtime value unchanged; it never substitutes `max(probabilities)`. Public responses contain only `model`, `answers`, and `usage`.
 - The hosted endpoint accepts one or more named questions without a fixed question-count cap. In direct mode, each model instance owns its physical microbatch setting. Choice accepts 2–255 options, Score accepts 2–10 ordered levels, and JSON requests are limited to 256 KiB. Expanded state/question input is limited to 16 MiB so large Cartesian workloads stay bounded. Provide explicit nonempty instructions. State plus question plus all candidates must fit the model limit; overflowing requests are rejected without truncation.
-- In direct `drun` mode, the synchronous wait is configurable and each instance owns its own concurrency, queue, and physical-batch limits; `/v1/models` does not invent fixed values for them. A busy or timed-out service may return 529/503/504 (legacy queue mode may return 429). Completed requests do not consume admission capacity. Do not treat transport errors as predictions. SDK example retries are disabled to avoid duplicate inference.
-- `POST /v1/systemone/batches` applies one shared `questions` map to ordered `states: [{id, state}, ...]`. It requires the same explicit canonical `model`, unique state IDs, at most 1,024 states, questions, and total decisions, a 2 MiB JSON body, and the same 16 MiB expanded-input and per-question token budgets. Its atomic response contains `model`, ordered `results: [{id, answers, usage}, ...]`, and aggregate `usage`. This Decision extension is separate from the SDK's single-state method. There is no `/v1/systemone/batch` alias.
+- In direct serving mode, the synchronous wait is configurable and each instance owns its own concurrency, queue, and physical-batch limits; `/v1/models` does not invent fixed values for them. A busy or timed-out service may return 529/503/504 (legacy queue mode may return 429). Completed requests do not consume admission capacity. Do not treat transport errors as predictions. SDK example retries are disabled to avoid duplicate inference.
+- `POST /v1/systemone/batches` applies one shared `questions` map to ordered `states: [{id, state}, ...]`. It requires the same explicit canonical `model`, unique state IDs, at most 1,024 states, questions, and total decisions, a 2 MiB JSON body, and the same 16 MiB expanded-input and per-question token budgets. Its atomic response contains `model`, ordered `results: [{id, answers, usage}, ...]`, and aggregate `usage`. This Decision extension is separate from the SDK's single-state method.
 
 See [SYSTEM_ONE_MAPPING.md](SYSTEM_ONE_MAPPING.md) for the complete adapter contract. The standard single-state call, all three answer types, and model discovery are validated with the official SDK.
 
-In legacy pull-queue mode, completed asynchronous results are kept for up to 120 seconds, with the oldest completed records evicted when the 64-result cache fills. Direct `drun` mode does not create Gateway jobs or retain completion receipts. `GET /v1/models` publishes the service limits. The original Space origin remains available.
+In legacy pull-queue mode, completed asynchronous results are kept for up to 120 seconds, with the oldest completed records evicted when the 64-result cache fills. Direct serving mode does not create Gateway jobs or retain completion receipts. `GET /v1/models` publishes the service limits. The original Space origin remains available.

SYSTEM_ONE_MAPPING.md

@@ -16,13 +16,13 @@ Studio exposes a **SystemOne-format Decision service** with official Python SDK
 
 The public single-state endpoint requires exactly `model`, `state`, and `questions`, with a 256 KiB JSON body. The separate batch endpoint requires exactly `model`, `states`, and `questions`, with a 2 MiB JSON body and at most 1,024 states, questions, and total decisions. Both accept 2–255 Choice options, 2–10 Score levels, and up to 16 MiB of expanded context/question input. The direct runtime uses a per-model configurable physical microbatch size rather than a fixed eight rows. The complete-input limit is 1,024 tokens for Kai/Lex and 16,384 for Eos/Sol/Nox/Lux **per question**, including state and all candidate descriptions. Unsupported fields and models are rejected.
 
-Single-context responses preserve named `answers`, Choice `choice/probabilities`, Score `score/legend/probabilities`, and Noul `noul`. `usage.output_tokens=0` because these models do not generate text. The public inference envelopes contain only `model`, answers or results, and usage. In direct `drun` mode, Studio's `/api/evaluate` route returns that same strict envelope; legacy native and pull-queue modes retain their diagnostic response fields for rollback.
+Single-context responses preserve named `answers`, Choice `choice/probabilities`, Score `score/legend/probabilities`, and Noul `noul`. `usage.output_tokens=0` because these models do not generate text. The public inference envelopes contain only `model`, answers or results, and usage. In direct serving mode, Studio's `/api/evaluate` route returns that same strict envelope; legacy native and pull-queue modes retain their diagnostic response fields for rollback.
 
 The public inference responses supply versioned, type-aware Decision confidence: Choice uses the top-two probability margin, while Score uses ordinal concentration around the expected level relative to uniform variance. It is not calibrated correctness or a claim of equivalence to TypeSafe’s undisclosed confidence formula. The direct Gateway validates and preserves the runtime value rather than recalculating it as `max(probabilities)`. Noul returns its original probability of yes.
 
 This mapping is independently testable with small metadata fixtures. It does not change the model's packing, native graph, weights, scoring arithmetic, or export format.
 
-Sol and Nox use their published `question_row` and `predict_rows` path, the same numerical path used by `DecisionModel.decide`. Shipped temperatures, candidate order, true-probability orientation and ordinal Score arithmetic are preserved. Legacy Studio modes retain exact per-question input-token diagnostics; direct `drun` mode returns only strict aggregate usage. Neither path reinterprets a Decision statistic as TypeSafe confidence.
+Sol and Nox use their published `question_row` and `predict_rows` path, the same numerical path used by `DecisionModel.decide`. Shipped temperatures, candidate order, true-probability orientation and ordinal Score arithmetic are preserved. Legacy Studio modes retain exact per-question input-token diagnostics; direct serving mode returns only strict aggregate usage. Neither path reinterprets a Decision statistic as TypeSafe confidence.
 
 ## A shared question across contexts
 
@@ -46,6 +46,6 @@ Sol and Nox use their published `question_row` and `predict_rows` path, the same
 }
 ```
 
-Submit this payload to `POST /v1/systemone/batches`. Batch responses replace top-level `answers` with ordered `results: [{id, answers, usage}, ...]`. Context order and shared-question order are retained. Top-level `usage` sums all pairs. Legacy native/pull-queue Studio responses also report `contexts`, `questions`, and `decisions` in `timing`; direct `drun` responses stay strict. A row can expand to show the original probabilities. Score is an expected ordinal index; Noul is P(Yes), not an independent confidence estimate.
+Submit this payload to `POST /v1/systemone/batches`. Batch responses replace top-level `answers` with ordered `results: [{id, answers, usage}, ...]`. Context order and shared-question order are retained. Top-level `usage` sums all pairs. Legacy native/pull-queue Studio responses also report `contexts`, `questions`, and `decisions` in `timing`; direct responses stay strict. A row can expand to show the original probabilities. Score is an expected ordinal index; Noul is P(Yes), not an independent confidence estimate.
 
 The worker admits every complete context/question input before its first forward. Any overflow rejects the whole request: no truncation or partial result. Admitted pairs are flattened into one predictor call with physical batches of up to eight. This is actual GPU batching, not browser-side request fanout or shared-state caching. The native numerical engine, weights, candidate order and published temperatures remain unchanged.

app.py

@@ -14,7 +14,7 @@ from fastapi.staticfiles import StaticFiles
 from starlette.concurrency import run_in_threadpool
 
 from contract import MODEL, to_records
-from drun_gateway import DrunGateway, DrunGatewayError
+from direct_gateway import DirectGateway, DirectGatewayError
 from engine import Busy, Engine, Unavailable
 from relay import Relay, RelayError
 from systemone_api import (
@@ -112,13 +112,13 @@ def create_app(
     relay=None,
     registry=None,
     relays=None,
-    drun_gateway=None,
+    direct_gateway=None,
     tetris_adapter=None,
     tetris_manager=None,
 ):
     mode = mode or os.getenv("DECISION_BACKEND", "native")
-    if mode not in {"native", "pull_queue", "drun"}:
-        raise ValueError("DECISION_BACKEND must be native, pull_queue, or drun")
+    if mode not in {"native", "pull_queue", "direct"}:
+        raise ValueError("DECISION_BACKEND must be native, pull_queue, or direct")
     from model_registry import model_registry
     if relay is not None and registry is None:
         registry = [{'id': MODEL, 'label': 'Kai', 'version': '1.0', 'manifest_sha256': relay.manifest}]
@@ -126,16 +126,16 @@ def create_app(
     default_model = next(iter(registry))
     canonical_models = tuple(item['repo_id'] for item in registry.values())
     expected_artifacts = {item['repo_id']: item for item in registry.values()}
-    owns_drun_gateway = mode == "drun" and drun_gateway is None
-    if mode == "drun":
+    owns_direct_gateway = mode == "direct" and direct_gateway is None
+    if mode == "direct":
         if any('revision' not in item for item in registry.values()):
-            raise ValueError("Direct drun mode requires a pinned Hub revision for every model")
-        drun_gateway = drun_gateway or DrunGateway.from_environment(expected_artifacts)
-        if getattr(drun_gateway, "models", None) != frozenset(canonical_models):
+            raise ValueError("Direct serving mode requires a pinned Hub revision for every model")
+        direct_gateway = direct_gateway or DirectGateway.from_environment(expected_artifacts)
+        if getattr(direct_gateway, "models", None) != frozenset(canonical_models):
             raise ValueError(
-                "The drun Gateway must match every configured canonical model"
+                "The direct Gateway must match every configured canonical model"
             )
-        gateway_pins = getattr(drun_gateway, "expected_artifacts", None)
+        gateway_pins = getattr(direct_gateway, "expected_artifacts", None)
         if gateway_pins is not None and any(
             gateway_pins.get(model) != {
                 "revision": item["revision"],
@@ -145,9 +145,9 @@ def create_app(
             }
             for model, item in expected_artifacts.items()
         ):
-            raise ValueError("The drun Gateway artifact pins must match the registry")
-    elif drun_gateway is not None:
-        raise ValueError("A drun Gateway may only be supplied in drun mode")
+            raise ValueError("The direct Gateway artifact pins must match the registry")
+    elif direct_gateway is not None:
+        raise ValueError("A direct Gateway may only be supplied in direct mode")
     trusted_proxies = trusted_proxy_networks(
         os.getenv("TETRIS_TRUSTED_PROXY_CIDRS", "")
     )
@@ -156,9 +156,9 @@ def create_app(
     if tetris_manager is None:
         tetris_adapter = tetris_adapter or HTTPDecisionAdapter.from_environment(
             local_endpoints=(
-                drun_gateway.local_systemone_endpoints() if mode == "drun" else None
+                direct_gateway.local_systemone_endpoints() if mode == "direct" else None
             ),
-            direct_gateway=drun_gateway if mode == "drun" else None,
+            direct_gateway=direct_gateway if mode == "direct" else None,
         )
         tetris_manager = RaceManager.from_environment(tetris_adapter)
 
@@ -173,8 +173,8 @@ def create_app(
                     if owns_tetris_adapter:
                         await tetris_adapter.close()
         finally:
-            if owns_drun_gateway:
-                await drun_gateway.aclose()
+            if owns_direct_gateway:
+                await direct_gateway.aclose()
 
     api = FastAPI(
         title="Decision Studio",
@@ -200,7 +200,7 @@ def create_app(
     api.state.relays = relays
     api.state.relay = relays.get(MODEL)  # backward-compatible default for local tooling
     api.state.registry = registry
-    api.state.drun = drun_gateway
+    api.state.direct = direct_gateway
 
     api.state.tetris = tetris_manager
 
@@ -210,10 +210,10 @@ def create_app(
         return relays.get(model)
 
     async def direct_readiness(models):
-        """Probe distinct configured drun models without exposing their origins."""
+        """Probe distinct configured Decision models without exposing their origins."""
         selected = tuple(dict.fromkeys(models))
         observations = await asyncio.gather(
-            *(drun_gateway.probe(model) for model in selected),
+            *(direct_gateway.probe(model) for model in selected),
             return_exceptions=True,
         )
         return {
@@ -222,7 +222,7 @@ def create_app(
         }
 
     async def tetris_direct_readiness(competitor_ids=None):
-        if mode != "drun":
+        if mode != "direct":
             return {}
         competitors = (
             api.state.tetris.catalog()
@@ -247,7 +247,7 @@ def create_app(
             limit=(
                 2 * 1024 * 1024
                 if public_contract == 'batch'
-                or (mode == 'drun' and public_contract is None)
+                or (mode == 'direct' and public_contract is None)
                 else 256 * 1024
             ),
         )
@@ -260,7 +260,7 @@ def create_app(
             resolve_canonical_model(requested_model, registry)
             if public_contract is not None
             else resolve_model(
-                requested_model if mode == "drun" else requested_model or default_model,
+                requested_model if mode == "direct" else requested_model or default_model,
                 registry,
             )
         )
@@ -275,7 +275,7 @@ def create_app(
             records = to_records(payload, model=model)
         except (ValueError, TypeError, UnicodeError, RecursionError) as exc:
             if (
-                mode == "drun"
+                mode == "direct"
                 and "Expanded context/question input exceeds" in str(exc)
             ):
                 raise HTTPException(413, str(exc)) from None
@@ -287,8 +287,8 @@ def create_app(
         return JSONResponse({"detail": exc.message}, status_code=exc.code,
                             headers={"Retry-After": "2"} if exc.code in {429, 503} else None)
 
-    @api.exception_handler(DrunGatewayError)
-    async def drun_error(request, exc):
+    @api.exception_handler(DirectGatewayError)
+    async def direct_error(request, exc):
         headers = {"Retry-After": exc.retry_after} if exc.retry_after else None
         return JSONResponse({"detail": exc.message}, status_code=exc.code, headers=headers)
 
@@ -296,8 +296,8 @@ def create_app(
     async def status(model: str = default_model):
         model = resolve_model(model, registry)
         selected = select(model)
-        if mode == "drun":
-            observed = await drun_gateway.probe(registry[model]['repo_id'])
+        if mode == "direct":
+            observed = await direct_gateway.probe(registry[model]['repo_id'])
             loaded = observed['loaded']
             artifact = observed['artifact'] or {}
             return {
@@ -312,7 +312,7 @@ def create_app(
                 "loaded_content_sha256": artifact.get('content_sha256'),
                 "complete_input_tokens": registry[model]['complete_input_tokens'],
                 "context_batch": loaded,
-                "backend": "drun",
+                "backend": "direct",
                 "live_inference": loaded,
                 "running": False,
                 "queued": 0,
@@ -322,7 +322,7 @@ def create_app(
     @api.get("/api/ready")
     async def ready():
         """Return HTTP 503 when any configured model is unavailable."""
-        if mode == 'drun':
+        if mode == 'direct':
             loaded = await direct_readiness(canonical_models)
         elif relays:
             observations = await asyncio.gather(
@@ -366,7 +366,7 @@ def create_app(
     @api.post("/api/tetris/races", status_code=201)
     async def create_tetris_race(request: Request):
         payload = await read_json(request)
-        if mode == 'drun' and isinstance(payload, dict):
+        if mode == 'direct' and isinstance(payload, dict):
             selected_ids = {
                 value for side in ('left', 'right')
                 if isinstance(value := payload.get(side), str)
@@ -443,8 +443,8 @@ def create_app(
     @api.get("/v1/models")
     def models():
         synchronous_wait = (
-            getattr(drun_gateway, "timeout_seconds", 45)
-            if mode == "drun"
+            getattr(direct_gateway, "timeout_seconds", 45)
+            if mode == "direct"
             else 45
         )
         limits = {
@@ -452,17 +452,17 @@ def create_app(
             "expanded_input_bytes": 16 * 1024 * 1024,
             "questions": None,
             "contexts": None,
-            # drun capacity belongs to each live model instance, not the
+            # direct capacity belongs to each live model instance, not the
             # retired Gateway's fixed eight-request/eight-row profile.
-            "active_requests_per_model": None if mode == "drun" else 8,
-            "gpu_microbatch": None if mode == "drun" else 8,
+            "active_requests_per_model": None if mode == "direct" else 8,
+            "gpu_microbatch": None if mode == "direct" else 8,
             "synchronous_wait_seconds": synchronous_wait,
         }
         result = {
             "models": public_models(registry),
             "limits": limits,
         }
-        if mode != "drun":
+        if mode != "direct":
             result["default"] = registry[default_model]['repo_id']
         return result
 
@@ -482,8 +482,8 @@ def create_app(
         payload, records, selected, public_model, canonical_payload, _ = await input_for(
             request, public_contract=public_contract
         )
-        if mode == "drun":
-            return await drun_gateway.evaluate(
+        if mode == "direct":
+            return await direct_gateway.evaluate(
                 canonical_payload,
                 batch='states' in canonical_payload,
             )

drun_contract.py → direct_contract.py

@@ -163,7 +163,7 @@ def _answers_for_questions(questions: object, answers: object, path: str) -> Non
 def validate_response_for_request(
     request: Mapping[str, object], response: object, *, batch: bool
 ) -> None:
-    """Validate a strict drun response without changing any returned statistic."""
+    """Validate a strict direct response without changing any returned statistic."""
 
     expected_top = {"model", "results", "usage"} if batch else {
         "model",

drun_gateway.py → direct_gateway.py

@@ -1,4 +1,4 @@
-"""Private direct transport from the public Gateway to per-model drun servers.
+"""Private transport from the public Gateway to per-model Decision runtimes.
 
 The browser never receives backend locations.  Every inference response is
 validated against the originating strict request before it crosses the public
@@ -19,7 +19,7 @@ from urllib.parse import urlsplit
 
 import httpx
 
-from drun_contract import validate_response_for_request
+from direct_contract import validate_response_for_request
 
 SINGLE_PATH = "/v1/systemone"
 BATCH_PATH = "/v1/systemone/batches"
@@ -55,7 +55,7 @@ def _hex_digest(value: object, length: int) -> bool:
     )
 
 
-class DrunGatewayError(RuntimeError):
+class DirectGatewayError(RuntimeError):
     """A sanitized direct-backend failure safe to return to a caller."""
 
     def __init__(self, code: int, message: str, *, retry_after: str | None = None):
@@ -88,12 +88,12 @@ def _private_origin(value: object) -> str:
     """Accept an explicit private/loopback IP origin, never a URL path or DNS name."""
 
     if not isinstance(value, str) or not value or len(value) > 2048:
-        raise ValueError("Every drun endpoint must be a bounded URL string")
+        raise ValueError("Every direct endpoint must be a bounded URL string")
     try:
         parsed = urlsplit(value)
         port = parsed.port
     except ValueError:
-        raise ValueError("Every drun endpoint must be a valid private origin") from None
+        raise ValueError("Every direct endpoint must be a valid private origin") from None
     if (
         parsed.scheme not in {"http", "https"}
         or parsed.username is not None
@@ -106,15 +106,15 @@ def _private_origin(value: object) -> str:
         or not 1 <= port <= 65535
     ):
         raise ValueError(
-            "Every drun endpoint must be an http(s) origin with an explicit port"
+            "Every direct endpoint must be an http(s) origin with an explicit port"
         )
     if "%" in parsed.hostname:
-        raise ValueError("Scoped IPv6 drun endpoints are not supported")
+        raise ValueError("Scoped IPv6 direct endpoints are not supported")
     try:
         address = ipaddress.ip_address(parsed.hostname)
     except ValueError:
         raise ValueError(
-            "Every drun endpoint host must be a private or loopback IP literal"
+            "Every direct endpoint host must be a private or loopback IP literal"
         ) from None
     if isinstance(address, ipaddress.IPv6Address) and address.ipv4_mapped:
         address = address.ipv4_mapped
@@ -125,42 +125,42 @@ def _private_origin(value: object) -> str:
             for network in PRIVATE_NETWORKS
         )
     ):
-        raise ValueError("Every drun endpoint must stay on a private or loopback IP")
+        raise ValueError("Every direct endpoint must stay on a private or loopback IP")
     host = f"[{address.compressed}]" if address.version == 6 else address.compressed
     return f"{parsed.scheme}://{host}:{port}"
 
 
 def endpoints_from_environment(expected_models: Collection[str]) -> dict[str, str]:
-    raw = os.getenv("DECISION_DRUN_ENDPOINTS", "")
+    raw = os.getenv("DECISION_DIRECT_ENDPOINTS", "")
     if not raw:
-        raise ValueError("DECISION_DRUN_ENDPOINTS is required for the drun backend")
+        raise ValueError("DECISION_DIRECT_ENDPOINTS is required for the direct backend")
     if len(raw.encode("utf-8")) > MAX_ENDPOINT_CONFIG_BYTES:
-        raise ValueError("DECISION_DRUN_ENDPOINTS is too large")
+        raise ValueError("DECISION_DIRECT_ENDPOINTS is too large")
     try:
         value = _loads_strict(raw)
     except (TypeError, ValueError, UnicodeError, RecursionError) as exc:
-        raise ValueError("DECISION_DRUN_ENDPOINTS must be a strict JSON object") from exc
+        raise ValueError("DECISION_DIRECT_ENDPOINTS must be a strict JSON object") from exc
     if not isinstance(value, dict) or set(value) != set(expected_models):
         raise ValueError(
-            "DECISION_DRUN_ENDPOINTS must cover exactly the configured canonical models"
+            "DECISION_DIRECT_ENDPOINTS must cover exactly the configured canonical models"
         )
     return {model: _private_origin(endpoint) for model, endpoint in value.items()}
 
 
 def timeout_from_environment() -> float:
-    raw = os.getenv("DECISION_DRUN_TIMEOUT_SECONDS", "45")
+    raw = os.getenv("DECISION_DIRECT_TIMEOUT_SECONDS", "45")
     try:
         timeout = float(raw)
     except ValueError as exc:
-        raise ValueError("DECISION_DRUN_TIMEOUT_SECONDS must be numeric") from exc
+        raise ValueError("DECISION_DIRECT_TIMEOUT_SECONDS must be numeric") from exc
     if not math.isfinite(timeout) or not MIN_TIMEOUT_SECONDS <= timeout <= MAX_TIMEOUT_SECONDS:
         raise ValueError(
-            "DECISION_DRUN_TIMEOUT_SECONDS must be between 0.1 and 300"
+            "DECISION_DIRECT_TIMEOUT_SECONDS must be between 0.1 and 300"
         )
     return timeout
 
 
-class DrunGateway:
+class DirectGateway:
     """Keep-alive direct client with fail-closed model and response validation."""
 
     def __init__(
@@ -179,14 +179,14 @@ class DrunGateway:
             or any(not isinstance(model, str) or not model for model in expected)
             or len(set(expected)) != len(expected)
         ):
-            raise ValueError("Configure a nonempty set of canonical drun models")
+            raise ValueError("Configure a nonempty set of canonical Decision models")
         if set(endpoints) != set(expected):
-            raise ValueError("drun endpoints must cover exactly the configured models")
+            raise ValueError("direct endpoints must cover exactly the configured models")
         pinned = {}
         for model in expected:
             item = expected_artifacts[model]
             if not isinstance(item, Mapping):
-                raise ValueError("Pin each drun model to a released artifact")
+                raise ValueError("Pin each Decision model to a released artifact")
             revision = item.get("revision")
             manifest = item.get("manifest_sha256")
             content = item.get("content_sha256")
@@ -195,7 +195,7 @@ class DrunGateway:
                 or not _hex_digest(manifest, 64)
                 or (content is not None and not _hex_digest(content, 64))
             ):
-                raise ValueError("Pin each drun model revision and manifest digest")
+                raise ValueError("Pin each Decision model revision and manifest digest")
             pinned[model] = MappingProxyType(
                 {
                     "revision": revision,
@@ -214,15 +214,15 @@ class DrunGateway:
             except OverflowError:
                 timeout_valid = False
         if not timeout_valid:
-            raise ValueError("drun timeout must be between 0.1 and 300 seconds")
+            raise ValueError("direct timeout must be between 0.1 and 300 seconds")
         if (
             type(max_response_bytes) is not int
             or not 1 <= max_response_bytes <= MAX_INFERENCE_RESPONSE_BYTES
         ):
-            raise ValueError("Invalid drun response limit")
+            raise ValueError("Invalid direct response limit")
         normalized = {model: _private_origin(endpoints[model]) for model in expected}
         if len(set(normalized.values())) != len(normalized):
-            raise ValueError("Each configured Decision model requires its own drun origin")
+            raise ValueError("Each configured Decision model requires its own direct origin")
         self._endpoints = MappingProxyType(normalized)
         self.expected_artifacts = MappingProxyType(pinned)
         self.models = frozenset(expected)
@@ -239,7 +239,7 @@ class DrunGateway:
     @classmethod
     def from_environment(
         cls, expected_artifacts: Mapping[str, Mapping[str, str]]
-    ) -> DrunGateway:
+    ) -> DirectGateway:
         return cls(
             endpoints_from_environment(expected_artifacts),
             expected_artifacts=expected_artifacts,
@@ -268,9 +268,9 @@ class DrunGateway:
 
         model = payload.get("model") if isinstance(payload, Mapping) else None
         if not isinstance(model, str) or model not in self.models:
-            raise DrunGatewayError(422, "The selected canonical model is not configured")
+            raise DirectGatewayError(422, "The selected canonical model is not configured")
         if batch != ("states" in payload) or ("state" in payload and "states" in payload):
-            raise DrunGatewayError(422, "The Decision request does not match its route")
+            raise DirectGatewayError(422, "The Decision request does not match its route")
         try:
             encoded = json.dumps(
                 payload,
@@ -279,10 +279,10 @@ class DrunGateway:
                 allow_nan=False,
             ).encode("utf-8")
         except (TypeError, ValueError, UnicodeError, RecursionError) as exc:
-            raise DrunGatewayError(422, "The Decision request is not valid JSON") from exc
+            raise DirectGatewayError(422, "The Decision request is not valid JSON") from exc
         request_limit = MAX_BATCH_REQUEST_BYTES if batch else MAX_SINGLE_REQUEST_BYTES
         if len(encoded) > request_limit:
-            raise DrunGatewayError(413, "Request body exceeds the endpoint limit")
+            raise DirectGatewayError(413, "Request body exceeds the endpoint limit")
         started = self._clock()
         response = await self._request_json(
             "POST",
@@ -296,7 +296,7 @@ class DrunGateway:
         try:
             validate_response_for_request(payload, response, batch=batch)
         except (TypeError, ValueError, KeyError, OverflowError, RecursionError) as exc:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 502, "The selected Decision runtime returned an invalid response"
             ) from exc
         return response, request_ms
@@ -327,7 +327,7 @@ class DrunGateway:
                 and self._artifact_matches(model, artifact)
             )
             return {"loaded": bool(loaded), "artifact": artifact}
-        except DrunGatewayError:
+        except DirectGatewayError:
             return {"loaded": False, "artifact": None}
 
     @staticmethod
@@ -390,7 +390,7 @@ class DrunGateway:
     ):
         endpoint = self._endpoints.get(model)
         if endpoint is None:
-            raise DrunGatewayError(422, "The selected canonical model is not configured")
+            raise DirectGatewayError(422, "The selected canonical model is not configured")
         request_timeout = timeout_seconds or self.timeout_seconds
         try:
             headers = {
@@ -409,7 +409,7 @@ class DrunGateway:
                     timeout=request_timeout,
                 ) as response:
                     if 300 <= response.status_code < 400:
-                        raise DrunGatewayError(
+                        raise DirectGatewayError(
                             502,
                             "The selected Decision runtime returned an unsupported redirect",
                         )
@@ -418,20 +418,20 @@ class DrunGateway:
                     if attest_model is not None and not self._artifact_matches(
                         attest_model, self._parse_response_artifact(response.headers)
                     ):
-                        raise DrunGatewayError(
+                        raise DirectGatewayError(
                             503, "The selected Decision runtime artifact is unavailable"
                         )
                     return await self._read_json_response(response, limit)
         except asyncio.CancelledError:
             raise
-        except DrunGatewayError:
+        except DirectGatewayError:
             raise
         except (TimeoutError, httpx.TimeoutException) as exc:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 504, "The selected Decision runtime did not respond in time"
             ) from exc
         except httpx.HTTPError as exc:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 503, "The selected Decision runtime is unavailable"
             ) from exc
 
@@ -439,26 +439,26 @@ class DrunGateway:
     def _raise_status(response: httpx.Response) -> None:
         status = response.status_code
         if status == 413:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 413, "Decision input exceeds the selected model limit"
             )
         if status in {429, 529}:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 status,
                 "The selected Decision runtime is temporarily overloaded",
                 retry_after=_safe_retry_after(response.headers.get("retry-after")),
             )
         if status == 503:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 503,
                 "The selected Decision runtime is unavailable",
                 retry_after=_safe_retry_after(response.headers.get("retry-after")),
             )
         if status == 504:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 504, "The selected Decision runtime did not respond in time"
             )
-        raise DrunGatewayError(
+        raise DirectGatewayError(
             502, "The selected Decision runtime rejected a validated request"
         )
 
@@ -468,12 +468,12 @@ class DrunGateway:
             response.headers.get("content-type", "").split(";", 1)[0].strip().lower()
         )
         if content_type != "application/json":
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 502, "The selected Decision runtime returned an invalid content type"
             )
         encoding = response.headers.get("content-encoding", "identity").strip().lower()
         if encoding not in {"", "identity"}:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 502, "The selected Decision runtime returned an unsupported encoding"
             )
         declared = response.headers.get("content-length")
@@ -481,11 +481,11 @@ class DrunGateway:
             try:
                 declared_size = int(declared)
             except ValueError as exc:
-                raise DrunGatewayError(
+                raise DirectGatewayError(
                     502, "The selected Decision runtime returned an invalid response"
                 ) from exc
             if declared_size < 0 or declared_size > limit:
-                raise DrunGatewayError(
+                raise DirectGatewayError(
                     502, "The selected Decision runtime returned an oversized response"
                 )
         body = bytearray()
@@ -494,14 +494,14 @@ class DrunGateway:
         # live stream. Non-identity content encodings were rejected above.
         async for chunk in response.aiter_bytes(chunk_size=64 * 1024):
             if len(chunk) > limit - len(body):
-                raise DrunGatewayError(
+                raise DirectGatewayError(
                     502, "The selected Decision runtime returned an oversized response"
                 )
             body.extend(chunk)
         try:
             return _loads_strict(bytes(body))
         except (TypeError, ValueError, UnicodeError, RecursionError) as exc:
-            raise DrunGatewayError(
+            raise DirectGatewayError(
                 502, "The selected Decision runtime returned invalid JSON"
             ) from exc
 

static/app.js

@@ -300,9 +300,9 @@ async function run() {
   try {
     const result = status.backend === 'pull_queue' ? await queuedPrediction(payload, current) : await nativePrediction(payload, current);
     if(version!==revision || epoch!==modelEpoch || current.signal.aborted) return;
-    const expectedModel=status.backend==='drun'?modelInfo().repo_id:selectedModel;
+    const expectedModel=status.backend==='direct'?modelInfo().repo_id:selectedModel;
     if(result.model!==expectedModel || payload.model!==selectedModel) throw Error('The server returned a different model.');
-    if(status.backend!=='drun'&&result.source!=='live_native') throw Error('This server did not return a live native prediction.');
+    if(status.backend!=='direct'&&result.source!=='live_native') throw Error('This server did not return a live native prediction.');
     renderResult(result,payload);
   } catch(e) {if(e.name!=='AbortError' && version===revision){setModelActivity('error');setRunStatus('Could not complete this request','error');toast(e.message); if(!lastResult)$('results').innerHTML=`<div class="error-message">${esc(e.message)}</div>`;}}
   finally{if(controller===current)controller=null;updateRunButton();if(epoch===modelEpoch)await checkStatus();}

tests/studio_contract.test.mjs

@@ -73,7 +73,7 @@ test('browser request bytes match the single and batch API routes', () => {
   }
 });
 
-test('strict drun single response needs canonical identity and no diagnostics', () => {
+test('strict direct single response needs canonical identity and no diagnostics', () => {
   assert.equal(validateResult(strict, request, canonical), strict);
   assert.throws(() => validateResult({ ...strict, model: request.model }, request, canonical));
   assert.throws(() => validateResult({ ...strict, timing: {} }, request, canonical));
@@ -83,7 +83,7 @@ test('strict drun single response needs canonical identity and no diagnostics',
   } }, request, canonical));
 });
 
-test('strict drun batch response preserves state order and per-row usage', () => {
+test('strict direct batch response preserves state order and per-row usage', () => {
   const batchRequest = {
     ...request,
     states: [

tests/{test_drun_gateway.py → test_direct_gateway.py}

@@ -1,4 +1,4 @@
-"""Direct drun routing stays private and preserves the strict response contract."""
+"""Direct routing stays private and preserves the strict response contract."""
 
 import asyncio
 import inspect
@@ -12,7 +12,7 @@ from fastapi.testclient import TestClient
 
 from app import create_app
 from contract import MODEL
-from drun_gateway import ARTIFACT_RESPONSE_HEADERS, DrunGateway, DrunGatewayError
+from direct_gateway import ARTIFACT_RESPONSE_HEADERS, DirectGateway, DirectGatewayError
 from engine import DEFAULT_MANIFEST
 from model_registry import PROFILES
 from tetris_arena import Competitor, HTTPDecisionAdapter, LOCAL_MODELS
@@ -164,13 +164,13 @@ def batch_response(model=CANONICAL):
     }
 
 
-class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
+class DirectTransportTests(unittest.IsolatedAsyncioTestCase):
     async def gateway(self, handler, *, control_handler=False, **kwargs):
         artifact_pins = kwargs.pop("expected_artifacts", {CANONICAL: pins()})
         client = httpx.AsyncClient(
             transport=httpx.MockTransport(handler if control_handler else with_control(handler))
         )
-        gateway = DrunGateway(
+        gateway = DirectGateway(
             {CANONICAL: ORIGIN},
             expected_artifacts=artifact_pins,
             client=client,
@@ -179,6 +179,24 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
         self.addAsyncCleanup(client.aclose)
         return gateway
 
+    async def test_direct_environment_configures_private_origin_and_timeout(self):
+        with patch.dict(
+            os.environ,
+            {
+                "DECISION_DIRECT_ENDPOINTS": json.dumps({CANONICAL: ORIGIN}),
+                "DECISION_DIRECT_TIMEOUT_SECONDS": "17",
+            },
+            clear=True,
+        ):
+            gateway = DirectGateway.from_environment({CANONICAL: pins()})
+        self.addAsyncCleanup(gateway.aclose)
+
+        self.assertEqual(
+            gateway.local_systemone_endpoints(),
+            {CANONICAL: ORIGIN + "/v1/systemone"},
+        )
+        self.assertEqual(gateway.timeout_seconds, 17)
+
     async def test_routes_single_to_exact_model_and_preserves_non_max_confidence(self):
         seen = []
 
@@ -258,7 +276,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
 
         client = httpx.AsyncClient(transport=httpx.MockTransport(with_control(handler)))
         self.addAsyncCleanup(client.aclose)
-        gateway = DrunGateway(
+        gateway = DirectGateway(
             {CANONICAL: ORIGIN, LUX: LUX_ORIGIN},
             expected_artifacts={CANONICAL: pins(), LUX: pins(LUX)},
             client=client,
@@ -279,7 +297,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
 
         client = httpx.AsyncClient(transport=httpx.MockTransport(with_control(handler)))
         self.addAsyncCleanup(client.aclose)
-        gateway = DrunGateway(
+        gateway = DirectGateway(
             {CANONICAL: bridge_origin},
             expected_artifacts={CANONICAL: pins()},
             client=client,
@@ -313,7 +331,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
 
         gateway = await self.gateway(handler)
         for expected in ("confidence", "model", "timing"):
-            with self.assertRaises(DrunGatewayError) as raised:
+            with self.assertRaises(DirectGatewayError) as raised:
                 await gateway.evaluate(single_payload(), batch=False)
             self.assertEqual(raised.exception.code, 502)
             self.assertNotIn(ORIGIN, raised.exception.message)
@@ -328,7 +346,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
             )
 
         gateway = await self.gateway(handler, max_response_bytes=128)
-        with self.assertRaises(DrunGatewayError) as raised:
+        with self.assertRaises(DirectGatewayError) as raised:
             await gateway.evaluate(single_payload(), batch=False)
         self.assertEqual(raised.exception.code, 502)
         self.assertIn("oversized", raised.exception.message)
@@ -342,7 +360,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
             )
 
         gateway = await self.gateway(handler)
-        with self.assertRaises(DrunGatewayError) as raised:
+        with self.assertRaises(DirectGatewayError) as raised:
             await gateway.evaluate(single_payload(), batch=False)
         error = raised.exception
         self.assertEqual(error.code, 429)
@@ -359,7 +377,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
             )
 
         gateway = await self.gateway(handler)
-        with self.assertRaises(DrunGatewayError) as raised:
+        with self.assertRaises(DirectGatewayError) as raised:
             await gateway.evaluate(single_payload(), batch=False)
         self.assertEqual(raised.exception.code, 529)
         self.assertEqual(raised.exception.retry_after, "1")
@@ -371,7 +389,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
             return httpx.Response(200, json=single_response())
 
         gateway = await self.gateway(handler, timeout_seconds=0.1)
-        with self.assertRaises(DrunGatewayError) as raised:
+        with self.assertRaises(DirectGatewayError) as raised:
             await gateway.evaluate(single_payload(), batch=False)
         self.assertEqual(raised.exception.code, 504)
         self.assertNotIn(ORIGIN, raised.exception.message)
@@ -417,7 +435,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
                         )
 
                     gateway = await self.gateway(handler, control_handler=True)
-                    with self.assertRaises(DrunGatewayError) as raised:
+                    with self.assertRaises(DirectGatewayError) as raised:
                         await getattr(gateway, method_name)(single_payload(), batch=False)
                     self.assertEqual(raised.exception.code, 503)
                     self.assertEqual(calls, ["/v1/systemone"])
@@ -461,7 +479,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
                     control_handler=True,
                     expected_artifacts={CANONICAL: {**pins(), "content_sha256": CONTENT}},
                 )
-                with self.assertRaises(DrunGatewayError) as raised:
+                with self.assertRaises(DirectGatewayError) as raised:
                     await getattr(gateway, method_name)(single_payload(), batch=False)
                 self.assertEqual(raised.exception.code, 503)
                 self.assertEqual(calls, ["/v1/systemone"])
@@ -541,7 +559,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
 
     def test_direct_mode_requires_pinned_revision(self):
         with self.assertRaisesRegex(ValueError, "revision"):
-            DrunGateway(
+            DirectGateway(
                 {CANONICAL: ORIGIN},
                 expected_artifacts={CANONICAL: {"manifest_sha256": DEFAULT_MANIFEST}},
             )
@@ -556,16 +574,16 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
         )
         for endpoint in invalid:
             with self.subTest(endpoint=endpoint), self.assertRaises(ValueError):
-                DrunGateway(
+                DirectGateway(
                     {CANONICAL: endpoint},
                     expected_artifacts={CANONICAL: pins()},
                 )
 
     def test_endpoint_configuration_must_exactly_cover_registry(self):
         with self.assertRaises(ValueError):
-            DrunGateway({}, expected_artifacts={CANONICAL: pins()})
+            DirectGateway({}, expected_artifacts={CANONICAL: pins()})
         with self.assertRaises(ValueError):
-            DrunGateway(
+            DirectGateway(
                 {
                     CANONICAL: ORIGIN,
                     "llm-semantic-router/Decision-1.0-Lux-9B": (
@@ -575,7 +593,7 @@ class DrunTransportTests(unittest.IsolatedAsyncioTestCase):
                 expected_artifacts={CANONICAL: pins()},
             )
         with self.assertRaises(ValueError):
-            DrunGateway(
+            DirectGateway(
                 {CANONICAL: ORIGIN, LUX: ORIGIN},
                 expected_artifacts={CANONICAL: pins(), LUX: pins(LUX)},
             )
@@ -644,12 +662,12 @@ class SlowCloudAdapter:
         await asyncio.sleep(60)
 
 
-class DrunAppTests(unittest.TestCase):
+class DirectAppTests(unittest.TestCase):
     def setUp(self):
         self.direct = FakeDirectGateway()
         app = create_app(
-            mode="drun",
-            drun_gateway=self.direct,
+            mode="direct",
+            direct_gateway=self.direct,
             tetris_manager=FakeTetrisManager(),
             registry=[
                 {
@@ -713,11 +731,6 @@ class DrunAppTests(unittest.TestCase):
             self.direct.calls[-1],
             ("evaluate", batch_payload(), True),
         )
-        self.assertEqual(
-            self.client.post("/v1/systemone/batch", json=batch_payload()).status_code,
-            405,
-        )
-
     def test_status_is_compatible_and_never_contains_private_topology(self):
         response = self.client.get("/api/status", params={"model": MODEL})
         self.assertEqual(response.status_code, 200)
@@ -728,7 +741,7 @@ class DrunAppTests(unittest.TestCase):
         self.assertEqual(body["loaded_revision"], REVISION)
         self.assertEqual(body["loaded_manifest_sha256"], DEFAULT_MANIFEST)
         self.assertEqual(body["loaded_content_sha256"], CONTENT)
-        self.assertEqual(body["backend"], "drun")
+        self.assertEqual(body["backend"], "direct")
         self.assertTrue(body["loaded"])
         self.assertTrue(body["context_batch"])
         serialized = json.dumps(body)
@@ -779,7 +792,7 @@ class DrunAppTests(unittest.TestCase):
                 "revision": LUX_REVISION,
             },
         ]
-        app = create_app(mode="drun", drun_gateway=direct, registry=registry)
+        app = create_app(mode="direct", direct_gateway=direct, registry=registry)
         race = {"left": "kai", "right": "lux", "mode": "steps", "max_steps": 1}
         with TestClient(app) as client:
             self.assertEqual(client.get("/api/ready").status_code, 503)
@@ -812,8 +825,8 @@ class DrunAppTests(unittest.TestCase):
         direct = SixModelDirectGateway()
         direct.probe = disconnected
         app = create_app(
-            mode="drun",
-            drun_gateway=direct,
+            mode="direct",
+            direct_gateway=direct,
             tetris_adapter=SlowCloudAdapter(),
             registry=[
                 {
@@ -856,7 +869,7 @@ class DrunAppTests(unittest.TestCase):
         self.assertIsNone(limits["gpu_microbatch"])
         self.assertEqual(limits["synchronous_wait_seconds"], 17.0)
 
-    def test_tetris_uses_private_drun_route_even_when_legacy_local_url_is_set(self):
+    def test_tetris_uses_private_direct_route_even_when_legacy_local_url_is_set(self):
         with patch.dict(
             os.environ,
             {
@@ -865,8 +878,8 @@ class DrunAppTests(unittest.TestCase):
             },
         ):
             app = create_app(
-                mode="drun",
-                drun_gateway=FakeDirectGateway(),
+                mode="direct",
+                direct_gateway=FakeDirectGateway(),
                 registry=[
                     {
                         "id": MODEL,

tests/test_public_api_contract.py

@@ -99,8 +99,6 @@ class PublicAPIContractTests(unittest.TestCase):
         self.assertEqual(self.client.post("/v1/systemone/batches", json=duplicate).status_code, 422)
         self.assertEqual(self.client.post("/v1/systemone/batches", json=dict(payload, state="extra")).status_code, 422)
         self.assertEqual(self.client.post("/v1/systemone/batches", json=dict(payload, model=MODEL)).status_code, 422)
-        self.assertEqual(self.client.post("/v1/decision/batches", json=payload).status_code, 405)
-        self.assertEqual(self.client.post("/v1/systemone/batch", json=payload).status_code, 405)
 
 
 if __name__ == "__main__":

tetris_arena.py

@@ -23,7 +23,7 @@ from dataclasses import dataclass, field
 from typing import Any
 from urllib.parse import urlsplit
 
-from drun_gateway import DrunGatewayError
+from direct_gateway import DirectGatewayError
 from model_registry import MODEL_ORDER, PROFILES
 
 BOARD_WIDTH = 10
@@ -469,7 +469,7 @@ class HTTPDecisionAdapter:
     ) -> HTTPDecisionAdapter:
         env = os.environ if env is None else env
         if direct_gateway is not None and local_endpoints is None:
-            raise ValueError("Direct Tetris routing requires the owned drun endpoint map")
+            raise ValueError("Direct Tetris routing requires the configured private Decision endpoint map")
         shared_local_key = _first_environment(env, "TETRIS_LOCAL_API_KEY")
         endpoints: dict[str, Endpoint] = {}
         if local_endpoints is not None:
@@ -481,7 +481,7 @@ class HTTPDecisionAdapter:
                 raw_url = local_endpoints.get(competitor.request_model)
                 if raw_url:
                     endpoints[competitor.id] = Endpoint(
-                        _valid_url(raw_url, "Private drun endpoint"),
+                        _valid_url(raw_url, "Private Decision endpoint"),
                         "",
                         competitor.request_model,
                     )
@@ -598,7 +598,7 @@ class HTTPDecisionAdapter:
         if self._direct_gateway is not None and competitor.family == "decision":
             try:
                 document = await self._direct_gateway.evaluate(upstream_payload, batch=False)
-            except DrunGatewayError as exc:
+            except DirectGatewayError as exc:
                 raise ArenaUpstreamError(
                     "The selected model could not complete this turn."
                 ) from exc