feat: integrate Tier 6 distributed monad into build and add tests

[t81dev]

Integrate Tier 6 distributed recursive monad into the build system and add unit tests to verify its core semantics.

---

PR created automatically by Jules for task 18167212247620574083 started by @t81dev

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 6627908f70

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Update expected labels for sequential mesh reflection

These assertions assume each monad reflects against a snapshot of pre-round labels, but MeshReflector::mesh_reflect mutates monads in-place as it iterates, so the second monad reads the first monad’s already-updated label in the same round. As written, this assertion (and the later second-round label assertions) will fail whenever assertions are enabled (for example in local debug/assert builds), causing t81_tier6_test to abort even though the implementation behavior is unchanged.

Useful? React with 👍 / 👎.

[greptile-apps]

Greptile Summary

This PR wires a new Tier 6 distributed-recursive-monad module (distributed_monad.cpp) into the t81_experimental static library and introduces a matching unit test (tier6_test.cpp) registered through the T81_TEST_TARGETS foreach loop in CMake.

The CMake plumbing is correct — the source file is appended to t81_experimental, the test executable is defined, and the target is properly included in the T81_TEST_TARGETS list so add_test fires for it. However, a blocking runtime failure will occur:

• test_mesh_reflection_convergence will fail at the first assertion after round 1. The existing mesh_reflect() implementation mutates monad labels in-place during the iteration loop. When the second monad is processed, its peer lookup returns the already-updated label of the first monad (\"node1+node2\") rather than the original \"node1\", producing \"node2+node1+node2\" instead of the expected \"node2+node1\". The test correctly encodes synchronous (Jacobi) semantics; the implementation in distributed_monad.cpp must be fixed to snapshot labels before the round begins.
• Minor: t81_tracing is an OBJECT library whose objects are already compiled into t81_core. The explicit t81_tracing entry in the test's target_link_libraries is redundant and can be dropped for consistency with t81_tier5_test.

Confidence Score: 2/5

Not safe to merge — the new test will fail at runtime due to an in-place mutation bug in the underlying mesh_reflect() implementation.

The CMake integration is sound, but the primary deliverable — verifying Tier 6 semantics via tests — will immediately abort with a failed assertion in test_mesh_reflection_convergence. The fix requires a label-snapshot change in distributed_monad.cpp, which is not included in this PR.

tests/cpp/tier6_test.cpp and experimental/tiers/cog/tier6/distributed_monad.cpp (not in diff, but needs a label-snapshot fix before the test can pass).

Important Files Changed

Filename	Overview
tests/cpp/tier6_test.cpp	New test file for Tier 6 distributed monad; the synchronous-round expectations in test_mesh_reflection_convergence will fail at runtime due to in-place label mutation in the underlying mesh_reflect() implementation.
CMakeLists.txt	Correctly wires distributed_monad.cpp into t81_experimental and registers t81_tier6_test via the T81_TEST_TARGETS foreach loop; redundant t81_tracing link dependency is a minor style issue.

Sequence Diagram

sequenceDiagram
    participant Test as tier6_test.cpp
    participant MR as MeshReflector
    participant M1 as MonadState m1
    participant M2 as MonadState m2

    Test->>MR: mesh_reflect(monads)
    MR->>MR: entropy_check() → pass
    MR->>M1: composite = m1.label + peer(m2).label
    Note over M1: m1.label updated to "node1+node2"
    MR->>M2: composite = m2.label + peer(m1).label
    Note over M2,MR: ⚠️ peer(m1).label is NOW "node1+node2" (already mutated!)<br/>actual: "node2+node1+node2"<br/>expected: "node2+node1"
    MR-->>Test: ReflectionResult{converged=false, iterations=1}
    Test->>Test: assert(monads[1].label == "node2+node1") ❌ FAILS

Loading

_{Reviews (1): Last reviewed commit: "feat: integrate Tier 6 distributed monad..." | Re-trigger Greptile}

[greptile-apps]

In-place mutation causes synchronous-round test to fail

mesh_reflect() in distributed_monad.cpp mutates each monad's label in-place during the single for (auto& m : monads) loop. This means that when monads[1] (m2) is processed, the peer lookup for m1 returns the already-updated value "node1+node2" rather than the original "node1".

Tracing the first call:

Step	monad	composite built from	result label
1	m1	"node1" + peer m2 ("node2")	"node1+node2" ✓ written to monads[0]
2	m2	"node2" + peer m1 (now "node1+node2")	"node2+node1+node2" ✗

So the assertion on line 43 assert(monads[1].label == "node2+node1") will fail at runtime; the actual value is "node2+node1+node2". All subsequent assertions in this test (lines 50–51) are also invalidated.

The test correctly encodes the intended synchronous (Jacobi) semantics — each monad should see the pre-round labels of its peers. The implementation needs to snapshot all labels before the loop. This is a bug in the existing experimental/tiers/cog/tier6/distributed_monad.cpp that this PR needs to fix before the tests can pass.

[greptile-apps]

Redundant t81_tracing link dependency

t81_tracing is declared as an OBJECT library (line 195) and its objects are already compiled directly into t81_core via target_sources(t81_core PRIVATE $<TARGET_OBJECTS:t81_tracing>) (line 202). Listing it again here is redundant — the symbols are already present through t81_core. Compare with the analogous t81_tier5_test target which links only t81_core t81_experimental.

Suggested change

	target_link_libraries(t81_tier6_test PRIVATE t81_core t81_experimental t81_tracing)
	target_link_libraries(t81_tier6_test PRIVATE t81_core t81_experimental)