# Strata v0.1.43 experiment reproduction

This is an experiment recipe, not permission to change another Proxmox host.
Use an already authorized GPU-enabled Linux execution environment and verify
its available disk space before downloading. The experiment's private access
configuration is deliberately excluded. Existing models, volumes and results
must be preserved. Commands below refer to files in this experiment.

## Exact source and image

- Strata commit: `7695859aa13afb248bdb4d36f9b2e95707db079d`.
- v0.1.43 annotated tag object: `16374b3e6dfe452a163c3a961ae5faa3b4aec84b`.
- llama.cpp: `3cf03257f219afbe7334045ff7c6a06ac68c627d`.
- Engine SHA256: `ffae66a01126cbf32723380d249f49dff5387a35292c52818fb7e2ea6734837f`.
- Production image: `sonnyslabs/strata:0.1.43-sm120-v2`.
- Image ID: `sha256:f759e6167315dac77292d394a470240493dad78de6d23dd270eaa5c7ffc3e143`.
- Builder/prepare image: `sonnyslabs/strata:0.1.43-sm120-prepare-v1`.
- Builder ID: `sha256:50b372a9c3d9aef5278d3186fdc0af086481d9f36b7312c5511f7657d922271a`.

The retained Docker archives are under `/opt/strata-experiment/security/` on the
experiment filesystem. Loading the verified retained archive is more exact than
rebuilding against live OS repositories. They are intentionally not embedded in
the public report or upstream submission. Verify the archive checksum receipt
before `docker load -i runtime-image-v2.tar`, and then verify its image ID.

For a new build, clone the official repository into `upstream/`, check out the
exact source commit and verify both the tag object and resolved commit:

```bash
git clone https://github.com/Niko1221/Strata upstream
git -C upstream checkout --detach 7695859aa13afb248bdb4d36f9b2e95707db079d
git -C upstream rev-parse v0.1.43
git -C upstream rev-parse 'v0.1.43^{commit}'
```

Use `docker/Dockerfile` and `docker/build_engine.py`. The Dockerfile starts from
the official two-stage design, builds only architecture 120, disables vision,
captures llama.cpp source/wheel hashes, installs Python packages from the
downloaded wheelhouse, and removes build packages from the runtime. The engine
and upstream Python/benchmark source are unchanged.

```bash
DOCKER_BUILDKIT=0 docker build --target builder -f docker/Dockerfile \
  --build-arg BUILD_BASE=nvidia/cuda@sha256:435220c0fef35cbf712e11999f8670a83835ef3cdd18564e5e8122f83078c88c \
  --build-arg RUNTIME_BASE=nvidia/cuda@sha256:4757e6477d94d56fd8230e15b7d59956750c983a47a42584f44dbe143090da82 \
  -t sonnyslabs/strata:0.1.43-sm120-prepare-v1 .
DOCKER_BUILDKIT=0 docker build -f docker/Dockerfile \
  --build-arg BUILD_BASE=nvidia/cuda@sha256:435220c0fef35cbf712e11999f8670a83835ef3cdd18564e5e8122f83078c88c \
  --build-arg RUNTIME_BASE=nvidia/cuda@sha256:4757e6477d94d56fd8230e15b7d59956750c983a47a42584f44dbe143090da82 \
  -t sonnyslabs/strata:0.1.43-sm120-v1 .
```

The original build reused cached builder layers for the second target; do not
force unnecessary recompilation. `docker/Dockerfile.runtime-updates` derives a
separate v2 image from the exact compiled v1 image ID and updates signed OS/CUDA
packages, then checks that the engine SHA256 is unchanged. Its resolved package
inventory is retained under `docker/provenance-v2/`. Apt was not snapshot-pinned;
a later rebuild may resolve different packages and produce another image ID.
Observed wheel/archive hashes establish retained-byte integrity, not independent
trust before the first download. Preserve wheel/source archives in the builder.

## Models, preparation and storage

`reproducibility/model-lock.json` records exact GGUF names, revision, sizes and
LFS SHA256 values. Quantized repository revision:
`ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF@ed59f92082b1e93c0e96d60a8b11aab089b52f09`.
MTP uses `Qwen/Qwen3.8-Flash-Next@de4b8e4d43b917e7706784d8bb445c9af86a3540`.
All 31 staged MTP safetensors were checked strictly; the receipt is preserved.

The first shards differ by quantization. Both second shards are byte-identical
by complete SHA256 and are hardlinked only after verification. Do not infer that
unrelated packs, tokenizers or draft artifacts are compatible from filenames.
Each model has its own upstream native-expert pack and configuration. GGUF and
pack index headers are included in preparation receipts. No model download
occurs in the serving path.

The target preflight required 242,415,626,080 bytes, including packs, build
allowance and headroom, with 318,020,853,760 bytes available. Recheck your actual
target filesystem rather than relying on the Proxmox pool's free capacity.

`scripts/prepare-model.sh QUANT` runs upstream setup offline with verified
artifacts and the already compiled engine. Preserve its original configuration.
`scripts/derive-contexts.py QUANT` derives the 65,536/131,072 configurations with
32,768 resident KV tokens, changing only context/KV-streaming/log settings.
LOW_RAM is on, native experts are resident in RAM, cache/prefill are auto, int8
KV, requested VRAM reserve 1,024 MiB, MTP requested 4, minimum probability 0.5.
Auto cache resolves differently when tensor sizes differ; record actual slots.

## Serving and offline verification

`scripts/launch-inference.sh QUANT CONTEXT` uses the pinned v2 image ID, GPU
access, Docker network none, nonroot UID 65534 plus video group 44, read-only
root/data/models, zero capabilities, no-new-privileges, 48 GiB memory with no
Docker swap, ten CPUs, a 512 MiB temporary filesystem and dedicated log mount.
No Docker socket, host root, SSH keys or Proxmox management mount is supplied.
The containing unprivileged LXC has 52 GiB RAM and ten CPUs. The running host
driver is 615.71.09; the compiled CUDA toolkit is 13.0.0.

```bash
bash scripts/launch-inference.sh IQ2_XS 32768
bash scripts/start-container-telemetry.sh
bash scripts/run-offline-smoke.sh IQ2_XS
docker exec -i strata-iq2_xs-32768-v1 /opt/strata/.venv/bin/python - \
  < scripts/api-probe.py > results/iq2_xs/api-probe.json
```

The smoke client runs inside the same isolated namespace. It verifies health,
model discovery, real marker inference, loopback-only interfaces, empty routes,
blocked external TCP, UID/capability/read-only state and observed processes.
This local HTTP arrangement has no external or LAN interface; it does not use
host networking or a host port. It proves the measured inference path works
offline. Source review and the direct entry point provide separate evidence
about startup behavior; a process snapshot alone cannot prove no short-lived
process ever ran. The original false interface-check failure is retained.

## Official benchmark commands and raw output

```bash
bash scripts/run-official.sh IQ2_XS 32768 standard
# After evaluated shorter inputs and a deliberate 64K-profile model restart:
bash scripts/run-official.sh IQ2_XS 65536 optional
```

These wrappers run unmodified `./bench.sh --url http://127.0.0.1:8080 --config
/data/config/strata-QUANT-CONTEXT.json --runs 3 --out /output`, with `--long
--clients 2` for the optional run. The tool creates a dated child directory.
The benchmark client shares the server's isolated loopback namespace. Its GPU
device access is for upstream machine discovery, not another inference engine.

Repeat with IQ3_XXS after IQ2 completes. Preserve the original JSON/README
unchanged; the submission packages include a separate Sonny's Labs supplement.
Use upstream `tools/strata_bench.py --compare OLD --compare-only NEW` for saved
same-context comparisons. Review before external submission; none is authorized
by this experiment alone.

## Existing Sonny's Labs suite and scoring

`suite/` contains the byte-identical retained v2.1 clients/scorers/fixtures.
`reproducibility/suite-input-manifest.json` records their hashes. The adapter
only attaches lifecycle/transport to Strata, maps the API model name, and uses
the unchanged upstream tokenizer for the raw-text count because Strata lacks
llama.cpp's `/tokenize`. Complete prompt counts come from actual response usage.
Transport failures are explicit synthetic empty envelopes with preserved HTTP
evidence; original scorers keep them in the denominator. No prompt is rewritten.

```bash
bash scripts/run-sonny-phase.sh IQ2_XS subset
bash scripts/run-sonny-phase.sh IQ2_XS practical
bash scripts/run-sonny-phase.sh IQ2_XS dossier
bash scripts/run-sonny-phase.sh IQ2_XS humaneval
bash scripts/stop-inference.sh IQ2_XS 65536
bash scripts/score-sonny.sh IQ2_XS
```

Scoring automatically follows generation and stops the GPU engine first to
avoid CPU/memory overlap with timed inference. The unchanged existing scorer
script runs generated code in a separate restricted Docker container on the
new experiment LXC, rather than restarting the old stopped scorer LXC. Verified
generation/dataset archives are checked before scoring. This is a documented
placement adaptation; isolation flags, EvalPlus 0.3.1, dataset, original
clean_code logic, caps and scoring remain the same. The rebuilt scorer's
transitives are inventoried and not claimed identical to the historic image.

Practical: 24 tasks × three repetitions, temperature 0, seed 12345, cap 2,048.
HumanEval+: all 164 frozen problems, same sampling/cap. Dossier: three repetitions,
cap 3,072. Reasoning budget 512 for original Sonny clients; upstream official
and needle tests turn thinking off. Original v2.1 aggregate weights are retained.
Tool-format compatibility is tested separately from client workflow task scores.
Strict JSON-schema enforcement is unavailable in this runtime; no optional
dependency is installed during serving to hide that limitation.

## Long context, telemetry and recovery

Run unmodified `tools/needle_bench.py` at depths 10/50/90 with increasing tiers.
The source's character estimate can exceed a nominal context. Preserve HTTP
rejections and actual counts; a smaller 126K argument, if attempted, is a labeled
supplement and must never be renamed a successful 128K test.

One-second collectors preserve UTC and monotonic timestamps, NVIDIA SMI, procfs,
cgroup memory/CPU/I/O and host physical-disk counters. Never sum physical and
logical block-device layers or label whole-host disk traffic model-specific.
No global page-cache drop is used. Process-cold starts are not filesystem-cold.
Nonstreaming Sonny clients do not provide measured client TTFT; upstream
streaming measurements do. All derived charts retain units and source hashes.

On Windows, `python ops.py scripts/full-status.sh` reads the existing run;
`python collect_evidence.py` and `python collect_host_telemetry.py` save private
checksummed snapshots. Do not launch duplicate controllers. Check exit files,
current process/container state and original output identities before recovery.
`checkpoint.json` records observed progress, not inferred completion.

The canonical report directory is `reports/strata-v0.1.43-20261012`. Its generator
reuses original scores and assets; the old 17-entry Qwen27B generator is hardcoded
to a different experiment. No external report publication occurs automatically.
The canonical separate video-session handoff contract remains unchanged under
`videos/portable/sonnys-labs-benchmark-video/references/CODEX_SESSION_HANDOFF.md`.

## Historical report4 recalculation

The original published report4 and its saved scoring revision are preserved.
Run python recalculate_report4.py locally to verify all 15 archives, 17
configurations, 1,224 practical responses, 2,788 EvalPlus samples and 102
fixed/adaptive dossier outputs against retained raw artifacts. The original
practical/coding weights and scores remain unchanged. Empty finals receive zero
validated dossier quality regardless of reasoning content or API stop. Successful
speed requires three valid adaptive final answers; a separately labeled strict
reliability gate requires six completed answers with all 14 original literal
markers. This gate does not establish semantic correctness or create a new score.
The revised draft is comparisons/report4-recalculated/site/index.html.
No historical models were rerun and no external site was updated.