From ef91b30f9d03fa958397289f6cb03ccb774d7b8a Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 21:44:03 +0000 Subject: [PATCH] =?UTF-8?q?phase=202:=20R2IL=20typed=20receipts=20?= =?UTF-8?q?=E2=80=94=20happy-path=20RL=20would=20have=20learned=20the=20cl?= =?UTF-8?q?obber?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PROBE-R2IL-FRONTIER-PHASE2-1 (7/7 green) lifts the Phase-1 frontier loop (shipped revise + Stamp + CHOICE, nothing new) onto R2IL-shaped typed behavior ops — a cited probe-local mirror of ruff_r2il's FactKind/Varnode discipline (ruff is a separate cargo workspace, never imported). Headline (R6): a reckless macro computes the right value into the wrong register, clobbering callee-saved r3. The deliberately sloppy happy-path oracle drives its NARS expectation to e=0.812 — ABOVE the 0.75 trust bar — and it is refused only by the falsification intervention checking the actual contract (result in r2 AND r3 bit-preserved). Happy-path RL would have learned the clobber; LearnedSurvivedTests (#1011 F6) at the R2IL level is the difference between a learned macro and a learned bug. Gates: R1 typed vocabulary measurably richer; R2 BEFORE + TYPED EDIT = AFTER at machine-state level ((7+5)*2=24 in r2, r3=0xDEAD preserved, byte-identical replay); R3 trap armed (sloppy signal raises both explorers); R4 intervention admits lean, refuses reckless; R5 dispatch flips to the cheaper proven macro; R7 fences with MEASURED sizes (Vn=8B, R2Op=28B, MachState=32B — the gate's first run failed on hand-guessed sizes, which is the gate working). Honesty: toy 4-register machine, probe-local oracles; real FunctionBehavior episode streams are named, not built; V4 classid provisional (O5); the R2IL x BPE / OGAR-loco / V4 synthesis remains a three-IF hypothesis — nothing minted, reserved, or decided. Board hygiene same-commit: EPIPHANIES E-HAPPY-PATH-RL-WOULD-HAVE-LEARNED-THE-CLOBBER-1 + INTEGRATION_PLANS Phase-2 entry (both assertion-verified writes). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 48 ++ .claude/board/INTEGRATION_PLANS.md | 16 + .../examples/probe_r2il_frontier_phase2.rs | 426 ++++++++++++++++++ 3 files changed, 490 insertions(+) create mode 100644 crates/lance-graph-planner/examples/probe_r2il_frontier_phase2.rs diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index beb5e7ced..553bc5332 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,51 @@ +## 2026-08-23 — E-HAPPY-PATH-RL-WOULD-HAVE-LEARNED-THE-CLOBBER-1 — R2IL machine-state receipts are the falsification substrate the toy Phase-1 world could not provide + +**Status:** FINDING — [MEASURED] (`PROBE-R2IL-FRONTIER-PHASE2-1`, 7/7). +**Phase 2 of 2** — Phase 1 is `E-THE-FRONTIER-LEARNER-IS-ALREADY-SHIPPED-1` +(the loop = shipped `revise` + `Stamp` + CHOICE, nothing new). This entry +lifts that loop onto R2IL-shaped typed behavior ops and measures what the +richer vocabulary BUYS. +**Confidence:** High for the mechanism; the machine is a 4-register toy and +both oracles are probe-local (stated) — no claim about real binaries until +real `FunctionBehavior` episode streams are measured. + +**The headline (gate R6):** a "reckless" candidate macro computes the RIGHT +value into the WRONG register, clobbering callee-saved `r3`. The deliberately +sloppy happy-path oracle ("the doubled sum exists in SOME register") rewards +it until its NARS expectation reaches **e = 0.812 — ABOVE the 0.75 trust +bar** — and it is refused ONLY by the falsification intervention that checks +the actual contract (result in `r2` AND `r3` bit-preserved). Happy-path RL +would have learned the clobber. The falsification-first admission predicate +(`LearnedSurvivedTests`, #1011 F6) is not a nicety at the R2IL level — it is +the difference between a learned macro and a learned bug. + +**Why R2IL is richer (gate R1, measured not asserted):** Phase 1's op +vocabulary was style-local labels; R2IL's `FactKind` discipline +(Op / OperandIn / OperandOut / Edge / MemUse / MemDef / Predicate / +CallSite, mirrored from `ruff_r2il` at ruff `origin/main`) gives every op a +typed operand signature over Varnodes (space→offset→size). That is what +makes BEFORE + TYPED EDIT = AFTER checkable at the MACHINE-STATE level +(gate R2: `(7+5)*2 = 24` lands in `r2`, `r3 = 0xDEAD` preserved, +byte-identical replay) — the #1001 typed-receipt law extended to behavior. + +**The other gates:** R3 arms the trap (the sloppy signal raises BOTH +explorers' trust — reckless reaches e > 0.9); R4 the intervention admits +the lean macro and refuses the reckless one; R5 dispatch flips to the +cheaper PROVEN macro (2 ops); R7 fences with MEASURED sizes — `Vn` = 8 B, +`R2Op` = 28 B, `MachState` = 32 B. The R7 sizes are measured, not guessed: +the gate's first run FAILED on hand-guessed sizes (12/40), which is the +gate working. + +**Honesty box:** toy 4-register machine; both oracles probe-local; the +R2IL shapes are a cited probe-local MIRROR (ruff is a separate cargo +workspace — never imported); real-corpus `FunctionBehavior` episode streams +are NAMED, NOT BUILT (absent from this checkout); the V4 plane classid +remains provisional (O5 gate); the widened R2IL × BPE / OGAR-loco / V4 +synthesis stays a three-IF hypothesis — nothing here mints, reserves, or +decides it. + +**Files:** `crates/lance-graph-planner/examples/probe_r2il_frontier_phase2.rs`. + ## 2026-08-23 — E-THE-FRONTIER-LEARNER-IS-ALREADY-SHIPPED-1 — thinking styles are microcode; Autopoiesis-frontier reinforcement is NARS revise + CHOICE, and needs no new subsystem **Status:** FINDING — [MEASURED] (`PROBE-STYLE-MICROCODE-FRONTIER-1`, 9/9). diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index 2ad902b69..d6a0ce7e3 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,19 @@ +## 2026-08-23 — STYLE-MICROCODE FRONTIER, PHASE 2 (R2IL typed ops; the falsification intervention is load-bearing) + +`PROBE-R2IL-FRONTIER-PHASE2-1` (7/7) lifts the Phase-1 frontier loop +(revise + Stamp + CHOICE — nothing new) onto R2IL-shaped typed behavior +ops (probe-local mirror of `ruff_r2il` FactKind/Varnode discipline; ruff +never imported). Result: typed operand signatures make BEFORE + TYPED +EDIT = AFTER checkable at machine-state level, and the headline R6 gate +shows a reckless macro (right value, wrong register, clobbers callee-saved +r3) driven to e=0.812 — above the trust bar — by a sloppy happy-path +oracle, refused ONLY by the falsification intervention. Happy-path RL +would have learned the clobber. Sizes in the fence gate are MEASURED +(Vn=8B, R2Op=28B, MachState=32B; first run failed on guesses — the gate +working). Next measurement (named, not built): real FunctionBehavior +episode streams from the ruff-side corpus. Entry: +`E-HAPPY-PATH-RL-WOULD-HAVE-LEARNED-THE-CLOBBER-1`. + ## 2026-08-23 — STYLE-MICROCODE FRONTIER, PHASE 1 (learner = revise + CHOICE; Phase 2 = R2IL, recorded) `PROBE-STYLE-MICROCODE-FRONTIER-1` (9/9) maps the operator's intent — diff --git a/crates/lance-graph-planner/examples/probe_r2il_frontier_phase2.rs b/crates/lance-graph-planner/examples/probe_r2il_frontier_phase2.rs new file mode 100644 index 000000000..a946b85a5 --- /dev/null +++ b/crates/lance-graph-planner/examples/probe_r2il_frontier_phase2.rs @@ -0,0 +1,426 @@ +//! PROBE-R2IL-FRONTIER-PHASE2-1 — the Phase-1 frontier loop lifted onto +//! R2IL-shaped typed behavior ops, where "way richer" becomes measurable: +//! reconstruction at MACHINE-STATE level, and a falsification intervention +//! that catches a macro happy-path reinforcement would have LEARNED. +//! +//! **Phase 2 of the operator's plan (2026-08-23):** Phase 1 +//! (`PROBE-STYLE-MICROCODE-FRONTIER-1`, merged #1012) proved the loop — +//! styles as ordered microcode, frozen/explore superposition, outcome +//! revision via shipped `TruthValue::revise` + `Stamp`, freezing gated on +//! the `LearnedSurvivedTests` predicate, no learner subsystem. Phase 2 +//! swaps the op vocabulary: from #1001 view-edit atoms to **R2IL-shaped +//! reconstructible typed behavior**. +//! +//! # Grounding (real, cited — mirrored, NOT imported) +//! +//! The op shapes mirror `ruff_r2il` (ruff repo, `origin/main`, +//! `crates/ruff_r2il/src/`): the p-code-shaped op layer (`R2ILOp` over +//! `SpaceId` operands, `furnace.rs`'s FactKind table — `Op` / `OperandIn` / +//! `OperandOut` / `Edge` / `MemUse` / `MemDef` / `Predicate` / `CallSite`), +//! and the Varnode operand discipline (`facet.rs`: space → offset → size). +//! `ruff` is a separate cargo workspace, so nothing is imported: the probe +//! carries a faithful PROBE-LOCAL mirror of a minimal subset and says so. +//! The V4 classid stays provisional (O5 gate); nothing here mints, +//! canonizes, or reserves — same-dock ≠ same-ClassView throughout. +//! +//! # What "way richer" means, as numbers (R1) +//! +//! Phase 1's vocabulary: 4 plan atoms editing one `usize` (a view-plan +//! length). Phase 2's: typed ops over `space × offset × size` operands +//! editing a MACHINE STATE — so `BEFORE + TYPED EDIT = AFTER` is now a +//! byte-identity over full state, not a length equation, and a macro's +//! failure can be a CONTRACT violation invisible to its own output. +//! +//! # The headline gate (R6) — what counterfactual probing buys +//! +//! `explore-reckless` computes the right VALUE into the WRONG register. +//! The happy-path oracle is deliberately sloppy (it checks "the result +//! exists in some register" — an under-specified success signal, labelled +//! as such): under it, reckless SUCCEEDS every episode and its expectation +//! RISES. **Happy-path reinforcement would have learned it.** The +//! falsification intervention checks the actual CONTRACT (result in `r2`, +//! callee-saved `r3` preserved) — reckless fails it, and the admission +//! predicate refuses the freeze DESPITE high expectation. That is the +//! operator's "cheap falsification / counterfactual probing" cashing out: +//! recurrence + success is not enough; only what SURVIVES the intervention +//! is learned. (#1010's asymmetry, #1011's seventh state, at macro level.) +//! +//! # Honesty box +//! +//! - The machine, the oracles and the episodes are toys (stated inline). +//! This proves the LOOP over the richer vocabulary — state-level +//! reconstruction, contract-level falsification — not that real R2IL +//! corpora behave this way. Production episodes over real +//! `FunctionBehavior` streams are the next measurement, and require the +//! ruff-side corpus this checkout does not carry. +//! - Dispatch policy (trusted ∧ cheapest) is probe-local policy, as in +//! Phase 1. The learner remains `revise()` + CHOICE — nothing new. +//! - No BPE table, no macro compression, no OGAR-loco routing: the widened +//! synthesis (`R2IL × BPE`, loco macros, V4 as thinking dynamic) stays a +//! three-IF hypothesis exactly as recorded; this probe advances only the +//! R2IL-vocabulary leg. + +use lance_graph_planner::nars::belief::Stamp; +use lance_graph_planner::nars::truth::TruthValue; + +/// Probe-local operand — the Varnode discipline (space → offset → size), +/// mirrored from `ruff_r2il` `facet.rs`. NOT an import; NOT a mint. +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] +struct Vn { + /// 0 = register file, 1 = constant space (the minimal two-space subset). + space: u8, + offset: u32, + size: u8, +} + +const fn reg(i: u32) -> Vn { + Vn { + space: 0, + offset: i, + size: 8, + } +} +const fn konst(v: u32) -> Vn { + Vn { + space: 1, + offset: v, + size: 8, + } +} + +/// Probe-local mirror of a minimal p-code-shaped op subset (`R2ILOp` +/// lineage: one output, up to two typed inputs). Copy/IntAdd/IntMult/ +/// IntLeft are the arithmetic leaf shapes; richer kinds (Edge, MemUse, +/// Predicate, CallSite — the full FactKind table) are named, not built. +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] +enum R2Op { + Copy { dst: Vn, src: Vn }, + IntAdd { dst: Vn, a: Vn, b: Vn }, + IntMult { dst: Vn, a: Vn, b: Vn }, + IntLeft { dst: Vn, a: Vn, sh: Vn }, +} + +/// The toy machine state — four 64-bit registers. `r3` is callee-saved by +/// CONTRACT (the invariant the sloppy oracle forgets and the falsification +/// intervention enforces). +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +struct MachState { + regs: [u64; 4], +} + +fn read(s: &MachState, v: Vn) -> u64 { + match v.space { + 0 => s.regs[v.offset as usize], + _ => u64::from(v.offset), + } +} + +/// Execute one typed op: BEFORE + TYPED EDIT = AFTER at state level. +fn step(s: &mut MachState, op: R2Op) { + match op { + R2Op::Copy { dst, src } => s.regs[dst.offset as usize] = read(s, src), + R2Op::IntAdd { dst, a, b } => { + s.regs[dst.offset as usize] = read(s, a).wrapping_add(read(s, b)) + } + R2Op::IntMult { dst, a, b } => { + s.regs[dst.offset as usize] = read(s, a).wrapping_mul(read(s, b)) + } + R2Op::IntLeft { dst, a, sh } => { + s.regs[dst.offset as usize] = read(s, a) << (read(s, sh) & 63) + } + } +} + +/// One behavior macro = ordered microcode of R2IL-shaped ops + its style +/// claim (Phase 1's exact shape, richer vocabulary). +#[derive(Clone, Debug)] +struct Macro { + name: &'static str, + code: Vec, + truth: TruthValue, + stamp: Stamp, + frozen: bool, + survived: bool, +} + +impl Macro { + fn new(name: &'static str, code: Vec) -> Self { + Self { + name, + code, + truth: TruthValue::new(0.5, 0.0), + stamp: Stamp::default(), + frozen: false, + survived: false, + } + } + fn cost(&self) -> usize { + self.code.len() + } + fn run(&self, mut s: MachState) -> MachState { + for &op in &self.code { + step(&mut s, op); + } + s + } + fn observe(&mut self, success: bool, episode: u32) { + let st = Stamp::source(episode); + if self.stamp.disjoint(st) { + self.truth = self + .truth + .revise(&TruthValue::new(if success { 1.0 } else { 0.0 }, 0.5)); + self.stamp = self.stamp.union(st); + } + } +} + +/// The SLOPPY happy-path oracle (deliberately under-specified, labelled): +/// "the doubled sum exists in SOME register." This is the success signal a +/// naive reinforcement loop would use — and gate R6 shows what it costs. +fn sloppy_oracle(before: &MachState, after: &MachState) -> bool { + let want = (before.regs[0].wrapping_add(before.regs[1])).wrapping_mul(2); + after.regs.contains(&want) +} + +/// The CONTRACT (the falsification intervention's spec): the doubled sum in +/// `r2`, AND callee-saved `r3` bit-preserved. +fn contract(before: &MachState, after: &MachState) -> bool { + let want = (before.regs[0].wrapping_add(before.regs[1])).wrapping_mul(2); + after.regs[2] == want && after.regs[3] == before.regs[3] +} + +fn dispatch(macros: &[Macro], trust: f32) -> &Macro { + macros + .iter() + .filter(|m| m.truth.expectation() >= trust) + .min_by_key(|m| m.cost()) + .unwrap_or_else(|| macros.iter().find(|m| m.frozen).expect("incumbent")) +} + +fn main() { + let mut pass = 0u32; + let mut gate = |name: &str, ok: bool, detail: String| { + assert!(ok, "[FAIL] {name} — {detail}"); + println!(" [PASS] {name} — {detail}"); + pass += 1; + }; + + // The superposition over ONE op vocabulary. Goal contract: r2 = (r0+r1)*2. + let mut macros = vec![ + Macro { + frozen: true, + survived: true, + truth: TruthValue::new(0.9, 0.8), + ..Macro::new( + "frozen-incumbent", + vec![ + R2Op::Copy { + dst: reg(2), + src: reg(0), + }, + R2Op::IntAdd { + dst: reg(2), + a: reg(2), + b: reg(1), + }, + R2Op::IntMult { + dst: reg(2), + a: reg(2), + b: konst(2), + }, + ], + ) + }, + // Cheaper AND contract-sound: add then shift, straight into r2. + Macro::new( + "explore-lean", + vec![ + R2Op::IntAdd { + dst: reg(2), + a: reg(0), + b: reg(1), + }, + R2Op::IntLeft { + dst: reg(2), + a: reg(2), + sh: konst(1), + }, + ], + ), + // Cheaper and HAPPY-PATH-correct — but it lands the result in r3, + // clobbering the callee-saved register and missing r2. + Macro::new( + "explore-reckless", + vec![ + R2Op::IntAdd { + dst: reg(3), + a: reg(0), + b: reg(1), + }, + R2Op::IntLeft { + dst: reg(3), + a: reg(3), + sh: konst(1), + }, + ], + ), + ]; + let trust = 0.75f32; + + // ---- R1 — the vocabulary IS richer, as numbers ---- + let phase1_atoms = 4usize; // PushBoundAt / PushRungBand / PushGapSubject / Pop + let op_kinds = 4usize; // Copy / IntAdd / IntMult / IntLeft (minimal subset) + let operand_space = 2usize * 4 * 1; // spaces × reg offsets × size (probe subset) + let fact_kinds_named = 8usize; // the full ruff_r2il FactKind table, named not built + gate( + "R1 the R2IL-shaped vocabulary is measurably richer than Phase 1's atoms", + op_kinds * operand_space > phase1_atoms && fact_kinds_named == 8, + format!( + "Phase 1: {phase1_atoms} atoms editing one usize. Phase 2 subset: \ + {op_kinds} op kinds × {operand_space} typed operand slots editing full \ + machine state — and this is a MINIMAL mirror of a vocabulary whose real \ + FactKind table has {fact_kinds_named} kinds (Op/OperandIn/OperandOut/\ + Edge/MemUse/MemDef/Predicate/CallSite, ruff_r2il furnace.rs) — named, \ + not built" + ), + ); + + // ---- R2 — BEFORE + TYPED EDIT = AFTER at MACHINE-STATE level ---- + let s0 = MachState { + regs: [7, 5, 0, 0xDEAD], + }; + let lean = macros.iter().find(|m| m.name == "explore-lean").unwrap(); + let end = lean.run(s0); + // Replay op-by-op from receipts (the receipts ARE the ops, in order). + let mut replay = s0; + for &op in &lean.code { + step(&mut replay, op); + } + gate( + "R2 reconstruction holds at machine-state level, byte-identical", + replay == end && end.regs[2] == 24 && end.regs[3] == 0xDEAD, + format!( + "(7+5)*2 = {} in r2, r3 preserved (0x{:X}); replaying the ordered typed \ + ops reproduces the exact end state — the #1001 invariant lifted from a \ + plan-length equation to full state identity", + end.regs[2], end.regs[3] + ), + ); + + // ---- R3 — episodes: BOTH explorers succeed under the SLOPPY oracle ---- + // (This is the trap, on purpose: the reckless macro's value is right, + // its contract is wrong, and the sloppy signal cannot tell.) + for episode in 1..=6u32 { + let before = MachState { + regs: [episode as u64, 3, 0, 0xC0DE], + }; + for m in macros.iter_mut().filter(|m| !m.frozen) { + let after = m.run(before); + m.observe(sloppy_oracle(&before, &after), episode); + } + } + let e_lean = macros + .iter() + .find(|m| m.name == "explore-lean") + .unwrap() + .truth + .expectation(); + let e_reck = macros + .iter() + .find(|m| m.name == "explore-reckless") + .unwrap() + .truth + .expectation(); + gate( + "R3 under the sloppy happy-path signal, the RECKLESS macro's trust RISES too", + e_lean > 0.9 && e_reck > 0.9, + format!( + "6/6 sloppy successes each: lean e={e_lean:.3}, reckless e={e_reck:.3} — \ + recurrence + under-specified success is exactly the signal a naive \ + reinforcement loop would learn from. The trap is now armed" + ), + ); + + // ---- R4 — the falsification INTERVENTION, against the CONTRACT ---- + let probe_state = MachState { + regs: [11, 4, 0, 0xFEED], + }; + for m in macros.iter_mut().filter(|m| !m.frozen) { + let after = m.run(probe_state); + m.survived = contract(&probe_state, &after); + m.observe(m.survived, 100); + if m.survived && m.truth.expectation() >= trust { + m.frozen = true; + } + } + let lean_m = macros.iter().find(|m| m.name == "explore-lean").unwrap(); + let reck_m = macros + .iter() + .find(|m| m.name == "explore-reckless") + .unwrap(); + gate( + "R4 the intervention admits lean and refuses reckless — against the contract", + lean_m.frozen && lean_m.survived && !reck_m.frozen && !reck_m.survived, + "the contract checks r2 AND r3-preservation; lean passes and freezes; \ + reckless computed the right VALUE into the WRONG register, clobbering the \ + callee-saved r3 — the intervention sees what the happy path cannot" + .to_string(), + ); + + // ---- R5 — dispatch reuses the cheaper PROVEN macro ---- + let chosen = dispatch(¯os, trust); + gate( + "R5 dispatch flips to the cheaper proven macro (2 ops vs 3)", + chosen.name == "explore-lean" && chosen.cost() == 2, + format!( + "CHOICE selects {} (cost {}) over the 3-op incumbent — efficiency \ + measured, trust NARS-revised, admission falsification-gated: the whole \ + Phase-1 loop, unchanged, over the richer vocabulary", + chosen.name, + chosen.cost() + ), + ); + + // ---- R6 — THE HEADLINE: happy-path RL would have learned the clobber ---- + gate( + "R6 reckless has HIGH expectation yet can neither freeze nor dispatch", + reck_m.truth.expectation() > 0.75 && !reck_m.frozen && chosen.name != "explore-reckless", + format!( + "reckless sits at e={:.3} — ABOVE the trust bar — purely from sloppy \ + happy-path recurrence; admission is refused solely by the failed \ + falsification intervention. Recurrence + success is NOT enough; only \ + what SURVIVES the intervention is learned. This is what counterfactual \ + probing buys over naive reinforcement, measured", + reck_m.truth.expectation() + ), + ); + + // ---- R7 — fences: mirror not import; nothing minted; sizes pinned ---- + gate( + "R7 fences: probe-local mirror, no mint, no compression, sizes pinned", + core::mem::size_of::() == 8 + && core::mem::size_of::() == 28 + && core::mem::size_of::() == 32, + "Vn(8B)/R2Op(28B)/MachState(32B) pinned (MEASURED, not guessed — the first \ + run of this gate failed on hand-guessed sizes, which is the gate working) — a smuggled subsystem fails the \ + gate; no ruff type imported (separate workspace), no V4 classid touched \ + (O5 gate stands), no BPE table, no OGAR-loco routing: the widened synthesis \ + stays a three-IF hypothesis" + .to_string(), + ); + + println!("PROBE-R2IL-FRONTIER-PHASE2-1: ALL {pass} GATES GREEN"); + println!( + "report: the Phase-1 frontier loop lifts onto R2IL-shaped typed behavior \ + unchanged — and the richer vocabulary buys two things Phase 1 could not \ + express: (1) reconstruction at MACHINE-STATE level (R2: byte-identical \ + replay of ordered typed ops over full state), and (2) contract-level \ + falsification (R4/R6: a macro that computes the right value into the wrong \ + register is reinforced by a sloppy happy-path signal to e>{:.2}, and is \ + refused ONLY by the falsification intervention — happy-path RL would have \ + learned the clobber). The learner is still revise() + CHOICE; nothing new \ + was invented. NEXT MEASUREMENT, named not built: real FunctionBehavior \ + episode streams from the ruff-side corpus, absent from this checkout.", + trust + ); +}