CHANGELOG.md

Changelog

All notable changes to ludoSpring are documented in this file.

Format follows Keep a Changelog. This project does not use SemVer — versions are session-sequential (V1–V53).

[V55] — 2026-04-27

Deep debt resolution — barracuda crate modernization

• Method constants centralized: Expanded ipc/methods.rs with activation, math, noise, compute, storage, dag, braid, ai, spine, tensor modules. All raw string literals in production IPC code replaced with constants. Compile-time consistency test verifies key capabilities match niche::CAPABILITIES.
• IpcError source chaining: Added From<serde_json::Error> and From<std::io::Error> for IpcError, eliminating .to_string() error conversion across IPC modules.
• RpcClient extracted: New ipc/rpc_client.rs provides a shared RpcClient struct for Unix socket JSON-RPC 2.0 operations. Refactored neural_bridge.rs, push_client.rs, discovery/mod.rs, and btsp.rs to delegate transport to RpcClient, removing ~120 lines of duplication.
• Capability-first niche: NicheDependency struct evolved: name replaced by hint_name: Option<&'static str>, capability reordered as primary key. Discovery resolves by capability first, falling back to hint_name for socket filename matching.
• Typed library errors: VoxelError, BaselineError, ComparisonError (thiserror enums) replace Result<_, String> in game/voxel.rs, validation/mod.rs, composition_targets.rs.
• Typed binary errors: CliError (thiserror) replaces Result<_, String> across ludospring commands, validate_all (RunnerError), and validate_primal_proof (now uses IpcError via RpcClient).
• File refactors: envelope.rs inline tests extracted to envelope_tests.rs (824 → 409 lines). ludospring_guidestone.rs (812 lines) split into guidestone/ module directory: main.rs, constants.rs, tier1.rs, tier2.rs, tier3.rs (all under 220 lines).
• Zero regressions: 656/656 non-environment-dependent tests pass. Clippy clean with -D warnings across all features.

[V54] — 2026-04-27

Composition library absorption — interaction fidelity lane

• Upstream composition tooling absorbed: nucleus_composition_lib.sh (reusable NUCLEUS wiring: discovery, DAG, ledger, braids, petalTongue, sensor stream), composition_nucleus.sh (parameterized launcher replacing ad-hoc startup). Sourced from primalSpring's TTT reference implementation.
• ludo_composition.sh: Domain-specific interactive game science composition. Three modes: Fitts law pointing task (randomized targets, barraCuda ID computation), reaction time / Hick's law (go/no-go with variable delay), free explore DAG sandbox (undo, branches, merkle). All modes wire DAG → ledger → braid provenance.
• Exploration lane: Interaction fidelity and real-time feedback — multi-player input routing, continuous vs event-driven rendering, DAG branching for game state time-travel, braid replay integrity, petalTongue stress testing.
• New PGs noted: PG-45 (rhizoCrypt UDS no JSON-RPC response), PG-46 (toadStool slow on short timeouts), PG-47 (barraCuda missing stats.entropy), PG-48 (petalTongue plasmidBin musl + winit threading), PG-39 (graph schema mismatch).
• Live composition tested (FAMILY_ID=nucleus01): 5/7 capabilities discovered (visualization, security, compute, tensor, attribution). DAG and ledger offline (PG-45, GAP-07). Fitts ID sweep (W=20..100, Shannon variant confirmed), Hick bits sweep (n=2..16, log₂(n) confirmed). sweetGrass braids with full JSON-LD provenance. Scene push/dismiss, interaction subscribe/poll verified.
• Findings: petalTongue v1.6.6 missing proprioception.get, motor.continuous; capability.list doesn't enumerate viz/interaction methods. uds_rpc.py created as socat fallback (python3 UDS transport).

[V53] — 2026-04-25

Upstream absorption (cell_launcher, PG-38, GAP-07/11 resolved)

• Cell graph v2.0: Synced from primalSpring v0.9.17 (commit 8bb90fb). biomeOS-compatible [[nodes]] format with by_capability routing.
• cell_launcher.sh: Portable cell deployment from plasmidBin — starts all 12 primals in dependency order, auto-generates BTSP seed, health checks.
• nucleus_launcher.sh: Fixed BearDog NODE_ID, Songbird --beardog-socket, petalTongue server mode (no --socket flag).
• GAP-07 RESOLVED: loamSpine startup panic fixed upstream (PG-33, d34100f).
• GAP-11 RESOLVED: barraCuda Fitts/Hick convention is intentional (PG-38). Default is Shannon/log₂(n); pass variant: "fitts" or include_no_choice: true for textbook formulas.
• Live composition verified: 18/20 capabilities through NUCLEUS, 5 primals with sockets via nucleus_launcher, game.tick loop in 0.6ms (200x headroom).
• downstream_manifest.toml: ludospring entry now guidestone_validation = "composition", composition_model = "pure", with visualization.render.scene
  • interaction.poll in validation capabilities.

Binary to composition evolution

Springs are NOT primals — they produce primals and define compositions. The ludospring binary in plasmidBin was an oversight from the Rust validation round. V53 corrects this: game science capabilities are now served by composing existing primals via the NUCLEUS cell graph, not by deploying a spring binary.

• plasmidBin entry transformed: Removed ludospring binary from plasmidBin/ludospring/. Metadata transformed from binary primal description to composition manifest with [composition] section, capability routing table, and primal dependency list.
• Cell graph evolved: ludospring_cell.toml no longer has a ludospring node. Game science capabilities route to barraCuda (math.*, activation.*, stats.*, noise.*), petalTongue (visualization.*, interaction.*), Squirrel (ai.*), and the provenance trio. 12 primal nodes (was 14 — removed ludospring node and biomeOS infra node).
• Gaming niche graph evolved: ludospring_gaming_niche.toml replaces germinate_ludospring with germinate_barracuda for game math. Validation checks barraCuda health instead of ludospring.
• manifest.lock updated: ludospring moved from [springs.*] to [compositions.ludospring_game] — a composition entry with cell graph reference and 11-primal dependency list.
• GAP-10 resolved: The game.* primal identity gap is resolved by the pure composition model. Game science methods map to barraCuda capabilities (activation.fitts, math.sigmoid, etc.) — no standalone game domain primal needed.
• Spring binary unchanged: The ludospring binary in the source tree (target/release/ludospring) continues as the Rust validation target (tier 2 of the 3-tier ladder: Python → Rust → Composition). 817 workspace tests continue to validate the Rust tier.

[V52] — 2026-04-25

Game tick loop and interaction-driven desktop gameplay

Wires the full desktop game loop: push scene → poll interactions → record action → compute metrics → respond. Three new handlers complete the composition pattern for live desktop-style gameplay through petalTongue.

• game.tick composite handler: One RPC call performs a full game loop tick — pushes scene to petalTongue, polls interaction events, records player action in the provenance DAG, computes engagement metrics, and returns combined game state. Uses is_skip_error for graceful degradation when petalTongue is absent.
• game.subscribe_interaction handler: Subscribes to petalTongue input events with is_skip_error degradation.
• game.poll_interaction handler: Polls petalTongue for pending input events with is_skip_error degradation.
• handle_push_scene evolved: Now classifies errors semantically via is_skip_error() — reports degraded: true when petalTongue is absent instead of opaque error strings.
• 30 capabilities (was 27): New methods registered in niche, capability domains, operation dependencies, and cost estimates.
• ludospring_cell.toml: New cell graph defines the full NUCLEUS deployment for desktop gameplay — 14 nodes (Tower, Node, Nest, Springs, AI, Store) with all interaction loop methods.
• Deploy graphs updated: ludospring_gaming_niche.toml and game_loop_continuous.toml now include interaction.poll node and all new capability mappings.
• 9 new tests: GameTickParams, SubscribeInteractionParams, PollInteractionParams deserialization, handler dispatch for all new methods, push_scene degraded field.
• 817 tests, zero clippy warnings.

[V51] — 2026-04-25

Absorb typed composition patterns for live desktop UI

Absorbed upstream primalSpring v0.9.17 composition patterns (commits 0844c5c, 49c0eab) — method constants, skip-error semantics, and visualization method routing.

• ipc::methods module: New module mirrors primalspring::ipc::methods for the visualization, interaction, health, lifecycle, and capability domains. All constants are &str compile-time constants usable in match arms. Replaces ~30 hardcoded string literals across dispatch and push paths — eliminates the class of typo-induced silent routing failures.
• Handler dispatch evolved: dispatch_lifecycle and dispatch_infrastructure in handlers/mod.rs now match on methods::visualization::*, methods::interaction::*, etc. instead of string literals. All six neural.rs dispatch functions (render, management, degraded, no-peer) similarly evolved.
• VisualizationPushClient evolved: All 8 RPC method strings in push_client.rs (push_render, push_stream, push_scene, push_dashboard, export, subscribe_interaction, poll_interaction, validate, probe_with_capability) replaced with ipc::methods constants.
• IpcError::is_skip_error(): New query method mirrors upstream primalspring::composition::is_skip_error. Returns true for connection errors and protocol errors — enables the call_or_skip graceful degradation pattern when petalTongue is absent.
• 2 new tests: methods::tests::all_constants_are_dotted validates all 19 method constants, is_skip_error_for_connection_and_protocol validates the skip-error classification.
• 810 tests, zero clippy warnings.

[V50] — 2026-04-25

IpcError debt resolution — absorb primalSpring v0.9.17 pattern

Absorbed the upstream IpcError pattern from primalSpring v0.9.17 (commit 0844c5c). The last Result<_, String> debt in ludoSpring's IPC layer is gone.

• IPC client modules: All 43 public functions across loamspine, sweetgrass, rhizocrypt, provenance/mod, nestgate, squirrel, toadstool, coralreef, and composition now return Result<_, IpcError> instead of Result<_, String>.
• classify_io_error: New helper mirrors upstream — classifies io::Error into semantic IpcError variants (Connect, Timeout, Io).
• Query methods aligned with upstream: Added is_connection_error(), is_timeout_likely(), is_protocol_error() to local IpcError, matching primalSpring's query API.
• JsonRpcError::internal(): Widened from &str to impl Display, enabling callers to pass IpcError directly without .to_string().
• cmd_server: Evolved from Result<(), String> to Result<(), IpcError>, using classify_io_error for I/O paths.
• Zero Result<_, String> in IPC layer: The entire barracuda/src/ipc/ directory has zero Result<_, String> function signatures remaining.
• 9 new tests covering classify_io_error, query methods, and internal() with IpcError display.

[V49] — 2026-04-25

Deep Debt Resolution — idiomatic Rust, capability-based, zero external deps

Systematic audit and evolution of remaining deep debt across the codebase.

• Handler test extraction: Extracted 650+ lines of inline tests from ipc/handlers/mod.rs (818L → 169L) to ipc/handlers/tests.rs. Production dispatch module is now concise and readable.
• Capability-based discovery: validate_primal_proof.rs now discovers barraCuda by compute/tensor capability from niche::DEPENDENCIES instead of hardcoded socket names. validate_composition.rs derives fallback socket names from niche::NICHE_NAME/NICHE_DOMAIN constants.
• MCP surface complete: tools.call and mcp_tools_descriptors now expose all 15 game.* methods (added game.record_action, game.voice_check). Previously only 13 were wired.
• base64 external dep removed: Replaced with 20-line inline base64_encode (standard alphabet, padding). One fewer transitive dependency. RFC 4648 test vectors validate correctness.
• Typed errors in BTSP: All Result<_, String> in ipc/btsp.rs evolved to Result<_, IpcError> — beardog_call, write_json_line, write_error_frame, classify_first_line, perform_handshake now use the typed error hierarchy (Connect, Io, Serialization, RpcError, NotFound, NoResult).
• Named constants: ACCEPT_POLL_MS replaces magic 50 in server accept loop. DEFAULT_FAMILY_ID replaces inline "default" string in niche.rs.
• Tests: 798 → 799 (+1: base64_encode_known_vectors).
• Clippy: zero warnings (workspace-wide).

[V48] — 2026-04-25

Phase 45c Debt Resolution — BTSP relay, interaction.poll, honest push_scene

Absorbs primalSpring v0.9.17 Phase 45c downstream audit. Implements the three highest-priority debt items identified in the cell graph composition review.

• BTSP relay pattern: Full 4-step BearDog handshake in ipc/btsp.rs per SOURDOUGH_BTSP_RELAY_PATTERN.md. Auto-detects BTSP ClientHello vs. plain JSON-RPC on first line. Gates on FAMILY_ID via btsp_required(). The ludoSpring IPC server (ludospring-barracuda) now speaks BTSP when deployed in a NUCLEUS cell graph with security_model = "btsp".
• interaction.poll wired: New poll_interaction() method on VisualizationPushClient calls petalTongue's interaction.poll JSON-RPC. Dispatched through infrastructure tier (viz_management_dispatch). Degraded fallback returns empty events when no viz primal is discovered. This is the missing return path for the live interaction loop: game.push_scene → petalTongue → player → interaction.poll → game.record_action.
• Honest push_scene: handle_push_scene now reports actual push status (pushed: true/false) and propagates error details instead of silently swallowing failures. Wire contract is honest telemetry.
• plasmidBin→genomeBin in ludospring.rs: CLI help and log strings updated.
• Tests: 791 → 798 (+7: BTSP relay, interaction.poll, honest push_scene).
• Clippy: zero warnings (workspace-wide).
• Cell graph ready: primalSpring/graphs/cells/ludospring_cell.toml declares 14 nodes, all security_model = "btsp", ludospring-barracuda at order 12.

[V47] — 2026-04-20

Live NUCLEUS Validation — 54/54 checks, guideStone standard v1.2.0, genomeBin v5.1

First live NUCLEUS validation of ludospring_guidestone: deployed 12 primals from genomeBin, ran the guideStone externally — 54/54 checks passed (2 skipped), exit 0. All three tiers validated against real primal IPC.

• Live NUCLEUS deployment: 12 primals from genomeBin (barraCuda built from source, 11 from plasmidBin x86_64 binaries). BearDog, NestGate, barraCuda, sweetGrass, toadStool alive on UDS.
• 54/54 checks passed (2 expected skips: toadStool protocol mismatch, compute.capabilities connection reset).
  • Tier 1: 31/31 bare (20 structural + 11 BLAKE3).
  • Tier 2: 13/13 pass + 2 skip — Fitts, Hick, sigmoid, log2, mean, variance, std_dev, Perlin, rng, tensor.create, tensor.matmul (ID-based), health.
  • Tier 3: 8/8 cross-atomic — BearDog crypto.hash (base64 payload→base64 BLAKE3), NestGate storage roundtrip, cross-atomic pipeline (hash→store→retrieve→verify).
• Upstream absorption: local call_or_skip() and is_skip_error() removed; now imported from primalspring::composition.
• v1.2.0 tolerance ordering: full 7-constant invariant validated.
• guidestone_properties manifest field: All 5 properties = true.
• IPC formulation divergence (GAP-11): barraCuda uses different Shannon formulations for Fitts/Hick and sample variance (ddof=1). IPC checks now use barraCuda-expected values. Bare checks retain Python golden values. Both are deterministic and documented.
• tensor.matmul: Now uses multi-step create→matmul flow with tensor IDs (barraCuda API requires lhs_id/rhs_id, not inline matrices).
• BearDog crypto.hash: Payload sent as base64; hash received as base64 (44 chars, not 64-char hex). Length check updated.
• extract_any_scalar: Handles {"result": [value]} array-wrapped scalars (barraCuda's response format for math.sigmoid, math.log2).
• genomeBin v5.1: All deployment references updated.
• NUCLEUS deployment env vars documented: BEARDOG_FAMILY_SEED, BEARDOG_NODE_ID, SONGBIRD_SECURITY_PROVIDER, NESTGATE_JWT_SECRET.
• GAP-11: barraCuda formulation divergence documented.
• Tests: 791 total (unchanged).

[V46] — 2026-04-20

guideStone readiness 4 — Three-Tier NUCLEUS Validation

Evolved ludospring_guidestone from readiness 3 (bare works) to readiness 4 (NUCLEUS validated) following primalSpring v0.9.16 three-tier pattern.

• Three-tier architecture:
  • Tier 1 — LOCAL_CAPABILITIES (20 bare checks): 5 certified properties including BLAKE3 checksum manifest verification (Property 3, guideStone standard v1.1.0 via primalspring::checksums::verify_manifest).
  • Tier 2 — IPC-WIRED (15 checks): domain science via composition IPC to barraCuda. Protocol tolerance: Songbird/petalTongue HTTP-on-UDS classified as SKIP via is_protocol_error() || is_transport_mismatch().
  • Tier 3 — FULL NUCLEUS (8 checks): cross-atomic validation — BearDog crypto.hash (BLAKE3 64-char hex), NestGate storage.store / storage.retrieve roundtrip, cross-atomic pipeline (hash → store → retrieve → verify).
• Protocol tolerance: is_skip_error() helper classifies connection, protocol, and transport mismatch errors as SKIP (not FAIL).
• BLAKE3 Property 3: checksums::verify_manifest(v, "validation/CHECKSUMS") per guideStone standard v1.1.0.
• Check naming: bare:* (Tier 1), ipc:* (Tier 2), nucleus:* (Tier 3).
• validation/CHECKSUMS: BLAKE3 manifest (11 files) for Property 3 self-verification — guideStone source, Python baselines, composition targets. Tier 1 bare check count grows to 31 when manifest is present (20 structural + 11 file integrity via p3:checksum:*).
• exp054 fix: Edition 2024 implicit-borrow pattern in coordination.rs.
• #[expect] migration: python_parity.rs #[allow(clippy::cast_precision_loss)] → #[expect(..., reason = "...")].
• Tests: 791 total (up from 790+).
• Quality table: Updated to 791 tests, 60+ #[expect] sites documented.

[V45] — 2026-04-18

Level 5 guideStone — Self-Validating NUCLEUS Node (readiness 3)

ludoSpring now has a proper guideStone binary (ludospring_guidestone) that uses the primalSpring composition API rather than raw IPC socket calls. The guideStone carries five certified properties validated in bare mode (no primals needed), discovers NUCLEUS primals via capability- based routing, and validates domain science against Python golden values.

• ludospring_guidestone binary: Level 5 guideStone. Three layers:
  • Layer 0 (Bare): 15 checks across 5 certified properties — determinism (recompute Fitts, Hick, sigmoid, log2, mean, variance from formulas), traceability (7 golden values sourced to papers), self-verification (tamper detection via tolerance guard), environment-agnostic (pure Rust), tolerance ordering (DETERMINISTIC < IPC_ROUND_TRIP ≤ WGSL_SHADER).
  • Layer 1 (Discovery): validate_liveness for tensor + compute.
  • Layer 2 (Domain Science): 15 composition IPC checks — Fitts, Hick, sigmoid, log2, stats.mean, stats.variance, stats.std_dev, Perlin, rng.uniform, tensor.create, tensor.matmul (identity parity), compute.capabilities, health.readiness. Exit 0/1/2 (certified/failed/bare-only). Requires guidestone feature.
• Bare mode achieves readiness Level 3: guideStone passes all structural checks without any live primals, producing exit 2 with zero failures.
• primalspring dependency: Optional path dep gated behind guidestone feature.
• validate_all updated: Includes ludospring_guidestone with exit-2 skip.
• CI updated: cargo build --features guidestone step.
• validate_primal_proof retained: Raw IPC validator for comparison/fallback.

[V44] — 2026-04-17

Level 5 Primal Proof — barraCuda IPC Validation

The primal proof is operational: validate_primal_proof calls barraCuda over JSON-RPC UDS (not library imports) and compares results against Python golden values. This is the first binary that proves ludoSpring's domain math works through the sovereign primal compute stack.

• validate_primal_proof binary: Level 5 validator. Discovers barraCuda socket (env override BARRACUDA_SOCK or XDG scan), calls 10 IPC methods (activation.fitts, activation.hick, math.sigmoid, math.log2, stats.mean, stats.std_dev, noise.perlin2d, rng.uniform, tensor.create, health.liveness), compares scalar results against Python baseline golden values using ANALYTICAL_TOL. Exit 0/1/2 (pass/fail/skip). Requires ipc feature.
• validate_all updated: Includes validate_primal_proof with exit-2 skip handling.
• GAP-02 updated: Status PARTIAL — 10 barraCuda methods validated via IPC; domain-level methods (math.flow.evaluate, math.engagement.composite) remain gaps for upstream absorption.
• Validation ladder status: Level 1 (Python) ✓, Level 2 (Rust) ✓, Level 3 (IPC composition) ✓, Level 5 (primal proof) ✓ (core math), Level 6 (clean-machine) pending.

[V43] — 2026-04-17

Three-Layer Composition Validation — Python→Rust→IPC Golden Chain

The full validation lifecycle is now wired end-to-end: Python baselines validate Rust library code (Layer 1), Rust library produces golden composition_targets.json (Layer 2), and IPC calls validate primal composition against those golden targets (Layer 3).

• validate_composition binary: Layer 3 IPC validator. Loads golden targets from composition_targets.json, discovers ludoSpring socket, calls game.* methods over JSON-RPC, compares to golden values. Validates lifecycle.composition report and health probes. Exit 0/1/2 (pass/fail/skip). Requires ipc feature.
• composition_parity.rs (Layer 2.5): 6 integration tests validating every method group in composition_targets.json against direct library calls — catches drift before IPC testing.
• check_composition_drift example: Analogous to check_drift.py for Python baselines. Recomputes all targets, compares to stored JSON. Runs in CI.
• composition_targets.json expanded: Added game.wfc_step (WFC entropy collapse), expanded _provenance with methods array and pending_regeneration flag. 7 method groups with named tolerances.
• validate_all updated: Runs validate_composition with exit-2 skip handling (server not running = honest skip, not failure).
• IPC Fitts dispatch expanded: handle_fitts_cost now branches on hick_reaction_time and steering_time methods, matching golden targets.
• TensorSession sigmoid wired: game::engine::tensor_ops implements sigmoid batch via barraCuda TensorSession (GPU feature gate). Upstream SessionOp::Sigmoid added to barraCuda.
• plasmidBin harvest: v0.10.0, sha256-verified, manifest.lock synced.
• NUCLEUS_SPRING_ALIGNMENT.md: Updated to 790+ tests, three-layer validation in detail.
• NICHE_STARTER_PATTERNS.md: Added ludoSpring game science composition example.
• #[allow] in test modules: Reverted #[expect] on test modules to #[allow] — #[expect] requires the lint to fire in every module, which is not guaranteed for unwrap_used/expect_used in test code. Production code retains #[expect] where appropriate.
• Clippy clean: cargo clippy --all-targets --features ipc -- -D warnings passes with zero warnings.
• Tests: 781 → 790+ (+6 composition parity, +3 examples).

[V42] — 2026-04-11

Composition Evolution — Rust+Python validate NUCLEUS patterns

Python validated Rust. Now Rust and Python are validation targets for ecoPrimal NUCLEUS composition patterns. This release completes the evolution from validation spring to composition spring.

• lifecycle.composition handler: Wired as a dispatched JSON-RPC method in handlers/lifecycle.rs. CompositionReport is now externally callable — biomeOS and peers can probe ludoSpring's proto-nucleate composition at runtime.
• Capability-first discovery: probe_dependency() in ipc/composition.rs now resolves via discover_by_capability(dep.capability) first, falling back to name-based discover_primal_tiered(). Aligns with SPRING_COMPOSITION_PATTERNS §3.
• nest_atomic in fragments: Declared in FRAGMENTS, capability_registry.toml, and PRIMAL_GAPS.md. Trio primals remain required: false (aspirational until GAP-06/GAP-07 resolve). GAP-09 updated to RESOLVED.
• Provenance unified: All BaselineProvenance commits, test headers, and doc comments aligned to 19e402c0 (matches combined_baselines.json). Eliminated three conflicting commit references (4b683e3e, 74cf9488). Dates aligned to 2026-04-10.
• ecoBin banned-crate enforcement: deny.toml [bans].deny list added for 8 C dependencies per ecoBin v3.0 (openssl-sys, ring, aws-lc-sys, native-tls, zstd-sys, lz4-sys, libsqlite3-sys, cryptoki-sys). cargo deny check passes.
• fog_of_war.wgsl README: Reconciled with shader body — documents distance-based radial mask (not Bresenham occlusion, which is a planned Tier C promotion).
• exp045 doc link: Fixed broken OrExit intra-doc link (rustdoc warning eliminated).
• Tests: 780 → 781 (+1 lifecycle_composition_returns_report). Zero clippy warnings. Zero fmt diffs. Zero regressions.

[V41] — 2026-04-11

Composition Evolution — Absorbed primalSpring patterns

Absorbs 9 hardened composition patterns from primalSpring, plasmidBin, and SPRING_COMPOSITION_PATTERNS.md. Completes the evolution from validation spring to composition spring.

• IpcErrorPhase + PhasedIpcError: Annotates IPC errors with communication phase (connect, send, receive, parse, timeout) for smart retry logic. is_retriable(), is_recoverable(), is_method_not_found() classification methods.
• Method normalization: normalize_method() strips ludospring., barracuda., biomeos., game.ludospring. prefixes before dispatch. Handles double-prefixed calls from biomeOS routing.
• Three-tier dispatch: dispatch_lifecycle() → dispatch_infrastructure() → dispatch_science() replaces flat 40-arm match. Clean separation of concerns.
• Tiered discovery: DiscoveryTier enum (6 tiers: ExplicitEnv → XdgFamily → XdgPlain → TempFallback → DirectoryScan → NeuralApiSweep). DiscoveryResult returns Found { endpoint, tier } or NotFound { target, searched }.
• NicheDependency table: 11 typed proto-nucleate entries in niche.rs with name, role, required flag, and capability domain.
• Typed inference wire types: InferenceCompleteRequest, InferenceEmbedRequest/Response, InferenceModelsRequest, ModelInfo in ipc/squirrel.rs.
• CompositionReport: New ipc/composition.rs module probes all 11 niche dependencies at runtime, reports live/absent counts and composition completeness.
• --port CLI flag: ludospring server --port 8080 for plasmidBin/orchestrator binding.
• Tests: 733 → 779 (+46 composition pattern tests). Zero clippy warnings. Zero regressions.
• PRIMAL_GAPS.md: Updated with absorbed patterns table and GAP-09 nest_atomic decision (aspirational stubs).
• plasmidBin metadata: Session version bumped to V41.
• Handoff: V38/V39/V40 archived; V41 handoff to infra/wateringHole/handoffs/.

[V40] — 2026-04-11

Audit & workspace cleanup (April 11, 2026)

Documentation and tooling aligned with the April 2026 code review:

• Clippy: Workspace-wide cargo clippy --all-features -- -D warnings — 207 → 0 warnings across crates (including experiments exp030–exp100).
• cargo fmt: Clean — no formatting diffs on touched surfaces.
• cargo deny / deny.toml: Policy file migrated for current cargo-deny and workspace layout; supply-chain gate passes in CI.
• ipc/handlers/neural.rs: Refactored from a single ~228 LOC module into three submodules under 100 LOC each (dispatch, delegation, helpers).
• Baseline loader: validation::load_baseline_f64 exercised by unit tests in barracuda/src/validation/mod.rs; provenance blocks re-verified against current baselines.
• Primal gaps: 10 gaps documented as GAP-01–GAP-10 in docs/PRIMAL_GAPS.md — including GAP-09 (nest_atomic vs Nest-side IPC stubs) and GAP-10 (game.* primal identity — ludoSpring not a graph node).
• Test counts (authoritative): 605 barracuda lib tests + 102 barracuda --tests integration targets + 26 metalForge forge tests = 733 total workspace #[test] functions (see README Quality table).

[V39] — 2026-04-10

Added — NUCLEUS Composition Parity (Layer 3 Validation)

Python validated Rust (Layer 1). Rust validated IPC (Layer 2, V38). Now both Python and Rust validate primal composition patterns (Layer 3):

• exp100 — NUCLEUS Composition Parity — 27-check three-layer validator: niche self-knowledge integrity (7 checks), health probes (2), capability discovery (4), science parity through IPC (8), and golden chain Python→Rust→IPC round-trip (6). Exit code 2 for skip when primals not running. Uses tolerances::RPC_TIMEOUT_SECS for IPC calls.
• config/capability_registry.toml — machine-readable capability SSOT matching niche.rs, following the neuralSpring registry pattern. Includes identity, fragments, capabilities by category, semantic mappings, external dependencies, and proto-nucleate references.
• barracuda/src/bin/commands/hud_fixtures.rs — shared HUD element fixtures for FPS, RTS, sandbox, RPG, puzzle genres. Eliminates duplication between dashboard.rs and tufte_dashboard.rs.
• tolerances::game::D6_SUCCESS_THRESHOLD (4) and tolerances::game::DIALOGUE_EMA_ALPHA (0.3) — centralized from inline literals in dialogue.rs with calibration citations.

Changed — CI and Quality Gates

• Coverage in CI: Added cargo-llvm-cov --fail-under-lines 90 step to .github/workflows/ci.yml — coverage floor now enforced in CI, not just locally via make coverage.
• Makefile test parity: make test now includes ludospring-forge tests, matching CI's test scope.
• Forge workload naming: fraud_batch() → anti_cheat_batch() — correct game-science domain vocabulary.
• Dashboard deduplication: dashboard.rs and tufte_dashboard.rs now share hud_fixtures.rs instead of maintaining identical element builders.

Fixed

• python_parity.rs provenance commit updated from 4b683e3e to 19e402c0 to match current combined_baselines.json artifact.
• specs/BARRACUDA_REQUIREMENTS.md path corrected from ../../barraCuda/ to ../../../primals/barraCuda/ matching actual Cargo.toml.

[V38] — 2026-04-10

Added — Composition Validation Chain (Track 29)

Three-layer validation chain proving Python → Rust → IPC → NUCLEUS parity:

• baselines/rust/composition_targets.json — golden reference values from direct Rust library calls for all 8 science methods (flow, Fitts, engagement, noise, DDA, accessibility, WFC, analyze_ui)
• baselines/rust/generate_composition_targets.rs — registered as cargo example; generates targets with provenance metadata
• 7 composition parity tests in ipc_integration.rs — each starts IpcTestServer, calls a science method via JSON-RPC, and asserts the response matches the direct Rust library call within ANALYTICAL_TOL (1e-10)
• exp099 — Composition Validation experiment — standalone 13-check experiment validating all science methods via IPC against Rust library, with dry-mode when no server running
• game.gpu.batch_raycast IPC handler — DDA batch line-of-sight via toadStool GPU delegation with CPU fallback
• coralReef IPC client (ipc/coralreef.rs) — typed client for shader compilation services via NeuralBridge with graceful degradation
• condition_map.rs — extracted from transition.rs for single-responsibility condition mapping between RPGPT planes
• 5 external primal degradation tests — verify graceful behavior when Squirrel, NestGate, Provenance trio, GPU dispatch, and health probes are unavailable
• docs/PRIMAL_GAPS.md — centralized documentation for 8 identified primal composition gaps (GAP-01 to GAP-08)

Changed — ecoBin Harvest + plasmidBin Deployment

• ecoBin built and harvested to infra/plasmidBin/ludospring/ — 3.1M PIE ELF x86-64, sha256-verified
• metadata.toml updated to v0.8.0 with 30 capabilities (was 5), checksum, expanded provenance
• manifest.lock updated — ludospring v0.8.0, timestamp refreshed
• Discovery method ordering — capability.list tried before capabilities.list (canonical naming)
• Health probe ordering — health.liveness → lifecycle.status → health.check
• Circuit breaker configurable — LUDOSPRING_CIRCUIT_COOLDOWN_MS, LUDOSPRING_CIRCUIT_MAX_RETRIES, LUDOSPRING_CIRCUIT_RETRY_DELAY_MS env vars
• Coverage gate raised — cargo llvm-cov floor 85% → 90%
• baselines/python/tolerances.py — expanded to 30+ constants matching Rust gpu.rs, validation.rs, game.rs

Fixed

• Baseline provenance hash aligned to current commit in tests/validation.rs
• CONTEXT.md corrected "ludoSpring does not ship a binary" → documents UniBin subcommands
• combined_baselines.json regenerated, no drift

Test counts

• barracuda lib: 696 (was 592)
• barracuda ipc integration: 23 (was 16)
• metalForge/forge: 26
• Total: 745 (was 732)
• Experiments: 99 (was 98)

[V37.1] — 2026-03-31

Added — plasmidBin Live Validation Run

First full run of all 15 composition experiments (exp084-098) against live primals started from infra/plasmidBin/. Score: 95/141 (67.4%).

5 experiments fully PASS: exp086 (tensor), exp090 (gameflow), exp092 (pipeline), exp093 (continuous session), exp097 (population dynamics).

Fixed — Local Experiment Debt (V37.1)

• exp094/095/098: BearDog crypto.blake3_hash now sends base64 data (not raw strings)
• exp094/095: BearDog crypto.sign_ed25519 now uses {"message": ...} (not {"data": ...})
• exp094/098: NestGate storage.store/retrieve now includes required family_id parameter
• exp093: Removed unused has_result function (dead code warning)

Documented — Primal Evolution Gap Matrix

10 primal gaps documented and handed off via wateringHole/handoffs/LUDOSPRING_V371_PLASMIDBINLIVE_GAP_MATRIX_HANDOFF_MAR31_2026.md:

Gap	Owner	Severity	Impact
TCP-only transport (no UDS)	rhizoCrypt	CRITICAL	blocks 4 experiments
Startup panic (runtime nesting)	loamSpine	CRITICAL	blocks 1 experiment
Fitts/Hick formula mismatch	barraCuda	HIGH	-4 checks
Perlin3D lattice invariant	barraCuda	MEDIUM	-1 check
No capability registration	biomeOS Neural API	HIGH	-14 checks
No binary in plasmidBin	barraCuda	HIGH	deployment gap
Inter-primal discovery	toadStool↔coralReef	MEDIUM	-1 check

Projected: all fixes → 130/141 (92.2%).

[V37] — 2026-03-30

Added — NUCLEUS Game Engine Composition (Track 28)

Five new experiments that validate ALL game engine patterns via full NUCLEUS composition — session/provenance, RPGPT dialogue, Lysogeny mechanics, content ownership — and structure everything as abstractable patterns for esotericWebb:

• exp094 — Session lifecycle via Nest Atomic: BearDog hash/sign + rhizoCrypt DAG + NestGate store/retrieve (8 checks)
• exp095 — Content ownership via Provenance Trio: loamSpine mint + rhizoCrypt trade + sweetGrass attribution + BearDog sign (8 checks)
• exp096 — NPC dialogue via NUCLEUS: Squirrel ai.query + barraCuda math.sigmoid/stats.weighted_mean + rhizoCrypt DAG + petalTongue scene (10 checks)
• exp097 — Population dynamics (Lysogeny) via tensor: replicator dynamics, Markov transitions, Wright-Fisher fixation, all via tensor.create/scale/reduce/matmul (10 checks)
• exp098 — NUCLEUS Complete game session: 10-tick loop composing barraCuda science + Squirrel AI + petalTongue viz + trio provenance + BearDog crypto + NestGate storage (6 checks)

Two new deploy graphs:

• graphs/composition/nucleus_game_session.toml — full 60Hz NUCLEUS game session (esotericWebb reference)
• graphs/composition/session_provenance.toml — session lifecycle: hash → DAG → cert → attribution → storage

Changed — Deploy Graph Migration (V37)

Migrated 2 existing deploy graphs from [[nodes]]+[nodes.primal]+[nodes.operation] to [[graph.node]] format with v2.80 conventions:

• rpgpt_dialogue_engine.toml — 7 phases (Tower → ludoSpring → petalTongue → Squirrel → toadStool → Trio → Validation)
• ludospring_deploy.toml — 5 phases (Tower → toadStool → ludoSpring → Validation → Provenance)

Both now use by_capability, health_method, spawn, order, capabilities list, required per primalSpring convention.

Summary — V36 + V37 Capability Coverage

After V37, every game.* capability in niche.rs (27 total) has a demonstrated primal composition equivalent:

Capability domain	Primal	Experiments
Science (flow, DDA, Fitts, engagement, noise, WFC)	barraCuda	exp089-093
Session lifecycle	rhizoCrypt + BearDog + NestGate	exp094
Content ownership	loamSpine + sweetGrass + BearDog	exp095
NPC dialogue + voices	Squirrel + barraCuda	exp096
Game mechanics (population dynamics)	barraCuda tensor/stats	exp097
Full NUCLEUS game tick	All primals	exp098

esotericWebb can replace its local science/ module with these exact capability.call chains.

[V36] — 2026-03-30

Added — Science via Primal Composition (Track 27)

Five new experiments that validate each HCI model's math purely through barraCuda IPC composition, comparing results to the same Python baselines:

• exp089 — Fitts + Hick + Steering via activation.fitts/activation.hick/math.log2 (8 checks)
• exp090 — Flow + Engagement + DDA via math.sigmoid/stats.weighted_mean/tensor.* (10 checks)
• exp091 — Perlin + WFC via noise.perlin2d/noise.perlin3d/tensor.* (8 checks)
• exp092 — GOMS KLM + Four Keys via stats.mean/stats.weighted_mean/tensor.* (8 checks)
• exp093 — Full game session (10 tick simulation) via Continuous composition (6 checks)

New deploy graph: graphs/composition/science_validation.toml composes all barraCuda capability domains (math, activation, tensor, noise, stats, rng) needed to validate all 13 HCI models without any ludoSpring binary.

Changed — Composition Graph Migration (V36)

Migrated all 4 existing graphs/composition/*.toml from [[nodes]] to [[graph.node]] format with biomeOS v2.80 specific capability domains:

• math_pipeline.toml — "compute" → "tensor"/"stats", removed stale gap comments
• engagement_pipeline.toml — "compute" → "stats", documented resolved IPC gaps
• shader_dispatch_chain.toml — added "shader"/"compute"/"math" domains + health_method
• game_loop_continuous.toml — capability per node ("math"/"activation"/"ai"/"visualization"/"dag"/"security")

All graphs now include: health_method, order, spawn = false, capabilities list, depends_on per primalSpring convention.

Changed — Experiment Alignment (V36)

• exp084-088: Updated doc headers to reference primalSpring graphs and V36 science experiments
• exp085: Documented barraCuda Sprint 24 barracuda-naga-exec CPU shader backend
• exp086: Noted as infrastructure foundation for exp090/exp092
• exp087: Updated to reference Pipeline coordination pattern and primalSpring validation graphs
• exp088: Added primalSpring gaming_mesh_chimera.toml reference

[V35.3] — 2026-03-30

Changed — Ecosystem Evolution Review + Experiment Alignment

Pulled and reviewed ALL primals, springs, and infra. Key findings:

biomeOS v2.80 resolves 3 of our 4 V35.2 genuine gaps:

• Bootstrap graph now has register_barracuda node with all 30 method translations
• Bootstrap graph bundled via include_str!() — no filesystem dependency
• graph.save accepts {"toml": "..."} format (was returning parse errors)
• Auto-discovery improved but needs live revalidation

barraCuda Sprint 24:

• 15-tier precision continuum, docs alignment
• Regression: for_precision_tier missing #[cfg(feature = "gpu")] (fixed locally)

primalSpring Phase 23d:

• gen4_storytelling_minimal.toml has ludoSpring as optional
• ludospring_validate.toml still V32-era — needs V35 update

Fixed — Experiment alignment with biomeOS v2.80

• exp087 + exp088: graph.save key "graph_toml" → "toml" (biomeOS v2.80 schema)
• exp087: Added capability_call_math check (math → barraCuda routing via new domain)
• exp087 + exp088: Capability domain routing "compute" → "tensor"/"math" (biomeOS now has explicit barraCuda domain instead of routing all through toadStool)
• barraCuda: #[cfg(feature = "gpu")] on for_precision_tier (Sprint 24 regression)

Experiment	V35.2	Expected V35.3	Change
exp084	12/15	12-15/15	No code change — barraCuda already passes
exp085	7/8	7-8/8	No code change — readback is hardware gap
exp086	10/10	10/10	Already perfect — barraCuda tensor API confirmed
exp087	3/7	5-8/8	graph.save + capability routing fixes + new math check
exp088	2/10	4-8/10	graph.save + tensor/math domain routing fixes

[V35.2] — 2026-03-30

Fixed — Local Debt Resolution + Revalidation

Deep audit revealed most V35.1 "gaps" were LOCAL mistakes in ludoSpring experiments:

• Wrong JSON-RPC method names (e.g. math.activation.sigmoid → math.sigmoid)
• Wrong param keys (e.g. values → data, d → distance)
• Placeholder tensor IDs instead of real ones from tensor.create
• tensor.reduce_sum → tensor.reduce (correct name)
• capability.call using args instead of params
• Graphs not deployed via graph.save API

All 5 experiments rewritten with correct barraCuda v0.3.11 API schemas. Better error reporting distinguishes -32601 (method_not_found) from -32602 (invalid_params).

Experiment	V35	V35.1	V35.2	Key change
exp084	0/12	4/15	12/15	All 8 math methods PASS; only Neural API routing + 2 domain methods remain
exp085	2/8	7/8	7/8	Compile+dispatch work; readback needs sovereign GPU driver
exp086	0/10	5/10	10/10	ALL tensor ops PASS — add, scale, clamp, reduce, sigmoid all work
exp087	1/7	3/7	3/7	graph.save returns parse error; biomeOS bootstrap has no barraCuda domain
exp088	2/10	2/10	2/10	Same — biomeOS capability registry has no primal domains

Total: 21/50 → 34/50 (68%)

Remaining gaps (GENUINE, not local debt)

1. biomeOS: No barraCuda domain in capability registry (compute→toadStool only)
2. biomeOS: Auto-discovery finds 0 primals despite sockets existing
3. biomeOS: graph.save returns "Failed to parse graph" for our composition TOMLs
4. biomeOS: Bootstrap mode (no tower_atomic_bootstrap.toml in CWD) — only 5 capabilities
5. toadStool: Sovereign dispatch needs coralReef driver for actual GPU readback
6. barraCuda: math.flow.evaluate and math.engagement.composite don't exist (domain-level)

[V35.1] — 2026-03-30

Revalidated — Primal Evolution Confirmed

Pulled and rebuilt evolved primals (barraCuda v0.3.11 local, biomeOS v2.79 local, coralReef Iter70 plasmidBin, toadStool S168 plasmidBin). Reran all 5 composition experiments. Total: 5/47 → 21/50 (42%).

Resolved (by primal teams)

• P0: barraCuda binary exists with 30 JSON-RPC methods
• P1: coralReef speaks raw newline-delimited JSON-RPC on UDS
• P2: biomeOS continuous executor wired with capability routing
• P2: biomeOS graph.save + nucleus/runtime tier separation
• P3: biomeOS health.liveness implemented

[V35] — 2026-03-30

Added — Primal Composition Gap Discovery (Track 26)

• 5 new composition experiments (exp084–exp088): probe whether ludoSpring's validated game science can be replicated using ONLY primal composition (no ludoSpring binary in the loop)
• 4 deploy graphs (graphs/composition/*.toml): math pipeline, shader dispatch chain, engagement pipeline, 60Hz continuous game loop — biomeOS- compatible [graph] header with [[nodes]] and by_capability routing
• exp084 (barraCuda math IPC): 12 math methods probed over JSON-RPC
• exp085 (shader dispatch chain): coralReef compile → toadStool dispatch E2E
• exp086 (tensor composition): engagement scoring via tensor element-wise ops
• exp087 (Neural API pipeline): graph.execute, pipeline, continuous orchestration
• exp088 (60Hz game loop): full storytelling loop at continuous tick rate

Fixed — Build Infrastructure

• Fixed barraCuda path dependency in barracuda/Cargo.toml, metalForge/forge/Cargo.toml, exp030_cpu_gpu_parity/Cargo.toml (incorrect relative paths)
• Fixed provenance trio path dependencies in 7 experiments (exp052–054, exp061–064): phase2/ → primals/ for rhizoCrypt, loamSpine, sweetGrass
• Graph TOMLs use [graph] header (not [metadata]) for biomeOS compatibility
• #![expect(missing_docs)] → #![allow(missing_docs)] in binary crates

Validated — Live Primal Composition (Mar 30, 2026)

Ran all 5 experiments against live primals from plasmidBin (v2026.03.25):

Experiment	Result	Key finding
exp084	0/12	barraCuda not in plasmidBin release
exp085	2/8	coralReef HTTP-wrapped JSON-RPC vs raw UDS
exp086	0/10	barraCuda missing — tensor API unreachable
exp087	1/7	Neural API discovered; primals not registered
exp088	2/10	Sub-ms capability.call latency confirmed

Documented — 5 Critical Gaps for Primal Evolution

• P0: barraCuda not in plasmidBin (blocks all math composition)
• P0: Running primals not auto-registered with Neural API
• P1: coralReef HTTP vs raw JSON-RPC on UDS
• P1: barraCuda math/stats/noise methods not on JSON-RPC
• P2: biomeOS continuous executor stub + nucleus graph bundling

Handoff

• Central: LUDOSPRING_V35_PRIMAL_COMPOSITION_GAP_DISCOVERY_HANDOFF_MAR30_2026.md (wateringHole) — full gap analysis with per-team actions

[V34] — 2026-03-29

Added — Full NUCLEUS Nest Atomic Composition

• exp083_neural_api_e2e v2: Evolved from 10 to 13 checks — full Nest Atomic validation:
  • BearDog: Blake3, SHA3-256, ChaCha20-Poly1305 roundtrip, Ed25519 sign
  • Songbird: discovery.peers via Neural API
  • ToadStool: compute.dispatch.capabilities via Neural API (RTX 4060)
  • NestGate: storage.store/storage.retrieve roundtrip via Neural API
  • Squirrel: ai.list_providers + tool.list (25 tools) via Neural API
  • Cross-domain provenance chain: hash(BearDog) → sign(BearDog) → store(NestGate) → verify
  • Capability registry completeness (5 domains verified)
• barracuda discovery refactor: Split discovery.rs (652 lines) into module:
  • discovery/mod.rs: registry, probing, scanning (~280 lines)
  • discovery/capabilities.rs: 6-format parser, semantic aliases, base injection (~230 lines)
• IPC timeouts now env-configurable: LUDOSPRING_RPC_TIMEOUT_SECS, LUDOSPRING_PROBE_TIMEOUT_MS, LUDOSPRING_CONNECT_PROBE_TIMEOUT_MS
• Stale test fix: gpu_fog_of_war_degrades_without_toadstool assertion aligned to evolved message

Validated — Full NUCLEUS (5 Primals)

• BearDog v0.9.0 (crypto): Blake3, SHA3-256, ChaCha20-Poly1305, Ed25519
• Songbird v0.2.1 (discovery): peer listing via Neural API
• ToadStool (compute): GPU dispatch capabilities (Vulkan/CUDA on RTX 4060)
• NestGate v2.1.0 (storage): store/retrieve/list via Unix socket JSON-RPC
• Squirrel v0.1.0 (AI/MCP): 25 tools, AI provider routing (abstract socket bridged)
• biomeOS neural-api: Coordinated Mode, 60+ capabilities across 5 primals
• Cross-domain provenance: hash → sign → store → retrieve verified end-to-end

Test counts

• barracuda lib: 424 (discovery 24 incl. capabilities submodule)
• metalForge/forge: 26
• esotericWebb: 341
• Experiments: 83 (82 structural + exp083 live 13/13)
• Total workspace (excl exp032 pre-existing): 734

[V33] — 2026-03-29

Added — Neural API E2E Pipeline

• exp083_neural_api_e2e: 10-check validation of full biomeOS Neural API pipeline
  • Blake3 + SHA3-256 hashing via capability.call → BearDog
  • ChaCha20-Poly1305 encrypt/decrypt roundtrip through Neural API routing
  • Songbird network primal reachability via Neural API
  • Capability listing verification (crypto, network domains)
  • Sub-200ms latency assertion for routed crypto calls
• barracuda discovery evolution: multi-probe fallback (lifecycle.status → health.check + capabilities.list)
  • Format E: BearDog provided_capabilities (type + methods objects)
  • Format F: Songbird flat capability arrays
  • Semantic alias generation (crypto → crypto.hash, crypto.encrypt, crypto.sign)
  • Auto-injection of system.ping, health.check, health.liveness for responsive primals
  • 4 new unit tests for new formats (discovery tests 15→19)
• esotericWebb Neural API wiring: PrimalBridge.neural_api field, neural_api_call() method, resilient_call() fallback to capability.call when direct domain client absent
  • resolve_neural_api_socket() in niche.rs now consumed by bridge discover()
  • 322 esotericWebb tests pass with zero regressions

Validated — Live Primal E2E

• BearDog v0.9.0 server on Unix socket (real Blake3, SHA3-256, ChaCha20-Poly1305, Ed25519)
• Songbird v0.2.1 server on Unix socket (network discovery, federation)
• biomeOS neural-api with 16 registered capabilities routing to live primals
• ToadStool compute dispatch through Neural API (RTX 4060 detected, DRM mode)
• exp042 9/9 against live BearDog + Songbird (first real-primal run)
• exp083 10/10 full Neural API pipeline validation

Test counts

• barracuda lib: 343 (discovery 19)
• metalForge/forge: 26
• esotericWebb: 322
• Experiments: 83 (82 structural + exp083 live)

[V32.2] — 2026-03-29

Added

• Game shader CPU–GPU parity in exp030 — fog-of-war, tile lighting, pathfind wavefront (checks 24→32)
• GPU_LIGHTING_ABS_TOL tolerance constant
• Substrate::Npu, recommend_substrate_full(), GameWorkload::QuantizedInference
• BandTarget::NpuCompute, BandTarget::NpuToGpuTransfer pipeline bands
• HardwareProfile::mixed_gpu_npu(), npu_to_gpu_transfer_ms()
• NPU/GPU budget fields on BudgetEstimate
• Seven new metalForge tests — NPU routing, mixed pipeline, PCIe bypass, budget (forge 19→26)
• Three new Forge integration checks in exp032 (20→23)
• Eight new checks in exp033 — NUCLEUS mixed pipeline + biomeOS NPU graph (19→27)
• V32.2 handoff: wateringHole/handoffs/LUDOSPRING_V32_2_COMPUTE_EVOLUTION_HANDOFF_MAR29_2026.md

Changed

• Validation matrix: all 82 experiments validated (81 green + 1 live-IPC)

Fixed

• exp003 — RTS HUD bounds + Tufte assertion direction
• exp004 — engagement session params for composite threshold
• exp052 — Arc<str> API drift in sweetGrass braid metadata
• exp062 — mislabel fraud detection (inject_collect_event_for_test now records sample_type)
• Seven trio experiments — #![allow(missing_docs)] for workspace lint inheritance

[V32] — 2026-03-29

Added

• specs/BARRACUDA_REQUIREMENTS.md — consumed/unused modules, shader promotion tiers, upstream evolution requests
• 5 new Python parity tests: fun_keys_zero_scores, fun_keys_max_scores, fbm_3d_lattice_zero, lsystem_turtle_ff_end, lsystem_turtle_square_dist
• CI baseline drift check job in .github/workflows/ci.yml (baselines job with check_drift.py)
• CI workspace-wide cargo check and full workspace cargo clippy
• STRICT_ANALYTICAL_TOL, NUMERICAL_FLOOR, DDA_ADJUSTMENT_EPSILON, SPAN_FLOOR to tolerances::validation
• TRUST_EQUALITY_TOL to tolerances::game
• niche::ECOSYSTEM_SOCKET_DIR constant replacing hardcoded "biomeos" socket path

Changed

• All 77 experiment provenance blocks aligned to current baselines commit (4b683e3e)
• 34 analytical experiments populated with commit hashes and dates (was "N/A")
• exp030 rewritten from legacy ValidationResult to ValidationHarness with GPU-skip via EXIT_SKIPPED (525-line rewrite)
• 27 experiment files migrated from manual eprintln!("FATAL:..."); exit(1) to .or_exit("context") — zero manual FATAL patterns remain
• All test 1e-10 literals replaced with ANALYTICAL_TOL across 6 library modules (23 instances)
• 1e-6 in flow.rs and science.rs handlers replaced with named constants (SPAN_FLOOR, DDA_ADJUSTMENT_EPSILON)
• f64::EPSILON in transition.rs replaced with TRUST_EQUALITY_TOL
• GPU degradation messages made primal-agnostic (no primal name in DEGRADE_REASON)
• MCP tool descriptions reference capabilities not primal names
• deny.toml: unmaintained = "warn" (invalid for cargo-deny 0.19) → "workspace"
• deploy/ludospring.toml: added game.gpu.batch_raycast, capability count 26→27
• Makefile coverage floor: 80%→85% (aligns with CONTEXT.md)
• IPC integration test: hardcoded /tmp/ludospring-register.sock → dynamic tempdir
• push_client.rs: hardcoded "biomeos" → niche::ECOSYSTEM_SOCKET_DIR
• TensorSession documented as future-only with shader promotion roadmap reference
• Deprecated binaries removed: ludospring_dashboard, ludospring_live_session, ludospring_tufte_dashboard (consolidated in UniBin V30)

Removed

• 3 deprecated binary stubs (ludospring_dashboard.rs, ludospring_live_session.rs, ludospring_tufte_dashboard.rs) and their Cargo.toml entries — superseded by ludospring dashboard|live-session|tufte-dashboard since V30

[V31] — 2026-03-28

V31 changelog is in the README.md (inlined for historical reasons). See git log for details.

[V30] — 2026-03-23

Added

• thiserror 2.x for all error types — IpcError and all handler errors now #[derive(thiserror::Error)]
• MCP tools.list and tools.call JSON-RPC methods — 8 science tool descriptors with JSON Schema input specs
• tarpc-ipc optional feature with LudoSpringService typed RPC trait mirroring JSON-RPC surface
• CI pipeline: .github/workflows/ci.yml with fmt, clippy, test, doc, cargo deny gates
• CONTEXT.md per PUBLIC_SURFACE_STANDARD
• deploy/ludospring.toml — primalSpring deploy graph fragment (26 capabilities, optional trio + viz deps)
• LICENSE-ORC and LICENSE-CC-BY-SA — scyBorg triple license files
• Mock IPC test harness IpcTestServer — spawns real IpcServer for integration tests
• Neural handler methods: lifecycle.register, capability.deregister, capability.discover, capability.call
• 273 new tests across IPC handlers, provenance trio, external clients, chaos/fault injection

Changed

• Handler refactor: ipc/handlers.rs (1208 LOC) → ipc/handlers/ directory with 5 submodules (lifecycle, science, delegation, mcp, neural) — all under 300 LOC
• UniBin consolidation: dashboard, live-session, tufte-dashboard merged as ludospring subcommands (7 total); old binaries deprecated
• Coverage: 80.2% → 91.27% line coverage (85% floor enforced, was 80%)
• Tests: 402 → 675 barracuda tests (587 unit + 42 integration + 3 doctests + 19 proptest + extras)
• Clippy strictness: added cast_possible_truncation = "deny", cast_sign_loss = "deny", cast_precision_loss = "warn"
• health.liveness returns {"status": "alive"} per SEMANTIC_METHOD_NAMING_STANDARD v2.1
• All 14 broken rustdoc intra-doc links fixed
• Provenance trio coverage: ~40% → ~84% (param builders, response mappers, serde round-trips)
• External client coverage: squirrel 49% → 84%, toadstool 47% → 90%, nestgate 52% → 81%
• Handler test coverage: 70% → 95%
• Makefile: CARGO_TARGET_DIR + CARGO_HOME overrides for noexec mount environments

[V29] — 2026-03-23

Added

• GpuContext module (game::engine::gpu_context) — shared WgpuDevice lifecycle with TensorSession access, behind #[cfg(feature = "gpu")]
• Shader absorption handoff for barraCuda: LUDOSPRING_V29_PERLIN_DDA_SHADER_ABSORPTION_HANDOFF_MAR23_2026.md
• cargo-llvm-cov gating: make coverage at 80% floor, cargo coverage / cargo coverage-html aliases in .cargo/config.toml
• make coverage-report target for summary-only output
• 7 new experiments: exp076 (Pong), exp077 (Spacewar), exp078 (Tetris), exp079 (Civilization), exp080 (Diablo Loot), exp081 (Procedural Generation), exp082 (Symphony Pipeline)
• PERLIN_SAFE_BOUND and BSP_AREA_CONSERVATION_TOL in tolerances::validation
• Python parity tests expanded from 25 to 42 (fun_keys, Doom Fitts, Hick sweep, flow, engagement, GOMS extended, BSP offset)

Changed

• barraCuda dependency: default-features = false (upstream feature-gating bug fixed — plasma_dispersion and spectral::stats now properly gated behind gpu)
• barcuda_math re-exports expanded from 8 to 22 CPU primitives
• metalForge/forge refactored from monolithic lib.rs (911 LOC) into 4 domain modules: substrate, workload, routing, pipeline (19 tests)
• baselines/python/run_all_baselines.py relaxed Python requirement from 3.12 to 3.10+ (matches existing provenance)
• All Python baseline scripts: provenance headers updated to "CPython 3.10+"
• combined_baselines.json regenerated with content_sha256 field
• Hardcoded test socket paths replaced with temp_dir() + process-unique slugs in ipc/neural_bridge.rs and ipc/discovery.rs
• Coverage target: 80% floor enforced (80.2% actual, bins excluded)
• Experiments provenance: exp061, exp067–exp075 now include BaselineProvenance with specs/ references

[V28] — 2026-03-18

Changed

• Evolved exp042 (Tower Atomic) from hardcoded primal names ("beardog", "songbird") to capability-based discovery via discovery::discover_primals() — discovers by crypto.hash and system.ping capabilities at runtime
• Parameterized coordination::viz_register() in exp054 to accept primal_id argument, removing hardcoded "petaltongue" name
• Evolved 3 dashboard binaries from hardcoded sandbox/ paths to LUDOSPRING_OUTPUT_DIR environment variable with fallback default
• Fixed prop_assert! format string conflict with matches! struct patterns in ipc/envelope.rs proptest
• Fixed IPC integration test isolation — unique socket paths per test via atomic counter (was shared PID-based path causing connection resets)

Fixed

• missing_errors_doc warnings on DispatchOutcome::into_result and extract_rpc_result in ipc/envelope.rs
• IPC integration test evaluate_flow — expected "flow_state" / "Flow", actual serialized field is "state" / "flow"
• IPC integration test capability_list — expected "capabilities" array, actual response uses "total_capabilities" + "domains"

Added

• V28 handoff: toadStool/barraCuda deep evolution handoff with capability-based discovery patterns
• ipc feature dependency on exp042 Cargo.toml for runtime primal discovery

[V27] — 2026-03-18

Changed

• Migrated all 9 #[allow()] instances to #[expect(reason = "...")] across 5 experiment files (exp034, exp050, exp051, exp055, exp061)
• Migrated 4 .expect() calls to OrExit pattern in exp045, exp052, exp053, exp054 (vertex id computation, skill lookup)
• Migrated exp058 (conjugant) from hand-rolled validation to ValidationHarness + BaselineProvenance
• Centralized lint configuration: 16 experiment Cargo.toml files migrated from local [lints.clippy] to [lints] workspace = true
• Added must_use_candidate and return_self_not_must_use to workspace lint overrides
• Refactored exp062_field_sample_provenance/src/sample.rs: extracted monolithic detect_sample_fraud (180 lines, too_many_lines suppression) into 6 focused per-rule functions
• Replaced brittle string-parsing fraud detection (MislabeledSpecimen) with structural collect_sample_types tracking on SampleSystem
• Documented exp030 validation exemption (legacy ValidationResult, pending harness per-section skip support)

Added

• CHANGELOG.md (this file) per SPRING_PRIMAL_PRESENTATION_STANDARD
• NOISE_MEAN_TOL to baselines/python/tolerances.py (was missing from Python mirror)
• SampleSystem::collected_sample_type() accessor for structural fraud detection

Fixed

• V26 handoff claim "zero legacy ValidationResult usage" — now accurately documented as one exemption (exp030)

[V26] — 2026-03-18

Changed

• Migrated 71/75 experiments to ValidationHarness + BaselineProvenance
• Centralized 14 GPU tolerances in tolerances::gpu module
• Tightened missing_errors_doc and missing_panics_doc lints to warn
• Deduplicated perlin_2d.wgsl and dda_raycast.wgsl into barracuda/shaders/game/validated/
• Unified shader audit: 7 upstream absorption candidates, 2 domain-specific retained

Added

• ValidationSink trait (pluggable output: StderrSink, BufferSink)
• check_abs_or_rel method on ValidationHarness
• V26 handoffs: full harness migration + toadStool/barraCuda absorption

[V24] — 2026-03-17

Added

• Leverage guide handoff for ecosystem coordination

[V23] — 2026-03-16

Changed

• Cross-ecosystem deep debt resolution
• toadStool/barraCuda absorption coordination

[V22] — 2026-03-16

Changed

• Ecosystem absorption: aligned with wetSpring V119+ patterns

[V21] — 2026-03-16

Changed

• Deep debt evolution for barraCuda/toadStool integration
• Workspace lint consolidation (expect_used = "deny", unwrap_used = "deny")

[V20] — 2026-03-16

Changed

• Deep primal integration: barraCuda/toadStool wiring

[V19] — 2026-03-16

Changed

• barraCuda/toadStool deep debt resolution

[V18] — 2026-03-15

Added

• Niche self-knowledge: niche.rs with 26 capabilities, socket resolution
• Neural Bridge IPC client
• biomeOS domain registration/deregistration

Changed

• barraCuda/toadStool niche absorption

[V17] — 2026-03-15

Changed

• Deep evolution: barraCuda/toadStool coordination patterns

[V16] — 2026-03-15

Added

• Niche deployment: ludospring_deploy.toml, ludospring-game.yaml
• UniBin architecture: ludospring server, --help, --version

Changed

• barraCuda/toadStool absorption

[V15] — 2026-03-14

Added

• GPU dispatch buildout: exp030 CPU-vs-GPU parity validation
• 11 WGSL shaders for game-domain compute
• GpuOp catalog (FogOfWar, TileLighting, PathfindStep, PerlinTerrain, BatchRaycast)

[V14] — 2026-03-14

Changed

• Deep audit: barraCuda/toadStool integration review

[V13] — 2026-03-13

Added

• Cross-spring provenance: rhizoCrypt, loamSpine, sweetGrass integration
• Provenance trio IPC clients