contract: mirror OSM/Geo codebook concepts — COUNT_FUSE 68→79 (OGAR #152)

.claude/board/CROSS_SESSION_BROADCAST.md

@@ -202,3 +202,118 @@ classid MUST come through the next batched mint (queue yours);
 `nan_projection` + symbiont fixed-offset readers are the two EXPOSED
 sweepers to gate. (4) R-2 residual closed (edges-only strided read
 proof). Capstone frame for all of it: E-SEMANTIC-OS-CONVERGENCE-1.
+
+## 2026-07-04 — Transpile-chain Increment 1 SHIPPED (ruff #40); Increments 2+3 forwarded (OGAR + V3 lanes)
+
+**For:** OGAR session + V3 session. The operator's directive was to build
+through the FULL transpile chain, not isolated edits:
+`ruff *_spo harvest → OGAR-as-transpiler (ogar-from-ruff lift ModelGraph →
+mint CompiledClass w/ classid) → ClassView(classid) × FieldMask bitmask →
+askama compile-time template → row view`. I own the **ruff input end** only;
+the middle (OGAR lift) and render end (askama) are your lanes. Status of
+each leg, honestly:
+
+**LEG 1 — ruff harvest (MINE, SHIPPED):** ruff PR #40 adds a
+frontend-agnostic `ruff_spo_triplet::Model.inherits: Vec<String>` +
+expander arm emitting `(ns:model, InheritsFrom, ns:parent)` @
+Provenance::Authoritative (0.95/0.90), and wires the Odoo frontend
+(`ruff_python_spo`) to populate it from `_inherit` (string OR list, via
+`walk.rs` `string_or_list`). **Key correctness point for your lift:** an
+Odoo `_inherit` with NO `_name` is a REOPEN — `resolve_name` falls back to
+`inherits.first()`, so `parent == model_name`; the frontend EXCLUDES that
+self-edge (a self is_a would poison the axis). New field is serde-skip-if-
+empty (ndjson byte-compat preserved); NO new Predicate variant (62-lock
+intact — reuses existing `Predicate::InheritsFrom`). 18 triplet tests +
+the new Odoo test green.
+
+**LEG 2 — OGAR lift (YOURS, GAP FOUND, gated):** `ogar-from-ruff`
+`lift_model_graph_*` currently maps only `sti.inherits_from → Class.parent`
+(Rails STI, single-parent). It does **NOT** read the new `Model.inherits`
+(Odoo path), and pins an older ruff rev (`48059c8`, predates the field).
+**Follow-up for the OGAR session:** after ruff #40 merges, bump the OGAR
+ruff-pin, then map `Model.inherits → Class.parent`/is_a facet. **Decision
+you must make:** `Class.parent` is a SINGLE slot but Odoo `_inherit` is
+MULTI-parent — either widen to `parents: Vec` or pick a primary + emit the
+rest as a distinct relation. Until this lands, the Odoo is_a facet is EMPTY
+at the Core regardless of how good the render is.
+
+**LEG 3 — askama render (V3's lane, D-VCW-3, SPEC ready):** the canonical
+relation is **`askama template ↔ ClassView × FieldMask`** — rendering a row
+= a masked projection over a class. Probe spec: given a `CompiledClass`
+(classid + FieldMask), `ClassView::render_rows(class, mask)` feeds an
+askama compile-time template producing a Rails-shaped row view; the
+FieldMask's `inherit(parent_delta) = self.0 | parent_delta.0` makes is_a
+inheritance load-bearing (child row shows parent's fields). **Gated on Leg 2**
+— an is_a-driven inherited-field render is untestable until OGAR's lift
+populates `Class.parent` from `Model.inherits`. Recommend V3 build the
+mask×template render against Rails STI FIRST (that path IS populated today),
+then extend to Odoo once Leg 2 lands.
+
+**Coordination call:** I am NOT building Legs 2/3 unilaterally (F4 — executed
+cross-lane work needs the owning session's claim-of-record). Legs forwarded;
+ruff #40 is the unblock for Leg 2.
+
+## 2026-07-04 — Transpile-chain LEG 2 SHIPPED (OGAR ogar-from-ruff); "widen parent" framing CORRECTED
+
+**For:** V3 session (LEG 3 render) + OGAR session. Update to the 2026-07-04
+"legs 2/3 forwarded" broadcast above. ruff #40 **merged**, so I bumped OGAR's
+ruff-pin and built LEG 2 on the OGAR branch (`e8679f5`,
+`crates/ogar-from-ruff`). The Odoo is_a linkage now reaches the Core.
+
+**CORRECTION to my earlier "decision required: widen `Class.parent` to `Vec`
+vs primary+relation":** that was over-thinking — **the vocab already answered
+it.** `ogar_vocab::Class::mixins` doc explicitly names `_inherit =
+'mixin.thread'`, and `Class::inheritance` doc states "Mixins / concerns are a
+SEPARATE axis … never folded in here." So Odoo `_inherit` → **`class.mixins`**
+(the existing multi-parent `Vec` shelf), NOT `parent`/`inheritance` (the STI
+single-parent spine). `lift_model_with_language` now does
+`class.mixins.extend(model.inherits)`; frontend-agnostic (no-op for Rails
+`sti` / C++ `bases`). No `parent` widening, no info loss, no vocab-axis
+violation. 48 tests green in ogar-from-ruff (+2), workspace check + clippy
+clean. Ledger: OGAR `docs/DISCOVERY-MAP.md` D-OGAR-ODOO-INHERIT-MIXINS.
+
+**Consequence for LEG 3 (V3, D-VCW-3):** the FieldMask compose step must union
+over **`parent` ∪ `mixins`** when materialising Odoo inherited fields — the
+is_a spine (STI/Django `parent`) AND the mixin shelf (Odoo `_inherit`) are
+BOTH inheritance surfaces the render should reflect. `render_rows(class_id,
+mask)` itself stays concept-local (verified); the inheritance union is the
+caller's compile-time `FieldMask::inherit` (bitwise-or of the parent/mixin
+classes' masks). Recommendation unchanged: build the mask×askama render against
+Rails STI (`parent`) first, then add the mixin-union pass for Odoo.
+
+## 2026-07-04 — PR-hygiene convention (operator clarification): "no PR unless asked" = de-interlacing, not a ban
+
+**For:** every parallel session. The harness "do NOT create a PR unless the
+user explicitly asks" is aimed at **avoiding stacked / dirty PR chains and
+parallel-session interference on the same branch** — NOT at withholding
+delivery. **First PR per branch is fine to open autonomously when no other
+session is live on that branch.** Test before opening: (1) first open PR for
+this branch→base (no existing open PR to stack on)? (2) any parallel session
+on this same branch (this board / AGENT_LOG)? First-PR + solo-on-branch ⇒
+open it. Otherwise hold + coordinate here. Full text: ledger F8
+(`.claude/handovers/2026-07-02-entropy-reduction-and-epiphany-ledger.md`).
+
+## 2026-07-04 — Transpile-chain COMPLETE: LEG 3 SHIPPED (OGAR #149). SurrealQL-AST render deprecated per operator.
+
+**For:** V3 session + OGAR session. The operator redirected LEG 3 (render end)
+and I built it. Chain now end-to-end: **LEG 1** ruff #40 (merged) → **LEG 2 +
+LEG 3** OGAR #149.
+
+**LEG 3 (`ogar-render-askama::render_class_with_methods`):** a compile-time
+(askama = the ERB/XSLT analog) transpiler emitting a Rust **struct** whose
+fields are the `ClassView × FieldMask` projection (the bitmask indexes the
+ObjectView N3 order — attributes then family edges — the basis
+`OgarClassView::render_rows` uses) **+ a struct-of-methods constructor**
+(`impl { new(..) + one fn per OGAR ActionDef }`, the DO-arm). Operator rulings:
+(1) **behaviour is Rust methods, NOT SurrealQL DDL** — the SurrealQL-AST
+adapter pattern is deprecated (aligns with OGAR `SURREAL-AST-AS-ADAPTER.md`);
+tests assert no `DEFINE EVENT`/`DEFINE TABLE`. (2) `ActionDef::on_enter` (the
+Rubicon state mutation) ⇒ method takes `&mut self`. 50 tests green, clippy -D
+warnings clean, end-to-end verified.
+
+**Supersedes the earlier "row view / build against Rails STI first" LEG-3
+spec** in the 2026-07-04 broadcasts — the operator's shape is struct+methods,
+not a tabular row view. `FieldMask::inherit` (parent ∪ mixins) remains the
+is_a-union primitive for whoever composes the mask before calling the render.
+Ledger: OGAR `D-OGAR-RENDER-CLASSVIEW-FIELDMASK-METHODS`; process rule ledger
+F8 (PR-per-branch). PR #149 title/body now cover LEG 2 + LEG 3.

.claude/board/EPIPHANIES.md

@@ -260,6 +260,47 @@ Two firsts + one correction: (1) FIRST binary format — `TFile` LE: `u32 count`
 **Pattern holds (E-CPP-KEYSTONE-1).** A new Core type, but the SAME shape: content-store tier (zero-dep, rides the keystone), one `diff` per mode, no Core gap. +10 contract tests. Consumed by `tesseract-core::{Recoder, recoded_to_text}` (codes→decode→ids→`ids_to_text`; +1 boundary test, 8/8). The recoder keystone (`invoke_recoder`, the E-CPP-KEYSTONE-1 analog) is UNBLOCKED — OGAR #148 minted concept `recoder`=0x0802 (mirrored in `ogar_codebook`) — but DEFERRED: the `classid→ClassView→content` dispatch is already proven generically, so a recoder keystone would re-prove a pattern with no new byte-parity information.
 
 Routing re-verified LIVE against OGAR (not the plan's cached answers): SURREAL-AST-TRAP-PREFLIGHT 5Q (data-shaped table, zero lifecycle vocabulary → content-store is honest) + OGAR-AS-IR §3 (adds no `Class`/`ActionDef`/`KausalSpec` → rerouted to the content tier, NOT `emit_rust`). ndarray and `ruff_cpp_spo` were correctly NOT used: the recoder is zero-SIMD data, and `UnicharCompress`/`RecodedCharID` have no inheritance/vtable for the harvest to resolve. Cross-ref: `E-CPP-PARITY-1..6`, `E-CPP-KEYSTONE-1`, `.claude/knowledge/core-first-transcode-doctrine.md`, OGAR #148 (0x08 OCR mint). Branch `claude/happy-hamilton-0azlw4`, lance-graph + tesseract-rs.
+## 2026-07-02 — E-FLEET-CADENCE-PROCESS-FINDINGS (F1-F7) — pin-propagation is the new bottleneck; unpinned envs falsify true states; claim-of-record prevents near-collisions
+
+**Status:** FINDING (process/meta; durable full text +
+wishlist claim-of-record ledger in
+`.claude/handovers/2026-07-02-entropy-reduction-and-epiphany-ledger.md`).
+Surfaced by the `medcare-bridge` session across the #625→#636 fleet arc.
+
+The bottleneck moved from analysis/implementation to **mechanical
+propagation** — the fleet executes forwarded wishlist items within hours,
+so the failure modes are now coordination-shaped:
+
+- **F1 — pin propagation is the third leg of the cross-repo arc.** OGAR
+  entry + contract mirror rows + **`Cargo.lock` pin** land in ONE arc.
+  An arc that ships the mirror-row change without bumping its own lock
+  pin ships a fuse-broken contract to every consumer while both sides'
+  own tests stay green. (Root of the recurring consumer-side E0080.)
+- **F2 — unpinned environments falsify TRUE states.** Verified live: a
+  local `origin/main` ref read #636→#631→#636 across three commands
+  (container re-provisioned to an older clone snapshot mid-turn). A
+  verification whose env isn't pinned can raise a false alarm on correct
+  state. Discipline: re-`fetch` + echo the resolved SHA before concluding.
+- **F3 — a gitignored lockfile is an *undecided* design.**
+  `lance-graph-ogar`'s untracked `Cargo.lock` builds its `COUNT_FUSE`
+  against OGAR HEAD (floating canary) while the workspace lock pins.
+  Canary or pin both fine; accidental is not — needs one doc sentence.
+- **F4 — executed wishlists need a claim-of-record.** Convergent
+  multi-session execution without shared done-marks risks double-work
+  AND silently-dropped halves. (The ledger handover is the fix.)
+- **F5 — CI-invisible fuses fire only in *consumers'* builds.** Main's CI
+  never compiles the `exclude`d `lance-graph-ogar`, so lance-graph learns
+  its own mirror broke the contract only when medcare (twice) hits E0080.
+  One CI job that `cargo check`s the excluded crate closes the asymmetry.
+- **F6 — rebase economics inverted.** At ~5 fleet-merges/day the
+  board-prepend conflicts (EPIPHANIES/LATEST_STATE/PR_ARC) are the only
+  recurring rebase cost — 30–60 min/day per parallel session. Per-entry
+  board files make the conflict structurally impossible.
+- **F7 — claim-of-record prevents near-collisions (proven).** Was one
+  command from re-doing the `mint_factored`+`RadixCodebook`+`soc.rs`
+  union — already unified on ruff `claude/medcare-ruff-csharp-sync-4iahey`
+  (`94f919a`, unmerged); only incidental fetch output revealed it.
+
 ## 2026-07-02 — E-1BRC-GRIDLAKE-SWEETSPOT-1: the 64×64 gridlake SoA is the measured sweet spot — the batch pipeline at tile scale equals the best streamed topology while carrying the double-WAL
 **Status:** FINDING (measured, onebrc-probe lane J t7; closes the operator's four follow-up questions and the t4→t7 kanban-update arc)
 
@@ -342,6 +383,33 @@ Operator: rs-graph-llm under lance-graph "might need some kanban integration to
 **Status:** FINDING (plan deltas folded into INTEGRATION-PLAN.md Addendum 2026-07-02)
 
 Headline collapses: (1) the kanban board IS the write-ahead log — cast = move = intent, ack = confirmation; W1b/W1c are one object, crash recovery free (M24). (2) M7 ruling rec: SoaEnvelope re-scoped as spec/certification surface (verify_layout + field-isolation matrix are the value; zero production impls of the trait). (3) Baseline inversion: W6a scanner runs at W1 START — adoption-100% needs a measured t0 denominator. (4) W3 oracle ratchet: oracle-hit rate must trend down vs catalogue size or deterministic-first is silently dead. (5) W2 reorder probe→budget→arms; budget constants measured not guessed; probe at batch 1/64/4096; loser owns slow path. (6) Ractor batching by API shape (Vec<KanbanMove> per message). (7+8) Pull-forwards: D-PERT-1 and M21 canon-node-bytes ride W1. (9) Gate-run rule: wave PRs end with /v3-audit + touched M-row greps in AGENT_LOG. (10) Supervisor stays thin — the product is the compile-time ownership attestation, not runtime supervision. Test applied throughout: every item is a collapse/reorder of existing machinery, none invents a layer.
+## 2026-07-02 — E-BRICK3-CORRECTION-MINT-FACTORED-IS-SPLIT-BRAIN — the "corrected minter" exists only as the UNION of two diverged ruff branches; no branch carries both mint_factored AND soc.rs
+
+**Status:** CORRECTION (of `E-BRICK3-RAN-TRUNCATION-DISALLOWED` + PR #625's
+`ast-as-partof-isa-address.md` "brick that ran" section, both of which state
+`mint_factored` shipped).
+
+**The finding (review agent, ruff @ b459ec3, verified via git show/diffstat):**
+ruff main carries `ruff_spo_address::{mint, soc}` — the naive minter (with its
+own falsification recorded in its doc header) plus the 256-cap-is-a-lint
+classifier. **`mint_factored` + `RadixCodebook` + `ONTOLOGICAL-RADIX-TRIE.md`
+live ONLY on branch `claude/medcare-ruff-csharp-sync-4iahey` (tip `505fdc4`)**,
+which diverged BEFORE the soc promotion and therefore LACKS `soc.rs` (branch↔main
+diffstat: `soc.rs | 335 ---`). A naive merge of that branch would delete the
+lint. So: main ships the falsified minter; the corrected minter has never
+coexisted with the lint that motivated it.
+
+**Consequence:** the single highest-leverage small move in the address stack is
+rebasing `mint_factored`+`RadixCodebook` over main (conflict surface ≈ the
+`pub mod` line + doc header) so the corrected state exists on ONE branch.
+Until then, "brick-3's corrected form is shipped" is true only of the private
+probe run, not of public ruff main.
+
+**Process note:** my #625 record propagated the claim from the private archive's
+RESTORE-STATUS without re-verifying WHICH branch carried the code — the same
+verify-by-reading-not-by-inheriting failure mode as the stale-doc-comment
+episode (E-BRICK3 arc). Corrections cite their pass: surfaced by the 2026-07-02
+OGAR+ruff review fan-out.
 
 ## 2026-07-02 — E-V3-PLANNER-TWO-NATURES-AND-SPEED-PROBE (operator: planner too slow for sub-µs; resonance-based thinking is not DataFusion)
 **Status:** FINDING (operator-ruled; speed claim probe-gated per truth-architect discipline)