docs/sealed-runner.md

# FUTURE-TS Sealed Runner

## Status

MVP implemented in `future_ts/sealed_runner.py`; production hosted isolation is
still future work. The local runner signs manifests, enforces CPU/wall-clock
budgets, applies best-effort memory limits, and attempts Linux network
namespace isolation. On non-Linux hosts the CLI prints a prominent warning:
environment scrubbing is not structural isolation and raw sockets are not
blocked.

## Why it matters

Two capabilities in the benchmark only become credible once the runner is
enforced:

- **Efficiency (`E`).** The capability vector's E dimension comes from
  per-prediction `runtime_ms` / `memory_mb` reports against each task's
  `resource_budget`. Without a sealed runner, those numbers reflect whatever
  hardware the submitter used. They are not comparable across models and
  should not feed a capability vector that users read as cross-model.
- **Live tier integrity (`blind_archive`, `live`).** The validation layer
  already requires `platform_received_at <= earliest prediction issue_time`,
  but that only checks timestamps the submitter declared. A sealed runner
  stamps those timestamps from the platform clock and the issue-time boundary
  is enforced by the platform, not self-reported.

## Contract

A sealed runner MUST satisfy all of:

1. **Fixed hardware class.** Each task's `resource_budget` declares a
   `hardware_class` tier. The runner provisions exactly that class — same
   CPU model / GPU class / RAM / swap — for every submission evaluated
   against the task. Submissions that exceed the budget fail coverage, not
   silently run slower.

2. **No network egress.** The container has no outbound network. Tasks that
   require retrieval must provide a pinned retrieval snapshot mounted
   read-only; submissions that declare `uses_external_retrieval=true` without
   consuming a provided snapshot are rejected. The local subprocess runner only
   enforces this structurally on Linux with `CLONE_NEWNET`; macOS/Windows runs
   should use Docker/Kubernetes `--network=none` before treating a result as
   production-sealed.

3. **Timestamps signed by the platform.** `platform_issued_at` and
   `platform_received_at` are written by the runner, not the submission.
   `platform_received_at` is the wall-clock time the runner accepted the
   submission artifact. `platform_issued_at` is the wall-clock time the
   runner handed the task to the submission's forward function.

4. **Deterministic seeding.** The runner injects a fixed random seed derived
   from `source_snapshot_id`. Non-deterministic submissions (e.g. models that
   sample without respecting the seed) are rerun N times and the mean is
   reported with its own standard deviation.

5. **Tamper-evident prediction log.** Each prediction is appended to a log
   the runner signs before writing. The signed log is what
   `prediction_hash` is computed against. Submissions cannot retroactively
   edit predictions.

6. **Resource-budget enforcement.** Per-prediction `runtime_ms` is the
   platform-measured wall-clock for the forward call, not a submitter
   report. Exceeding `task.resource_budget.latency_ms` on more than X% of
   predictions fails the task (not just penalised via efficiency_score),
   where X is task-declared.

7. **Archive-by-default.** The runner uploads the predictions,
   run_manifest, and a bit-exact container digest to an artifact bucket.
   Any score can then be recomputed against the archived predictions
   (see `future_ts recompute-metric`) without re-running the model.

## Submission surface changes

No new submission fields are required. The existing `execution_mode`
enum already separates `sealed` from `self_attested`. What changes is the
validator's interpretation:

- `self_attested`: accepted for `public_dev` tier. Submitter-declared
  timestamps. Submitter-reported runtime_ms/memory_mb may be used for E but
  must carry a `self_attested` provenance flag on any leaderboard surface.
- `sealed`: required for `blind_archive` and `live` tiers. Platform-signed
  timestamps and platform-measured resource usage. Leaderboard surfaces for
  E comparing across models SHOULD filter to `sealed` rows only.

The validation layer enforces `sealed` for the non-dev tiers today via
`requires_sealed` in `validation.validate_submission`. That check gates the
file format. What it does NOT enforce is that the numbers inside a
`sealed` submission actually came from a sealed runner. Implementing that
is the work this document frames.

## Operational levels

The repository uses two file-format values (`self_attested`, `sealed`) but
reviewers should distinguish four operational levels:

| Level | Meaning |
| --- | --- |
| `self_attested` | Submitter ran the model and supplied timestamps/runtime. Useful for public development only. |
| `local_sealed_mvp` | The current subprocess runner: hashes, platform timestamps, CPU/wall-clock limits, best-effort memory, Linux network namespace when available. |
| `hosted_sealed` | Evaluator-run container or job with fixed hardware, no egress, immutable artifacts, and platform-measured telemetry. |
| `hosted_attested_live` | Hosted sealed execution plus pre-registered live waves and labels that did not exist at submission time. |

Only the last two levels should be used for public claims about comparable E
scores or externally attested live integrity.

## Implementation sketch

Stage 1 (current MVP): a local subprocess runner that takes a Python entry
point, mounts task windows in a scratch workspace, writes predictions to a
signed output file, and produces the `run_manifest` from platform state.
Linux attempts `CLONE_NEWNET`; other platforms warn that the network seal is
not structurally enforced.

Stage 1b: optional Docker local backend. This should run the same contract in
a `--network=none` container and use container or cgroup memory limits instead
of Python `resource` limits. This is the recommended local path for macOS and
Windows users who need enforceable isolation.

Stage 2: Kubernetes job per submission, with resource quotas enforced by
the cluster (not just the container). Required for production
`blind_archive` / `live` runs because local Docker cannot guarantee GPU
isolation across tenants.

## Memory limits in the MVP

The MVP uses `resource.setrlimit` for CPU and memory. It prefers `RLIMIT_DATA`
for memory and falls back to `RLIMIT_AS` only when `RLIMIT_DATA` is not
available. `RLIMIT_AS` caps virtual address space and can fail Python ML
runtimes during interpreter startup or shared-library loading even when RSS is
small. Production runs should rely on cgroups/Docker/Kubernetes memory limits
instead.

Stage 3: a public submission endpoint. Accepts a container image URL +
`artifact_uri`, provisions a runner, runs the evaluation, produces a
signed `BenchmarkReport`, uploads predictions to the archive bucket,
returns the report to the submitter. Until this stage lands, submissions
are produced by the evaluator (TSFM.ai) running models on behalf of authors
— which is how the `reports/tsfm_ai_empirical_v2_multi_budget` run was produced.

## Open questions

- Should submitters be permitted to provide fine-tuning datasets inside
  the sealed container, or must PEFT/FT adaptation happen at submission
  time using a provided train split? (Currently ambiguous; the
  `adaptation_budgets` contract says the budget is part of the submission
  but does not pin where data came from.)
- What minimum hardware class does `public_dev` require to produce
  comparable E numbers? Current submissions run on whatever the author
  has. The sealed-runner work should pin this explicitly.
- How does the runner expose task-level actuals to the submission without
  leaking labels to models that might memorize them? One option: the
  runner hands the submission only historical context and an issue_time,
  never the future label; labels are matched post-hoc by the scorer.