Blame for common/source/starBenchserver/benchmarks/simBenchmarks/SERVER_PROTOCOL.md

# SIM server interface

The simulator is a separately launched service. Models do not import it or own
its lifecycle. This protocol standardizes communication, not robot capabilities:
each benchmark still declares its own sensors, physical actions, reset schedule
and native scorer in `EVALUATION_PROTOCOL.md`.

```text
AgentPolicies/<profile>/                              benchmarks/simBenchmarks/<name>/
model <- allowed observation <- trusted driver -- HTTP --> server.py -> native SIM
      -> action decision      -> SIM client   <- declared sensors + private outcome
                    |                                  |
                    +---- records / source / media ----+
                                benchkit tools
```

## Ownership and access

- `<benchmark>/server.py` selects the native factory and benchmark-specific
  runtime capture/exclusions. Its adapter bridges the public contract to native
  execution. All implemented benchmarks group service adapters in
  `bench_server/`, with task definitions and public receipt schemas in `bench_server/protocol/`.
  `environment/` contains native workers, assets and installation tools. The
  [RoboDojo directory guide](RoboDojo/README.md#directory-responsibilities) maps
  these packages without changing the common wire protocol.
  Implemented services no longer provide top-level adapter bridges;
  their current callers import `bench_server.adapter` directly. Benchmark-owned
  task selection lives in `bench_server/protocol/plan.py`, not an extra
  `evaluation/` package. These path changes do not alter native control semantics.
- `benchkit/sim_server/` supplies transport, strict serialization,
  session lifecycle and artifact transfer. `AgentPolicies/policy_support/runner.py`
  supplies an optional reusable agent-side loop. `benchkit` supplies record,
  source-capture and reporting tools, not a separate required control service.
- `AgentPolicies/<profile>/` contains the model policy/configuration and its results.
  A profile can represent a complete multi-model agent method. The wire protocol
  is the integration boundary; Python `Policy` and the reference runner are
  optional conveniences. Internal planning/tool calls do not grant additional
  environment channels. Declare the method and report available inference usage
  separately from decision and native-control counts.
  Policy code receives `EpisodeContext`, allowed `Observation` and execution
  counters. It does **not** receive the server client, endpoint, credential,
  task reset state, reward, metrics or management interface.

An explicitly reviewed model-owned **trusted driver** may retain the
administrative client for episode claims and results, but it must not pass that
client to the model actor. This client is not an episode-scoped, actor-safe
capability. `benchkit.sim_server` is the shared implementation, not a compatibility
bridge. Benchmark entrypoints import it directly; no second transport package
is retained under `benchmarks/simBenchmarks/service`.

The service has no grasp, navigation, task-solving or hybrid-policy RPC. One
`step` applies one native action vector, including only protocol-fixed native
control/units/interpolation. No simulator tick or model request is generated
while idle. A native runtime may own background rendering/resources; this
service does not create an autonomous physics stepping loop.

Action chunk length, repeated controls within a decision and replan timing are
policy-method choices, implemented by the trusted agent driver. The wire `step`
accepts one action, not a chunk or a repeat count. A driver may issue multiple
successive `step` requests from one decision; the shared service neither tracks
that decision boundary nor rejects a sixth control because a method example
used a five-control prefix. Action validity, exact sequencing, native execution
and termination, and the declared total execution budget still apply. A repeated
target is a new control at the next sequence, not a retry after an uncertain ACK.
The number of native physics substeps, control timing and protocol-fixed
interpolation inside one action are not policy-owned repeat settings.

Existing tracks are not all decoupled: legacy `budget_mode=decisions` contracts
still couple `max_policy_calls` and `replan_interval` to an execution cap, with
adapter/client agreement checks. The `required_replan_interval` observation
contracts described below also remain enforced. These are retained constraints
pending explicit migration, not a universal server-owned decision loop. This
clarification does not change those tracks, native budgets or policy presets.

Process separation makes deployment ownership explicit; it is not an OS security
sandbox. Run an untrusted policy separately without evaluator credentials or
filesystem/process access. Merely putting a policy in another Python directory
does not enforce that restriction.

Robot state is not automatically privileged: measured joints, end-effector
poses or other proprioception may be declared by the benchmark's public sensor
contract. Undeclared object truth, private scoring predicates and hypothetical
simulator rollouts remain outside the policy interface. The selected service
workflow enforces this division through an evaluator-held client; legacy
in-process adapter factories remain available for explicitly selected local
workflows and tests, not as a second capability granted to the remote policy.

## Launch and connect

Select an implemented service through the shared entrypoint:

```sh
rsi-bench list
rsi-bench serve --benchmark simpler_env --help
```

Source-checkout equivalent: `python -B -m benchkit.sim_server.cli`. The explicit
registry delegates to the selected benchmark's `server.main(argv)`; it does not
replace its factory, schedule constraints or source/asset capture. Generic help
and listing import no benchmark modules. Selecting a service for help loads its
import-safe wrapper, but does not create a service or reset an environment.
The list describes development entrypoints, not installation or validation status.

Install the selected native environment first. Use a launcher Python satisfying
the benchmark's adapter dependencies; benchmarks with a private native worker
select that worker's interpreter in their deployment configuration. Launching
fixes the adapter parameters and episode schedule, but does
not call `reset`. Source capture and native package/assets readiness are separate.
Generate a strong URL-safe bearer token outside the repository and provide the
same `RSI_SIM_SERVER_TOKEN` environment value only to server and evaluator.
Do not put it in JSON parameters, prompts, command-line token arguments or Git.

Example (replace paths with your configuration and a **new** result directory):

```sh
rsi-bench serve --benchmark simpler_env \
  --parameters /absolute/benchmark-parameters.json \
  --seed 20260907 --episodes 1 --port 8765 \
  --output-dir /absolute/AgentPolicies/my_profile/results/simpler_env/raw/my-run/server
```

The selector includes all 13 implemented service routes; `rsi-bench list` shows
canonical IDs and repository-relative setup guides. Only the explicit alias
`robocasa_365` maps to `robocasa365`. Per-benchmark module entrypoints, such as
`python -B -m benchmarks.simBenchmarks.SimplerEnv.server`, remain valid. Neither
route changes the existing benchmark contract or implies native parity.

Schedule selection is benchmark-owned. RoboDojo requires a complete named
`panel` from [its protocol catalog](RoboDojo/bench_server/protocol/task_catalog.json) and rejects
server-side `--episodes` truncation: `classify_objects` has five layouts in
`fast` and 50 in `full`, each attempted once. See its
[launch example](RoboDojo/README.md#start-the-benchmark-server).

The server binds **only `127.0.0.1`**. For another node use an authenticated SSH
local forward, for example `ssh -N -L 8765:127.0.0.1:8765 YOUR_EVAL_NODE`.
HTTP is not a public-network API; no unauthenticated LAN/WAN bind is supported.
The client uses a direct connection without environment proxies or redirects.

Run the evaluator in its own Python environment (RGB transport needs NumPy):

The model-owned `AgentPolicies.gpt6_astra.run` driver defaults to generic
[`codex-direct/v3`](../../AgentPolicies/gpt6_astra/docs/DIRECT_CONTROL.md), consuming
the selected service's numeric action contract rather than assuming EEF16.
[`codex-native/v1`](../../AgentPolicies/gpt6_astra/docs/NATIVE_CONTROL.md) and
`codex-planned/v1` are separately selected methods; compatibility does not prove
native validation or equal capability. RoboDojo's Direct v2 **server interface**
is a different versioned contract from the model method. Neither name changes
the shared `starvla-rsi.sim-server/v1` wire protocol. The following mailbox command
is an optional registered-profile workflow, not a required loop for participants.

```sh
python -B -m benchkit run --benchmark simpler_env \
  --sim-server http://127.0.0.1:8765 \
  --model-profile anonymous_code_agent --policy-args '{"directory":"/absolute/opaque-mailbox"}' \
  --seed 20260907 --episodes 1 \
  --budget-mode decisions --max-policy-calls 200 --replan-interval 5 --max-steps 1000 \
  --output-dir AgentPolicies/anonymous_code_agent/results/simpler_env/raw/my-run/evaluator
```

The benchmark parameter file must declare the matching decision budgets and
selected task. Configure the model/mailbox using its own profile guide; the SIM
server does not configure or call model APIs. `--benchmark` must match the
server's `descriptor.name`, not a registry alias. Remote runs reject
`--benchmark-args`: only the server controls native construction.

`python -B -m benchkit.sim_server` launches only the synthetic smoke world with
the same flags. It needs no simulator and is not capability evaluation.

## Evaluator RPC, version 1

All requests are bounded JSON `POST /rpc`, authenticated with `Bearer`. The
envelope contains `protocol="starvla-rsi.sim-server/v1"`, a random `request_id`,
`server_id`, `op` and `params`. The initial `describe` uses null `server_id`;
all later calls bind that returned service identity. Responses echo protocol and
request identity and contain either `result` or a closed error code.

| Operation | Meaning |
| --- | --- |
| `describe` | Read immutable descriptors, budgets, deployment-source identities and selected episodes; no native control. |
| `open` | Permanently claim one predeclared episode ID; no caller-supplied reset metadata or native configuration. |
| `reset` | The one permitted initialization, with sequence 0. |
| `step` | Execute one server-validated native action, with exact next sequence 1, 2, …; return one transition. |
| `metrics` | Read adapter-owned cached native outcome; evaluator-only. |
| `finish` | Finalize artifacts once, close once, then inventory the closed files. Repeated finish reads the cached result, never repeats native cleanup. |
| `read_artifact` | Read at most 1 MiB from an inventoried relative path after finish; no arbitrary file access. |

Only one native episode is active per server. Different concurrent episodes need
separate service instances/output directories and explicit resource assignment.
Successful `open` is not successful reset. Claims precede native session creation;
failed openings are retained and cannot be reclaimed. Existing service directories
cannot be restarted or overwritten. Reconciliation/resumption of interrupted
servers is not implemented; a new directory is not permission to repeat a task.

Reset/step consume sequence numbers before native execution. Duplicate/stale or
out-of-order commands never execute another control. Any native/transport error
poisons further client controls. **No automatic action/reset retry** occurs,
even when a timeout leaves execution uncertain. Returned valid controls and
unknown in-flight native execution must not be conflated. The client timeout
does not kill or roll back a running native operation; retain server evidence and
use the deployment supervisor for a stuck process. Cleanup is still attempted
once. A failed native close blocks further sessions on that service.

### Pre-execution action rejection extension

New descriptions advertise `action_rejection: starvla-rsi.action-rejection/v1`.
Generic action checks and an optional benchmark-owned pure `validate_action_input`
hook run before consuming a sequence. The hook can check submitted values and
public contract constants only, not native state or task feasibility.

A rejected input returns `error.code=invalid_action`, a closed `rejection` issue
(code, declared field, optional finite actual/limit/component index),
`executed=false` and unchanged `next_sequence`. No control, sensor or scoring
call occurs. The session stays running. Only a negotiated, correlated receipt
permits a corrected command at the same sequence; old code-only errors and lost
replies remain fail-closed. Older strict clients may reject the new description;
use a matching frozen client/service pair.

An agent driver can select `invalid_action_handling=feedback` and return the
issue at the next counted policy call with the last acknowledged observation.
The current reference loop requires a finite decision-call safety budget for
this mode; it grants no extra sensors or task reset. Internal inference/tool
loops belong to the declared method, not a universal one-request rule.
ACKed valid prefixes retain their real counts.
`benchkit/validation.py` holds the shared data format, not the control loop.

## Observations, records and limits

The JSON codec rejects duplicate keys, non-finite numbers and messages exceeding
16 MiB. RGB is copied as lossless inline base64 `uint8 H×W×3` bytes with explicit
shape. No pickle, filesystem image references, arbitrary RPC method lookup or
code execution is accepted. Camera/state channels must match `ObservationSpec`.
Adapters remain responsible for the content allowlist: a transport cannot prove
that arbitrary metadata was derived only from permitted sensors. Transition
reward/info belongs to the evaluator, never the policy observation.

An optional `ObservationSpec.control_feedback_schema` declares a separately
versioned public robot-control receipt. Its `Observation.control_feedback` is
null at reset and a bounded JSON object after each acknowledged control, with
`schema` matching that declaration and `control_target` matching the observation
step. Without the declaration both wire keys remain absent; unsolicited,
missing, stale or reset receipts are rejected. Older strict clients reject the
new spec rather than silently dropping this sensor channel. The benchmark must
project a closed allowlist from actual execution, not forward its private logs,
metrics or arbitrary diagnostics. Payload semantics remain benchmark-owned.

The agent-side runner groups every acknowledged control in the executed prefix
as `control_acks` in normal execution or rejection feedback. Each entry binds
`environment_step`, `observation_step` and the public `payload`; a zero-execution
rejection carries an empty list, not the preceding decision's receipts. No
extra observation, model call, simulation tick or action replay is generated.
Uncertain execution still terminates; no acknowledgement is invented. The run
manifest binds `control_acknowledgement_version` and `control_feedback_schema`.
RoboDojo's [robot feedback](RoboDojo/ROBOT_FEEDBACK.md)
is mandatory in its current fixed Direct v2 service; the shared transport supports
other benchmarks without that channel. Model notes, preview images and target selection
remain under `AgentPolicies/<profile>/`; native RGB and evaluator-private records are
not replaced by model-side previews.

A benchmark may declare a positive integer `required_replan_interval` in its
description's budget object. This is an observation-interface requirement:
the evaluator must configure that action-prefix length before opening an
episode. For example, a changing-language interface can require prefix 1 so an
old action chunk never crosses an unseen instruction boundary. The runner
rejects a mismatch before policy calls or native initialization and records the
requirement in its manifest. It does not silently change the prefix, impose a
model-call count, extend the native horizon or implement a persistence strategy.
Benchmarks without this optional field retain their existing behavior. Use a
matching updated client; older strict clients reject the new field rather than
silently ignore the requirement.

The evaluator manifest records server deployment provenance separately from its
own local source snapshot. New service launches capture an explicit shared-service
source scope plus only the selected benchmark's declared runtime supplements;
they do not require reference-model drivers or other benchmarks' source files.
The reference agent runner and retained campaign path still use the broader
evaluation capture. Existing frozen inventories are not rewritten or reinterpreted.
Neither source inventory proves loaded-memory,
asset/dependency parity or provider identity. Old frozen campaigns remain on
their original path: **server-mode `campaign prepare/run-case` is not integrated**.
Use the standalone remote runner with a predeclared service schedule; do not
describe it as an audited native-full campaign.

Run services from a stable, versioned source snapshot and do not edit it during
operation. V1 records launch-time source bytes but does not recheck later worker
file reads; operators must verify snapshot integrity before and after a run.

`finish` preserves close-time receipts before transfer. For new services, videos
are the default permanent visual record on the server. After successful native
finalization/close, eligible temporary frame images are removed unless the server
was launched with `--retain-frame-images`; missing videos or cleanup errors retain
the images as fallback evidence. `server_media_retention.json` records retained
policy, omissions and fallback reasons. The final inventory describes remaining
files, not paths already deleted. Historical inventories are never rewritten.

Remaining regular files beneath the episode directory are inventoried. New clients
retain media references by default; `--copy-server-media` explicitly downloads
selected media with SHA-256 verification into `sim_server_files/`. Symlinks,
unsafe paths and overwritten destinations are rejected. V1 bounds each episode
to 100,000 files / 16 GiB; exceeding a bound is an explicit infrastructure error,
not silent truncation. A benchmark launcher may declare runtime-only directories
to omit from transfer; this is benchmark-owned storage classification, not a
policy option or permission to omit outcome evidence. SIMPLE and RoboDojo exclude
only their episode-local `cache/` directories; RoboTwin uses the same rule for
native CUDA build outputs. The exclusion is recorded in the
session receipts and the captured benchmark launcher. Observations, actions, native logs, metrics, source
provenance and videos are not excluded. Canonical server videos remain retained;
artifact downloads never delete or relocate them. Changed export declarations
apply only to new launches, never to frozen historical inventories or results.

New clients can select optional **client retention** through
`RecordingOptions` before an episode starts. They still call `finish` once and
retain the private close receipt and native result/provenance records. Standard
mode disables retained client frame images and duplicate server-media downloads;
video references remain available in the receipt. The full server inventory and
omitted download paths remain recorded. A reference is not proof of downloaded
bytes. Live RGB/state transport and runtime capture remain unchanged; there is
no client RPC to delete server evidence or change native capture. Unknown
non-media artifacts are retained conservatively rather than dropped with images.
Selective copies cannot satisfy an audit requiring every original
file, but missing optional history does not prevent basic result publication.
See [recording settings](../../docs/recording.md).

The local `sim_server_receipt.json` records server identity, source references and
the closed artifact inventory without credentials. Legacy benchmark artifact
auditors assume older directory layouts; they are not yet validators of this
new server layout. Transport regression, native execution and model capability
are separate evidence claims. Fast/full sampling and model persistence rules are
unchanged by this service abstraction.