# Design Journal Internal engineering history for FUTURE-TS. The papers, CHANGELOG, and README describe the benchmark that shipped. This file captures the internal decision path that got it there, so future contributors can understand why specific pieces exist without having to reconstruct the history from git. ## Naming The repository shipped publicly as FUTURE-TS `v0.1.0`. Internally the work happened in three overlapping waves, labeled `v1`, `v2`, and `v3` in commits and scratch notes. - **internal v1** — the original scaffold. Schemas, tier-aware validation, capability vector, scoring pipeline. - **internal v2** — integrity and scoring repair. Closed the scoring loophole, added paired point/probabilistic metrics, added the pretraining data manifest (honest-but-optional), added the rank-based aggregate with bootstrap CI, separated capR from capA, deprecated capD because no task actually carried a utility-kind metric, renamed the headline scalar to `tier_weighted_score`. - **internal v3** — public-preview readiness. Promoted the pretraining manifest to a validator-enforced requirement on a new strict benchmark bundle, restored capD with an actual newsvendor task, added the sealed runner MVP, added the multi-budget runner, added the TSFM.ai catalog manifests, and added the external submission onramp. The public `0.1.0` preview consolidates those internal waves. The benchmark bundle that had been called `benchmarks/v1-strict/` was renamed to `benchmarks/v1/`. The permissive original 24-task surface stayed at `benchmarks/v0/` for regression fixtures. ## Why capD was deprecated and then restored The scaffold defined capD as the mean skill on tasks whose primary metric had kind `utility`, but no task in the v0 or v2 empirical suites actually carried such a metric — so capD was null in every real report. Internal v2 removed capD on the principle that a dimension that is always null is weaker evidence than one that is absent. Internal v3 restored capD once we had a concrete utility-kind task: `public_dev_inventory_holding_cost`, a newsvendor framing with an explicit asymmetric cost function (`h=0.5` per over-forecast unit, `p=2.0` per under-forecast unit). A symmetric MAE minimiser loses to a slight over-forecaster by design, so capD has genuine discriminatory power rather than being a label wrapping the same signal as capF. ## Why `overall_score` survives as an alias We renamed the headline scalar to `tier_weighted_score` in internal v2. We kept `overall_score` in the report format as an identical-value alias because external consumers of the report format already referenced the old key. The names are intentionally equal; do not rename either one alone. ## Why the sealed runner is an MVP rather than a service The local runner enforces the integrity contract that matters for cross-model capE comparability and for the `execution_mode="sealed"` property: CPU / wallclock / memory caps, Linux network-namespace isolation, platform-signed timestamps, and integrity-hash rebuild against the predictions the subprocess produced. Kubernetes job isolation with GPU quotas, cryptographic attestation of container digests, per-prediction platform-measured latency, and artifact-bucket immutability are follow-ups for a hosted multi-tenant service. The MVP intentionally does not implement them because the benchmark package should run reproducibly on any workstation; the hosted service is a separate program that consumes this package. ## Why the multi-budget runner is a wrapper rather than a rewrite The single-budget TSFM.ai runner is ~1700 lines. Refactoring it to support multi-budget execution natively would have been risky and invasive. The wrapper in `future_ts.multi_budget` monkey-patches `_forecast_parameters` per budget, calls the existing runner once per budget with a budget-specific `context_length`, and merges the per-budget submissions with recomputed integrity hashes. Budgets that require actual weight updates (`peft`, `ft`) are skipped with a warning because the hosted inference API cannot provide them; they become operable once the sealed runner accepts model-author-side training at submission time. ## Why the strict benchmark is separate from the v0 benchmark The v0 benchmark surface predates the pretraining-manifest system and is used by regression tests, scaffolding fixtures, and older tutorial content. Forcing the manifest requirement onto v0 would break historical submissions and documentation examples that are useful exactly because they are permissive. `benchmarks/v1/` is the strict public-preview surface that submissions should target. It sets `require_pretraining_manifest=true` so missing manifests are a structural rejection rather than a silent `pretraining_overlap=None`. ## Sealed runner relative-path bugfix An early iteration of the sealed runner passed the submission script into the subprocess as a path relative to `working_dir`. CI caught that when a caller passed a repo-relative script path and a working directory that was not a descendent of the repo, the subprocess `cwd=workspace` made the relative path resolve against the workspace instead of against the repo — so the script could not be found. The fix: resolve both `submission_script` and `working_dir` to absolute paths before `subprocess.Popen`. There is a regression test (`test_relative_script_path_is_resolved_before_exec`). ## Task paths in the v1 bundle `benchmarks/v1/benchmark.json` references task cards at `../v0/tasks/*.json`. The tasks themselves are shared across `benchmarks/v0` and `benchmarks/v1`; only the bundle configuration (strictness, task list, tier weights, track list) changes. This keeps the single source of truth for task cards in `benchmarks/v0/tasks/` regardless of how many benchmark bundles reference them.