# Standalone public SDK follow-up — 2026-10-17

The selected standalone Java SDK commands already pass on both hosts at
their separately pinned source; see
[the complete execution/skip accounting](RECORD_2026-10-17_java_standalone_sdk.md).
The remaining public C++, .NET and Rust manifests are now exported from the
same devel source `1671eb9431e907888f1769c6eb7b515a0c6a305a` and queued for
their complete verification commands. These source exports have zero
closure, link and scrub findings. Export verification is explicitly deferred
to the scheduled host jobs.

| Public SDK | Exported files | Inventory SHA-256 | Selected manifest commands |
|---|---:|---|---:|
| C++ | 992 | `5d1987a04443f510cf7d532b2ae8ef60f92241b5fadb1f839821c2a921e591f0` | 7 |
| .NET | 796 | `b7f0c5a2b247a02fbb5f652e85cd96b244e4d3630f39d05a32c54d59270784b2` | 5 |
| Rust | 332 | `0ab8f4d402681bc9393ce0e1d5e3f40b889b1d4fb19d3934e1c9228b3a22ba26` | 7 |

The jobs use high-priority HP `isol` leases, serializing the three complete
outer foreground verifications while allowing shared work. Each snapshots
slot status, running processes, memory and disk after acquiring its lease.
Build products and fixtures stay below the owning session's build root;
the immutable source capsules stay in its persistent cache. The configured
compiler is GCC 14; Cargo parallelism is two. C++/native Make commands retain
the manifest's maximum eight jobs. .NET requires its native provider to load.

The C++ sequence includes all open correctness binaries, every exported tool
entry point and portable tool suite, both tuner decision/confirmation tests,
kernel tuning self-tests and the expected explicit PGO input refusal.
.NET builds the normal hftnet location, runs native and managed tests, then
both tuning selector checks. Rust runs the open crate and every exported
tool crate, warning-free library docs, optimized-build controls, the actual
packaged crate's suite and both explicit private-feature refusals.

At this checkpoint C++'s initial correctness command is compiling; .NET and
Rust remain queued. None has a completed qualification or passing SDK grade
yet. Each job saves every command result and reported skip line. Final source
inventory equality is mandatory; failed jobs retain their original receipt
and logs. Bounded read-only collectors bring back final pass/failure receipts
and log tails, with no automatic Git writes or raw benchmark download.

On HP the immutable capsules are
`~/.cache/libhft/fullbench-{cpp,dotnet,rust}-current-sdk-20261017-v1` and
the verification roots are
`~/build/codex-fullbench/libhft/{cpp,dotnet,rust}-current-sdk-standalone-20261017-v1`.
This is source/build verification. Stage 5 timings, remaining peer/anchor
admission, licensing, hosted qualification and coordinated release stay
separate gates.

## Original C++ and .NET failures and corrected execution environment

The original C++ command builds all its selected correctness binaries, then
fails in `test_fix_metrics_http` at filesystem Unix socket admission. Its
115-byte fixture path exceeds the socket pathname limit. The failed command,
receipt, original compiler outputs and all logs remain intact. The short
v2 fixture root stays within this session's build tree, and the same immutable
source inventory and completed build are reused. Every correctness test and
all seven manifest commands execute again; no test is skipped to repair it.

The original .NET run passes its native build and native-unit commands.
Its managed suite reports **4,874 passed, 12 failed and 90 skipped, total
4,976**. All twelve failures independently identify oversized Unix socket
paths in the FIX/FIXP telemetry tests. The original failed grade remains.
The v2 fixture root is `~/build/codex-fullbench/libhft/t/n2`; it reruns all
five manifest commands against the same source and standard native output
location, reusing the completed build. Test selection and assertions remain.

After the failed .NET frontend exited, its Roslyn compiler server remained
in the original supervised process group and held the CPU lease. Ownership
was checked against the original preflight process snapshot and the server's
PID/group/command before that one owned server received SIGTERM. No global
build-server shutdown was issued. The v2 run sets
`UseSharedCompilation=false`, `MSBUILDDISABLENODEREUSE=1` and
`DOTNET_CLI_USE_MSBUILD_SERVER=0`; its managed test command additionally uses
`-p:UseSharedCompilation=false -nr:false`. These options keep compilation in
the supervised foreground and do not change the tested SDK or native code.

The original Rust reservation is dequeued before input delivery, capsule
creation or execution. Its source has Unix socket ownership fixtures too;
the replacement first execution uses the identical 332-file export and
manifest commands with a short per-instance fixture root,
`~/build/codex-fullbench/libhft/t/r2`. No Rust suite has failed or passed at
this checkpoint. Its new source capsule and verification root use suffix v2.

All v2 jobs retain high priority and queue normally. The independent skip
audit now scans every case variant of skip/ignore messages in complete final
command logs; it preserves native, platform and external-corpus omissions
instead of inferring zero skips from command return codes. Original C++
multicast loopback omission and all 90 original managed omissions remain
visible. Final SDK grades still require every selected command to pass and
the original source bytes/modes to remain unchanged.

## C++ complete standalone verification passes

The v2 HP retry completes all **seven selected public C++ manifest commands**
with return code zero and an identical final 992-file source byte/mode
inventory. All correctness tests run again against the unchanged SDK and
completed compiler products. Tool entry points and portable tool suites,
both tuner selector/confirmation checks, `tune-selftest` and the expected
explicit PGO input refusal also pass. Correctness takes 360.672 seconds and
the kernel tuning self-test 166.697 seconds; these are verification durations,
not benchmark timings.

The independent case-insensitive audit preserves two explicit multicast
loopback omissions in correctness (joined socket plumbing passed, delivery
and codec-over-wire did not execute), a correctness Python suite reporting
five skips, and the portable tool suite's twelve skips among its first 147
tests. The remaining tool suites report 21, five, four, three and fifteen
tests with no skips. Passing commands do not erase these declared omissions.
Complete original logs remain on HP with independent hashes; the compact
receipt and bounded log tails are collected locally. The original v1 Unix
socket path failure remains a failed attempt.

No C++ Stage 5, release or all-feature admission is added by this SDK pass.
The .NET v2 native tests are still running; Rust and corrected QuickFIX/J
qualification remain queued at high priority on HP.

## .NET complete standalone verification passes

The v2 HP retry now completes all **five selected public .NET manifest
commands**, with identical final source bytes/modes for all 796 files.
Native compilation and the native TLS-off/TLS-on units pass. The managed
suite reports **4,886 passed, zero failed and 90 skipped, total 4,976**.
All twelve original Unix socket fixture failures pass under the shorter
fixture root, with unchanged source and assertions. The managed command
takes 150.053 seconds. Both tuner commands also pass: twenty decision-rule
properties and three selector/profile tests.

The independent skip audit finds exactly ninety distinct managed case
names: 85 `QuickFixAcceptanceSessionTests`, two `QuickFixConformanceTests`,
one `SbeFramingTests`, one `AcceptorReusePortTests` and one
`NativeSessionTests`. The public export retains those explicit omissions.
The Linux reuse-port refusal case is platform-inapplicable; the native pool
broadcast case requires an explicitly configured multi-thread acceptor
pool. This default manifest pass does not claim either unselected variant,
external acceptance/corpus coverage or multicast delivery. The native
provider remains required by the executed command and native load guard.

Collected final receipt SHA-256 is
`9af48e4588594651bb358653e652c4fe28aa8d5d99666dc791691a5aea705d1f`.
No compiler server remains holding the original v2 lease; the helper starts
the next queued Rust verification automatically. C++ and .NET whole selected
manifest checks now pass on HP; Java's separately pinned selected manifest
checks pass on both hosts. Rust is executing its first actual standalone
manifest sequence. No cross-language timing, peer, release or licence gate
is promoted by these SDK checks.

## Rust complete standalone verification passes

HP completes all **seven selected public Rust SDK manifest commands**, with
all 332 original source files retaining their bytes and modes. The direct
crate suite reports 2,562 passing tests across 67 result blocks, zero failures
and zero ignored tests. The actual packaged/extracted crate independently
reports the same 2,562 passes, zero failures and zero ignored tests. Exported
tool crates add 61 passes across fifteen result blocks, zero failures/ignored.
Warning-free library documentation and both explicit private-feature
refusals pass. The optimized-build Python controls run seventeen tests:
fourteen pass and three development-layout-only checks remain explicit skips.

The original direct crate command takes 550.750 seconds; the independent
package/build/test sequence takes 581.579 seconds. The final exact receipt
SHA-256 is `6aa888eb1b1d37949ca25ec8c7dc18067acf74ed502f5d4fa650dd16a96de53a`.
Both complete command logs and the case-insensitive skip/ignore audit remain
on the producing host; bounded receipts/log tails are collected locally.
A zero ignored count in Rust result lines is not counted as a skipped test.

The selected standalone manifests now pass for C++, .NET and Rust on HP,
and for the separately pinned Java SDK on both hosts. These are the exact
selected public export scopes, with all stated platform/corpus/development
omissions. Wider feature coverage, timing, peer/anchor, licences and release
gates remain separate.