7473bb7e44
Address the Codex GPT-5.5 review of the standalone fake C++ gRPC Shard worker. Four root protocol defects fixed: - Fail closed before SessionOpen: a per-session `opened` flag gates chunk/decode so no activation bypasses lifecycle, cancellation, epoch or flow-control state (terminal ERROR_CODE_INTERNAL), even when an out-of-band Cancel created placeholder state. - Strict flow-control negotiation: NegotiateFlow takes the strictest of peer-vs-worker bounds (mirrors codec.negotiate_flow_control) and the negotiated per-session max_chunk_bytes is enforced on every bundle instead of trusting the peer proposal. - In-stream ReleaseSignal now erases session state immediately. - SessionOpen rejects incompatible schema, fingerprint, and shard-range identity and reports the worker's own served fingerprint rather than echoing the caller. Adds 9 regression tests (worker suite 18 -> 27). Real gates on the rebuilt pinned-gRPC binary: cmake build exit 0; ctest 2/2; worker pytest 27 passed; harness+protocol 63 passed; compileall 0; diff --check clean; ldd/nm show 0 llama/ggml linkage. DGR-033 passes -> true. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Native Shard protocol
proto/shard_runtime.proto is the semantic contract between a Meshnet node and
a Shard worker: Protocol Buffers over gRPC/HTTP2 (ADR-0020). It is the source of
truth. The Python and C++ types are generated from it; neither is the contract.
What lives here
| Path | Purpose |
|---|---|
proto/shard_runtime.proto |
The schema: capability, health, session stream, release, cancel |
testdata/*.binpb |
Committed conformance vectors both languages assert against |
tests/test_shard_protocol_conformance.cpp |
C++ conformance test |
CMakeLists.txt |
C++ generation, build wiring, and ctest registration |
The Python stubs are generated into
packages/node/meshnet_node/native_protocol/generated/ and are committed, so
installing a node needs no protoc. The C++ stubs are generated into the build
tree and are never committed — a C++ consumer already has a toolchain, and a
committed copy could only rot.
Regenerating
pip install grpcio-tools==1.82.1 # bundles protoc; no system protoc needed
python scripts/generate_native_protocol.py # rewrite the Python stubs
python scripts/generate_native_protocol.py --check # fail if they drifted
python scripts/generate_protocol_goldens.py --check # fail if the vectors drifted
Both --check modes run in CI via tests/test_native_shard_protocol.py, so a
schema edit that is not accompanied by regenerated output fails the suite rather
than shipping stubs that disagree with the schema they claim to implement.
DGR-006 decode and tail compatibility
DecodeStep.bundle is the versioned TensorBundle fast-path boundary. It is
authoritative whenever present and supports architecture sidebands. The original
DecodeStep.tensor remains readable as the compact one-tensor encoding for
certified boundaries that need only one tensor; new readers wrap it into a
one-member bundle. Tail completions use TailResult, which binds logits or a
sampled token to request/recipe identity and sampling/template/reasoning inputs.
Building and running the C++ conformance test
If the machine has no protobuf C++ toolchain:
bash scripts/bootstrap_native_toolchain.sh build/native-toolchain
Then:
cmake -S packages/node/native -B build/native \
-DCMAKE_PREFIX_PATH="$PWD/build/native-toolchain"
cmake --build build/native -j
ctest --test-dir build/native --output-on-failure
The bootstrap pins and builds Protobuf 33.1, gRPC C++ 1.82.1, and the
matching grpc_cpp_plugin into one ignored prefix. CMake requires those exact
package versions and always generates both message and service stubs; it does
not fall back to an arbitrary system plugin.
How the cross-language check actually proves something
Two codecs that each round-trip their own output prove only that each is self-consistent. Instead:
- Python builds the canonical message and commits its bytes to
testdata/. - The C++ test parses those bytes, asserts every field, independently
recomputes the CRC32C from the polynomial, and re-serializes to
cpp_roundtrip.binpbin the build tree. test_cpp_and_python_agree_byte_for_bytecompares that file to the golden.
Byte equality across the two implementations is the claim; anything less is two parallel test suites that can drift apart.