From 2c24e3dc52acc17734a476136af7c29c08496d54 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 21 Jun 2026 16:43:32 +0000 Subject: [PATCH 1/3] test(symbiont): live-cycle NaN census at scale (kanban run-NaN, #580 cognitive half) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The cognitive-half answer to #580's run-NaN hypothesis (the actor-side half was proven green there). Drive the full Rubicon forward arc — including the BF16 Domino sweep burned through CognitiveWork — over a 4096-row SoA, then census the energy column: assert 0% NaN / 0% Inf with non-trivial finite energy. The phase/i4 path is integer-only and the sweep is guarded by the NaN-projection surface, so a live-cycle census reads clean. (Validation build in flight: cargo test --manifest-path crates/symbiont kanban_loop — the full golden-image stack.) Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_01VGXeWN4XfVjteBVcVeuLo4 --- crates/symbiont/src/kanban_loop.rs | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/crates/symbiont/src/kanban_loop.rs b/crates/symbiont/src/kanban_loop.rs index 91bf01dd..f92d1ce3 100644 --- a/crates/symbiont/src/kanban_loop.rs +++ b/crates/symbiont/src/kanban_loop.rs @@ -249,6 +249,31 @@ mod tests { assert!(board.energy().iter().any(|&e| e != 0.0)); } + #[test] + fn run_nan_census_live_cycle_is_zero_at_scale() { + // The cognitive-half run-NaN answer (#580 handoff). Drive the FULL Rubicon + // forward arc — including the BF16 Domino sweep burned through CognitiveWork + // — over a large SoA, then census the energy column. The phase/i4 path is + // integer-only and the sweep is guarded by the NaN-projection surface, so a + // live-cycle census must read 0% NaN / 0% Inf. + let mut board = SymbiontBoard::spawn(4096, 13); + let trail = board.run_to_absorbing(&NextPhaseScheduler); + + assert!(board.phase().is_absorbing(), "must reach the absorbing Commit"); + assert!(!trail.is_empty(), "the arc must have advanced"); + + let energy = board.energy(); + let total = energy.len(); + let nan = energy.iter().filter(|e| e.is_nan()).count(); + let inf = energy.iter().filter(|e| e.is_infinite()).count(); + let nonzero = energy.iter().filter(|&&e| e != 0.0).count(); + + assert_eq!(nan, 0, "live-cycle NaN census: {nan}/{total} NaN over the arc"); + assert_eq!(inf, 0, "live-cycle Inf census: {inf}/{total} Inf over the arc"); + // The sweep must have produced real, finite energy (not a no-op all-zeros). + assert!(nonzero > 0, "the BF16 Domino sweep produced no finite energy"); + } + #[test] fn illegal_skip_is_rejected_no_mutation() { let mut board = SymbiontBoard::spawn(16, 2); From 15bc5b49fe817bbc80ecb617668c671a3b6865e6 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 21 Jun 2026 17:05:19 +0000 Subject: [PATCH 2/3] fix(ogar_codebook): sync CODEBOOK mirror to OGAR class_ids::ALL (health 0x09XX) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit OGAR main advanced its class_ids::ALL 32→39 (added the 0x09XX Health domain: patient/diagnosis/lab_value/medication/treatment/visit/vital_sign) but the contract's wire mirror CODEBOOK was still at 32 (commerce 0x0206). The lance-graph-ogar const parity guard (mirror::CODEBOOK.len() == ogar_vocab::class_ids::ALL.len()) therefore failed the build of everything that links lance-graph-ogar (symbiont, cognitive-stack). Mirror was already prepped for health — ConceptDomain::Health, the 0x09 => Health mapping, and the 0x0901==Health test all exist; only the 7 CODEBOOK entries were missing. Added them verbatim from OGAR (stable ids). CODEBOOK now 39 == class_ids::ALL; contract codebook tests green. Unblocks the symbiont run-NaN census on this branch. Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_01VGXeWN4XfVjteBVcVeuLo4 --- crates/lance-graph-contract/src/ogar_codebook.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/lance-graph-contract/src/ogar_codebook.rs b/crates/lance-graph-contract/src/ogar_codebook.rs index 08a62ea8..b11fbce4 100644 --- a/crates/lance-graph-contract/src/ogar_codebook.rs +++ b/crates/lance-graph-contract/src/ogar_codebook.rs @@ -138,6 +138,14 @@ pub const CODEBOOK: &[(&str, u16)] = &[ ("billing_party", 0x0204), ("payment_record", 0x0205), ("currency_policy", 0x0206), + // ── 0x09XX — Health domain (MedCare; OGIT NTO/Healthcare promotion) ── + ("patient", 0x0901), + ("diagnosis", 0x0902), + ("lab_value", 0x0903), + ("medication", 0x0904), + ("treatment", 0x0905), + ("visit", 0x0906), + ("vital_sign", 0x0907), ]; /// Resolve a **canonical-concept** string to its stable `u16` codebook id via From d75f53b07275b27f67acee9d9fe5778a0281f6d9 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 21 Jun 2026 17:15:24 +0000 Subject: [PATCH 3/3] =?UTF-8?q?board:=20AGENT=5FLOG=20cont.=C2=B3=E2=81=B6?= =?UTF-8?q?=20=E2=80=94=20run-NaN=20cognitive=20half=20proven=20+=20ogar?= =?UTF-8?q?=5Fcodebook=20drift=20fix?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_01VGXeWN4XfVjteBVcVeuLo4 --- .claude/board/AGENT_LOG.md | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index b52bf511..0859876a 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,25 @@ +## 2026-06-21 (cont.³⁶) — run-NaN COGNITIVE half PROVEN green (#580 handoff) + fixed the ogar_codebook drift that blocked it + +**Main thread (Opus), cognitive-compilation session.** Picked up the cognitive +half #580 explicitly handed to this session: instrument `symbiont::kanban_loop:: +run_to_absorbing` for a live-cycle NaN%. Added `run_nan_census_live_cycle_is_zero_at_scale` +— drives the FULL Rubicon arc (incl. the BF16 Domino sweep through CognitiveWork) +over a **4096-row SoA**, censuses the energy column: **0% NaN / 0% Inf, non-trivial +finite energy. PROVEN green** (`cargo test --manifest-path crates/symbiont kanban_loop`, +4/4). The phase/i4 path is integer-only + the sweep is NaN-projection-guarded. + +**Blocker found + fixed en route:** the symbiont build (and cognitive-stack) +failed at the `lance-graph-ogar` const parity guard — OGAR main advanced +`class_ids::ALL` 32→39 (added the 0x09XX **Health** domain) but the contract wire +mirror `ogar_codebook::CODEBOOK` was stale at 32. The mirror was already prepped +for health (`ConceptDomain::Health`, `0x09 => Health`, the `0x0901==Health` test); +only the 7 entries were missing. Synced CODEBOOK→39 (verbatim, stable ids); +contract codebook tests green. This unblocks symbiont + cognitive-stack +workspace-wide (the golden image builds on current OGAR main again). Branch +`claude/symbiont-run-nan-census` (2 commits). Coordination note for the OGAR +session: keep the contract mirror in lockstep when advancing `class_ids::ALL` — +the const guard is the discipline. + ## 2026-06-21 (cont.³⁵) — run-NaN actor-side half PROVEN green — run_to_absorbing drives a full Rubicon cycle, lance-free **Main thread (Opus), self-directed ("what do you choose next").** Chose the highest-value LIGHT move over forcing a disk-heavy lance build: answered the buildable half of the capstone's **run-NaN HYPOTHESIS**. New `lance-graph-supervisor::kanban_actor::run_to_absorbing(actor, max_ticks)` — repeatedly `drive_version_tick` until the owner reports an absorbing column (`Commit`/`Prune`), returning the forward-arc `KanbanMove` trace; `max_ticks` is a defensive non-termination guard (pure forward arc always reaches `Commit`). This is the actor-side, lance-free, symbiont-free analog of `symbiont::kanban_loop::run_to_absorbing`. **+1 test (14 total green):** `run_to_absorbing_drives_a_full_rubicon_cycle_no_nan_no_panic` — a mailbox runs `Planning → CognitiveWork → Evaluation → Commit`, terminates, every move is a legal Rubicon edge, no panic, no spurious `Illegal`, idempotent at rest (second run empty, phase unchanged). The phase/i4 path is integer-only ⇒ **NaN is structurally impossible on this half**, so green IS the actor-side run-NaN answer. clippy + fmt clean; light build, no lance/disk/symbiont gate. **Remaining run-NaN (symbiont/disk-gated):** the cognitive half — instrument `symbiont::kanban_loop::run_to_absorbing` over the energy column for a live-cycle NaN% (other session owns symbiont; coordinate). Plan run-NaN status annotated "actor-side half PROVEN". Rides a PR on jirak. Capstone actor-side substrate now complete: S4 (#576/#577) + S2 (#578) + S3 (#579) + run-to-absorbing (this).