From 14c45ee4e6abcf227d94a9c3344dba2f92d340c9 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 16:16:39 +0000 Subject: [PATCH 1/3] mask-risc: D-RPF-0 resident CE64 field predicate probe (test-only) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01R2EuNHrariL6B3G3agyASK --- crates/lance-graph-mask-risc/Cargo.toml | 5 + .../tests/resident_ce64_predicate.rs | 353 ++++++++++++++++++ 2 files changed, 358 insertions(+) create mode 100644 crates/lance-graph-mask-risc/tests/resident_ce64_predicate.rs diff --git a/crates/lance-graph-mask-risc/Cargo.toml b/crates/lance-graph-mask-risc/Cargo.toml index 891a37010..2973f6c4a 100644 --- a/crates/lance-graph-mask-risc/Cargo.toml +++ b/crates/lance-graph-mask-risc/Cargo.toml @@ -12,3 +12,8 @@ description = "The one mask-RISC evaluator/fuser above ndarray::simd — a plan ndarray = { path = "../../../ndarray", default-features = false, features = ["std"] } [dev-dependencies] +# D-RPF-0 (`tests/resident_ce64_predicate.rs`): the CE64 accessors are the +# oracle and the contract supplies the tenant offsets. Test-only — the library +# still names neither. +causal-edge = { path = "../causal-edge" } +lance-graph-contract = { path = "../lance-graph-contract" } diff --git a/crates/lance-graph-mask-risc/tests/resident_ce64_predicate.rs b/crates/lance-graph-mask-risc/tests/resident_ce64_predicate.rs new file mode 100644 index 000000000..f4671eeef --- /dev/null +++ b/crates/lance-graph-mask-risc/tests/resident_ce64_predicate.rs @@ -0,0 +1,353 @@ +//! D-RPF-0 (`.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md`): +//! a CE64 field predicate over resident `NodeRow` bytes, with no extracted +//! lane. +//! +//! The four `CausalEdge64` words of `ValueTenant::MaterializedEdges` (32 B, +//! `u64` LE each) are read in place through two 16-byte strided windows: edges +//! 0 and 1 in the first, edges 2 and 3 in the second. Edge `k` is matched in +//! window `k / 2`, half `k % 2`, with `care` zero on the other edge's eight +//! bytes, so no window reaches outside the tenant. +//! +//! Two independent spellings of each field meet here: +//! - the predicate is built from `causal_edge::isa::Field::span()`, the ISA's +//! field table; +//! - the oracle is the CE64 named accessors (`causal_mask`, +//! `inference_mantissa`, `epistemic_raw5`), which never consult that table. +//! +//! Tenant offsets come from `ValueTenant::value_offset()`; no literal offset. + +use causal_edge::isa::Field; +use causal_edge::CausalEdge64; +use lance_graph_contract::canonical_node::{ValueTenant, NODE_ROW_STRIDE, VALUE_SLAB_ROW_OFFSET}; +use lance_graph_mask_risc::exec::{execute_into, Scratch}; +use lance_graph_mask_risc::reference::reference_execute_into; +use lance_graph_mask_risc::{ + words_for, Foreign, LaneRef, MaskOp, Operand, Out, Planes, Pred, Program, StridedRef, Terminal, + Value, +}; + +/// Edges per `MaterializedEdges` tenant. +const EDGES: usize = 4; +/// 3 tiles of 512 rows plus a ragged tail. +const N: usize = 3 * 512 + 37; + +/// SplitMix64: all 64 output bits vary. (A `>> 11` LCG leaves bits 53..63 — +/// the witness and epistemic fields — zero in every word, which made the +/// epistemic tests vacuous until the selectivity guard caught it.) +fn lcg(seed: &mut u64) -> u64 { + *seed = seed.wrapping_add(0x9E37_79B9_7F4A_7C15); + let mut z = *seed; + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) +} + +/// Row offset of the `MaterializedEdges` tenant. +fn edges_row_offset() -> usize { + VALUE_SLAB_ROW_OFFSET + ValueTenant::MaterializedEdges.value_offset() +} + +/// `(window index, byte offset of edge k inside its 16-byte window)`. +fn placement(k: usize) -> (usize, usize) { + (k / 2, 8 * (k % 2)) +} + +/// Row-relative byte offset where window `w` starts. +fn window_offset(w: usize) -> usize { + edges_row_offset() + 16 * w +} + +/// `N` rows of random bytes: every tenant, the key and the edge block are +/// noise, so a predicate that reads anything but its cared bits shows up. +fn fixture(seed: u64) -> Vec { + let mut s = seed; + let mut bytes = vec![0u8; N * NODE_ROW_STRIDE]; + for chunk in bytes.as_chunks_mut::<8>().0 { + *chunk = lcg(&mut s).to_le_bytes(); + } + bytes +} + +fn edge_at(bytes: &[u8], row: usize, k: usize) -> CausalEdge64 { + let o = row * NODE_ROW_STRIDE + edges_row_offset() + 8 * k; + CausalEdge64::from_le_bytes(bytes[o..o + 8].try_into().expect("8 bytes")) +} + +/// The oracle: read the field through the CE64 accessor, not the span table. +fn accessor(field: Field, e: CausalEdge64) -> u64 { + match field { + Field::Pearl => e.causal_mask() as u64, + Field::Inference => (e.inference_mantissa() as u8 & 0x0F) as u64, + Field::Epistemic => e.epistemic_raw5() as u64, + other => panic!("no accessor oracle wired for {other:?}"), + } +} + +/// `(window, pattern, care)` for "edge `k`'s `field` equals `value`", built +/// from `field_care` so a test can hand in a deliberately wrong care. +fn pattern_with_care( + k: usize, + value: u64, + field_care: u64, + shift: u32, +) -> (usize, [u8; 16], [u8; 16]) { + let (w, half) = placement(k); + let mut pattern = [0u8; 16]; + let mut care = [0u8; 16]; + pattern[half..half + 8].copy_from_slice(&((value << shift) & field_care).to_le_bytes()); + care[half..half + 8].copy_from_slice(&field_care.to_le_bytes()); + (w, pattern, care) +} + +fn field_pattern(k: usize, field: Field, value: u64) -> (usize, [u8; 16], [u8; 16]) { + pattern_with_care(k, value, field.mask(), field.span().0) +} + +/// The two windows as strided lanes over the same row bytes. +fn lanes(bytes: &[u8]) -> [LaneRef<'_>; 2] { + let view = |w: usize| { + LaneRef::Strided(StridedRef { + bytes, + first_offset: window_offset(w), + stride: NODE_ROW_STRIDE, + records: N, + }) + }; + [view(0), view(1)] +} + +/// Run `ops` with a `Keep` of the last-written slot, executor and oracle, and +/// return the mask (both paths must agree). +fn run_keep(bytes: &[u8], ops: Vec, result_slot: u16) -> Vec { + let lanes = lanes(bytes); + let planes = Planes { + n_rows: N, + masks: &[], + lanes: &lanes, + }; + let p = Program::new( + ops, + Terminal::Keep { + mask: Operand::Scratch(result_slot), + }, + ); + let mut got = vec![0u64; words_for(N)]; + let mut want = vec![0u64; words_for(N)]; + let mut s = Scratch::for_program(&p, N).expect("addressable"); + let g = execute_into(&p, &planes, &Foreign::NONE, &mut s, Out::Mask(&mut got)); + let r = reference_execute_into(&p, &planes, &Foreign::NONE, Out::Mask(&mut want)); + assert_eq!(g, r, "executor vs oracle result"); + assert!( + matches!(g, Ok(Value::Mask(_))), + "expected a kept mask, got {g:?}" + ); + assert_eq!(got, want, "executor vs oracle mask"); + got +} + +fn single(lane: usize, pattern: [u8; 16], care: [u8; 16]) -> Vec { + vec![MaskOp::Pred { + pred: Pred::MatchFacet16Strided { + lane: lane as u16, + pattern, + care, + }, + under: None, + dst: 0, + }] +} + +fn bit(mask: &[u64], row: usize) -> bool { + mask[row / 64] >> (row % 64) & 1 == 1 +} + +fn expected(bytes: &[u8], pred: impl Fn(CausalEdge64) -> bool, k: usize) -> Vec { + let mut m = vec![0u64; words_for(N)]; + for row in 0..N { + if pred(edge_at(bytes, row, k)) { + m[row / 64] |= 1 << (row % 64); + } + } + m +} + +fn popcount(m: &[u64]) -> usize { + m.iter().map(|w| w.count_ones() as usize).sum() +} + +const FIELDS: [Field; 3] = [Field::Pearl, Field::Inference, Field::Epistemic]; + +/// FAILS IF: a window leaves the tenant, or the tenant is not four `u64`s. +#[test] +fn both_windows_stay_inside_the_materialized_edges_tenant() { + assert_eq!(ValueTenant::MaterializedEdges.byte_len(), 8 * EDGES); + let lo = edges_row_offset(); + let hi = lo + ValueTenant::MaterializedEdges.byte_len(); + for k in 0..EDGES { + let (w, half) = placement(k); + let start = window_offset(w); + assert!( + start >= lo && start + 16 <= hi, + "window {w} leaves the tenant" + ); + assert_eq!( + start + half, + lo + 8 * k, + "edge {k} is not where its half points" + ); + } +} + +/// FAILS IF: the in-place predicate disagrees with the CE64 accessor for any +/// edge, field or value. Anti-vacuity: each field has at least one value that +/// admits a strict, non-empty minority of rows. +#[test] +fn equality_on_each_field_of_each_edge_equals_the_accessor() { + let bytes = fixture(0xD5F0); + for k in 0..EDGES { + for field in FIELDS { + let width = field.span().1; + let mut selective = false; + for value in 0..(1u64 << width) { + let (w, p, c) = field_pattern(k, field, value); + let got = run_keep(&bytes, single(w, p, c), 0); + let want = expected(&bytes, |e| accessor(field, e) == value, k); + assert_eq!(got, want, "edge {k} {field:?} == {value}"); + let n = popcount(&got); + selective |= n > 0 && n * 3 < N; + } + assert!( + selective, + "edge {k} {field:?}: no value is a selective filter" + ); + } + } +} + +/// FAILS IF: a care that names the wrong bits still agrees with the accessor. +/// Shifting the care up by one bit must disagree for some value. +#[test] +fn a_care_shifted_by_one_bit_disagrees_with_the_accessor() { + let bytes = fixture(0xD5F1); + let k = 1; + for field in FIELDS { + let (shift, width) = field.span(); + let mut disagreed = false; + for value in 0..(1u64 << width) { + let (w, p, c) = pattern_with_care(k, value, field.mask() << 1, shift + 1); + let got = run_keep(&bytes, single(w, p, c), 0); + let want = expected(&bytes, |e| accessor(field, e) == value, k); + disagreed |= got != want; + } + assert!( + disagreed, + "{field:?}: a wrong-bit care was indistinguishable" + ); + } +} + +/// FAILS IF: anything outside the cared bits changes the mask. Every byte of +/// every row is rewritten except the cared field of the edge under test. +#[test] +fn bytes_outside_the_cared_field_do_not_move_the_mask() { + let base = fixture(0xD5F2); + let mut noise = fixture(0x7E57); + for k in 0..EDGES { + for field in FIELDS { + let keep = field.mask(); + for row in 0..N { + let o = row * NODE_ROW_STRIDE + edges_row_offset() + 8 * k; + let a = u64::from_le_bytes(base[o..o + 8].try_into().expect("8 bytes")); + let b = u64::from_le_bytes(noise[o..o + 8].try_into().expect("8 bytes")); + noise[o..o + 8].copy_from_slice(&((a & keep) | (b & !keep)).to_le_bytes()); + } + let value = 1u64; + let (w, p, c) = field_pattern(k, field, value); + assert_eq!( + run_keep(&base, single(w, p, c), 0), + run_keep(&noise, single(w, p, c), 0), + "edge {k} {field:?}: bytes outside the field moved the mask" + ); + assert_ne!(base, noise, "the noise fixture must differ from the base"); + } + } +} + +/// `x >= t` on an n-bit field as a disjoint union of at most n + 1 ternary +/// patterns: `x == t`, plus, for every bit of `t` that is 0, the prefix of `t` +/// above it with that bit set and everything below don't-care. +fn ge_patterns(t: u64, width: u32) -> Vec<(u64, u64)> { + let full = (1u64 << width) - 1; + let mut out = vec![(t, full)]; + for i in 0..width { + if t >> i & 1 == 0 { + let above = full & !((1u64 << (i + 1)) - 1); + out.push(((t & above) | (1 << i), above | (1 << i))); + } + } + out +} + +/// FAILS IF: the threshold-as-pattern-union disagrees with `raw5 >= t` on any +/// edge, or uses more than width + 1 patterns. +#[test] +fn epistemic_threshold_as_a_pattern_union_equals_the_accessor() { + let bytes = fixture(0xD5F3); + let field = Field::Epistemic; + let (shift, width) = field.span(); + for k in 0..EDGES { + for t in 0..(1u64 << width) { + let pats = ge_patterns(t, width); + assert!(pats.len() <= width as usize + 1); + let (w, _) = placement(k); + let mut ops = Vec::new(); + for (i, &(v, c)) in pats.iter().enumerate() { + let (_, p, care) = pattern_with_care(k, v, c << shift, shift); + ops.push(MaskOp::Pred { + pred: Pred::MatchFacet16Strided { + lane: w as u16, + pattern: p, + care, + }, + under: None, + dst: (i + 1) as u16, + }); + } + // Fold the pattern masks into slot 0 with Or. + ops.push(MaskOp::Or { + a: Operand::Scratch(1), + b: Operand::Scratch(1), + dst: 0, + }); + for i in 2..=pats.len() { + ops.push(MaskOp::Or { + a: Operand::Scratch(0), + b: Operand::Scratch(i as u16), + dst: 0, + }); + } + let got = run_keep(&bytes, ops, 0); + let want = expected(&bytes, |e| u64::from(e.epistemic_raw5()) >= t, k); + assert_eq!(got, want, "edge {k}: raw5 >= {t}"); + if t == 0 { + assert_eq!(popcount(&got), N, "raw5 >= 0 admits every row"); + } + } + } +} + +/// FAILS IF: the threshold rows are not where `bit` says, i.e. the row/bit +/// convention the helpers above assume is wrong (LSB-first per word). +#[test] +fn the_mask_is_lsb_first_per_word() { + let bytes = fixture(0xD5F4); + let (w, p, c) = field_pattern(0, Field::Pearl, 0b101); + let got = run_keep(&bytes, single(w, p, c), 0); + for row in 0..N { + assert_eq!( + bit(&got, row), + edge_at(&bytes, row, 0).causal_mask() as u64 == 0b101, + "row {row}" + ); + } +} From 165bc9d60ea02eb530f03b8b1a2b203a8bf426b4 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 16:17:45 +0000 Subject: [PATCH 2/3] board: D-RPF-0 measured and test-pinned Entry 2026-10-08-d-rpf-0-resident-ce64-predicate.md; plan checkbox and STATUS_BOARD row updated; entries index regenerated; supersession index regenerated after the board writes (unchanged). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01R2EuNHrariL6B3G3agyASK --- .claude/board/STATUS_BOARD.md | 2 +- ...6-10-08-d-rpf-0-resident-ce64-predicate.md | 40 +++++++++++++++++++ .claude/board/entries/README.md | 3 +- ...-10-08-resident-projection-fold-mask-v1.md | 2 +- 4 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 .claude/board/entries/2026-10-08-d-rpf-0-resident-ce64-predicate.md diff --git a/.claude/board/STATUS_BOARD.md b/.claude/board/STATUS_BOARD.md index 0887a931b..b52a2ec14 100644 --- a/.claude/board/STATUS_BOARD.md +++ b/.claude/board/STATUS_BOARD.md @@ -4,7 +4,7 @@ Plan: `.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md`. Mask = adm | D-id | scope | status | gate / falsifier | |---|---|---|---| -| **D-RPF-0** | Pearl3 / Epi5 / mantissa predicate over `MaterializedEdges` via `MatchFacet16Strided`, threshold as ≤ n+1 patterns | Queued | equals CE64 accessors; wrong-bit care disagrees; unnamed fields silent; both windows stay inside the 32 B tenant | +| **D-RPF-0** | Pearl3 / Epi5 / mantissa predicate over `MaterializedEdges` via `MatchFacet16Strided`, threshold as ≤ n+1 patterns | In PR (test-pinned, `mask-risc/tests/resident_ce64_predicate.rs`) | equals CE64 accessors; wrong-bit care disagrees; unnamed fields silent; both windows stay inside the 32 B tenant | | **D-RPF-1** | Law tables → per-recipe ternary pattern set (≤ 24 × 8), run under an admission plane (class, rail, generation, provenance) | Queued | equals `measure_declared`; dropping one code loses exactly its rows; removing the admission plane admits a v1 row | | **D-RPF-2** | Census of eligibility and read-set classes on a real population | Queued | classes/rows reported; near 1 drops D-RPF-3; no population-sized seen-set | | **D-RPF-3** | Exact read-set dedup per CE64 instruction, key incl. handle context | Queued (after D-RPF-2) | removing cohort from key changes a result; dedup-then-fold equals per-row for Count/Sum/Avg | diff --git a/.claude/board/entries/2026-10-08-d-rpf-0-resident-ce64-predicate.md b/.claude/board/entries/2026-10-08-d-rpf-0-resident-ce64-predicate.md new file mode 100644 index 000000000..f4981e78b --- /dev/null +++ b/.claude/board/entries/2026-10-08-d-rpf-0-resident-ce64-predicate.md @@ -0,0 +1,40 @@ +# 2026-10-08 — D-RPF-0: CE64 field predicate over resident `NodeRow` bytes + +**Status:** MEASURED, TEST-PINNED +(`crates/lance-graph-mask-risc/tests/resident_ce64_predicate.rs`, 6 tests; +`cargo test -p lance-graph-mask-risc --test resident_ce64_predicate`). +Test-only: the library is unchanged; `causal-edge` and `lance-graph-contract` +are dev-dependencies of mask-risc. + +## Claim and result + +A Pearl3, Inference (raw 4-bit nibble) or Epi5 predicate on any of the four +`CausalEdge64` words in `ValueTenant::MaterializedEdges` runs in place through +`Pred::MatchFacet16Strided` over two 16-byte windows (edges 0,1 and 2,3), with +no extracted lane. Executor and oracle agree, and both equal the CE64 named +accessors, row by row, for every value of every field on every edge +(3 tiles + 37 rows). `raw5 >= t` is a union of at most 6 patterns and equals +the accessor for all 32 thresholds on all four edges. + +The predicate is built from `isa::Field::span()`; the oracle reads the CE64 +accessors, which never consult that table. Offsets come from +`ValueTenant::value_offset()`. + +## Falsifiers + +- can fire: a care shifted up by one bit disagrees with the accessor for some + value of every field; +- can stay silent: rewriting every byte of every row except the cared field + leaves the mask unchanged; +- anti-vacuity: each field has a value admitting a strict, non-empty minority + (< 1/3) of rows. It fired on the first run: the fixture generator (`>> 11` + LCG) left bits 53..63 zero in every word, so Epi5 was constant. Replaced by + SplitMix64. + +Disable runs (anchor asserted, each red): window `k` instead of `k / 2` (4), +half always 0 (3), threshold without the equality pattern (1), silent-arm noise +keeping none of the base field (1). + +## OPEN + +None for D-RPF-0. D-RPF-1 adds the admission plane in front of these patterns. diff --git a/.claude/board/entries/README.md b/.claude/board/entries/README.md index d1a137647..820d8bad3 100644 --- a/.claude/board/entries/README.md +++ b/.claude/board/entries/README.md @@ -25,7 +25,7 @@ index row, (3) no duplicate entry id. Checks 1 and 2 are deliberately opposite directions; the stranding this convention prevents shows up in exactly one of them, never both. -271 entries, 2026-08-06 .. 2026-10-08. +272 entries, 2026-08-06 .. 2026-10-08. | date | entry id | finding | file | |---|---|---|---| @@ -36,6 +36,7 @@ exactly one of them, never both. | 2026-10-08 | `moore-nars16-isa-visible-representation` | | [2026-10-08-moore-nars16-isa-visible-representation.md](2026-10-08-moore-nars16-isa-visible-representation.md) | | 2026-10-08 | `D-MOORE-NARS-0` | | [2026-10-08-moore-nars-0-recipe-learning-gomoku.md](2026-10-08-moore-nars-0-recipe-learning-gomoku.md) | | 2026-10-08 | `hhtl-nars-moore-value-tenants` | | [2026-10-08-hhtl-nars-moore-value-tenants.md](2026-10-08-hhtl-nars-moore-value-tenants.md) | +| 2026-10-08 | `D-RPF-0` | | [2026-10-08-d-rpf-0-resident-ce64-predicate.md](2026-10-08-d-rpf-0-resident-ce64-predicate.md) | | 2026-10-08 | `coresearch-ce64-moore-masking-wiring` | | [2026-10-08-coresearch-ce64-moore-masking-wiring.md](2026-10-08-coresearch-ce64-moore-masking-wiring.md) | | 2026-10-08 | `ce64-isa-register-contract` | | [2026-10-08-ce64-isa-register-contract.md](2026-10-08-ce64-isa-register-contract.md) | | 2026-10-07 | `tinker-janus-fold-harvest` | TinkerPop bulk = K (GroupReduce), ONE_BULK = S, GValue pinning = bundle invalidation; JanusGraph slice = OrderedLaneWitness→Range (30–38×); no new V4 op | [2026-10-07-tinker-janus-fold-harvest.md](2026-10-07-tinker-janus-fold-harvest.md) | diff --git a/.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md b/.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md index 422c979b3..51fd4029f 100644 --- a/.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md +++ b/.claude/plans/2026-10-08-resident-projection-fold-mask-v1.md @@ -51,7 +51,7 @@ between them. Where a hop has no primitive, the phase stops and files the gap. ## Checklist -- [ ] **D-RPF-0** — Resident CE64 field predicate in place +- [x] **D-RPF-0** — Resident CE64 field predicate in place (`lance-graph-mask-risc/tests/resident_ce64_predicate.rs`; entry `2026-10-08-d-rpf-0-resident-ce64-predicate.md`) - [ ] **D-RPF-1** — Law-table → pattern-set compiler (recipe eligibility as a mask) - [ ] **D-RPF-2** — Class census: how many distinct eligibility and read-set classes a real population has - [ ] **D-RPF-3** — Read-set dedup for CE64 instructions (hotspot dedup, exact) From b12cd90d6e31c61ce4305bb1d9922c07aa97ab48 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 16:49:29 +0000 Subject: [PATCH 3/3] ci: port #1412 member-tests fix (shader-driver at opt-level 3) member-tests hits its 30-minute limit on main too (runs 37766947128, 37806803926); #1412 is the fix. Identical change, so it no-ops once #1412 merges. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01R2EuNHrariL6B3G3agyASK --- .github/workflows/rust-test.yml | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/.github/workflows/rust-test.yml b/.github/workflows/rust-test.yml index f7a375926..0e742356e 100644 --- a/.github/workflows/rust-test.yml +++ b/.github/workflows/rust-test.yml @@ -436,8 +436,16 @@ jobs: run: cargo test --manifest-path crates/sigma-tier-router/Cargo.toml - name: Run neural-debug tests (previously ungated) # 11 green run: cargo test --manifest-path crates/neural-debug/Cargo.toml + # opt-level 3 for THIS package only, debug stays 0 (manifest). The + # crossword_real_words_probe example tests (D-PUZZLE-0, 2026-10-07) run a + # solver search that takes 810 s at opt-level 0 and pushed this job past + # its 30-minute limit on main (run 37766947128, cut off in `hydrate`). + # Measured locally at opt-level 3: 183 s, 4m08 including the compile. + # `--config` keeps every other crate on the shared opt-level-0 cache. - name: Run shader-driver tests (previously ungated) # 107 + 2 green - run: cargo test --manifest-path crates/cognitive-shader-driver/Cargo.toml + run: >- + cargo test --manifest-path crates/cognitive-shader-driver/Cargo.toml + --config 'profile.dev.package.cognitive-shader-driver.opt-level=3' # The default run above skips these targets: `w2_differential` and # `mailbox_cutover` are `cfg(feature = "mailbox-thoughtspace")`, and the # StreamDto circuit probe needs `with-engine` for `StreamDto`.