diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 207af434..03015ce9 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -141,6 +141,46 @@ OGAR `docs/OSINT-SUBSTRATE-REUSE-MAP.md` (ClassView + askama-ERB transfer stack) `ISS-OSINT-SYSTEM-ROOT-SLOT-VIOLATION` (the frozen-side id fix). --- +## 2026-07-01 — E-BRICK3-RAN-TRUNCATION-DISALLOWED — the (part_of:is_a) rank-minter brick-3 RAN; naive 6-tier mint falsified at scale; truncation is DISALLOWED (overflow = SoC-reroute trigger); DO-arm residue triaged into 3 buckets + +**Status:** FINDING (brick-3 measured) + DOCTRINE (operator: "truncations were +disallowed / we introduced bucket overflow with separation of concerns as a +trigger for rerouting"; the 3-bucket DO triage). + +**What ran.** The `ast-as-partof-isa-address.md` "missing brick" (deterministic +part_of/is_a rank-minter) is no longer missing — public `ruff_spo_address::{mint, +mint_factored}` shipped and the brick-3 probe RAN against a real C# corpus via +`ruff_csharp_spo` + `medcare_probe`. Result: the **naive fixed-width 6-tier +`(part_of:is_a)` packing was falsified at scale** (mass truncation + god-class +collisions); **`mint_factored`** (base-255 positional path + +`is_a`-from-`inherits`-only) drives truncation AND collisions to 0. The +proprietary measured numbers live ONLY in the private MedCare-rs +`.claude/archive/ruff-spo-address-medcare-probe/` (MedCare-rs is private; +lance-graph + ruff are not) — this board records the design consequence, never +the numbers. + +**The doctrine (operator).** Truncation is **disallowed by policy** — not +"reduced by a bigger packer." A bucket that exceeds capacity (256-cap or 6-tier +depth) neither truncates nor field-widens: **the overflow itself is the +separation-of-concerns REROUTE trigger** — split the god-class into sub-concerns, +or escalate to the next cascade level. This is the OGAR `256-cap-is-a-lint` law +made operational (`scale = the next cascade level, never field-widening`, OGAR +#130/#140). Division of labour: `mint_factored` = addressing precision; +overflow→SoC-reroute = structure. + +**DO-arm triage (operator, new doc).** The behavioural residue after the THINK +arm partitions into 3 buckets: (1) **fuzzy/order-varying** → canonicalize first, +re-triage; (2) **anticipated standard DO** → ontologically-shaped landing zone, +do ONCE as DTO adapter + codebook swiss-knife (`open`/`filter`/`reorder`/ +`apply_mask`); (3) **truly random** → hand-port, partially inventing new standard +interfaces so recurrences graduate to bucket 2. Refines OGAR's 85/15 split. Gap: +the DO extractor (`ruff_python_dto_check`) is **Python-only** — no C#/C++ DO +harvester yet. Full doc: `.claude/knowledge/do-arm-triage-3-bucket.md`. + +**Docs updated in this arc:** `ast-as-partof-isa-address.md` (Status → +PARTIALLY MEASURED; headline section rewritten with measured design consequence; +"missing brick" → "brick that ran"; Next-bricks checkmarked + re-fetch/reroute- +automation/LSP open bricks), new `do-arm-triage-3-bucket.md`. ## 2026-07-01 — E-OGAR-LANCEGRAPH-MOVE-IN-PARALLEL — OGAR + lance-graph are one coupled pair moved together every session; the `COUNT_FUSE` is the intentional dependency contract that enforces it (NOT a break to engineer away) diff --git a/.claude/knowledge/ast-as-partof-isa-address.md b/.claude/knowledge/ast-as-partof-isa-address.md index 0a8536b0..6cc61ae2 100644 --- a/.claude/knowledge/ast-as-partof-isa-address.md +++ b/.claude/knowledge/ast-as-partof-isa-address.md @@ -2,8 +2,13 @@ > **READ BY:** integration-lead, truth-architect, core-first-architect, > family-codec-smith, baton-handoff-auditor -> **Status:** CONJECTURE (design; the **carrier is now SHIPPED** — see V3 -> alignment below — only the rank-minter is unbuilt/unmeasured). +> **Status:** PARTIALLY MEASURED (design; the **carrier is SHIPPED** — see V3 +> alignment below — and the **rank-minter brick-3 has now RUN** against a real +> corpus. The naive 6-tier `(part_of:is_a)` mint was **falsified at scale**; +> `mint_factored` is the corrected minter. The measured numbers are proprietary +> and live **only** in the private `MedCare-rs` +> `.claude/archive/ruff-spo-address-medcare-probe/` — this doc records the +> *design* consequence, not the numbers.). > **Cross-ref:** `crates/lance-graph-contract/src/facet.rs` (the **SHIPPED** > `FacetCascade` substrate, #613/#614), `canonical_node.rs` > (`TailVariant::V3` / `mint_for` / `CLASSID_OSINT_V3`, #615), @@ -155,19 +160,61 @@ across every consumer** — MedCare / WoA / SMB / Odoo / OpenProject-nexgen all the *same* OGIT patterns (the regulatory `NTO/{Audit, Compliance, Legal}` set imported once; cf. boundary #1). That magnitude — "much cheaper than 500K LOC" — is precisely the CONJECTURE's payoff, and the brick-3 probe (MedCare harvest → -mint → SoA → LSP query, MedCareV2 oracle) is what turns it from a claim into a -measurement. - -**Headline target (CONJECTURE — the probe measures it):** OpenProject + Odoo -together as **~2 MB of GUID-encoded `(part_of:is_a)`** instead of ~20 MB / ~250K -LOC — a ~10× collapse. Dimensionally credible: at 16 B/`FacetCascade`, -2 MB ≈ **131K class/member/field nodes**, enough to hold both ERPs' structural -skeleton. The honest caveat: that 2 MB is the **THINK-arm structure + classaction -pointers**; the DO-arm `ActionDef` *bodies* don't vanish — they are minted **once** -in OGAR and shared (amortized across every consumer), so the figure is the -*per-consumer marginal* footprint over a shared primitive library, not the whole -system reduced to 2 MB. The 10× ratio is the hypothesis the MedCare probe gives -the first real datapoint for. +mint → SoA → LSP query, MedCareV2 oracle) is what turned it from a claim into a +first measurement. + +**Headline target:** OpenProject + Odoo together as **~2 MB of GUID-encoded +`(part_of:is_a)`** instead of ~20 MB / ~250K LOC — a ~10× collapse. Dimensionally +credible: at 16 B/`FacetCascade`, 2 MB ≈ **131K class/member/field nodes**, enough +to hold both ERPs' structural skeleton. The honest caveat: that 2 MB is the +**THINK-arm structure + classaction pointers**; the DO-arm `ActionDef` *bodies* +don't vanish — they are minted **once** in OGAR and shared (amortized across every +consumer), so the figure is the *per-consumer marginal* footprint over a shared +primitive library, not the whole system reduced to 2 MB. + +**What brick-3 actually measured (design consequence, numbers are private).** +The rank-minter probe RAN — `ruff_csharp_spo` harvest of a real corpus → +`ruff_spo_address::{mint, mint_factored}` → `medcare_probe`. Two findings that +change this doc's design (the proprietary counts stay in the private MedCare-rs +archive, cross-referenced below, never embedded here): + +1. **The naive 6-tier `(part_of:is_a)` mint was falsified at scale.** A packing + that maps each concept into a fixed 6-tier `(hi:lo)` cascade *truncates* a + large fraction of a real corpus and *collides* on god-classes (a WinForms + god-class exceeds the fixed per-tier 256-cap / 6-tier budget, so the naive + packer truncates and collides instead of rerouting). "2 MB" is not reachable + by naively bit-packing whatever the harvest emits. +2. **`mint_factored` (base-255 positional path + `is_a`-from-`inherits`-only) is + the corrected minter** — it drives collisions **and** truncation to 0 by + construction, because the path is positional (not a fixed-width bitfield) and + `is_a` is derived only from real inheritance edges (killing the god-class + `is_a` redundancy). + +**Truncation is DISALLOWED; bucket overflow is a separation-of-concerns REROUTE +trigger.** The falsification above is *not* "reduce truncation with a bigger +packer." Per the OGAR `256-cap-is-a-lint` law (`scale = the next cascade level, +never field-widening`; OGAR #130/#140), a tier/family that exceeds its capacity +(the 256-cap, or the 6-tier depth) does **not** truncate and does **not** +field-widen — the **overflow itself is the signal to reroute**: split the +overflowing god-class into sub-concerns (SoC), or escalate to the next cascade +level (a new family/basin). So the god-classes brick-3 surfaced are **flagged for +SoC split**, not silently mangled — the overflow is a real transcode signal (a +hundreds-of-members god-class *should* decompose), not a minter limitation. Division of +labour: `mint_factored` handles **addressing precision**; overflow→SoC-reroute +handles **structure**. Together: zero truncation, zero collision, god-classes +flagged for split. The 10× headline is therefore a *design target reachable with +`mint_factored` + overflow-reroute*, and the private archive holds the pre-policy +falsification numbers that motivated the disallow-truncation rule. + +**Where the measured numbers live (privacy).** `MedCare-rs` is private; `ruff` is +public. The proprietary corpus counts (triples/nodes/classes, truncation and +collision figures) are recorded **only** in `MedCare-rs` +`.claude/archive/ruff-spo-address-medcare-probe/` (`RESTORE-STATUS.md` + +`medcare_probe.rs`). This doc, being in the (fork-)public lance-graph tree, states +the *design* outcome and deliberately embeds **no** proprietary numbers. A +re-fetch pass against the moved-forward public `ruff` (`origin/main` `b459ec3`+, +carrying scrubbed `ruff_spo_address` + `ruff_csharp_spo`) will re-confirm the +numbers on the current minter; treat the archive's figures as *last measured*. **What the primitives actually are: laws and regulations, not CRUD shapes — content stays with the consumer.** An ERP's hard value is *compliance* (tax law, @@ -294,16 +341,24 @@ the FacetCascade carries the full address. The rank-minter therefore targets the allocation is left to ratify, and the only open ordering is the classid half-order above (Canon:Custom), which is orthogonal to per-tier packing. -## The missing brick — a deterministic part_of/is_a rank-minter +## The brick that ran — a deterministic part_of/is_a rank-minter (`mint_factored`) Between the SPO harvest and the GUID is the **one** genuinely-new component — the -carrier (`FacetCascade`) is **already shipped**, so this is the only brick to +carrier (`FacetCascade`) is **already shipped**, so this was the only brick to build: a pure-Rust, dependency-free rank-minter. Given the corpus's part_of edges + is_a edges, assign each node its `(po_rank, ia_rank)` at each tier and write them into the 6 `FacetCascade` tiers (`tier.hi = po_rank`, `tier.lo = ia_rank`); `FacetCascade::to_bytes()` is then the 16-byte facet and `hi_chain()`/`lo_chain()` the two prefix-routable hierarchies — no new layout, no new type. +**This brick has now RUN** (brick-3, public `ruff_spo_address::mint_factored`, +measured against a private corpus — see the "What brick-3 actually measured" +section above). The naive fixed-width 6-tier packing (`mint`) was falsified; +`mint_factored` (base-255 positional path + `is_a`-from-`inherits`-only) is the +corrected form, and **truncation is disallowed** — bucket overflow triggers an +SoC reroute, never a truncation or a field-widen. The description below is the +`mint_factored` design as it now stands. + - **part_of tree** (namespace → class → member): deterministic sibling/ topological rank. - **is_a lattice** (class → base, member → kind): deterministic type rank. @@ -342,21 +397,41 @@ linter surface — it is a **language-agnostic semantic-navigation surface** ove whatever frontend filled the graph (Python / C++ / **C#-MedCare** / Ruby), because at that layer it is all the same `Model`/ClassView keyed by GUIDs. -## Next bricks (ordered; each gated on the prior) +## Next bricks (ordered; ✔ = done) -1. **Slot allocation — LOCKED (shipped).** The 6-pair / 12-slot layout is the +1. **Slot allocation — LOCKED (shipped).** ✔ The 6-pair / 12-slot layout is the shipped `FacetCascade` (#613/#614); no ratification needed. The ONLY remaining ordering decision is the classid `(part_of:is_a)` half-order (the operator's - Canon:Custom correction) — orthogonal to per-tier ranking, so it does **not** - block brick 2. + Canon:Custom correction) — orthogonal to per-tier ranking. 2. **Build the deterministic rank-minter** (`ruff_spo_address`, pure std): SPO - graph → `(po_rank, ia_rank)` per level → packed slots. Verifiable in - isolation. + graph → `(po_rank, ia_rank)` per level → packed slots. ✔ **DONE** — shipped as + `mint` (naive, falsified) + `mint_factored` (corrected: positional path, + `is_a`-from-`inherits`-only, truncation-disallowed). 3. **Probe on MedCare**: `ruff_csharp_spo` harvest → mint → lance SoA → `typeHierarchy`/`definition` query → diff the class graph against the C# - original, with `MedCareV2` as the parity oracle. - -The per-tier layout is **locked** (the shipped `FacetCascade`), so brick 2 (the -rank-minter) can proceed now — it writes into existing tiers, inventing no type. -Only the classid half-order (Canon:Custom) remains a decision, and it is -orthogonal to per-tier packing, so it does not gate the minter. + original, with `MedCareV2` as the parity oracle. ✔ **RAN** (brick-3) — the naive + mint falsified at scale, `mint_factored` corrects it, overflow→SoC-reroute + handles god-classes. Proprietary numbers in the private MedCare-rs archive. + +**Remaining open bricks (post-brick-3):** + +- **Re-fetch pass** against the moved-forward public `ruff` (`origin/main` + `b459ec3`): diff RAN 2026-07-01 — `lib.rs` is **byte-identical** to the + archived snapshot; the forward movement is a **new `soc` module** (below). + The `medcare_probe` re-run on the current minter remains blocked on input + data (the harvest NDJSON is not in this container). +- **Overflow→SoC-reroute — classification SHIPPED, reroute execution open.** + `ruff_spo_address::soc` now carries the reusable `256-cap-is-a-lint` + (`soc_findings` → `SocVerdict::{Duplication, Conflation, + DuplicationAndConflation, Counterexample}`, `law_holds` falsifier) promoted + from the probe's §[G] check, CI-runnable. Operator refinement recorded there + (2026-06-29): the ClassView cascade **shape is class-conditioned, inherited + from the class's format** — Rails → `6×2`, other frameworks → `4×3`, the + canonical GUID → `3×4` (all `G·D = 12`, 8-bit tiers); never lock one shape. + What is still NOT built: *executing* the reroute (the actual SoC split / + next-cascade-level escalation) inside the mint pipeline — the lint flags, + a human splits. +- **classid half-order (Canon:Custom)**: still the one open ordering decision; + orthogonal to per-tier packing, so it did not gate the minter. +- **LSP serve end** (`ruff-lsp` → lance store): the read surface is still a clean + slate (vanilla fork, no SPO/lance wiring). diff --git a/.claude/knowledge/do-arm-triage-3-bucket.md b/.claude/knowledge/do-arm-triage-3-bucket.md new file mode 100644 index 00000000..e3bfda9f --- /dev/null +++ b/.claude/knowledge/do-arm-triage-3-bucket.md @@ -0,0 +1,161 @@ +# The DO-arm triage — three buckets, one classaction pointer + +> **READ BY:** integration-lead, core-first-architect, adapter-shaper, +> family-codec-smith, baton-handoff-auditor, truth-architect +> **Status:** DESIGN (operator-directed triage; the THINK arm is measured — +> see `ast-as-partof-isa-address.md` brick-3 — the DO arm is the residue this +> doc partitions). +> **Cross-ref:** `ast-as-partof-isa-address.md` (the THINK arm — the +> `(part_of:is_a)` structural skeleton), OGAR `OGAR-AST-CONTRACT.md` +> (`ActionDef`/`ActionInvocation`/`KausalSpec`), OGAR +> `SURREAL-AST-AS-ADAPTER.md` (behaviour flows producer → OGAR `Class`+ +> `ActionDef` → adapter, **never** producer → DDL), OGAR +> `core-first-transcode-doctrine.md` (thin classid-keyed adapters assume the +> Core), `ogar-consumer-preflight.md`. + +--- + +## Why there is a DO arm at all + +The `(part_of:is_a)` address (`ast-as-partof-isa-address.md`) holds the **THINK +arm** — the class/member/type graph, the ClassView method-resolution manifest, +the harvest's *structural* predicates (`has_function`, `inherits_from`, +`virtually_overrides`). That skeleton is now measured: `mint_factored` mints it +losslessly, truncation is disallowed, god-classes reroute by SoC. + +But an ERP is not just structure — it *does* things: posts an invoice, reconciles +a bank line, escalates a dunning level, signs a checkout. That behaviour is the +**DO arm**. It does **not** live in `(part_of:is_a)` (a method body is not a +`part_of` or `is_a` relation) and it does **not** live in DDL (OGAR +`SURREAL-AST-AS-ADAPTER.md` §0 rejects the "`DEFINE EVENT … WHEN … THEN …` +carrying lifecycle" negative-beauty hijack). It lives in `ActionDef` / +`ActionInvocation` / `KausalSpec`, **keyed by** the GUID (`CausalEdge64` on the +value/edge side), never encoded in the address. + +**The classaction pointer.** Because ontologies are lossless (OWL/OGIT class +round-trips proved bijective), the DO arm becomes an *object-oriented reusable +classaction pointer* in the consumer: the `ActionDef` **points to** a body; it +never inlines it. The transcoded almato/HIRO/arago `ActionHandler` (OGAR #125 +`ResolvingDaemon` = class-late-bound dispatch) is exactly this — the dispatch is +resolved against the class at call time, so one `ActionDef` shape serves every +consumer that imports the class primitive. The DO arm is conditionalized *at the +cost of a ClassView classaction*, not at the cost of re-transcoding the body. + +--- + +## The triage — three buckets + +Not all DO is equal. After the THINK arm is minted, the *behavioural residue* +partitions into three buckets by **how ontologically-shaped it is**. This refines +OGAR's earlier coarse 85/15 (structure/residue) split: the 15% residue is itself +not uniform — most of it is anticipated-standard, a sliver is genuinely random. + +### Bucket 1 — fuzzy-shaped (order-varying): canonicalize first + +**Signature:** "something that emits X but changes the order every time +differently." The *content* is stable; the *sequence/shape* wobbles run to run +(iteration order over a hash map, non-deterministic field emission, incidental +ordering that carries no semantics). + +**Treatment:** **canonicalize before you address.** Sort/normalize into a +deterministic form, *then* it collapses into a stable landing zone (usually +bucket 2). Do **not** mint an address for the wobble — that manufactures +false distinctions. This is the DO-arm analogue of the THINK-arm rule "encode +identity positions, never incidental order" (`I-VSA-IDENTITIES`). + +### Bucket 2 — anticipated standard DO: an ontologically-shaped landing zone + +**Signature:** the DO that *every domain has* and OGIT already anticipates — +auth/session/login, CRUD lifecycle, audit-emit, validation guards, the typical +"emit the standard auth + session" flow. OGIT's `NTO/Auth` (and the regulatory +`NTO/{Audit, Compliance, Legal}` set) already carry these as patterns. + +**Treatment:** **do it ONCE as a DTO adapter, then reuse via a codebook of +tools.** Mint the standard shape a single time as an ontologically-named landing +zone (label the fields so the AST *lands* looking recognizable), and give the +consumer a **codebook-shaped swiss-knife** of operations over it: + +| tool | what it does to the landed DTO | +| --- | --- | +| `open` | decode the standard DTO into its named slots | +| `filter` | select the subset a route/handler needs | +| `reorder` | re-sequence into the consumer's expected order | +| `apply_mask` | project/redact (RBAC lo-u16, PII leaf-rename, field-set) | + +This is the big win: the anticipated-standard bucket is the *majority* of the DO +residue, and it collapses to **import-the-pattern + apply-the-swiss-knife**, not +re-transcode. `account.move.post`, `res.partner`-lifecycle, OpenProject +`Issue`-workflow, MedCare visit-open/close — all land in the *same* codebook of +tools over ontologically-named DTOs. Do-once, amortized across every consumer, +exactly like the THINK-arm primitive-mint. + +### Bucket 3 — truly random: manual rewrite, invent new interfaces + +**Signature:** behaviour so bespoke it has no ontological landing zone — genuinely +novel control flow, a one-off algorithm, a customer-specific rule that no pattern +anticipates. + +**Treatment:** **hand-port**, and where the hand-port recurs, *partially invent a +new standard interface* so the next occurrence graduates to bucket 2. This is the +Frankenstein-flattening guard from `core-first-transcode-doctrine.md`: never +force an intrusive/stateful method into the adapter mold — route it to a +raw-pointer hand-port, and if the Core is missing a capability, *extend the Core +deliberately* (a new value tenant / ClassView capability, filed + reviewed), never +hack the adapter. Bucket 3 is where the Core *grows*; buckets 1–2 are where it is +*reused*. + +--- + +## The ordering rule + +```text +harvest DO residue + → is the shape order-varying? yes → BUCKET 1: canonicalize, re-triage + → does a standard pattern anticipate it? yes → BUCKET 2: import DTO + swiss-knife + → otherwise → BUCKET 3: hand-port; graduate to 2 if it recurs +``` + +Buckets are visited in order: canonicalize *first* (else fuzz masquerades as +novelty), match the standard *second* (the common case), hand-port *last* (the +expensive case, kept small). The cost gradient is steep and deliberate — bucket 2 +is meant to swallow the bulk so bucket 3 stays a sliver. + +--- + +## The harvest gap — the DO extractor is Python-only + +The THINK-arm harvesters cover multiple frontends (`ruff_cpp_spo`, +`ruff_csharp_spo`, `ruff_ruby_spo`, `ruff_python_spo`). The **DO-arm** extractor — +`ruff_python_dto_check` (DTO/route/handler harvest → matcher/contract dedup → +codegen, modules bundle/calibrate/codegen/config/contract/emit/extractors/matcher/ +observations/preflight) — is currently **Python-only** (built on +`ruff_python_parser`). + +**Consequence for the C#-MedCare / C++-Tesseract / Ruby-Redmine paths:** the DTO +triage above can be *reasoned* about, but there is **no automated DO harvester** +that emits DTO/route/handler bundles for those frontends yet. The `ruff_*_spo` +crates emit the *structural* predicates (the THINK arm); they do not emit the +DTO/handler observations that `ruff_python_dto_check` produces for Python. + +**Open brick:** a language-agnostic (or per-frontend C#/C++) DO extractor that +emits the same DTO/route/handler bundle shape `ruff_python_dto_check` emits, so +the 3-bucket triage can run automatically on the non-Python corpora. Until then, +the DO triage is a manual classification over the THINK-arm harvest, not a +pipeline stage. This is the DO-arm counterpart to the THINK-arm's brick-3 (which +*did* run, cross-frontend, via `ruff_csharp_spo`). + +--- + +## Boundary summary + +| arm | what | where it lives | harvest status | +| --- | --- | --- | --- | +| THINK | class/member/type graph | `(part_of:is_a)` `FacetCascade` address | measured (brick-3, multi-frontend) | +| DO bucket 1 | order-varying behaviour | canonicalized → bucket 2 | manual (needs canonicalizer) | +| DO bucket 2 | anticipated-standard DO | imported DTO + codebook swiss-knife, keyed by GUID | Python-only extractor | +| DO bucket 3 | truly-novel behaviour | hand-port; grows the Core | manual | + +The skeleton is in the address; the muscle is in `ActionDef`/`KausalSpec`, keyed +by the GUID. The 3-bucket triage is *how the muscle is partitioned* so that the +majority (bucket 2) collapses to import-and-apply, and only the sliver (bucket 3) +pays the hand-port cost. diff --git a/Cargo.lock b/Cargo.lock index 55ffc294..45e4b488 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#fc7b2c9579ea8d9bb3a7633723bdeac900f61d07" +source = "git+https://github.com/AdaWorldAPI/lance-graph?branch=main#c8e1ec42afb25bf6abcdf598bcaa59aa2707322b" dependencies = [ "glob", "serde", @@ -6042,7 +6042,7 @@ dependencies = [ [[package]] name = "ogar-adapter-surrealql" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#597ecb120fc8842c5b8aa552be506d2462151cec" +source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#a0c7936bc39a14dc3472a2723a21c1b10ab66e3e" dependencies = [ "ogar-vocab", ] @@ -6050,7 +6050,7 @@ dependencies = [ [[package]] name = "ogar-class-view" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#597ecb120fc8842c5b8aa552be506d2462151cec" +source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#a0c7936bc39a14dc3472a2723a21c1b10ab66e3e" dependencies = [ "lance-graph-contract 0.1.0 (git+https://github.com/AdaWorldAPI/lance-graph?branch=main)", "ogar-vocab", @@ -6059,12 +6059,12 @@ dependencies = [ [[package]] name = "ogar-ontology" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#597ecb120fc8842c5b8aa552be506d2462151cec" +source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#a0c7936bc39a14dc3472a2723a21c1b10ab66e3e" [[package]] name = "ogar-vocab" version = "0.1.0" -source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#597ecb120fc8842c5b8aa552be506d2462151cec" +source = "git+https://github.com/AdaWorldAPI/OGAR?branch=main#a0c7936bc39a14dc3472a2723a21c1b10ab66e3e" [[package]] name = "once_cell"