diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index 0289b415..fae92b00 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,7 @@ +## 2026-06-25 (cont.⁴³) — SoA value-tenant migration Phase-1 HARVEST: the filled §4 inventory (executing session) + +**Main thread (Opus), operator-directed (executing session for `soa-value-tenant-migration-v1.md`).** Ran the brief's Phase-1 harvest under read-not-grep. Read FULLY: `canonical_node.rs` 1–1091 (the whole `ValueTenant`/`VALUE_TENANTS`/`ValueSchema`/`ReadMode` surface — the `const _` assert `Full.field_mask().count()==VALUE_TENANTS.len()` PROVES exactly **10 tenants**, none hiding in the test module), `class_view.rs` (full), `cascade_key.rs` (full). Two parallel mapping subagents: in-workspace+ndarray producer/consumer map (Opus general-purpose, confirmed-by-read) + cross-repo consumer locator (Explore). **Deliverable:** NEW `.claude/plans/soa-value-tenant-migration-v1-harvest.md` (filled §4 inventory, 10 rows). **Two findings:** (A) **two disjoint SoA worlds** `[G]` — the canonical `NodeRow.value` 480 B slab vs a parallel `MailboxSoA` of separate `[T;N]` columns; only `EntityType≡class_id` shared; **6/10 slab tenants have NO live producer** (only Energy/EntityType/Kanban/Fingerprint are live slab writers) → near-term migration = RECONCILING the two worlds, not homogenizing. (B) **homogeneity-non-closure HOLDS over the slab** `[H]` (the honest §8.5 outcome) — 9/10 tenants irreducibly heterogeneous (identity/scalars/bitfield/cursor) → KEEP (EXCEPT Qualia i4-16D + the future thinking-style i4-32D, which **DEFER** for a bigger substrate-validation test — i4 faithfulness, `I-NOISE-FLOOR-JIRAK`); §8 reduces to "classid is a schema pointer", SHIPPED (`ReadMode`/`ValueSchema`/`ClassView`, `ocr.rs:105` exemplar). **The closure is the operator's ONE CONTAINED facet** (2026-06-25): `facet_classid(4) | helix-place(6 B/48-bit = HelixResidue) | cam-pq(6 B/48-bit canonical CAM-PQ) = 16 B` — identity⊥search⊥schema, codec-selected by facet_classid, layout-preserving (no `ValueSchema` variant, no #500), I-VSA-IDENTITIES-clean (disjoint byte ranges, never bundled). Precise point: the facet wants the **6 B CAM-PQ**, NOT today's 16 B `TurbovecResidue` turbovec — a width decision for §6. **Corrections logged:** q2 `new_v2` blocker is CLOSED (API landed gated, `guid-v2-tail`); the cross-repo agent's "medcare-rs/ogar disk-walled" is a casing miss (`/home/user/{MedCare-rs,OGAR}` ARE present — top follow-up corrective sweep). Doc-only, zero code, no collision. EPIPHANIES E-TWO-SOA-WORLDS + E-HOMOGENEITY-CLOSES-AS-CONTAINED-FACET; INTEGRATION_PLANS prepend supersedes the BRIEF entry's "additive `ValueSchema::Homogeneous`" line. On branch `claude/serene-mayer-1a09he`. + ## 2026-06-24 (cont.⁴²) — strong form §8: the substrate as a full-stack compiler (thesis capstone, doc-only) **Main thread (Opus), operator-directed ("Holy Grail" → "continue") + cross-session feedback.** Appended **§8 "The strong form — the substrate as a full-stack compiler"** to `substrate-unification-thesis.md` (the doc shipped cont.⁴¹). §0–§7 read ONE node five ways; §8 asks: what if the VALUE SLAB itself is homogeneous in the key's algebra and `classid` is a schema pointer? Then the 512-byte node becomes a *compilation unit*: data → index → schema → view. **§8.1 homogeneous facet** `[H]` — carve value as N×16-byte facets, each a `(part_of:is_a)` cascade (`facet_classid(4) | 6×(8:8)=12`); a NEW `ValueSchema::Homogeneous` ALONGSIDE the existing `ValueTenant` columns → layout-preserving, no `ENVELOPE_LAYOUT_VERSION` bump (vs a key re-carve = canon-level). **Conflation trap named up front:** not every facet is part_of:is_a — scalars (susceptance/price/timestamp) aren't hierarchical, forcing them into 8:8 is the §1 split-error in reverse; honest form = scalar facets carry PQ codes, `facet_classid` discriminates codec-per-facet, **gated on F-1** (faithful centroids) + F-code (lossless). **§8.2 classid dual-dispatch** `[H]` — one radix lookup yields BOTH `classid→ReadMode` (codec: place⊕residue = Helix ⊕ CAM-PQ, the OGAR deterministic-phase/stored-magnitude split) AND `classid→ClassView` (schema: rails/AST/ERP, the OGAR `has_function`/`inherits_from` harvest); failure mode = drift between the two tables (`I-LEGACY-API-FEATURE-GATED` in spirit). **§8.3 LEGO** `[S]` — EdgeBlock click across domains via shared OGAR codebook (`canonical_concept_id`); compile = SPO manifest→ClassView, run = SoA under `UnifiedStep`/semiring; bounds: shared-concept lattice only (else adapter bricks at the membrane), structure⊥flow, core-gap extended not hacked; CONJECTURE until `PROBE-OGAR-ADAPTER-UNICHARSET` green. **§8.4 view layer** `[S]` — ClassView→askama, **Redmine as donor** (sharpened by other-session feedback): `Redmine::FieldFormat`→codebook-kind→cell-renderer map (partonomy tile→link/enum, value-quantile→number/gauge, identity→reference), `Query`/`QueryColumn`→ClassView→lenses→cells, `CustomField`/`CustomValue`→customattribute lens per classid. **The one real seam** = askama compile-time vs custom-fields runtime; three reconciliations (codegen / generic-renderer / **hybrid=the answer**: static type-safe shell + dynamic codebook cells = the `jinja<>dynamic classview` arrow), all inside the firewall (build-time codegen-from-manifest = sanctioned "compile types", medcare-rs Iron Rule 7). **Payoff closes the loop:** row/table = the **4th projection** of the node (next to 3D scene/graph/splat — `TorsoMap` three tenants→four); §0's "one object, N readings" reaches the screen. **§8.5** — §8 inherits §4's gates (8.1→F-1+F-code, 8.2→F-collapse, 8.3/8.4→OGAR core-first probe); §8-specific KILL = **homogeneity non-closure** (if facets are irreducibly heterogeneous, §8 reduces to "key is a schema pointer"). Honest line: engineering rungs (§2 axes, #605/#607) shipped & real; the full-stack-compiler reading is a coherent bet whose every load-bearing joint already has a named, un-run probe. Doc-only, zero code, no collision. Rides a fresh PR on jirak (#607 merged → jirak==main). diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index e98c04dd..f1f46b70 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,11 @@ +## 2026-06-25 — E-TWO-SOA-WORLDS — the value-tenant migration's real object is the slab↔parallel-MailboxSoA seam, not homogenization + +**Status:** FINDING `[G]` (confirmed-by-read; Phase-1 harvest of `soa-value-tenant-migration-v1`). The 480 B `NodeRow.value` slab (10 `ValueTenant`s, `canonical_node.rs:606`) and the parallel `MailboxSoA` (`cognitive-shader-driver/src/mailbox_soa.rs`, separate `[T;N]` columns) BOTH implement `MailboxSoaView`/`Owner` (`soa_view.rs`) but are **disjoint** — they share exactly one semantic column, `class_id()≡entity_type()` (`soa_view.rs:75`). **6 of 10 slab tenants have NO live producer** (Meta/MaterializedEdges/HelixResidue/TurbovecResidue/Plasticity — only schema tests or parallel-SoA mirrors); only Energy/EntityType/Kanban/Fingerprint are written into the actual slab. `SymbiontBoard` straddles both (carries `Vec` but exposes parallel mirror `Vec`s). **Consequence:** the migration's load-bearing decision is which world becomes canonical (the A↔B reconciliation), NOT homogenizing tenants. Open (un-answerable from source, a §6-panel question): does `MailboxSoA.edges` become the slab `MaterializedEdges` tenant? Full inventory: `soa-value-tenant-migration-v1-harvest.md`. + +## 2026-06-25 — E-HOMOGENEITY-CLOSES-AS-CONTAINED-FACET — §8 homogeneity doesn't close over the slab; it closes as the operator's one 16 B place⊕search facet + +**Status:** FINDING `[H]` (operator-proposed 2026-06-25, harvest-grounded; gated F-1 + F-code; pending §6 sign-off). Applying §3's gates to the actual 10 tenants: 9/10 are irreducibly heterogeneous (identity Fingerprint / scalars Energy·Plasticity·EntityType / bitfield Meta / fixed-vector Qualia / already-PQ Turbovec / cursor Kanban / deferred edges) → **KEEP** — except Qualia (i4-16D) and the operator-named future thinking-style (i4-32D), which **DEFER** for a bigger substrate-validation pass (i4 faithfulness — Cronbach/ICC/Spearman vs ground truth, `I-NOISE-FLOOR-JIRAK`); only HelixResidue (structure) matches the facet shape. So §8's homogeneous-value-slab reduces — per its own §8.5 fallback, NOT a failure — to "**classid is a schema pointer**", which is SHIPPED (`ReadMode`/`ValueSchema`/`ClassView`; `ocr.rs:105` end-to-end). **The closure exists as ONE contained special case** (operator): `facet = facet_classid(4) | helix-place(6 B / 48-bit Signed360 = `ValueTenant::HelixResidue`) | cam-pq(6 B / 48-bit canonical CAM-PQ) = 16 B` — fuses identity (frozen ruler, ICC→1.0) ⊥ search (CAM-PQ) ⊥ schema (facet_classid), codec-selected by facet_classid (the §3/§8.1 provision → a `classid → ClassView` reading, **no `ValueSchema` variant**, layout-preserving, no #500). **I-VSA-IDENTITIES-clean by construction:** helix∥CAM-PQ in disjoint byte ranges ([0:6],[6:12]), concatenated never XOR-bundled. **Precise design point:** the facet wants the 6 B canonical CAM-PQ, NOT today's 16 B `TurbovecResidue` (turbovec 32×4-bit) — a width decision for the §6 panels. This is the §8.1 facet made concrete with a *place⊕search* codec instead of a `part_of:is_a` tile. Detail: `soa-value-tenant-migration-v1-harvest.md` §1 Finding B. + ## 2026-06-23 — E-OGAR-11-OF-11-CLOSURE — the cross-axis identity gap from odoo-rs #14 is fully closed (OGAR #111 + #126 + #127; lance-graph #597 + #606 + this D4) **Status:** FINDING (milestone). odoo-rs PR #14 surfaced 11 missing diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index 3c7abaf8..32831cfd 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,11 @@ +## 2026-06-25 — soa-value-tenant-migration v2 SEQUENCING (operator-locked; identity→V3, then V3-tenants) + +Plan: `.claude/plans/soa-value-tenant-migration-v2.md`. **Operator-locked ordering** for the migration the v1 BRIEF opened + the v1-HARVEST inventoried: **ONE migration, TWO ordered phases — Phase 1 identity→V3 (key-side), Phase 2 V3-shaped value tenants (value-side).** Identity-first is **forced, not chosen**: OGAR #128's envelope parser resolves `tail_variant` (key shape) UPSTREAM of `value_schema` (tenant shape), so the tenants cannot be shaped to a V3 geometry the key does not yet express (the key is the coordinate system; tenants are read *through* it; the Phase-2 `helix-place‖CAM-PQ` facet is a *reflection* of the V3 part_of/is_a key). **Phase 1** = OGAR-registry + envelope-parser wiring: `0x1007` leading-`1` prefix → V3 `tail_variant`, **coexist-by-classid** (legacy zero-prefix stays V2 via `new_v2`/`guid-v2-tail`; RESERVE-DON'T-RECLAIM ⇒ zero V2-corpus re-mint, layout-preserving), grade `[H]` gate **F-update**. **Phase 2** = the harvest (contained facet + 8 KEEP + 2 DEFER, F-1/F-code; the §5 body still gated on the two 5+3 panels). **Payoffs:** identity-first migrates the one shared `entity_type≡class_id` anchor to V3 *before* the A↔B reconciliation (Phase 2 reconciles in V3 coords, no redo), and dissolves the harvest's scope question (harvest = the Phase-2 input). **Watch:** Phase 1's substance IS the OGAR casing-miss gap (harvest §6.1) — the corrective `/home/user/{OGAR,MedCare-rs}` sweep gates Phase-1 start, not optional polish. Doc-only. On `claude/serene-mayer-1a09he` (rides with the harvest to main). + +## 2026-06-25 — soa-value-tenant-migration-v1 HARVEST (Phase-1 deliverable; supersedes the BRIEF's §5/§8.1 framing) + +Plan: `.claude/plans/soa-value-tenant-migration-v1-harvest.md` (the filled §4 inventory). **Phase-1 of the 2026-06-24 BRIEF (below) is DONE.** **Correction (supersedes the BRIEF entry's "§5 migration body … additive `ValueSchema::Homogeneous`+`FacetCascade`" line, per the Codex-P2 reframe on #610):** the migration mints **NO `ValueSchema` enum variant** — the homogeneous facet is a `classid → ClassView` *reading* over an existing preset (`Full`/`Compressed`), enum + 16/16/480 layout untouched, no `ENVELOPE_LAYOUT_VERSION` bump (#496 §0 / #500 no-new-variant guardrail). **Harvest result:** the slab does NOT homogenize (8 KEEP + 2 DEFER — Qualia i4-16D and the future thinking-style i4-32D parked for substrate validation — + 1 homogenize-to-facet; the honest §8.5 outcome); the closure is the **operator's ONE contained 16 B facet** `facet_classid(4) | helix-place(6) | cam-pq(6)` (identity⊥search⊥schema; the **6 B canonical CAM-PQ**, NOT the 16 B turbovec residue). Plus **Finding A:** the canonical slab and the parallel `MailboxSoA` are two disjoint worlds (only `entity_type≡class_id` shared; 6/10 tenants producer-less) — reconciling them is the real near-term migration. **Next:** corrective `/home/user/{OGAR,MedCare-rs}` sweep (casing-miss gap), then the two independent 5+3 panels (§6). Doc-only. On `claude/serene-mayer-1a09he`. + ## 2026-06-24 — soa-value-tenant-migration-v1 (BRIEF; harvest-pending) Plan: `.claude/plans/soa-value-tenant-migration-v1.md`. NOT the migration — diff --git a/.claude/plans/soa-value-tenant-migration-v1-harvest.md b/.claude/plans/soa-value-tenant-migration-v1-harvest.md new file mode 100644 index 00000000..b4870909 --- /dev/null +++ b/.claude/plans/soa-value-tenant-migration-v1-harvest.md @@ -0,0 +1,294 @@ +# SoA Value-Tenant Migration — Phase-1 Harvest Result (the filled §4 inventory) + +> **Status:** HARVEST (2026-06-25, cont.⁴³). The Phase-1 deliverable the brief +> (`soa-value-tenant-migration-v1.md`) commissioned: the §4 inventory, filled by +> READ (not grep-to-conclude), plus the two findings the read surfaced and the +> operator's contained-facet closure. **NOT the migration** — §5 is still written +> for real only after the two 5+3 panels (§6) sign off on this. +> +> **Provenance / honesty (per the brief's read-discipline):** +> - **Confirmed-by-read (main thread):** `lance-graph-contract/src/canonical_node.rs` +> lines 1–1091 (the entire `ValueTenant`/`VALUE_TENANTS`/`ValueSchema`/`ReadMode` +> definitional surface — the remaining 1092–1866 is `KanbanTenant::to_bytes` + +> the test module; the `const _` assert `ValueSchema::Full.field_mask().count() +> == VALUE_TENANTS.len()` *proves* there is no 11th tenant hiding in the tests); +> `class_view.rs` (full); `cascade_key.rs` (full); `AGENT_LOG.md` head (cont.³⁸–⁴²); +> `INTEGRATION_PLANS.md` head. +> - **Subagent-mapped (confirmed-by-read by the agent):** in-workspace + ndarray +> producer/consumer map (Opus general-purpose, `tasks/a820786a55a562a0f`); +> cross-repo consumer locator (Explore). +> - **Not read this session (named, not hidden):** `place_buffer.rs`/`columns.rs` +> (taken from AGENT_LOG cont.⁴⁰ + the in-workspace agent's full read); +> `MedCare-rs` + `OGAR` (a casing-miss in the cross-repo sweep — see §6); +> the dense body of `LATEST_STATE.md` (grep-located only, board_status below). + +--- + +## 1. Two headline findings (the read changed the question) + +### Finding A — there are TWO disjoint "SoA" worlds `[G]` + +The migration's object is not one structure but the *seam between two*: + +- **(A) the canonical `NodeRow.value` 480-byte slab** — the 10 `ValueTenant`s, + carved by `VALUE_TENANTS` (`canonical_node.rs:606`), addressed via + `ValueTenant::value_offset()`. +- **(B) a parallel `MailboxSoA`** (`cognitive-shader-driver/src/mailbox_soa.rs`) + — separate `[T; N]` / `Vec` columns (energy / qualia / meta / entity_type / + edges) that implement the SAME `MailboxSoaView`/`MailboxSoaOwner` traits + (`contract::soa_view.rs`) but **do NOT touch the slab or `ValueTenant`**. + +The two worlds share exactly **one** semantic column: `MailboxSoaView::class_id()` +aliases `entity_type()` (`soa_view.rs:75`), which is `ValueTenant::EntityType`. +`SymbiontBoard` (`symbiont/src/kanban_loop.rs:137`) straddles both — it *carries* +`Vec` (the slab) but exposes tenants through **parallel mirror `Vec`s** +(`self.energy/edges/meta/entity`), reading the slab head only for +`edge_block_at`/`hhtl_path_at`. **The near-term migration is reconciling A and B**, +not homogenizing — and the choice of which becomes canonical is the load-bearing +design decision the §6 panels must arbitrate. + +**Live-producer reality (decisive for migration_class):** only **4 of 10** slab +tenants have a live (non-test) slab producer — **Energy, EntityType, Kanban, +Fingerprint**. The other **6 — Meta, MaterializedEdges, HelixResidue, +TurbovecResidue, Plasticity** — exist only as schema-membership tests (`ocr.rs`) +or as parallel-`MailboxSoA` mirrors; `MaterializedEdges`/`HelixResidue`/ +`TurbovecResidue` are explicitly **deferred**. A producer-less tenant migrates +very differently from an actively-written one. + +### Finding B — homogeneity does NOT close over the slab; it closes as ONE contained facet `[H]` + +The §8.5 KILL gate asked: are the value facets homogeneous, or irreducibly +heterogeneous? Applying §3's gates to the *actual* 10 tenants: **heterogeneous.** +They are identity (Fingerprint), scalars (Energy / Plasticity / EntityType — the +§3 named conflation trap), a bitfield (Meta), a fixed 16×i4 vector (Qualia), +already-PQ codes (Turbovec), a structured cursor (Kanban), and deferred edges. +**Only HelixResidue (the structure/place axis) matches the facet shape.** So §8 +reduces — per its own §8.5 fallback, *not* a failure — to "**classid is a schema +pointer**", which is **shipped and real**: `ReadMode { value_schema, edge_codec }` +resolved by `classid_read_mode()` through `BUILTIN_READ_MODES` +(`canonical_node.rs:891`), with the cleanest end-to-end exemplar at +`ocr.rs:105 to_node_row` (reads `classid_read_mode(classid).value_schema`, then +`schema.has(tenant)`-gates every write). + +**But the closure exists — as one CONTAINED special case (operator, 2026-06-25):** + +```text +contained place⊕search facet = 16 B, layout-preserving, facet_classid-selected codec + facet_classid (4 B) ← the schema pointer (which ClassView reads these 12 bytes) + helix-place (6 B) ← 48-bit Signed360 place⊕residue = ValueTenant::HelixResidue + cam-pq (6 B) ← 48-bit canonical CAM-PQ 6×256 code (the 6 B CAM-PQ, NOT turbovec) +``` + +This is the §8.1 facet (`facet_classid(4) | 12`) made concrete with a **place⊕search +codec** instead of a `6×(8:8 part_of:is_a)` tile — both are 12-byte payloads under +a 4-byte `facet_classid`; the difference is the codec, and **`facet_classid` +discriminates the codec** (the §3 / §8.1 provision, so this is a `classid → +ClassView` *reading*, never a new `ValueSchema` variant → no #500 violation, +layout-preserving). It fuses the three codes that genuinely belong together — +**identity (helix place, the frozen ruler, ICC→1.0) ⊥ search (CAM-PQ, the §3 +"scalars → PQ-code facet" target) ⊥ schema (facet_classid)** — into one +self-describing 16-byte unit, the same width as the key and the EdgeBlock. + +It is **I-VSA-IDENTITIES-clean by construction**: helix and CAM-PQ occupy +*disjoint* byte ranges ([0:6] and [6:12]) — concatenated, never XOR-bundled — so +the iron rule "CAM-PQ is for search, kept separate from the identity/bundling +layer" is enforced by the carve itself. + +**The one precise design point (do not gloss):** the facet wants the **6 B +canonical CAM-PQ** (`canonical_node` codec atlas "CAM-PQ (6B, varies)"; +OGAR-path-aligned 6×256), which is **NOT** today's `ValueTenant::TurbovecResidue` +(16 B turbovec 32×4-bit). So the contained facet is *not* "HelixResidue(6) + +TurbovecResidue(16)" (= 22 B); it consolidates **HelixResidue + a 6 B CAM-PQ +reading + classid → 16 B**, and the migration must decide whether the 16 B +turbovec stays out-of-facet (Full-preset only) or is replaced by the 6 B CAM-PQ in +the Compressed/cold-reference domain. Grade **`[H]`**, gated **F-1** (4⁴-vs-flat +codebook fidelity) **+ F-code** (lossless containment) — the shape is canon-sound; +the fidelity is unproven. + +--- + +## 2. The filled §4 inventory (10 rows) + +Slab offset = full-row `row_offset` − 32. `layout` is **preserving** for all +(every preset/facet carves within the reserved 480 B slab; `const _`-asserted at +`canonical_node.rs:795`, `is_layout_preserving()==true`). `producers`/`consumers` +cite the in-workspace map (Agent-confirmed-by-read) + the cross-repo sweep. + +| # | tenant | def_site | slab off / B | axis | codec | producers (slab) | consumers | migration_class | conflation_risk | gate | +|---|---|---|---|---|---|---|---|---|---|---| +| 0 | **Meta** | `canonical_node.rs:554` | 0 / 8 | truth/awareness | `MetaWord` u64 bitfield | none (parallel-SoA `mailbox_soa.rs:583 set_meta`) | `mailbox_soa.rs:577 meta_at` | **KEEP** (flat bitfield, not hierarchical) | low | none | +| 1 | **Qualia** | `:556` | 8 / 8 | angle | `QualiaI4_16D` 16×i4 | none (test `:1205`; parallel `mailbox_soa.rs:571 set_qualia`) | slab `:1125 NodeRow::qualia()`→`:1149 mul_phase_step`; `sigma-tier-router:365` | **DEFER** (i4-16D — bigger substrate-validation test, §2a) | low | substrate-validation | +| 2 | **MaterializedEdges** | `:558` | 16 / 32 | composition | 4× `CausalEdge64` | none — **deferred** (`mailbox_scan.rs:39`) | none | **KEEP / deferred** (reconcile vs `MailboxSoA.edges`) | n/a | none | +| 3 | **Fingerprint** | `:560` | 48 / 32 | identity | `Fingerprint<256>` 256-bit print | **live:** `symbiont/domino.rs:69 write_lanes` | `domino.rs:61 read_lanes` (AMX GEMM) | **KEEP** (the identity ruler — homogenizing identity is nonsensical, thesis §3) | none | none | +| 4 | **HelixResidue** | `:564` | 80 / 6 | **structure** | helix `Signed360` 48-bit place⊕residue | none (prototype `place_buffer.rs:49 helix_place`) | none live; `ocr.rs` Compressed-schema tests | **homogenize-to-facet** → the contained 16 B facet (Finding B) | low (place⊕residue already orthogonal, cont.⁴⁰) | **F-1 + F-code** | +| 5 | **TurbovecResidue** | `:566` | 86 / 16 | codec/search | turbovec PQ 32×4-bit (128-bit) | none — deferred | none live; `ocr.rs` tests | **PQ-already** — but the contained facet wants the **6 B CAM-PQ**, not this 16 B turbovec (§1 design point) | none (already a PQ code) | F-1 (if activated) | +| 6 | **Energy** | `:568` | 102 / 4 | dynamics | `f32` accumulator (scalar) | **live:** `symbiont/bridge.rs:38 set_energy`, `domino.rs:77`, `ocr.rs:113` | `bridge.rs:46`, `domino.rs:81`, `nan_projection.rs` | **KEEP** (scalar — forcing into 8:8 is the §3 split-error in reverse) | **HIGH if homogenized** | none (explicitly NOT homogenize) | +| 7 | **Plasticity** | `:570` | 106 / 4 | dynamics | u32 counter + stamp | none (parallel `mailbox_soa.rs:336`) | `ocr.rs:262` test; `mailbox_soa.rs:517` | **KEEP** (scalar pair) | high-if-homogenized | none | +| 8 | **EntityType** | `:572` | 110 / 2 | schema/identity | u16 OGIT discriminator | **live:** `ocr.rs:110` | `ocr.rs:183`; **`soa_view.rs:75 class_id()` alias** → `mailbox_scan.rs:78 match_nodes_by_class` (Cypher `MATCH (n:Label)`) | **KEEP** (the class discriminator = the ClassView key; the A↔B reconciliation anchor) | none | none | +| 9 | **Kanban** | `:578` | 112 / 8 | lifecycle | `KanbanTenant` phase+exec+cycle | **live:** `canonical_node.rs:1114 set_kanban` (owner-only) | `:1103 kanban()`→`:1150 mul_phase_step`; `tenant_counter.rs:16` | **KEEP** (structured cursor, owner-only-write exemplar) | none | none | + +**Net:** **8 KEEP, 2 DEFER (Qualia i4-16D + the future thinking-style i4-32D), 1 homogenize-to-facet (HelixResidue, into the contained 16 B +place⊕search facet with a 6 B CAM-PQ).** This IS the honest §8.5 outcome: +homogeneity does not close over the slab; it closes as the operator's one +contained facet for the cold place⊕search (Compressed / FMA-anatomy) workload, +while the hot heterogeneous tenants stay `KEEP` (the Cognitive/Full presets) and the +i4-quantized cognitive vectors (Qualia, thinking-style) **DEFER** (§2a). + +### 2a. Deferred for future substrate validation (operator, 2026-06-25) + +**Qualia (i4-16D, tenant #1) and the future thinking-style (i4-32D) DEFER — not +`KEEP`, not homogenize.** Both are i4-quantized (signed-4-bit, 16 levels) cognitive +vectors; whether i4 *faithfully* encodes a 16-D qualia / 32-D thinking-style +geometry is a **bigger substrate-validation test** than the contained facet's +F-1/F-code — it is the thinking-engine calibration question (Cronbach α / Spearman +ρ / ICC vs the f32 ground truth, with Jirak-not-classical significance bounds per +`I-NOISE-FLOOR-JIRAK`, since the channels are weakly dependent). So they are +**parked** for a dedicated substrate-validation pass, not migrated this round. The +thinking-style **i4-32D** is the operator-named *companion future tenant* to Qualia +(NOT one of the 10 today — `Meta` carries the MetaWord bits; the i4-32D style vector +is carried alongside Qualia when validated). This keeps the migration's first cut to +what is provable now (the contained facet + the A↔B reconciliation) and quarantines +the heavier measurement question. + +`board_status` (all 10): the canon is recorded in `LATEST_STATE.md` Contract +Inventory at the **type level** (`canonical_node` / `NodeRow` / `ValueSchema` / +`ReadMode` — ~20 grep hits), **not per-tenant**. This filled table is the first +per-tenant enumeration → a board-hygiene addition (recorded in the INTEGRATION_PLANS +prepend, not a drift). + +--- + +## 3. The carriers — the "classid → ClassView reading" mechanism is SHIPPED `[G]` + +The migration's §5.1 ("ClassView reading over an existing preset, no new variant") +is not aspirational — it is built and tested: + +- **`ValueSchema`** (`canonical_node.rs:715`): `Bootstrap`(∅) / `Cognitive`(7 + tenants) / `Compressed`(4) / `Full`(10). `is_layout_preserving()==true`, + `const _`-asserted. *(Doc-drift noted: `Cognitive`'s doc-comment lists 6 tenants + but `field_mask` adds `Kanban` = 7 — `:719` vs `:734`.)* +- **`ReadMode` + `classid_read_mode()`** (`:815`,`:912`): the `{value_schema, + edge_codec}` pair, resolved through `BUILTIN_READ_MODES` (DEFAULT/OSINT/FMA/ + PROJECT/ERP), zero-fallback to `ReadMode::DEFAULT`. **Live debt:** + `ReadMode::DEFAULT.value_schema = Full` is a **TEMPORARY 2026-06-15 POC** + (`:826`) paired with `ClassView::value_schema`'s `Full` default (`class_view.rs:395`) + and the revert test `value_schema_default_is_full_temporary_poc` — the migration + must flip both to `Bootstrap` together (one revert, two sites + test). +- **`ClassView`** (`class_view.rs:305`): the resolver-above-the-SoA; owns + `value_schema()` + `edge_codec_flavor()` (selection-only, "never a stride + change") + `compute_dag()`. **The contained facet (Finding B) lands here as a + new `ClassView` reading method in the same mold** — additive, layout-preserving. + +--- + +## 4. The perturbation-sim prototypes — relationship clarified `[G]` + +The brief §2.3/§2.4 named `cascade_key`/`place_buffer`/`INERTIA_SLOT` as "prototype +tenants." The read corrects this: **they are a SEPARATE, zero-dep SoA that is NOT +wired into `NodeRow.value`** (`columns.rs` header, verbatim: "*nothing here +serializes or touches the operator-locked canonical_node spine*"). + +- **`cascade_key.rs` V3** `CascadeKeyV3` (the `(part_of:is_a)` 8:8 tile, + `:226`,`tier_v3:238`) produces **HEEL/HIP/TWIG = KEY bytes** (GUID offsets + 4..10), **not value tenants**. The `v3_two_hierarchies_are_independent` test + (`:534`) proves part_of ⊥ is_a. It is the prototype the §8.1 tile-codec + generalizes — but it lives in the *key cascade*, not the value slab. +- **`place_buffer.rs`**: `helix_place` (LOCATION, deterministic √u golden-spiral, + never reads the grid, ICC 1.00) ⊥ `BufferResidue` (8×BF16 impulse-permeability, + ICC 0.51). Maps *conceptually* onto `ValueTenant::HelixResidue` (the 6 B place + octets of the contained facet) + a future buffer tenant — but never imports + `lance_graph_contract`. +- **`columns.rs` `SoaMemberSpec`** is a **calibration spec, not a runtime + encoder**; `INERTIA_SLOT=5` + `INERTIA_PROMOTION` = the §0-guardrail + `RatifiedReuse` verdict (operator sign-off 2026-06-16: reuses the helix-residue + slot, invents no tenant). + +The only live `NodeRow.value` ↔ perturbation bridge is `symbiont/bridge.rs` + +`domino.rs`, which write only `Energy` (+ `Fingerprint` for the AMX tile). + +--- + +## 5. Cross-repo consumer blast radius `[G]` (read-side) + +- **q2 — CLEAR.** `osint-bake` / `cockpit-server` call `NodeGuid::new_v2(...)` + (`osint-bake/src/lib.rs:606,745`). **The brief's §2.5 `new_v2` blocker is + CLOSED:** `new_v2` now exists (`canonical_node.rs:244`, `#[cfg(feature = + "guid-v2-tail")]`, the D-GV2-1 7-arg v2 tail) AND q2 enables `guid-v2-tail` at + the workspace root → correctly gated, not an `I-LEGACY-API-FEATURE-GATED` + violation. The brief's "a 7-group API that does NOT exist" framing is stale. +- **woa-rs / openproject-nexgen-rs / redmine-rs — CLEAR.** Pull via + `ogar_vocab::canonical_concept_id`, no `*Bridge` construction outside the + allow-list, no codebook copy. woa-rs owns its 16 B layout dep-free + (`src/erp/canon.rs`). +- **odoo-rs — zero hits.** +- **BBB-barrier audit: PASS** across all swept consumers. + +--- + +## 6. Completeness note — named gaps (not hidden) + +1. **`MedCare-rs` + `OGAR` not swept — casing miss.** The cross-repo agent + searched `/home/user/medcare-rs` and `/home/user/ogar`; the clones are + **`/home/user/MedCare-rs`** and **`/home/user/OGAR`** (case-sensitive FS). Its + "disk-walled" verdict for those two is **wrong** — both are available. `OGAR` + is where "a minted class's read-mode is layered in one level up" + (`canonical_node.rs:888`) — i.e. the producer side of `classid → ReadMode` + specialization. `MedCare-rs` is a named BBB consumer. **Top follow-up: a + corrective sweep of `/home/user/{OGAR,MedCare-rs}`** before §5 is written. +2. **6 producer-less tenants** (Meta / MaterializedEdges / HelixResidue / + TurbovecResidue / Plasticity) — a real finding, not a coverage gap: their + live writes (where any) happen in the parallel `MailboxSoA`, not the slab. +3. **`place_buffer.rs` / `columns.rs`** taken from AGENT_LOG cont.⁴⁰ + the + in-workspace agent's full read, not a main-thread read this session. +4. **`(located, not read)`** by the in-workspace agent: `crates/learning/*`, + `lance-graph-cognitive/src/grammar/*`, `surreal_container/*` (the kv-lance + `MailboxSoaView` impl, DESIGN-LOCKED/deferred) — likely parallel-SoA + consumers, lower confidence. +5. **Open design question (un-answerable from source):** does the migration + intend `MailboxSoA.edges` to *become* the slab `MaterializedEdges` tenant? + This is the crux of the A↔B reconciliation (Finding A). +6. **`LATEST_STATE.md` body** is grep-located only (the file exceeds the + single-read token cap); board_status established at the canon-type level. + +--- + +## 7. Hand-off to Phase 2 (the two independent 5+3 panels) + +The filled inventory (§2) + the two findings (§1) + the carriers (§3) are the +input the §6 sign-off panels harden. The seams to scrutinize hardest: + +1. **The contained facet (Finding B).** `truth-architect` / `container-architect`: + is the 6 B-CAM-PQ-vs-16 B-turbovec width decision sound, and does F-1/F-code + actually gate it? `iron-rule-savant`: confirm helix∥CAM-PQ disjoint-range + concatenation respects I-VSA-IDENTITIES (no superposition). +2. **The A↔B reconciliation (Finding A).** `dto-soa-savant`: does collapsing the + parallel `MailboxSoA` into the slab (or vice-versa) land as a column, not a new + layer? `baton-handoff-auditor`: the `class_id()≡entity_type()` alias is the + only shared column — does the cross-crate roundtrip survive? +3. **The POC default.** `overclaim-auditor`: the `value_schema = Full` POC + (two sites + test) is unreverted — any inventory row that assumes `Bootstrap` + semantics is premature. +4. **`firewall-warden` / `dilution-collapse-sentinel`:** does folding HelixResidue + into the contained facet *dilute* a sharp tenant or *collapse* a distinct one? + (The harvest's read: no — it *consolidates* the place⊕search pair the operator + identified, and the hot heterogeneous tenants stay KEEP.) + +**Reconciliation rule (brief §6):** run the two panels independently; convergence +is signal, divergence names the seam. No tenant migrates on one panel's say-so. + +--- + +## Cross-references +- `soa-value-tenant-migration-v1.md` (the brief: §2 where-to-read, §3 gates, §4 + schema, §6 5+3). +- `substrate-unification-thesis.md` §8.1 (homogeneous facet), §8.5 + (homogeneity-non-closure — the KILL gate this harvest answers). +- `canonical_node.rs` (`ValueTenant:552` / `VALUE_TENANTS:606` / `ValueSchema:715` + / `ReadMode:815` / `classid_read_mode:912`; `new_v2:244` gated). +- `class_view.rs` (`ClassView:305`, `value_schema:395` POC default). +- `perturbation-sim/src/{cascade_key.rs, place_buffer.rs, columns.rs}` (key-side + prototypes, separate SoA). +- Iron rules: `I-VSA-IDENTITIES` (the contained facet's disjoint-range carve), + `I-LEGACY-API-FEATURE-GATED` (the q2 `new_v2` gate, now closed), + `I-SUBSTRATE-MARKOV`. +- AGENT_LOG cont.⁴⁰ (location⊥permeability split), cont.⁴² (§8 thesis, PR #610). diff --git a/.claude/plans/soa-value-tenant-migration-v2.md b/.claude/plans/soa-value-tenant-migration-v2.md new file mode 100644 index 00000000..fa7afa37 --- /dev/null +++ b/.claude/plans/soa-value-tenant-migration-v2.md @@ -0,0 +1,197 @@ +# SoA Value-Tenant Migration v2 — Operator-Locked Phase Sequencing + +> **Status:** OPERATOR-LOCKED SEQUENCING (2026-06-25). Supersedes the v1 BRIEF's +> implicit single-pass framing: the migration is **ONE migration in TWO ordered +> phases** — **Phase 1 identity→V3 (key-side)**, then **Phase 2 V3-shaped value +> tenants (value-side)**. The per-tenant §5 migration body stays gated on the two +> 5+3 panels (unchanged, harvest §7); THIS doc locks only the *ordering* + its +> forcing rationale — which the panels do **not** arbitrate, because it is forced +> by the envelope parser, not chosen. +> +> Reads with: `soa-value-tenant-migration-v1.md` (brief), +> `soa-value-tenant-migration-v1-harvest.md` (the filled §4 inventory = the +> Phase-2 input), `substrate-unification-thesis.md` §8, OGAR #128 (the +> producer-side envelope parser). + +## 0. The lock, one line + +Identity is the **coordinate system**; the value tenants are expressed in it. +**Migrate the address to V3 first; shape the tenants to V3 second.** Not a +preference — a forcing function (§1). + +## 1. Why identity-first is the ONLY correct order (forced, not chosen) + +OGAR #128's envelope parser resolves `classid → registry → {tail_variant, +value_schema, edge_codec}`, and **`tail_variant` (the identity/key shape) is +resolved UPSTREAM of `value_schema` (the tenant shape).** You physically cannot +shape value tenants to a V3 geometry the key does not yet express — the parser +reads `tail_variant` *first* to know how to read everything after it. + +This mirrors the thesis axes: **identity** (key-as-place) and **structure** +(HHTL = `(part_of:is_a)`) are the **key-side** axes; the value tenants are read +*through* them. A V3 address carries the two orthogonal hierarchies +(where-it-is ⊥ what-it-is); the Phase-2 contained facet's +`helix-place(6) ‖ CAM-PQ(6)` shape is a **reflection of that same part_of/is_a +split**. The facet is a shadow the V3 key casts — so the key casts first. + +## 2. Phase 1 — identity → V3 (key-side; NOT in the harvest's value inventory) + +The harvest correctly **bracketed this key-side** ("a SEPARATE, zero-dep SoA … +NOT wired into `NodeRow.value`", harvest §4) — so it is *not* covered by the +value-tenant inventory; it is the prerequisite that inventory assumes. + +- **New-gen classids carry the `0x1007` leading-`1` prefix** → route through the + **V3 `tail_variant`** in the OGAR registry; the HHTL tiers read as the + `(part_of:is_a)` 8:8 tile (`perturbation-sim/src/cascade_key.rs` + `CascadeKeyV3`, already coded + tested: `v3_two_hierarchies_are_independent`). +- **Coexist-by-classid, NOT rewrite.** Legacy zero-prefix classids keep their + current `tail_variant` — **V1** (the default `family·identity` tail) or **V2** + (`new_v2` `leaf·family·identity` 3×u16, `guid-v2-tail`-gated — what q2's + `osint-bake` already mints). **RESERVE-DON'T-RECLAIM ⇒ zero re-mint of the + V1/V2 corpus**, layout-preserving: the same 16-byte key, tiers *reinterpreted* + by `tail_variant`, never re-carved. +- **Mostly an OGAR-registry + envelope-parser wiring job** — exactly the + producer side OGAR #128's canon (`E-CLASSID-ENVELOPE-PARSER` / `D-ENVPARSE`) + specced (**doc-only**; the `tail_variant` axis is to-wire on OGAR's side too). +- **Grade `[H]`**, gate **F-update**: the cheap end of the thesis's F-update + axis — but "zero-cost V2/V3 coexistence" is *precisely* the claim F-update + must confirm. A V2 tail silently reinterpreted under a V3 reader is the + `I-LEGACY-API-FEATURE-GATED` failure mode; the same version-gate + + field-isolation discipline that closed the q2 `new_v2` seam applies to the + tail. + +### 2.1 The reusable pattern — extend the one `ReadMode`, never a public `new_v3` + +P-A's mechanism **must BE Phase-2's mechanism, not merely enable it.** Both sides +hang off the **single** `classid → ReadMode` dispatch (`canonical_node.rs:912` +`classid_read_mode`), whose doc-invariant (:810) is "consumers and OGAR read the +identical schema." `ReadMode` (:815) already carries the value reading; identity +is a **third field on the same struct**, resolved by the same lookup — mirroring +OGAR #128's `classid → {tail_variant, value_schema, edge_codec}`: + +```rust +pub struct ReadMode { + pub tail_variant: TailVariant, // P-A adds — which KEY shape (resolved first, per #128's parse order) + pub value_schema: ValueSchema, // Phase 2 — which tenants (already shipped) + pub edge_codec: EdgeCodecFlavor, // edges (already shipped) +} +``` + +**The symmetric spine** (the test that it serves Phase 2): + +| side | call | shapes | +|---|---|---| +| key (Phase 1) | `mint_for(classid_read_mode(c).tail_variant, …)` | the address | +| value (Phase 2) | `to_node_row(classid_read_mode(c).value_schema, …)` | the tenants | + +Same `classid_read_mode(c)`, sibling fields. Consumers **mint by classid**, never +hardcode v1/v2/v3 — exactly as they later shape tenants by classid. Migrating a +class's **identity** to V3 = flip `tail_variant` on its `ReadMode` const; later +migrating its **tenants** = flip `value_schema` on the *same* const. Two +field-flips on one registry entry; no consumer rewrite either time. + +**Litmus (guardrail):** anything that is **not** `classid_read_mode(c).` — +a consumer `if classid_is_v3 {…}`, or a public `new_v3` consumers call directly — +is the *layer-not-column* anti-pattern and will not serve Phase 2. Reject it. + +**Three locks (cross-session grounding, 2026-06-25):** +- **L1 — `ReadMode::DEFAULT.tail_variant = V1`** (the zero-fallback const at :833). + Every un-minted classid stays V1 → **zero re-mint of the V1/V2 corpus** + (RESERVE-DON'T-RECLAIM). V3 is opt-in per-classid via `BUILTIN_READ_MODES` + (:891), never the default. +- **L2 — keep the POC-`Full` flip separable.** `ReadMode::DEFAULT.value_schema` + is still the unreverted `Full` POC (:825-833, guarded by the revert test). + Adding `tail_variant` and flipping `value_schema → Bootstrap` are **two + independent field migrations on one struct** — document the canonical target + triple `{V1, Bootstrap, CoarseOnly}`, do not entangle them. +- **L3 — mechanism is NOT blocked on the classid lock (P-C).** Extending + `ReadMode` + the `TailVariant` enum + the `mint_for` carrier + the + `guid-v3-tail` gate are additive / default-V1 / feature-gated → they land + **now**, non-breaking. Only the per-consumer `classid → tail_variant: V3` + **entries** (the `0x1007` placement) need the P-C operator-lock. + +**Parity fuse — structural-against-canon, NOT runtime-vs-struct.** OGAR #128 +(`E-CLASSID-ENVELOPE-PARSER` / `D-ENVPARSE`, merged, **doc-only**) pins the target +verbatim — *"the registry entry must gain the `tail_variant` (V2/V3) axis beside +`ReadMode {value_schema, edge_codec}`"* — but `tail_variant` is **to-wire on +OGAR's side too** (the pieces #128 lists as CODED — `classid_read_mode` / +`BUILTIN_READ_MODES` / `ClassView` / `new_v2` / `cascade_key`-V3 — carry none). So +the fuse asserts the contract `ReadMode`'s field set **== the three canon axes** +`{tail_variant, value_schema, edge_codec}` (a compile-time *structural* guard +against the canon), **not** a runtime comparison against a live OGAR struct — that +is the shape the codebook `COUNT_FUSE` has only because its `ogar_vocab` +counterpart already exists. It upgrades to the runtime form once OGAR codes its +registry's `tail_variant`. + +### 2.2 P-C classid lock (operator-ratified 2026-06-25) + +**Generation marker = flip the leading nibble `0 → 1`** on the *current* classid +(#128's "exact u32 placement" pinned to the high nibble; versioning in the +schema-pointer, never a GUID-tail nibble). OGAR's canonical `0xDDCC` domain map +(`ogar-vocab/src/lib.rs:1062-1086`) is **kept as-is**. The three V3 consumers: + +| consumer | base classid | V3 (gen-marked) | OGAR domain | note | +|---|---|---|---|---| +| OSINT | `0x0007` | **`0x1007`** | `0x07` OSINT | canon ✓, kept as-is | +| FMA | `0x0008` | **`0x1008`** | `0x08` OCR | **kept as-is** (jungle-avoidant). Canon home is `0x0A` Anatomy — firewall-split from `0x09` Health PHI (lib.rs:1078-1086) — so the realign to `0x100A` is **deferred domain-debt**; flip this one row if/when realigned. | +| CPIC | `0x000C → 0x000D` | **`0x100D`** | `0x0D` Genetics (new) | the **one forced move**: `0x0C` is Automation (HIRO/MARS), so CPIC's current `0x0C` collides — Genetics mints into the next free slot, then gen-marks. | + +`ReadMode::DEFAULT.tail_variant = V1` (L1) keeps every other classid legacy; these +are the only `BUILTIN_READ_MODES` V3 entries, each `guid-v3-tail`-gated. The +Genetics-domain mint (OGAR + contract) and CPIC's `0x0C → 0x0D` move ride with the +P-A mechanism, not this doc. + +## 3. Phase 2 — V3-shaped value tenants (value-side; = the harvest) + +This is what `-v1-harvest.md` inventoried. With the address already V3: + +- The ClassView *reading* shapes the value to match the now-V3 key: the + contained `facet_classid(4) | helix-place(6) | CAM-PQ(6)` facet + (HelixResidue → facet), the **8 KEEP** tenants under `Cognitive`/`Full`, and + Qualia + the future thinking-style i4-32D **DEFER** (substrate-validation). +- **Gates F-1 + F-code** (unchanged). The per-tenant §5 body is written for real + only after the two independent 5+3 panels sign off (harvest §7). THIS doc does + not pre-empt them — it only fixes that Phase 2 runs *after* Phase 1, in V3 + coordinates. + +## 4. Two structural payoffs of this order + +1. **De-risks Finding A (the two-worlds seam).** The canonical slab and the + parallel `MailboxSoA` share exactly **one** semantic column: + `entity_type ≡ class_id` (`soa_view.rs:75`). Identity-first migrates **that + shared anchor** to V3 *before* the A↔B reconciliation — so Phase 2 reconciles + the two worlds **already in V3 coordinates**, instead of reconciling them in + V2 and redoing it once the address moves. +2. **Dissolves the harvest's scope question.** "Is the harvest the migration or + the inventory?" → it is precisely the **Phase-2 input**; Phase 1 is the + prerequisite it correctly left key-side. No scope confusion survives once the + two phases are named. + +## 5. The watch — Phase 1's substance IS the OGAR gap + +Phase 1 leans almost entirely on OGAR (the registry, the envelope parser, the +`0x1007` mint path). The harvest's OGAR sweep was the **casing-miss gap** +(harvest §6.1 — the cross-repo agent searched `/home/user/ogar`; the clone is +`/home/user/OGAR`, and `/home/user/MedCare-rs` likewise). So the corrective +`/home/user/{OGAR,MedCare-rs}` sweep is **not optional polish deferred to +"before §5"** — it is **Phase-1's actual substance** and gates Phase-1 start. +OGAR is where `classid → ReadMode` is *produced* (`canonical_node.rs:888`, +"a minted class's read-mode is layered in one level up"); Phase 1 cannot wire +the V3 `tail_variant` without reading that producer side. + +## 6. Sequencing summary + +| Phase | Object | Side | Mechanism | Grade | Gate | Prereq | +|---|---|---|---|---|---|---| +| **1** | identity → V3 | key | OGAR registry + envelope parser; `0x1007` prefix → V3 `tail_variant`; coexist-by-classid | `[H]` | F-update | OGAR/MedCare-rs corrective sweep | +| **2** | V3-shaped tenants | value | ClassView reading: contained facet + 8 KEEP + 2 DEFER | `[H]`/`[S]` | F-1 + F-code | Phase 1 **+** 5+3 panels | + +## Cross-references +- `soa-value-tenant-migration-v1.md` (brief — §2 where-to-read, §3 gates, §6 5+3). +- `soa-value-tenant-migration-v1-harvest.md` (the filled inventory = Phase-2 input). +- `substrate-unification-thesis.md` §8 (the facet as a reflection of the V3 key). +- `perturbation-sim/src/cascade_key.rs` (`CascadeKeyV3`, `v3_two_hierarchies_are_independent`). +- `canonical_node.rs` (`new_v2:244` gated; `classid_read_mode`; `:888` the OGAR read-mode producer). +- `guid-v2-tail-per-family-codebook-v1.md` (the tail repartition this V3 prefix coexists with). +- OGAR #128 — `E-CLASSID-ENVELOPE-PARSER` / `D-ENVPARSE` (merged, **doc-only**): `classid → registry → {tail_variant, value_schema, edge_codec}`; the `tail_variant` axis is to-wire on both sides. +- Iron rules: `I-LEGACY-API-FEATURE-GATED` (the V2/V3 tail version-gate), `I-VSA-IDENTITIES` (the facet's disjoint carve), `I-SUBSTRATE-MARKOV`.