contract: unified ClassView render — facet value rows + is_a-walk resolution

.claude/board/AGENT_LOG.md

@@ -1,3 +1,13 @@
+## 2026-07-06 — opus-filigrane-contract — unified ClassView render (facet value projection + is_a walk)
+
+- **Agent:** opus-filigrane-contract (single Opus filigrane worker). **Branch:** `claude/classview-unified-render` (off origin/main; committed, NOT pushed).
+- **Deliverable:** additive, zero-dep extension of `lance-graph-contract::class_view` implementing the operator-confirmed "unified ClassView render" — (a) value projection of the V3 content-blind 4+12 facet + (b) is_a-walk card resolution. **NEW** `ValueRow<'a>` (`{label, predicate, position, value}`, value-projected sibling of `RenderRow`, re-exported from `lib.rs`); **NEW provided methods** `ClassView::facet_rows(class, mask, &[u8;12]) -> Vec<ValueRow>` (position `i` → facet byte `i` per le-contract §3; emit iff mask-present AND `< 12`; positions `>= 12` = value-slab, skipped/never-folded), `ClassView::is_a_parent(class) -> Option<ClassId>` (default `None` = no taxonomy), `ClassView::resolve_render_class(class) -> ClassId` (zero-fallback ladder: bespoke card → nearest ancestor's card → original/generic-dump signal; 16-hop cap + on-stack `[ClassId;16]` visited, cycle+depth safe, zero-dep).
+- **Additive-only:** no existing signature changed, no dependency added; all three methods defaulted so every existing `ClassView` implementor (e.g. ontology `RegistryClassView`) inherits them non-breaking. Presence-only C2 preserved.
+- **Tests:** +7 (extended `FakeClasses` with `extra`/`parents` maps + `with_class`/`with_isa` builders + `is_a_parent`). class_view 21/21; contract lib 822 passing; doctests 9 ok/3 ignored. `cargo fmt -p lance-graph-contract` + `cargo clippy -p lance-graph-contract --all-targets -- -D warnings` clean (exit 0).
+- **Board:** LATEST_STATE.md Current Contract Inventory new entry (this session). No EPIPHANY/STATUS_BOARD forced (no new doctrine surfaced — wires the already-locked E-V3-FACET-4-PLUS-12 §3 register into a projection).
+- **Wave 2 (q2 cockpit) handoff:** call `resolve_render_class(classid)` FIRST, then `facet_rows` on the resolved class for the value column; empty `fields()` on the resolved class = render the raw facet dump. `ValueRow.position` binds to facet byte index; consumers reading a tenant lane still owe the jc-pillar certification (le-contract §3b) before trusting a NEW byte-reading downstream.
+- **Outcome:** SHIPPED on branch (committed, unpushed). Gates green.
+
 ## 2026-07-02 — ractor ownership compile attestation + helper-scope ruling folded
 
 - Operator: "compile with ractor and call it owner so that the compiler believes it" — VERIFIED: `KanbanActor<O: MailboxSoaOwner>` has `type State = O`; the owner MOVES in at `pre_start(..., owner) -> Ok(owner)` (kanban_actor.rs:77,94,100-104). `cargo test -p lance-graph-supervisor --features supervisor` green against the AdaWorldAPI ractor fork (P0-compliant git dep): 15 kanban_actor unit tests + 7 integration tests (one-for-one restart, lifecycle audit, inert-G denies, Send/Sync compile proof) — 0 failures. The compiler and the runtime both attest mailbox-as-owner.

.claude/board/LATEST_STATE.md

@@ -10,6 +10,14 @@
 
 ---
 
+## 2026-07-06 — branch `claude/classview-unified-render` — `contract::class_view` unified ClassView render: facet value rows + is_a-walk resolution
+
+(Per APPEND-ONLY rule: new top-of-inventory entry. Branch work, not yet a PR — records the contract types so a new session does not re-derive them. Operator-ratified this session: any app calls the SAME unified projection — resolve (is_a rail) → carve (FieldMask) → emit — with routes as thin per-app skins.)
+
+### Current Contract Inventory — new entry
+
+- **`class_view::ValueRow<'a>` + `ClassView::facet_rows` + `ClassView::is_a_parent` + `ClassView::resolve_render_class`** (NEW; `ValueRow` re-exported from `lib.rs`; the three methods are DEFAULTED/provided → additive, zero signature changes, zero new deps). Closes the two gaps the q2 cockpit-server OSINT card surfaced in the contract: (a) a **VALUE column** and (b) **is_a-walk fallback** so every classid renders. **`ValueRow` = the value-projected sibling of `RenderRow`** — `{ label, predicate, position: u8, value: u8 }`: one populated field paired with the byte it reads from the node's V3 content-blind 12-byte facet payload. **Position `i` binds to facet byte `i`** per `.claude/v3/soa_layout/le-contract.md` §3 (the 12 B is a *dumb byte register the ClassView projects*; the class picks the reading — `6×(u8:u8)` rails / `4×(u8:u8:u8)` SPO / `3×(u8:u8:u8:u8)` quads all read off the SAME positional bytes). **`facet_rows(class, mask, &[u8;12]) -> Vec<ValueRow>`** iterates fields in class order, emitting a row for each position that is BOTH mask-present (C2 presence) AND `< 12` (facet-backed); **positions `>= 12` are value-slab fields, out of facet scope — skipped, never folded** onto byte `i & 11` (mirrors the `FieldMask::MAX_FIELDS` 64-guard). **`resolve_render_class`** walks `is_a_parent` (default `None` = no taxonomy) while `fields(current).is_empty()`, returning the first ancestor with a non-empty field set, else the ORIGINAL class — the **monotonic zero-fallback ladder: bespoke card → nearest ancestor's card → caller renders the generic facet dump**. Cycle- and depth-safe, zero-dep: a hard 16-hop cap + an on-stack `[ClassId;16]` visited array reject a `subClassOf` cycle (`A is_a B is_a A`) with no `HashSet`; either guard → return original (never loops, never panics). Presence-only C2 preserved throughout: the mask gates which rows exist, never what a byte means. +7 tests (facet position/byte binding + off-bit + `>=12` skip; FULL-mask 3-field; is_a→ancestor; orphan→self; 2-cycle + self-loop terminate; 20-parent depth-cap; render_rows regression canary) — class_view 21/21, contract lib 822 green; `cargo fmt`/`clippy -p lance-graph-contract --all-targets -D warnings` clean. Consumer note (Wave 2, q2 cockpit): route `resolve_render_class(classid)` first, then `facet_rows` on the resolved class for the value column; an empty `fields()` on the resolved class is the signal to render the raw facet dump.
+
 ## 2026-07-04 — branch `claude/happy-hamilton-0azlw4` — `contract::network` — the Tesseract `Network` layer graph sunk onto V3 SoA via ruff→OGAR (byte-parity vs libtesseract)
 
 **NEW** `lance_graph_contract::network`: `NetworkType` (27 layer types, ordinal == on-wire `kTypeNames` discriminant) + `NetworkHeader` (`from_le_bytes` = the base header `Network::CreateFromFile` reads before subclass dispatch: `i8 tag | u32+str type_name | i8 training | i8 needs_backprop | i32 flags | i32 ni | i32 no | i32 num_weights | u32+str name`) + `to_facet()` (the V3 SoA sink) + `NetworkType::classid()` (the `invoke_network` dispatch seed). Executes the operator directive *"6x8:8, 16 B tenant = classid + 12 B, ruff>OGAR sink-in"*: (1) the `ruff_cpp_spo` `harvest_network` example (committed to ruff) walks the 11 network headers via libclang → the `has_function`/`virtually_overrides` SPO manifest (62 classes, 5060 triples) = the `classid → ClassView` method-resolution table, NOT a hand-rolled enum; (2) each node sinks onto `crate::facet::FacetCascade` (16 B = `classid(4) | 6×(8:8)`, read `CascadeShape::G6D2`): tier0=ni, tier1=no, tier2=flags, tiers3-4=num_weights u32, tier5=lifecycle; `facet_classid = compose_classid(network_layer=0x0804, ntype)` canon-high. Byte-parity **GREEN** on real `/tmp/eng.lstm`: Rust parse == libtesseract `Network::CreateFromFile` — `Series ni=36 no=111 num_weights=385807 name=Series` — oracle `spec()` == the model spec string (known-answer self-check, 5.5.0-hdr/5.3.4-lib ABI skew guarded). Example `network_dump.rs`; +5 contract tests; clippy `-D warnings` + fmt clean (scoped `-p lance-graph-contract`). ONE `network_layer`=0x0804 OCR-domain mint added (subclasses in classid custom-low, not 27 slots). Deferred: per-subclass payload + tree recursion, the `invoke_network` keystone, the recognizer COMPUTE leaves. Refs: EPIPHANIES `E-OCR-NETWORK-SINK-1`; plan `tesseract-rs/.claude/plans/network-ruff-ogar-sink-v1.md`. Not yet a PR.