diff --git a/.claude/board/CROSS_SESSION_BROADCAST.md b/.claude/board/CROSS_SESSION_BROADCAST.md index ec9450e3..510773fb 100644 --- a/.claude/board/CROSS_SESSION_BROADCAST.md +++ b/.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` + +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. diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 3d74b326..d0d4c293 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.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 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) diff --git a/.claude/board/LATEST_STATE.md b/.claude/board/LATEST_STATE.md index 68d79495..56d553ac 100644 --- a/.claude/board/LATEST_STATE.md +++ b/.claude/board/LATEST_STATE.md @@ -117,6 +117,7 @@ Membrane consumers can now pull BOTH halves of a render `classid` BBB-safely fro | **#630** | 2026-07-02 | V3 W1 START: preflight deltas + WAL writer probes + adoption scan + D-PERT-1 + temporal synthesis | Fable-5 ten-point preflight (M24 board=WAL, W6a baseline inversion, W3 oracle ratchet, W2 probe-first reorder) + operator rulings folded live: zero-copy sink (cast = descriptor never bytes, flush via NodeRowPacket::as_le_bytes), "melden macht frei" (stacked casts never refused — 4 ignored probes define W1b green), temporal.rs deinterlace = the READ side (replay = QueryReference::at + deinterlace; M24/M25/time-travel are ONE mechanism; ack carries LanceVersion). Landed code: batch_writer skeleton + 4 probes; contract::classid_scan (771 green); D-PERT-1 rename (462 green). Audits: planner-SoA type-real/wiring-dormant (M15 GateDecision rename BLOCKING before W2); M7 corrected (NodeRowPacket IS production SoaEnvelope, codex P2); graph-flow benched ~0.4-0.5us/step (two-speed confirmed); M25 KanbanSessionStorage design (graph-flow-kanban envelope exists — wire don't invent). Merge `9a6df2a1`. | | **#629** | 2026-07-02 | V3 SUBSTRATE consolidated entry point (`.claude/v3/`) + ractor ownership attestation | `.claude/v3/` tree shipped: README (orientation), INTEGRATION-PLAN (W0–W6), COMPONENT-MAP (reuse/repurpose/retire), ENTROPY-MILESTONES (N→1 ledger), MODULE-TABLE (per-file census core/contract/planner), soa_layout/ (LE contract, tenant lanes, consumer map, routing), knowledge/ (substrate primer, mailbox-kanban model, sonnet-worker-guardrails), agents/BOOT.md (4 V3 cards); `/v3` skill + `/v3-audit` command; CLAUDE.md/BOOT.md ★ entrypoint. Review sharpenings folded: LE byte-order range-scan caveat, 3-shape legacy corpus scanner (incl. `0xAAAA_DDCC`), ractor helper-scope ruling (NOT messaging — slow; helper only: spawn/supervision/occasional control RPC). Ownership compile attestation: `KanbanActor` `type State = O`, owner MOVES in at pre_start; 22 supervisor tests green on the AdaWorldAPI ractor fork. Merge `28f17cd7`. | | **#628** | 2026-07-02 | classid canon:custom half-order flip EXECUTED (P0+P1+P2) | `CLASSID_ORDER = CanonHigh` live: canon `domain:appid` HIGH / custom LOW (`0x0701_1000` = `0x07:01::1000`); ONE flippable composition + `classid_canon_compat` (mint-forward both-forms reader — RBAC authorizes pre-flip rows, no re-bake); new-form mint constants + `CLASSID_*_LEGACY` aliases; hhtl dual-form fold; OGAR#95 reconciled (prefix = custom half, values unchanged); ogar pin → `19373a2` (OGAR #147 lockstep). Fleet: OGAR #147 + MedCare #180 + woa-rs #177 merged; q2 #71 + op-nexgen #68 open. Merge `6858118b`. | +| **#625** | 2026-07-02 | brick-3 RAN: truncation-disallowed / overflow-as-SoC-reroute + DO-arm 3-bucket triage | Knowledge tier: `ast-as-partof-isa-address.md` Status → PARTIALLY MEASURED (rank-minter brick-3 RAN via `ruff_csharp_spo` → `ruff_spo_address::{mint, mint_factored}` → `medcare_probe`; naive 6-tier mint FALSIFIED; truncation DISALLOWED — overflow = SoC-reroute trigger per OGAR `256-cap-is-a-lint` #130/#140; overflow *classification* shipped upstream as `ruff_spo_address::soc`, class-conditioned shapes 6×2/4×3/3×4). New `do-arm-triage-3-bucket.md` (fuzzy→canonicalize / standard-DO→one DTO adapter + codebook swiss-knife / random→hand-port-and-graduate; C#/C++ DO-extractor gap named). Proprietary numbers stay in private MedCare-rs archive. Lock: ogar → `a0c7936` (post-#146, fuse 65==65). Mid-arc OSINT mirror commits DROPPED per OGAR #146 ruling. Branch `claude/medcare-bridge-lance-graph-wmx76z`, merge `5561908`. | | **#627** | 2026-07-02 | classid canon:custom flip TRIGGERED (doc-only) | Operator ruling recorded + `classid-canon-custom-flip-v1.md` ACTIVE: canon `domain:appid` → hi u16, custom (`0x1000` temporary marker) → lo; `0x0701_1000` / `0x07:01::1000`; OSINT low byte = appid space (zero vocab rows, OGAR #146 67→65 fuse balanced); q2 gate WAIVED; ISSUES ×4 resolved/ruled; codex P2 guards locked (class_id via `classid_canon(id)` never `as u16`; legacy keys demote not retire). Merge `c8e1ec4`. | | **#626** | 2026-07-02 | V3 convergence wiring: tenant-carve certification, RungElevator, P6 wave probe, seam-list plan | "Wire, don't invent": `RungLevel::{from_u8,elevate,de_elevate,pearl_level,causal_mask_bits}` + `RungElevator` (sustained-BLOCK policy over P2/P3-certified masks; converged with `escalation::rung_delta` via `apply_delta` — one ladder, two signal sources) wired through the driver (persistent elevator, `ctx.rung=1` proxy retired, grpc rung saturates-never-wraps per codex P2); BOTH V3 tenant carves matrix-certified (Cognitive + Compressed); P6 probe (wave dist == certified palette read, markov_soa verified); `[patch.crates-io] ndarray` → local sibling path (fetch deadlock gone; first in-sandbox core build, 925/925). Plan `v3-convergence-wiring-v1.md`; worker Rule 7. Branch `claude/v3-substrate-migration-review-o0yoxv`, merge `5aaee33`. | | **#542** | 2026-06-18 | E-OGAR-IS-FOUNDRY capstone + 5+3 council + the key→row baton | Foundry/Gotham = "write the OGAR class schema + inheritance"; everything else is generic machinery over it (ontology=`classid→ClassView`+inheritance, AR=DO/THINK, pipelines=`compute_dag`, apps=Jinja-over-classes, query=Cypher⇄SurrealQL one IR). Added `MailboxSoaView::row_for_local_key -> Option` (default `None`, deferred-binding — the key→row baton for a future `Backend::MailboxSoa` router). Epiphanies `E-OGAR-IS-FOUNDRY`/`E-CYPHER-IS-THE-KANBAN-AST`/`E-GUID-IS-THE-GRAPH`; plan `cypher-kanban-ast-unification-v1`. Council corrections: `from_guid_prefix` is on `NiblePath` not `NodeGuid`; "odoo proof" = CONJECTURE; `ogar-adapter-surrealql` not a crate. Branch `claude/q2-substrate-grounding`, merge `faca377f`. | diff --git a/.claude/board/PR_ARC_INVENTORY.md b/.claude/board/PR_ARC_INVENTORY.md index 90bd11b3..a6a2d7b3 100644 --- a/.claude/board/PR_ARC_INVENTORY.md +++ b/.claude/board/PR_ARC_INVENTORY.md @@ -108,6 +108,27 @@ **Docs:** plan `classid-canon-custom-flip-v1.md` (phases now P0/P1/P2 DONE, P3 in q2 #71, P4 open); EPIPHANIES `E-CLASSID-FLIP-P1-LANDED` + `E-CLASSID-COMPAT-READER`; fleet inventories in AGENT_LOG. Sibling merges: OGAR #147, MedCare-rs #180, woa-rs #177; open: q2 #71, openproject-nexgen-rs #68 (lock bumped `ff3777b`, gate closed). **Confidence (2026-07-02):** HIGH — 774 contract tests (guid-v3-tail) + 759 default + doctests + dependents (callcenter/shader-driver/planner/rbac/ogar) green; clippy -D warnings; fleet verified per-repo. +## #625 lance-graph: brick-3 RAN (truncation-disallowed / overflow-as-SoC-reroute) + DO-arm 3-bucket triage + +**Status:** MERGED 2026-07-02 (merge commit `5561908`), branch `claude/medcare-bridge-lance-graph-wmx76z`. Knowledge-tier PR — closes the record-vs-reality drift after #616/#617: the design record catches up to the measurement. + +**Added:** `.claude/knowledge/ast-as-partof-isa-address.md` corrections — Status CONJECTURE → PARTIALLY MEASURED (carrier #613/#614/#615 shipped AND the rank-minter brick-3 has RUN: `ruff_csharp_spo` harvest → `ruff_spo_address::{mint, mint_factored}` → `medcare_probe`); "The missing brick" → "The brick that ran"; Next-bricks checkmarked with the real open bricks (reroute *execution* in the mint pipeline, probe re-run blocked on harvest input data, classid Canon:Custom half-order, LSP serve end). New `.claude/knowledge/do-arm-triage-3-bucket.md` — the operator's 3-bucket DO-residue triage (fuzzy/order-varying → canonicalize-first; anticipated standard DO → ontologically-shaped landing zone as ONE DTO adapter + codebook swiss-knife `open`/`filter`/`reorder`/`apply_mask`; truly random → hand-port, recurrences graduate to bucket 2), refining OGAR's 85/15 split; records the C#/C++ DO-extractor gap (`ruff_python_dto_check` is Python-only). Lock: ogar pin `597ecb1 → a0c7936` (post-OGAR-#146). EPIPHANIES `E-BRICK3-RAN-TRUNCATION-DISALLOWED` (same-commit hygiene). + +**Locked:** the naive fixed-width 6-tier `(part_of:is_a)` mint is FALSIFIED at real-corpus scale (mass truncation + god-class collisions); `mint_factored` (base-255 positional path + `is_a`-from-`inherits`-only) is the corrected minter. **Truncation is DISALLOWED by policy** — bucket overflow (256-cap / 6-tier depth) is a separation-of-concerns REROUTE trigger (split the god-class or escalate a cascade level; never truncate, never field-widen — the OGAR `256-cap-is-a-lint` law #130/#140 made operational). Division of labour: `mint_factored` = addressing precision; overflow→SoC-reroute = structure. Overflow *classification* SHIPPED upstream as `ruff_spo_address::soc` (`soc_findings` → `SocVerdict`, `law_holds`; class-conditioned cascade shapes Rails `6×2` / other `4×3` / canonical GUID `3×4`, all `G·D = 12`). **Privacy split:** proprietary corpus numbers live ONLY in private MedCare-rs `.claude/archive/ruff-spo-address-medcare-probe/`; the lance-graph tree carries the design consequence, zero corpus identifiers. + +**Deferred:** overflow-reroute *execution* inside the mint pipeline (the lint flags, a human splits); `medcare_probe` re-run on the current minter (needs corpus/NDJSON access); C#/C++ DO harvester (bucket-2 landing-zone extractor); classid Canon:Custom half-order (superseded mid-arc by the #627 canon:custom flip plan). + +**Mid-arc supersession note (immutable history):** this branch briefly carried the OSINT mirror rows + a `SHIPPED_ROOT_SLOT_CONCEPTS = [0x0700]` zero-slot carve-out (the ISS-OGAR-OSINT-MIRROR-PENDING READY PATCH). OGAR #146 executed the operator ruling ("OSINT contributes ZERO vocabulary rows — low byte is APPID space, domain-wise"), removing both #145 mints; the fuse balances 65 == 65 with zero mirror-side changes, so those commits were DROPPED in the rebase onto #626/#627 and never merged. Main's ISSUES.md (`ISS-OSINT-SYSTEM-ROOT-SLOT-VIOLATION` RESOLVED 2026-07-02) is authoritative. + +**Docs/board:** EPIPHANIES ×1; the two knowledge docs above; PR comments record the scope arc + the dropped-commit correction. + +**Confidence (2026-07-02):** HIGH for the knowledge content (brick-3 findings mirror the private archive's measured record; re-fetch diff against ruff `b459ec3` confirmed `lib.rs` byte-identical + `soc.rs` as the movement). Lock verified: contract `ogar_codebook` 8/8 + `lance-graph-ogar` standalone green at `a0c7936` (compile-time COUNT_FUSE holds); consumer medcare-bridge (`--features ontology`) compiles clean. NOTE: merged BEFORE #628's P1 flip — the ast-address doc's classid examples predate `ClassidOrder::CanonHigh`; interpret per the flip (canon `domain:appid` = HIGH u16). + +**Cross-ref:** #616/#617 (the ast-address doc lineage); #623 (OGAR sink-in plan); OGAR #145/#146 (OSINT mint + zero-rows ruling); ruff `b459ec3` (`ruff_spo_address` + `soc`); `E-CODEBOOK-MINT-IS-A-CROSS-REPO-ARC`; MedCare-rs private archive (RESTORE-STATUS re-fetch log). + +**Correction (2026-07-02, from the OGAR+ruff review fan-out):** the Locked line's "`mint_factored` … is the corrected minter" overstates its location — on public ruff main only `mint` + `soc.rs` exist; `mint_factored`+`RadixCodebook` are stranded on branch `claude/medcare-ruff-csharp-sync-4iahey` (`505fdc4`), which predates and LACKS `soc.rs`. The corrected-minter state exists only as the union of two diverged branches. See `E-BRICK3-CORRECTION-MINT-FACTORED-IS-SPLIT-BRAIN`. + +--- ## #627 lance-graph: classid canon:custom flip TRIGGERED — migration plan v1 + operator ruling record (doc-only) diff --git a/.claude/board/TECH_DEBT.md b/.claude/board/TECH_DEBT.md index 3b14c6d5..cdecec09 100644 --- a/.claude/board/TECH_DEBT.md +++ b/.claude/board/TECH_DEBT.md @@ -2946,3 +2946,8 @@ bijection needs re-seeding. Pair: D-IDENTITY-4. ## TD-CALLCENTER-QUERY-CLIPPY — 2026-06-20 — OPEN **Owed:** `cargo clippy -p lance-graph-callcenter --features query --lib --tests -- -D warnings` fails on PRE-EXISTING debt unrelated to the graph-adapter work: `oxrdf::Subject` deprecation (`src/edge.rs`, use `NamedOrBlankNode`), doc-list overindent + misc in `savant_reasoners.rs` / `vsa_udfs.rs` / `ttl_parse.rs` / `transcode/zerocopy.rs` / `hydrators/owl.rs`. Surfaced (not caused) by the 16-family-adapter PR, whose own files (`graph_table.rs`, `graph_gremlin.rs`) are clippy-clean (verified: zero errors originate in them). **Why deferred:** out of scope — fixing the oxrdf deprecation + doc lints across 6 unrelated modules is its own sweep; this PR is the OSINT graph adapter. **Pay when:** a callcenter-clippy-hardening pass, or opportunistically when those modules are next touched. + +## 2026-07-02 — TD-FLEET-CADENCE (F3/F5/F6, from E-FLEET-CADENCE-PROCESS-FINDINGS) +- **TD-CI-EXCLUDED-FUSE (F5):** main's CI never compiles the workspace-`exclude`d `lance-graph-ogar`, so its compile-time `COUNT_FUSE` fires only in *consumers'* builds (medcare hit E0080 twice). Fix: one CI job `cargo check`-ing the excluded crate against OGAR main. Effort S. +- **TD-OGAR-LOCK-UNDECIDED (F3):** `lance-graph-ogar/Cargo.lock` is gitignored → fresh checkouts build the fuse against OGAR HEAD (floating canary) while the workspace lock pins. Decide canary-vs-pin; document in one sentence. Effort S. +- **TD-BOARD-PREPEND-CONFLICTS (F6):** at fleet cadence the append-only board files (EPIPHANIES/LATEST_STATE/PR_ARC) are the only recurring rebase-conflict cost (~30-60 min/day/session). Per-entry board files + generated index make the conflict structurally impossible. Council-sized; forwarded to the V3/coordination session. diff --git a/.claude/handovers/2026-07-02-cross-session-wishlist-synthesis.md b/.claude/handovers/2026-07-02-cross-session-wishlist-synthesis.md new file mode 100644 index 00000000..81474c1f --- /dev/null +++ b/.claude/handovers/2026-07-02-cross-session-wishlist-synthesis.md @@ -0,0 +1,76 @@ +# Cross-session wishlist synthesis — 2026-07-02 (post-#630/#631) + +> From: the medcare-bridge session (branch `claude/medcare-bridge-lance-graph-wmx76z`). +> Inputs: this session's E1–E10 sweep (OGAR@19373a2 + ruff@b459ec3 review fan-out), +> the coverage session's grounded wishlist (ruff/OGAR/V3 items with acceptance +> tests), op-nexgen's R/L/O/X wishlist (2026-07-02). Operator relayed all three. +> APPEND-ONLY once committed; corrections cite their pass. + +## Ratified-by-convergence (≥2 sessions independently) + +1. **Two-sided fuses** — OGAR-side flip/COUNT_FUSE pinning test; "a dependency + contract named on one side is a slogan." (this session #1 ≡ coverage #7) +2. **Counts pinned by tests, never prose** — predicate-count pin (62), MethodSig + existence/parity pin, post-flip prose sweep. (E8 ≡ coverage #1/#2) +3. **Governance metrics = zero-dep contract folds** — classid_scan (#630) → + emission_scan (op-nexgen L2) is a design language now; name it in EPIPHANIES + so the next metric follows it (never a grep). +4. **F17 body triage** — unblocked since 06-30, consumed by nothing; flagged by + all three sessions. Most-agreed next move on the DO path. (mine #9 ≡ R6) +5. **Board prepend-collision fix** — per-entry board files (coverage #8) + + COORDINATION.md per repo (op-nexgen X1). Measured cost datapoint: 3 of this + session's rebases conflicted ONLY on board prepends. + +## Dedup decisions (avoid parallel work) + +- **E2-ruby DROPPED in favor of op-nexgen R1** (D-AR-3.5 column stratum from + the migration DSL — better Rails truth source than model-body extract_fields; + measured 99/65/27-typed on the real corpus). E2-python (`inherits_from` + emission in ruff_python_spo) STANDS — uncovered elsewhere; gates + mint_factored's is_a axis on Odoo. +- **"Disposition ledger" (coverage #5) ≡ the 3-bucket DO triage** + (`do-arm-triage-3-bucket.md`, #625): buckets = the routing decision, + disposition ledger = its conservation accounting. Cross-reference as ONE + doctrine; do not let two vocabularies grow. + +## ruff needs ONE sync arc (and minimal governance) + +Pending ruff work from three sessions: mint_factored split-brain rebase (E1), +coverage items 1–5, nexgen R1–R8 (incl. a vendored diff targeting "pristine +main" and R7's already-failing branch fixture). Proposed integration order: +(1) mint_factored rebase (smallest, oldest, ruff_spo_address only) → +(2) R1 D-AR-3.5 while main is pristine for the diff → +(3) R2 curated fixes + R7 fixture reconciliation → +(4) predicate-manifest parity test LAST (pins the union, guards forever). +Plus: give ruff a COORDINATION.md + 20-line LATEST_STATE before the arc starts. + +## One operator ruling covers two byte-truth conflicts + +E7 (hi-u16: `domain:appid` in le-contract vs `domain:concept-slot` in OGAR +canon) and coverage #9 (EdgeBlock: OGAR `key16+value496` vs lance-graph CANON +`key16|edges16|value480`) are the same defect class: byte layout stated +divergently in two append-only ledgers. Settle both in one ruling; the form of +the settlement: one set of consts + size asserts both repos PIN, both +CLAUDE.mds POINTING, not restating (#630 M7 is the in-repo precedent). + +## Columnar-interchange guard + +op-nexgen L3 (Arrow triples, 5 columns s p o f c) and this session's E5 (Mint → +Arrow facets batch) MUST share one `ruff-interchange` record-batch schema +family + one provenance header (R5), and the provenance stamp must include +`minter@sha` — E1's split-brain proved an artifact that doesn't name its +minter is unverifiable. Two adjacent Arrow schemas defined independently would +recreate the field_type three-dialect problem at the columnar layer. + +## Gap no list claimed + +**Probe-corpus archival rule, operationally:** F17, count_adoption-vs-bake, and +the medcare probe re-run will each produce a number quoted for months — archive +the reproduction (input + generation recipe + hash) WITH the run, or we +re-create "last measured, can't re-verify." + +## Kept by this session + +E1 mint_factored rebase (step 1 of the ruff arc), E2-python inherits_from, +C#-golden vs Predicate::ALL, E5 Mint emission (pending the shared interchange +schema decision), predicate-manifest test (step 4). diff --git a/.claude/handovers/2026-07-02-entropy-reduction-and-epiphany-ledger.md b/.claude/handovers/2026-07-02-entropy-reduction-and-epiphany-ledger.md new file mode 100644 index 00000000..8845e97d --- /dev/null +++ b/.claude/handovers/2026-07-02-entropy-reduction-and-epiphany-ledger.md @@ -0,0 +1,139 @@ +# Entropy-reduction pass + epiphany ledger — 2026-07-02 + +> From: the `claude/medcare-bridge-lance-graph-wmx76z` session (medcare-bridge / +> ruff-harvester / cross-session synthesis). Companion to +> `2026-07-02-cross-session-wishlist-synthesis.md` — this file adds the +> **process epiphanies** (durable, fleet-wide) and turns the wishlist into a +> **status-annotated ledger** (claim-of-record) so executed items stop being +> re-derived. APPEND-ONLY; status lines updatable. + +## Why this file exists (the entropy diagnosis) + +Three entropies force re-derivation of reality every turn: +1. **Stale local state** — a session's branch lags a fast-moving main. +2. **Ephemeral epiphanies** — insights live in chat, evaporate at session end. +3. **No claim-of-record** — executed wishlist items have no done-marks; work + gets nearly re-done (proven this session — see F7). + +This file kills #2 and #3 durably; the paired rebase kills #1. + +## Process epiphanies (F-pass, durable — the fleet needs these) + +- **F1 — Pin propagation is the third leg of the cross-repo arc.** The mint + + mirror rows + **lock pin** land in ONE arc, never split. An arc that ships the + mirror-row change without bumping its own `Cargo.lock` pin ships a + fuse-broken contract to every consumer while both sides' own tests stay green. + (Root of the recurring "OGAR concept count changed, consumer build E0080s".) +- **F2 — Unpinned environments falsify TRUE states.** Verified live this + session: a local `origin/main` remote-tracking ref read #636 then #631 then + #636 across three commands (container re-provisioned to an older clone + snapshot mid-turn). A verification whose environment isn't pinned can raise a + false alarm on a correct state. Discipline: `git -C ` + explicit + re-`fetch` + echo the resolved SHA **before** concluding; never trust a + remote-tracking ref you haven't refreshed this turn. +- **F3 — A gitignored lockfile is an *undecided* design, not a neutral one.** + `lance-graph-ogar`'s own `Cargo.lock` is untracked → fresh checkouts build its + `COUNT_FUSE` against OGAR **HEAD** (a floating canary) while the workspace + lock pins. Canary or pin are both defensible; *accidental* is not. One doc + sentence deciding it removes a "works here, breaks there" class. +- **F4 — Executed wishlists need a claim-of-record.** Convergent multi-session + execution without a shared done-ledger risks double-work AND silently-dropped + halves (e.g. a two-part item where only part 1 is confirmed). This ledger is + the fix. +- **F5 — CI-invisible fuses only fire in *other people's* builds.** Main's CI + never compiles the workspace-`exclude`d `lance-graph-ogar`, so lance-graph + learns its own mirror broke the contract only when a *consumer* (medcare, + twice) hits E0080. A single CI job that `cargo check`s the excluded crate + makes the fuse fire where the change is made. +- **F6 — Rebase economics inverted.** At ~5 fleet-merges/day the board-prepend + conflicts (EPIPHANIES/LATEST_STATE/PR_ARC) are the only recurring rebase cost; + that's 30–60 min/day per parallel session. Per-entry board files (one file per + entry + generated index) make the conflict structurally impossible — graduated + from nice-to-have to cheapest recoverable overhead in the system. +- **F7 — Claim-of-record prevents near-collisions (proven).** I was one command + from re-doing the `mint_factored`+`RadixCodebook`+`soc.rs` union — it was + already unified on ruff branch `claude/medcare-ruff-csharp-sync-4iahey` + (`94f919a`, "public-safe", −308 the medcare probe), just unmerged to ruff main. + Only incidental fetch output revealed it. Without this ledger the collision + recurs. +- **F8 — "No PR unless asked" is a de-interlacing rule, not a PR ban + (operator clarification, 2026-07-04).** The harness's "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. **The first PR per branch is fine to open + autonomously, as long as no other session is working that branch in + parallel.** Operational test before opening: (1) is this the *first* open PR + for this branch→base pair (no existing open PR to stack on — check + `list_pull_requests state=open head=`)? (2) is any parallel session + live on this same branch (broadcast / AGENT_LOG)? First-PR + solo-on-branch ⇒ + open it; otherwise hold and coordinate. This resolves the tension that made + me pause on the OGAR LEG-2 PR: ruff #40 was merged/closed and no parallel + session was on the OGAR branch, so opening it was always the correct + autonomous move — the caution was mis-calibrated. Corollary: the value the + rule protects is a *clean linear PR history per branch*, which the F6 + per-entry-board-files fix and the claim-of-record ledger (F4/F7) already + serve — same "don't interleave dirty state" family. + +## Wishlist status ledger (claim-of-record) + +Legend: **VERIFIED** (I read the code/count) · **CLAIMED-BY-COMMIT** (merge +message asserts it; not independently verified) · **OPEN** · **UNVERIFIED**. + +### OGAR-lane items (forwarded → executed by #148 `75d955b`) +| # | Item | Status | +|---|---|---| +| 1 | OGAR-side flip fuse (`app_of/concept_of` vs contract `ClassidOrder`) | CLAIMED-BY-COMMIT (#148 "flip fuse") — verify test exists | +| 2 | Genetics `0x0E` domain + reserve `0x1000` + q2 APP_PREFIX row | PARTIAL — `0x1000` reservation + Genetics domain CLAIMED-BY-COMMIT (#148); **q2 APP_PREFIX row UNVERIFIED** | +| 4 | OGAR post-flip prose sweep | CLAIMED-BY-COMMIT (#148 "post-flip prose sweep") | +| 6 | Fill `0x08XX` OCR slots (`unicharset`/`recoder`/`charset`) | **VERIFIED** — 3 rows, codebook 65→68 | +| 7 | Two-sided `COUNT_FUSE` | CLAIMED-BY-COMMIT (#148 "COUNT_FUSE" two-sided) | +| — | Main's own ogar lock propagated to #148 | **VERIFIED** — main `Cargo.lock` pin = `75d955b`, mirror = 68 (F1 resolved on main) | + +### Byte-truth / contract items +| # | Item | Status | +|---|---|---| +| 4b | `Facet`↔`FacetCascade` byte-parity test (cross-repo) | **UNVERIFIED (B4)** — flip fuse confirmed, byte-parity half not confirmed present | +| — | `emission_scan` / `RouteBucketTyped` (op-nexgen L1/L2) | CLAIMED-BY-COMMIT (#632) | + +### ruff-lane items (this session's kept work — HELD by operator "don't start yet") +| # | Item | Status | +|---|---|---| +| E1 | `mint_factored`+`RadixCodebook`+`soc.rs` union | **DONE + MERGED** — ruff PR #39 landed `94f919a` onto main (`3dba017`); verified green (18 tests, 0 failed, 2026-07-02). Split-brain closed. | +| E2-py | `inherits_from` emission in `ruff_python_spo` | **SHIPPED — ruff PR #40 (2026-07-04).** Frontend-agnostic `Model.inherits: Vec` on the shared IR + expander arm `(ns:model, InheritsFrom, ns:parent)` @Authoritative (0.95/0.90) + Odoo frontend wired (`_inherit` string/list via `walk.rs`); bare-`_inherit` reopen self-edge EXCLUDED. Reuses `Predicate::InheritsFrom` (62-lock intact); serde-skip-if-empty (ndjson byte-compat). 18+ tests green. **Gate moved to LEG 2 (OGAR lift).** | +| E2-ogar | `ogar-from-ruff` lift consumes `Model.inherits` | **SHIPPED — OGAR branch `e8679f5` (2026-07-04).** ruff #40 merged → bumped OGAR ruff-pin (`61ce2b49`) → `lift_model_with_language` now `class.mixins.extend(model.inherits)`. **The multi-parent "decision" was already answered by the vocab:** `Class::mixins` doc names `_inherit`; `Class::inheritance` excludes mixins. So `_inherit` → `mixins` (multi-parent `Vec`), NOT `parent` — no widening, no loss, no axis violation. 48 tests green (+2), workspace check + clippy clean. Ledger: OGAR `D-OGAR-ODOO-INHERIT-MIXINS`. Supersedes the earlier "widen parent" framing. | +| E2-render | askama `ClassView × FieldMask → struct + methods` (D-VCW-3, operator-redirected) | **SHIPPED — OGAR PR #149 / branch `b4e5cca` (2026-07-04).** Operator redirected LEG 3 from "row view" to a compile-time (askama = ERB analog) transpiler emitting a **struct** (fields gated by `ClassView × FieldMask` over the ObjectView N3 order) **+ a struct-of-methods constructor** (OGAR `ActionDef` DO-arm → methods; `on_enter` ⇒ `&mut self`). Ruling: behaviour is Rust methods, **NOT** SurrealQL DDL (deprecated AST adapter). `ogar-render-askama::render_class_with_methods`; +6 tests, 50 green, clippy -D warnings clean; end-to-end verified (masked `account.move` drops field 1). Ledger: OGAR `D-OGAR-RENDER-CLASSVIEW-FIELDMASK-METHODS`. Chain complete: LEG 1 (#40) + LEG 2 (#149) + LEG 3 (#149). | +| E2-ruby | ruby `extract_fields` | CEDED to op-nexgen R1 (migration-DSL column stratum is the better Rails truth source) | +| E3 | predicate-manifest parity test + C# `Program.cs`-vs-`Predicate::ALL` golden | OPEN | +| E5 | `Mint` → ndjson (now) / Arrow (after shared interchange-schema decision) | OPEN — landing zone is the #630/#631 WAL batch writer | + +## Open operator decisions (unblock the fleet) +- **One authoritative high-half naming** — le-contract `domain:appid` vs OGAR + general canon `domain:concept-slot`; settle once, pin as shared consts both + repos reference (merges with the EdgeBlock `value480` vs `value496` divergence + — same defect class, one ruling). +- **Probe-ledger Wave A green-light** (OGAR PROBE-SUBSTRATE-PROPOSAL §9). +- **F3** — `lance-graph-ogar` lockfile: canary or pin? + +## This session's immediate next (guided by the epiphanies) +1. ~~Commit this ledger~~ ✓ · 2. ~~Rebase onto #636~~ ✓ (lock inherited #148). +3. ~~Phase 1 (ruff mint_factored union)~~ ✓ **DONE+MERGED via ruff #39** — + verify-first caught it was already on main (avoided a redundant PR; F7). +4. ~~Phase 2 (`inherits_from` emission in `ruff_python_spo`)~~ ✓ **SHIPPED via + ruff PR #40** — frontend-agnostic `Model.inherits` on the shared IR + Odoo + frontend wired; self-edge reopen guard; 62-lock intact. + **Frontier = the middle + render legs, both cross-lane (forwarded, not built + unilaterally — F4):** + - **LEG 2 (OGAR):** bump OGAR ruff-pin post-#40, map `Model.inherits → + Class.parent`/is_a facet, decide single-vs-multi-parent. Blocks the Odoo + is_a axis at the Core. Broadcast 2026-07-04. + - **LEG 3 (V3, D-VCW-3):** askama `ClassView × FieldMask → row view`; + build against Rails STI first (populated today), extend to Odoo after + LEG 2. Broadcast 2026-07-04. + Then ruff Phase 3 (predicate-manifest parity + C# golden), Phase 4 + (`Mint` → ndjson into WAL). +5. Open for operator: B4 (facet byte-parity test?), high-half naming ruling, + probe-ledger Wave A green-light, F3 lockfile decision, LEG-2 single-vs-multi- + parent ruling (`Class.parent` widen to `Vec` or primary+relation). +6. **F2/F3 note:** the local lance-graph + ruff checkouts churned to stale + snapshots repeatedly this arc; the REMOTE branch survived every time. Push + early, treat remote as truth, `git -C ` + re-fetch before every read. diff --git a/Cargo.lock b/Cargo.lock index 3ecf60db..1a89f02e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4932,7 +4932,7 @@ dependencies = [ [[package]] name = "lance-graph-contract" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/lance-graph?branch=main#df367471df8cc74464733554b4c2338f90eae7d4" +source = "git+https://github.com/AdaWorldAPI/lance-graph?branch=main#b74378c7853a9b03b48adb29537e45af6524728c" dependencies = [ "glob", "serde", @@ -6043,7 +6043,7 @@ dependencies = [ [[package]] name = "ogar-adapter-surrealql" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#75d955bd3bfd1b97987ab9e4c2c1cedfcda1adfe" +source = "git+https://github.com/AdaWorldAPI/OGAR?rev=58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d#58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" dependencies = [ "ogar-vocab", ] @@ -6051,7 +6051,7 @@ dependencies = [ [[package]] name = "ogar-class-view" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#75d955bd3bfd1b97987ab9e4c2c1cedfcda1adfe" +source = "git+https://github.com/AdaWorldAPI/OGAR?rev=58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d#58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" dependencies = [ "lance-graph-contract 0.1.0 (git+https://github.com/AdaWorldAPI/lance-graph?branch=main)", "ogar-vocab", @@ -6060,12 +6060,12 @@ dependencies = [ [[package]] name = "ogar-ontology" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#75d955bd3bfd1b97987ab9e4c2c1cedfcda1adfe" +source = "git+https://github.com/AdaWorldAPI/OGAR?rev=58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d#58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" [[package]] name = "ogar-vocab" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#75d955bd3bfd1b97987ab9e4c2c1cedfcda1adfe" +source = "git+https://github.com/AdaWorldAPI/OGAR?rev=58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d#58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" [[package]] name = "once_cell" diff --git a/crates/lance-graph-contract/src/ogar_codebook.rs b/crates/lance-graph-contract/src/ogar_codebook.rs index 4f83a9aa..b60e33c4 100644 --- a/crates/lance-graph-contract/src/ogar_codebook.rs +++ b/crates/lance-graph-contract/src/ogar_codebook.rs @@ -80,7 +80,13 @@ pub enum ConceptDomain { /// `ogar_vocab::ConceptDomain::Genetics` — OGAR catches up under the drift /// guard (the parity tests pin `0x0E00 → Genetics`). Genetics, - /// Any high-byte slot not yet assigned a domain (`0x03XX`–`0x06XX`, `0x0FXX`+). + /// `0x0FXX` — Geo (OpenStreetMap geodata: node / way / relation / changeset / + /// element-tag / member / note / GPX trace / user). Public spatial reference + /// data; the Geo domain binds the HHTL tier axes to literal (x, y) tiles + /// (OGAR canon "256×256 centroid tile", D-BOTHCASC). Mirrors OGAR + /// `ogar_vocab::ConceptDomain::Geo`; the parity tests pin `0x0F00 → Geo`. + Geo, + /// Any high-byte slot not yet assigned a domain (`0x03XX`–`0x06XX`, `0x10XX`+). Unassigned, } @@ -102,6 +108,7 @@ pub fn canonical_concept_domain(id: u16) -> ConceptDomain { 0x0C => ConceptDomain::Automation, 0x0D => ConceptDomain::HR, 0x0E => ConceptDomain::Genetics, + 0x0F => ConceptDomain::Geo, _ => ConceptDomain::Unassigned, } } @@ -533,6 +540,20 @@ pub const CODEBOOK: &[(&str, u16)] = &[ ("action_handler", 0x0C07), ("action_applicability", 0x0C08), ("automation_trigger", 0x0C09), + // ── 0x0FXX — Geo domain (OpenStreetMap geodata; OGAR OSM harvest, PR #152). + // The core OSM graph — node / way / relation / changeset — plus element tags, + // relation members, way nodes, notes, GPX traces, and the user. `Old*` + // versioned rows ground to the same concept (temporal axis, not a new id). ── + ("osm_node", 0x0F01), + ("osm_way", 0x0F02), + ("osm_relation", 0x0F03), + ("osm_changeset", 0x0F04), + ("osm_element_tag", 0x0F05), + ("osm_relation_member", 0x0F06), + ("osm_way_node", 0x0F07), + ("osm_note", 0x0F08), + ("osm_gpx_trace", 0x0F09), + ("osm_user", 0x0F0A), ]; /// Resolve a **canonical-concept** string to its stable `u16` codebook id via @@ -613,7 +634,9 @@ mod tests { assert_eq!(canonical_concept_domain(0x0500), ConceptDomain::Unassigned); // Genetics (0x0E) operator-allocated 2026-06-26 for CPIC-V3 (was Unassigned). assert_eq!(canonical_concept_domain(0x0E00), ConceptDomain::Genetics); - assert_eq!(canonical_concept_domain(0x0F00), ConceptDomain::Unassigned); + // Geo (0x0F) allocated with the OSM harvest (OGAR #152; was Unassigned). + assert_eq!(canonical_concept_domain(0x0F00), ConceptDomain::Geo); + assert_eq!(canonical_concept_domain(0x1000), ConceptDomain::Unassigned); } #[test] diff --git a/crates/lance-graph-ogar/Cargo.toml b/crates/lance-graph-ogar/Cargo.toml index a076c598..82cba2ea 100644 --- a/crates/lance-graph-ogar/Cargo.toml +++ b/crates/lance-graph-ogar/Cargo.toml @@ -78,14 +78,21 @@ lance-graph-contract = { path = "../lance-graph-contract" } # against live in lance-graph-ontology (OGIT). OGIT does NOT depend on OGAR. lance-graph-ontology = { path = "../lance-graph-ontology" } -# ── OGAR Active-Record forks: git deps @ main (the canonical superset; matches +# ── OGAR Active-Record forks: git deps (the canonical superset; matches # symbiont's pins so they resolve to ONE source in the golden image) ── -ogar-vocab = { git = "https://github.com/AdaWorldAPI/OGAR", branch = "main" } -ogar-class-view = { git = "https://github.com/AdaWorldAPI/OGAR", branch = "main" } -ogar-ontology = { git = "https://github.com/AdaWorldAPI/OGAR", branch = "main" } +# +# TEMP-PIN to OGAR #152 rev (Geo/OSM + network_layer codebook mint: +# class_ids::ALL 68→79). The mirror in lance-graph-contract carries the same +# concepts, so COUNT_FUSE (mirror::CODEBOOK.len() == ogar_vocab::class_ids::ALL +# .len()) requires BOTH sides at 79. OGAR main is still 68 until #152 merges — +# pinning to the pushed rev keeps the lockstep green now. REVERT the four deps +# to branch = "main" once OGAR #152 lands on main (one source in the golden image). +ogar-vocab = { git = "https://github.com/AdaWorldAPI/OGAR", rev = "58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" } +ogar-class-view = { git = "https://github.com/AdaWorldAPI/OGAR", rev = "58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" } +ogar-ontology = { git = "https://github.com/AdaWorldAPI/OGAR", rev = "58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" } # default features only = the light emit() DDL formatter (no surrealdb tree); # the parser half is opt-in via this crate's `surrealql-parser` feature. -ogar-adapter-surrealql = { git = "https://github.com/AdaWorldAPI/OGAR", branch = "main" } +ogar-adapter-surrealql = { git = "https://github.com/AdaWorldAPI/OGAR", rev = "58a64d4701eaf70ff67fe53a5e2087d5d0c48c0d" } # Fold ogar-class-view's transitive `lance-graph-contract` (git # AdaWorldAPI/lance-graph#main) onto the SAME path copy this crate uses, so there diff --git a/crates/lance-graph-ogar/src/lib.rs b/crates/lance-graph-ogar/src/lib.rs index bf9abde8..ee4b75d9 100644 --- a/crates/lance-graph-ogar/src/lib.rs +++ b/crates/lance-graph-ogar/src/lib.rs @@ -144,6 +144,8 @@ pub mod parity { | (O::Auth, C::Auth) | (O::Automation, C::Automation) | (O::HR, C::HR) + | (O::Genetics, C::Genetics) + | (O::Geo, C::Geo) | (O::Unassigned, C::Unassigned) ) }