From a92bfd904deaa518685eae72d5ed36d65cb19906 Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:25:53 +0200 Subject: [PATCH 1/6] =?UTF-8?q?doc(knowledge):=20substrate-b=20=E2=86=94?= =?UTF-8?q?=20OLD=20HIRO/Bardioc=20stack=20capability=20correspondence?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Companion to lab-vs-canonical-surface.md (the rule) + hollow-wire-failure-modes.md (the failure mode). Captures the confirmed substrate-b ↔ OLD HIRO/Bardioc stack correspondence from three ground-truth sources: - Almato's own published OSS manifest (bitbucket.org/almatoag/opensource, the list r7.1 Product Description §5.5 cites) - OGIT closed-PR harvest (~493 PRs 2017-2026) - Almato Bardioc r7.1 Product Description (Oct 2025, 33 pages) 20-row correspondence table covers every confirmed OLD component → substrate-b primitive: Zitadel-stays + Security-Mesh bit-ops = palette256+Hamming + signed- audit = Lance-version-log + Kafka 0.8.2.2+ZooKeeper 3.4.6 = LanceVersionWatcher (in-proc) + Titan 0.4.4 → lance-graph + Gremlin 2.4 → lance-graph-planner + Cassandra → TiKV/surrealdb kv-lance + ES 1.7+Lucene 4.10 → Tantivy + ClickHouse+ Spark → DataFusion + InfluxDB → Lance versions + S3 → Lance fragments + swarm/ libcluster → ractor + sbroker/pobox → bounded mailbox + lru_cache/con_cache → dn_redis + rafted_value → openraft + gen_statem → Rubicon-as-ractor-actor (shape-exact) + expr → planner thinking + Jetty WS → substrate-b WS + Jena → OGIT compile-time check. Three load-bearing structural findings: 1. Three OLD components (Historisation + TSDB + audit) collapse to one NEW primitive (Lance versions) 2. Security Mesh bit-ops = palette256+Hamming (shape-exact) 3. gen_statem is the confirmed OLD-stack precedent for the Rubicon model (rafted_value uses it; state_enter/postpone/timeouts ARE Rubicon semantics) Boundary collapse documented: OLD 8 boundaries + 4 concurrency models → NEW 0 in-binary application boundaries + 1 retained external Go IAM + 1 concurrency model + honest Raft consensus tax. OGIT data model captured: 10 production workloads (BGFS, Auth/Device, three- layer identity Person/Account/DataScope, Documents, Automation, Knowledge, Tickets, OSINT, Org-lifecycle, Trust, Forms, MARS-survives-within-OGIT). --- .../knowledge/old-stack-capability-parity.md | 156 ++++++++++++++++++ 1 file changed, 156 insertions(+) create mode 100644 .claude/knowledge/old-stack-capability-parity.md diff --git a/.claude/knowledge/old-stack-capability-parity.md b/.claude/knowledge/old-stack-capability-parity.md new file mode 100644 index 000000000..12d026d10 --- /dev/null +++ b/.claude/knowledge/old-stack-capability-parity.md @@ -0,0 +1,156 @@ +# substrate-b ↔ OLD HIRO/Bardioc stack capability correspondence + +**READ BY:** integration-lead, truth-architect, anyone wiring a lance-graph + ractor + surrealdb stack as a replacement for a HIRO/Bardioc-shaped OLD stack (BEAM/OTP + JVM + Cassandra + Titan/JanusGraph + Gremlin + Elasticsearch + ClickHouse + Kafka). + +**Status:** preventive documentation + capability ground-truth. Captures the **confirmed** correspondences (from Almato's own published OSS manifest at `bitbucket.org/almatoag/opensource` + the OGIT PR harvest + the Almato r7.1 Product Description) between lance-graph-substrate-b capabilities and the OLD HIRO/Bardioc stack they replace. + +**Companion to:** `.claude/knowledge/lab-vs-canonical-surface.md` (the canonical surface rule), `.claude/knowledge/hollow-wire-failure-modes.md` (the failure mode when the canonical wire is incomplete), `.claude/knowledge/encoding-ecosystem.md` (the full codec ledger). + +--- + +## 1. Why this doc exists + +Anyone integrating lance-graph + ractor + surrealdb (the substrate-b shape, per `lance-graph-callcenter`'s ExternalMembrane + LanceVersionWatcher + Timeline view) as a replacement for a HIRO-like OLD stack hits the same question: *which lance-graph primitive replaces which OLD component, at what fidelity, with what version-substitution rationale?* + +This doc answers it once, with **confirmed sources only** (Almato's own manifest pins the OLD versions; the OGIT PR harvest pins the OLD data model; the r7.1 Product Description pins the OLD architectural shape). No conjecture — every mapping is grounded. + +## 2. The OLD-stack shape — Almato r7.1 9-component "OS for data" + +Per the Almato r7.1 Bardioc Product Description (Oct 2025), Bardioc IS an *"operating system (OS) for data"* with nine functional components (§2.3-§2.4): + +1. **Access Manager** — IAM (OIDC via Zitadel/Go) + Security Mesh (4-axis bit-op per-element auth: Subject(n) × Object(n) × Implicit(4) × Explicit(x), uncached) + AES256-at-rest + signed immutable audit +2. **Data Manager** — Scheduler + Memory Manager (tiered, COW, dedup, speculative pre-compute) +3. **Message Bus** — Apache Kafka 0.8.2.2 + ZooKeeper 3.4.6 (Producer/Consumer/Streams/Connect/Admin; Chain-of-Responsibility per-app-version topics) +4. **Knowledge Core** — six storage backends: Graph DB (Titan 0.4.4 → JanusGraph) + NoSQL (Cassandra 2.1.8) + TSDB (InfluxDB via exometer) + BLOB (S3) + KV (Cassandra) + Indexing (Elasticsearch 1.7 + Lucene 4.10) +5. **Knowledge APIs** — REST + WebSocket (Jetty 9.2) + Program API (.jar to JG node) + Streaming + Connector SDK; query langs OGP + Gremlin 2.4 + GraphQL +6. **Desktop** — Frontend SDK + Profile Manager + Graph Explorer + Ontology Manager +7. **Graph Applications** — Gremlin algorithm library (centrality/PageRank/shortest-path/tree + Spark-on-YARN OLAP) +8. **OGIT Ontology** — 5-ring meta-model (SGO → NTO → SNRA → SNBA → SNFA) +9. **OGIT Ontology Extensions** — domain-specific extensions (BGFS, Auth, Documents, Automation, Knowledge, Tickets, OSINT, Forms, Rating, Security, MARS-survives-within-OGIT) + +## 3. The substrate-b correspondence + +| # | OLD component (confirmed version) | substrate-b replacement | Fidelity | +|---|---|---|---| +| 1 | Zitadel (Go) OIDC/OAuth2 | **retained** + `auth-plug` in-proc JWT validation (substrate-b never replaces the IdP) | shape-exact | +| 2 | Security Mesh 4-axis bit-ops | per-vertex `_effectiveReaders` palette256/Binary16K bitmap + Hamming popcount | shape-exact | +| 3 | AES256-at-rest + signed audit log | Lance append-only version log (immutable by construction) | shape-exact | +| 4 | Data Manager scheduler + memory tiers | Lance version log + lance-graph-planner `AutocompleteCache` (cache/p64) | functional | +| 5 | **Apache Kafka 0.8.2.2 + ZooKeeper 3.4.6** | **`LanceVersionWatcher`** (in-proc, std::sync Condvar, `CognitiveEventRow` payload, BBB-invariant) + cluster bus for cross-instance | shape-exact in-proc | +| 6 | Titan 0.4.4 (Cassandra/ES/HBase) → JanusGraph | **lance-graph** (Lance columnar storage + indices) | functional | +| 7 | Gremlin 2.4 (Groovy) | **`lance-graph-planner`** (16 strategies) + future SurrealQL → lance-graph compiler | functional | +| 8 | Cassandra 2.1.8 (KV + NoSQL) | TiKV / surrealdb kv-lance (PR #35/#36 surrealdb merged) | functional | +| 9 | Elasticsearch 1.7 + Lucene 4.10 | Tantivy (Rust-native full-text) | functional | +| 10 | ClickHouse + Hadoop + Spark/YARN (OLAP) | DataFusion over Lance versions | functional | +| 11 | InfluxDB (TSDB via exometer_influxdb) | **Lance versions as time-series** (no separate TSDB needed) | shape-exact | +| 12 | BLOB store (S3 client) | Lance fragment storage OR external object store + Lance pointers | functional | +| 13 | swarm + libcluster + libring + locker (distributed actors) | ractor + mailbox-as-owner rotating topology + optional gRPC transport | functional | +| 14 | sbroker + pobox (backpressure) | ractor bounded mailbox + `MessagingErr::Saturated` (PR `AdaWorldAPI/ractor#1` merged) | shape-exact | +| 15 | lru_cache + con_cache (ETS hot cache) | `dn_redis` (Redis-protocol over Lance via DataFusion + OGIT class views; FalkorDB/KuzuDB shape — talk Redis without being Redis) | functional | +| 16 | rafted_value (gen_statem Raft) | openraft (Rust) | functional | +| 17 | **gen_statem** (the OTP state-machine substrate) | **ractor Actor + Lance-version-as-state-machine** (the Rubicon phase machine; see §4) | shape-exact | +| 18 | expr 0.1.0 (Elixir math rule evaluator) | `lance-graph-planner::thinking` (12 styles + NARS dispatch + sigma chain) | functional | +| 19 | Jetty WebSocket + websocket_client | substrate-b WebSocket endpoint (Layer-3 outbound, tokio per the I-2 invariant) | functional | +| 20 | Jena (Java OGIT runtime validation) | OGIT compile-time check (Rust types encode SNRA required-attrs) — **stronger than OLD** | improvement | + +## 4. The three load-bearing structural findings + +### 4.1 Three OLD components collapse to one NEW primitive + +OLD **Historisation** (JG versioning + temporal query) + OLD **TSDB** (InfluxDB via exometer_influxdb) + OLD **signed audit log** all become a **single substrate-b primitive**: Lance versions. + +- `dataset.checkout_version(V_ref)` = point-in-time query (Historisation) +- The version log itself = time-series (TSDB) +- Append-only immutability = signed audit log + +This is the substrate-b efficiency win — three OLD components, one NEW primitive. It is NOT a slogan; it is the architectural consequence of choosing an immutable append-only storage as the foundation. + +### 4.2 Security Mesh bit-ops = palette256 + Hamming popcount (shape-exact) + +The OLD-stack Security Mesh Layer (r7.1 §3.1.3) uses *"extremely efficient bit operations to verify authorisation for individual data access ... always executed for each data element without impacting access performance. As authorisation changes are not cached, they take effect immediately in the graph."* + +The substrate-b hot-path primitive is bit-op-per-element via palette256 + Hamming popcount on `Binary16K = [u64; 256]`. Same algorithmic shape; same per-element guarantee; same uncached / immediate-effect property. The materialised `_effectiveReaders` / `_effectiveDevices` (per BGFS PR `almatoai/OGIT#773` platform-reserved attributes) are computed via these primitives. + +### 4.3 gen_statem is the confirmed OLD-stack precedent for the Rubicon model + +`ericentin/gen_state_machine 2.0.1` is in the HIRO manifest. It is the OTP state-machine substrate; `rafted_value`'s Raft consensus runs on it (follower / candidate / leader = `:gen_statem` states). Its feature set IS the Rubicon model: + +| gen_statem feature | Rubicon analogue (substrate-b) | +|---|---| +| `state_functions` callback mode | ractor ClassActor: one `handle` arm per epistemic state (Contemporary / Anachronistic / Spoiler — see `STANDING_WAVE_ARCHITECTURE.md` §1.5 in any substrate-b consumer) | +| `handle_event_function` mode | typed-enum match in `Actor::handle` | +| `postpone` (defer until next state change) | Rubicon: hold events arriving before the Decision/Rubicon commit; replay after the phase transition | +| `state_enter` callbacks | Rubicon: fire the Lance commit on entering the Decision state | +| per-state / per-event / generic timeouts | SLA-bounded cold-path waits (ractor + `MessagingErr::Saturated`) | +| internal (self-generated) events | cognitive cycle self-dispatch (encode → decode → F-check → persist) | + +**The Rubicon model IS a gen_statem.** It is NOT an invention; it is the faithful translation of an OTP behavior HIRO already runs in production (rafted_value + the lifecycle machines). This matters for any consumer mapping the OLD-stack thinking layer onto substrate-b: the Rubicon shape is the confirmed precedent, not a hypothesis. + +## 5. The OLD data model — exact OGIT shapes (PR harvest) + +The OLD stack carries 10 production workloads (confirmed by walking ~493 OGIT closed PRs, 2017-2026). Any substrate-b consumer replacing HIRO needs to handle all of them: + +- **BGFS** (Bardioc Graph File System, PR #773 merged 2026-06-01) — 5 entities (File, Folder, Symlink, ShareLink, AppHandler) + 2 verbs (`refersTo`, `sharedVia`) + 17 attributes incl. capability fixed-set `{read, write, share, admin, delete}`; platform-reserved `_effectiveReaders` / `_effectiveDevices`; 16-hop symlink resolution +- **Auth/Device** (PR #775 open) — `Device` (deviceType ∈ {mobile, desktop, web, hsm, hardware-wallet}; securityLevel ∈ {0, 50, 80, 100}) + `usesDevice` + `hasVault` (Person-anchored, survives Account deactivation) + `isWorkspace` (Team marker) +- **Three-layer identity** (established 2018 in PRs #362/#376/#403) — Person (persistent) / Account (ephemeral, job-scoped) / DataScope (access perimeter; **mandatory-named** since 2018-11) +- **Documents** — `DocumentInfoRecord` with blob/status/creationTime/typ +- **Automation** — `AutomationIssue` with `savedTimeSeconds` (RPA ROI metric) +- **Knowledge Items** — with `manualProcessingTimeSeconds` (human cost metric) +- **Tickets** — `Ticket`/`ChangeRequest`/`ConfigurationItem` with `assignedTo`/`isPartOf`/`precedes`/`affects`/`subType` +- **OSINT** — Person/Organization/Address/Position/SecurityIncident relational graph + `locatedIn` +- **Org lifecycle** — Organization with `endedAt`/`precedes` +- **Trust** — Rating +- **Forms** — Form → Attachment connection +- **MARS** — survives within OGIT (`ogit.Automation:MARSNode` + `ogit/MARS/Resource` + `mars2ogit`); NOT deprecated, refactored + +## 6. Boundary collapse (the migration value) + +The OLD-stack request path traverses **8 boundaries**: + +1. Operator Query → BEAM (HTTP) +2. BEAM → JVM (HTTP, graph_conn → Java OGIT) +3. JVM → C++ (JNI, Java → Cassandra/Lucene) +4. Gremlin → Storage (TinkerPop → Titan backend) +5. App → DB (CQL serialize) +6. DB → Analytics (Cassandra → ClickHouse/Spark) +7. **Auth boundary** (Zitadel JWT validation) +8. **Message Bus produce/consume** (Kafka — every event) + +Plus **4 concurrency models**: BEAM (Phoenix + swarm + sbroker), JVM (Titan + Gremlin + ES), Go (Zitadel — retained), C++ (Cassandra + Lucene). + +The substrate-b shape collapses to: **0 in-binary application boundaries** + 1 retained external Go IAM (Zitadel) + 1 concurrency model (ractor) + the irreducible Raft consensus tax (honest — see `ROADMAP_RUST_PRIMARY_HEADSTONE.md` in any substrate-b consumer for the per-workload tax accounting). + +The 8 → 0 boundary collapse is the migration's measured value, not a slogan; the §14 acceptance gate proves it per-endpoint via dual-stack workload replay. + +## 7. Process rule for substrate-b consumers + +Before proposing a new lance-graph integration trait / contract / coordination surface to replace an OLD-stack capability: + +1. Check this doc — does the §3 correspondence already name the substrate-b primitive? +2. Check `.claude/knowledge/encoding-ecosystem.md` — does an existing codec serve the capability? +3. Check `.claude/knowledge/lab-vs-canonical-surface.md` — is the canonical bridge the right place? +4. Check `.claude/knowledge/hollow-wire-failure-modes.md` — am I about to wire the lab surface without plugging the canonical bridge? + +If steps 1-4 don't dissolve the proposal, then a new structure is warranted. Otherwise, the OLD-stack correspondence here already names what to wire against. + +--- + +## Cross-references + +### Source documents (confirmed ground truth) +- **Almato r7.1 Product Description** (Oct 2025, 33 pages) — the 9-component OS architecture (`BARDIOC_PRODUCT_CANONICAL.md` in substrate-b consumers) +- **Almato OSS dependency manifest** (`bitbucket.org/almatoag/opensource`, project KG) — the confirmed component versions (`BARDIOC_DEPENDENCY_MANIFEST_CONFIRMED.md`) +- **OGIT closed PR harvest** (~493 PRs 2017-2026 from `github.com/almatoai/OGIT`) — the exact data model shapes (`BARDIOC_HIRO_CONTEXT_HARVEST.md` + `TARGET_STACK_REFERENCE.md`) +- **substrate-b architecture doc** — `STANDING_WAVE_ARCHITECTURE.md` (awareness-in-Lance-versioning + §1.6 OGAR Sprint 7 muscle memory) + +### Companion lance-graph knowledge docs +- `.claude/knowledge/encoding-ecosystem.md` — the full codec ledger (MANDATORY read before any codec work) +- `.claude/knowledge/lab-vs-canonical-surface.md` — the canonical surface rule (MANDATORY read before any REST/gRPC/Wire DTO work) +- `.claude/knowledge/hollow-wire-failure-modes.md` — DRAFT-INERT / sealed-but-shadowed / feature-flag mismatch (companion to lab-vs-canonical-surface) +- `.claude/knowledge/vsa-switchboard-architecture.md` — the three-layer carrier (Switchboard / Domain role catalogues / Content stores) + +### Upstream PRs from this correspondence +- `AdaWorldAPI/lance-graph#452` (Lance-append-Raft dovetail), `#453` (cluster asymmetry), `#454` (post-merge corrections), `#455` (dn_redis as key-shape protocol), `#456`/`#457`/`#458` (Pearl junctions classifier + post-merge corrections) — all MERGED +- `AdaWorldAPI/lance-graph#464` (hollow-wire failure modes catalogue) — OPEN +- `AdaWorldAPI/surrealdb#35` (kv-lance SDK feature), `#36` (Lance backend struct + endpoint helper) — both MERGED +- `AdaWorldAPI/ractor#1` (`MessagingErr::Saturated` variant + `From` split) — MERGED From 67d421295264c2a28b9d9d163b5347a0e8b83ba7 Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:25:55 +0200 Subject: [PATCH 2/6] epiphany(E-OLD-STACK-CONFIRMED): three OLD components collapse to one NEW (Lance versions); Security Mesh = palette256+Hamming; gen_statem = Rubicon precedent MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PREPEND-only per board-hygiene rule. Records the three load-bearing structural findings from the substrate-b ↔ OLD HIRO/Bardioc capability correspondence, grounded in Almato's own published OSS manifest + the OGIT closed-PR harvest. --- .claude/board/EPIPHANIES.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 10e55ba62..95c56ff48 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,21 @@ +## 2026-06-04 — E-OLD-STACK-CONFIRMED — Almato's own published OSS manifest confirms the OLD HIRO/Bardioc stack shape; three OLD components collapse to one NEW primitive + +**Status:** FINDING (ground-truth from `bitbucket.org/almatoag/opensource` — the manifest Almato r7.1 Product Description §5.5 explicitly cites — + the OGIT closed-PR harvest, 2026-06-04; confirmed against `BARDIOC_PRODUCT_CANONICAL.md` and `BARDIOC_DEPENDENCY_MANIFEST_CONFIRMED.md` in substrate-b consumers). + +**Three structural findings** that any lance-graph + ractor + surrealdb consumer replacing a HIRO-shaped OLD stack must internalize: + +1. **Three OLD components collapse to one NEW primitive.** OLD Historisation (JG temporal query) + OLD TSDB (InfluxDB via exometer_influxdb) + OLD signed audit log all become **Lance versions** in substrate-b. `dataset.checkout_version(V_ref)` = point-in-time; the version log itself = time-series; append-only immutability = audit. One primitive, three OLD capabilities. Concrete efficiency win, not a slogan. + +2. **Security Mesh bit-ops = palette256 + Hamming popcount (shape-exact).** The OLD-stack 4-axis bit-op per-element auth (Subject(n) × Object(n) × Implicit(4) × Explicit(x), uncached, immediate) IS the substrate-b hot-path primitive. Materialised `_effectiveReaders` / `_effectiveDevices` (per `almatoai/OGIT#773` BGFS platform-reserved attributes) compute via these primitives. The OLD-stack security model survives migration unchanged. + +3. **gen_statem is the confirmed OLD-stack precedent for the Rubicon model.** `ericentin/gen_state_machine 2.0.1` is in the HIRO manifest; `rafted_value`'s Raft consensus runs on it (follower/candidate/leader = `:gen_statem` states). Its feature set — `state_functions`, `handle_event_function`, `postpone` (defer-until-next-state), `state_enter` callbacks, per-state timeouts, internal self-events — IS the Rubicon phase machine. `state_enter` fires the Lance commit on entering the Decision state; `postpone` holds events arriving before Rubicon; timeouts bound SLA waits. The substrate-b actor-state-machine is the faithful translation of an OTP behavior HIRO already runs. + +**Why this matters here (lance-graph):** any consumer mapping the OLD-stack thinking layer onto lance-graph + ractor needs these correspondences to avoid reinventing primitives that already exist. The new knowledge doc `.claude/knowledge/old-stack-capability-parity.md` is the reference; this entry records the three load-bearing structural findings as a single FINDING-level epiphany. + +**Cross-ref:** `.claude/knowledge/old-stack-capability-parity.md` (new); `.claude/knowledge/lab-vs-canonical-surface.md` (companion); `.claude/knowledge/hollow-wire-failure-modes.md` (companion); `AdaWorldAPI/lance-graph#452/#453/#454/#455/#456/#457/#458` (the merged contributions from this correspondence work); `AdaWorldAPI/surrealdb#35/#36` (kv-lance feature + Lance backend struct); `AdaWorldAPI/ractor#1` (`MessagingErr::Saturated` for the backpressure invariant). + +--- + ## 2026-06-03 — E-HELIX-NDARRAY-MANDATORY — `helix` ndarray wiring: optional `path` → mandatory `git` (codex P2 + "ndarray is mandatory") — an optional path dep is a clean-checkout trap **Status:** FINDING (codex P2 on #460 + user directive, 2026-06-03; fix verified — 63 unit + 6 doctests green with mandatory ndarray, clippy -D warnings + fmt clean; the git source was patched to the local `master` checkout for the in-sandbox build, github fetch deferred to CI). From 5b22404102151a73d22424b89a456f549d622d5d Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:25:57 +0200 Subject: [PATCH 3/6] =?UTF-8?q?agent-log:=20D-OLD-STACK-PARITY-DOC=20SHIPP?= =?UTF-8?q?ED=20=E2=80=94=20knowledge/old-stack-capability-parity.md=20(co?= =?UTF-8?q?mpanion=20to=20lab-vs-canonical-surface=20+=20hollow-wire)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PREPEND-only per board-hygiene rule. --- .claude/board/AGENT_LOG.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index eeab3b07a..8853aa860 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,19 @@ +## [Main thread / Opus, autoattended] D-OLD-STACK-PARITY-DOC — `.claude/knowledge/old-stack-capability-parity.md` SHIPPED (companion to lab-vs-canonical-surface + hollow-wire-failure-modes) + +**Branch:** claude/old-stack-capability-parity (this PR). New `.claude/knowledge/` doc capturing the substrate-b ↔ OLD HIRO/Bardioc stack capability correspondence, grounded in Almato's own published OSS manifest (`bitbucket.org/almatoag/opensource` — the list the r7.1 Product Description §5.5 cites) + the OGIT closed-PR harvest (~493 PRs 2017-2026, three Explore agents) + the Almato r7.1 Product Description (Oct 2025, 33 pages). + +**What it captures (20-row correspondence table):** Zitadel-stays + Security-Mesh-bit-ops-= palette256+Hamming + signed-audit = Lance-version-log + Kafka 0.8.2.2+ZooKeeper 3.4.6 = LanceVersionWatcher (in-proc) + Titan 0.4.4→lance-graph + Gremlin 2.4 → lance-graph-planner + Cassandra 2.1.8 → TiKV/surrealdb-kv-lance + ES 1.7+Lucene 4.10 → Tantivy + ClickHouse+Spark → DataFusion + InfluxDB → Lance versions + S3 → Lance fragments + swarm/libcluster → ractor + sbroker/pobox → bounded mailbox + lru_cache/con_cache → dn_redis + rafted_value → openraft + **gen_statem → Rubicon-as-ractor-actor (shape-exact)** + expr → lance-graph-planner thinking + Jetty WS → substrate-b WS + Jena → OGIT compile-time check (stronger). + +**Three load-bearing structural findings** (also recorded in EPIPHANIES as `E-OLD-STACK-CONFIRMED`): (1) three OLD components (Historisation + TSDB + audit) collapse to one NEW primitive (Lance versions); (2) Security Mesh bit-ops = palette256+Hamming (shape-exact); (3) gen_statem IS the confirmed Rubicon precedent (not invention). + +**Boundary collapse documented:** OLD 8 boundaries (Operator → BEAM → JVM → Gremlin → JG → Cassandra → Analytics → Kafka) + 4 concurrency models (BEAM/JVM/Go/C++) → NEW 0 in-binary application boundaries + 1 retained external Go IAM + 1 concurrency model (ractor) + honest Raft consensus tax. The 8 → 0 collapse is the migration's measured value, not a slogan. + +**Why it lives in lance-graph (not the consumer repo):** any consumer integrating lance-graph + ractor + surrealdb as an OLD-HIRO replacement hits the same correspondence question. Documenting it once upstream, with confirmed sources, lets every consumer reuse the answer. Companion to `lab-vs-canonical-surface.md` (the rule) + `hollow-wire-failure-modes.md` (the failure mode). + +**Outcome:** doc-only, no code changes. No new tests (knowledge docs don't ship tests). Spot-check provenance: Kafka 0.8.2.2 is at `bitbucket.org/almatoag/opensource/src/main/third-party-java.adoc:575-578`; Titan 0.4.4 blocks at `:lines around Titan-Core/Titan-Cassandra/Titan-ElasticSearch/Titan-HBase`; Elixir manifest at `third-party-elixir.adoc` (lru_cache 0.1.3 / con_cache 0.12.1 / gen_state_machine 2.0.1 / sbroker 0.7.0 / pobox 1.0.4 / swarm 3.0.5 / libcluster 3.0.2 / libring 1.3.1 / locker 6 / exometer_influxdb 0.5.8 / expr 0.1.0). + +--- + ## [Main thread / Opus, autoattended] D-HELIX-1 SHIPPED — `crates/helix` golden-spiral Place/Residue codec (zero-dep + optional ndarray-hpc) **Branch:** claude/gallant-rubin-Y9pQd. New standalone crate `crates/helix` (empty `[workspace]`, added to root `exclude`) realising the user's `KNOWLEDGE.md` Place/Residue encoding — HHTL = deterministic PLACE, helix = orthogonal RESIDUE: equal-area `√u` hemisphere placement (`HemispherePoint`) → stride-4-over-17 `CurveRuler` coupling → Fisher-Z/arctanh `Similarity` alignment → EULER_GAMMA hand-off → 256-palette `RollingFloor` quantise (occupancy-drift + floor-version stamp) → 3-byte `ResidueEdge` endpoint pair; metric-safe L1 via 256×256 `DistanceLut` (`distance_adaptive`) + non-metric byte-Hamming `distance_heuristic`. **Tests:** 61 unit + 6 doctests green on the default zero-dep build (clippy -D warnings + fmt clean); same 61+6 green under `--features ndarray-hpc` (batch Fisher-Z routes through `ndarray::simd::simd_ln_f32`; `batch_fisher_z_matches_scalar_reference` confirms bit-equivalence to the scalar path). Closed Open Item #1 — `prove()` is the 2-D golden-spiral discrepancy companion to `jc::weyl` (D*_φ=0.00160 < D*_ctrl=0.00252 at N=1597). **Process (autoattended):** 5 read-only research agents (weyl/jc template · bgz17 metric-safety · ndarray SIMD surface · HHTL offset · encoding-ecosystem placement) → main-thread foundation + spine → 4 parallel Sonnet leaf workers (placement / fisher_z / quantize / prove; edit-only, no worktree, tee writes) → central compile/clippy/fmt/test consolidation (fixed 1 contrived worker test + 4 clippy lints). **Honest finding (E-HELIX-OVERLAP):** ~80% of the pipeline pre-exists, some CERTIFIED (`bgz-tensor::Base17Fz`/`fisher_z::FamilyGamma` ρ≥0.999, `jc::weyl`); shipped as a user-directed zero-dep clean-room re-derivation — overlap + consolidation path documented in `crates/helix/KNOWLEDGE.md` and TD-HELIX-OVERLAP-1. Board: LATEST_STATE + STATUS_BOARD D-HELIX-1 + EPIPHANIES E-HELIX-OVERLAP + TECH_DEBT + this entry (same commit). From 50246d7e8d38d242c6b70d0af13dcfbca1aebc9a Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:28:37 +0200 Subject: [PATCH 4/6] =?UTF-8?q?doc(knowledge):=20substrate-b=20consumer=20?= =?UTF-8?q?integration=20=E2=80=94=20NEW-stack=20capability=20shape=20+=20?= =?UTF-8?q?plans?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit REWRITE focusing on substrate-b NEW-stack capabilities only — no consumer- internal specifications cross the upstream boundary. Captures: seven-capability composition (lance-graph + surrealdb kv-lance + Tantivy + DataFusion + ractor + LanceVersionWatcher + external Zitadel); three load-bearing primitives (Lance versions multi-purpose / palette256+Hamming per-element auth / ractor Actor + Lance-version-as-state-machine = Rubicon); built-today capability roadmap honest accounting; the migration endpoint contract as substrate-b's dual-stack ground- truth surface (POST /v1/{entity,edge,traverse,query,graphql,audit} + WS /v1/ stream + POST /v1/dispatch); five consumer integration patterns that fall out of the primitives (3-in-1 collapse / ACL changes immediate-by-construction / state history IS the version log / in-proc events are std::sync per I-2 / OGAR is the data-model entry point); process rule for substrate-b consumers. --- .../knowledge/old-stack-capability-parity.md | 227 +++++++++--------- 1 file changed, 120 insertions(+), 107 deletions(-) diff --git a/.claude/knowledge/old-stack-capability-parity.md b/.claude/knowledge/old-stack-capability-parity.md index 12d026d10..bac5421d8 100644 --- a/.claude/knowledge/old-stack-capability-parity.md +++ b/.claude/knowledge/old-stack-capability-parity.md @@ -1,156 +1,169 @@ -# substrate-b ↔ OLD HIRO/Bardioc stack capability correspondence +# substrate-b consumer integration — NEW-stack capability shape + plans -**READ BY:** integration-lead, truth-architect, anyone wiring a lance-graph + ractor + surrealdb stack as a replacement for a HIRO/Bardioc-shaped OLD stack (BEAM/OTP + JVM + Cassandra + Titan/JanusGraph + Gremlin + Elasticsearch + ClickHouse + Kafka). +**READ BY:** integration-lead, truth-architect, anyone wiring a lance-graph + ractor + surrealdb integration (the substrate-b shape, per `lance-graph-callcenter`'s `ExternalMembrane` + `LanceVersionWatcher` + `Timeline` view). -**Status:** preventive documentation + capability ground-truth. Captures the **confirmed** correspondences (from Almato's own published OSS manifest at `bitbucket.org/almatoag/opensource` + the OGIT PR harvest + the Almato r7.1 Product Description) between lance-graph-substrate-b capabilities and the OLD HIRO/Bardioc stack they replace. +**Status:** preventive documentation + capability roadmap for substrate-b consumers. Captures the design pattern + the built-today honesty + the planned capability roadmap. **Companion to:** `.claude/knowledge/lab-vs-canonical-surface.md` (the canonical surface rule), `.claude/knowledge/hollow-wire-failure-modes.md` (the failure mode when the canonical wire is incomplete), `.claude/knowledge/encoding-ecosystem.md` (the full codec ledger). --- -## 1. Why this doc exists +## 1. The substrate-b shape (the integration pattern this doc serves) -Anyone integrating lance-graph + ractor + surrealdb (the substrate-b shape, per `lance-graph-callcenter`'s ExternalMembrane + LanceVersionWatcher + Timeline view) as a replacement for a HIRO-like OLD stack hits the same question: *which lance-graph primitive replaces which OLD component, at what fidelity, with what version-substitution rationale?* +A substrate-b integration of lance-graph composes seven cooperating capabilities into a single binary: -This doc answers it once, with **confirmed sources only** (Almato's own manifest pins the OLD versions; the OGIT PR harvest pins the OLD data model; the r7.1 Product Description pins the OLD architectural shape). No conjecture — every mapping is grounded. +1. **Storage** — `lance-graph` (Lance columnar) + Lance versions as the temporal axis (`checkout_version(V)` is the time-travel primitive) +2. **Distributed KV** — `surrealdb` with `kv-lance` feature (PRs `AdaWorldAPI/surrealdb#35` + `#36` merged) OR external TiKV cluster +3. **Search** — Tantivy (Rust-native full-text) +4. **Analytics / OLAP** — DataFusion over Lance versions +5. **Actors / dispatch** — ractor + the mailbox-as-owner topology + `MessagingErr::Saturated` for backpressure (PR `AdaWorldAPI/ractor#1` merged) +6. **In-process event bus** — `lance-graph-callcenter::version_watcher::LanceVersionWatcher` (std::sync Condvar; never tokio per the I-2 invariant) +7. **OIDC / IAM** — external Zitadel (retained as the IdP boundary) + in-proc JWT validation via `auth-plug` -## 2. The OLD-stack shape — Almato r7.1 9-component "OS for data" +The `lance-graph-planner` (16 strategies + 12 thinking styles + NARS dispatch + the AutocompleteCache) is the compute / rule-evaluation layer that sits on top. -Per the Almato r7.1 Bardioc Product Description (Oct 2025), Bardioc IS an *"operating system (OS) for data"* with nine functional components (§2.3-§2.4): +## 2. The three load-bearing primitives substrate-b consumers must understand -1. **Access Manager** — IAM (OIDC via Zitadel/Go) + Security Mesh (4-axis bit-op per-element auth: Subject(n) × Object(n) × Implicit(4) × Explicit(x), uncached) + AES256-at-rest + signed immutable audit -2. **Data Manager** — Scheduler + Memory Manager (tiered, COW, dedup, speculative pre-compute) -3. **Message Bus** — Apache Kafka 0.8.2.2 + ZooKeeper 3.4.6 (Producer/Consumer/Streams/Connect/Admin; Chain-of-Responsibility per-app-version topics) -4. **Knowledge Core** — six storage backends: Graph DB (Titan 0.4.4 → JanusGraph) + NoSQL (Cassandra 2.1.8) + TSDB (InfluxDB via exometer) + BLOB (S3) + KV (Cassandra) + Indexing (Elasticsearch 1.7 + Lucene 4.10) -5. **Knowledge APIs** — REST + WebSocket (Jetty 9.2) + Program API (.jar to JG node) + Streaming + Connector SDK; query langs OGP + Gremlin 2.4 + GraphQL -6. **Desktop** — Frontend SDK + Profile Manager + Graph Explorer + Ontology Manager -7. **Graph Applications** — Gremlin algorithm library (centrality/PageRank/shortest-path/tree + Spark-on-YARN OLAP) -8. **OGIT Ontology** — 5-ring meta-model (SGO → NTO → SNRA → SNBA → SNFA) -9. **OGIT Ontology Extensions** — domain-specific extensions (BGFS, Auth, Documents, Automation, Knowledge, Tickets, OSINT, Forms, Rating, Security, MARS-survives-within-OGIT) +### 2.1 Lance versions are the multi-purpose temporal primitive -## 3. The substrate-b correspondence +A single primitive — Lance versions — serves three distinct capabilities a substrate-b consumer would otherwise build separately: -| # | OLD component (confirmed version) | substrate-b replacement | Fidelity | -|---|---|---|---| -| 1 | Zitadel (Go) OIDC/OAuth2 | **retained** + `auth-plug` in-proc JWT validation (substrate-b never replaces the IdP) | shape-exact | -| 2 | Security Mesh 4-axis bit-ops | per-vertex `_effectiveReaders` palette256/Binary16K bitmap + Hamming popcount | shape-exact | -| 3 | AES256-at-rest + signed audit log | Lance append-only version log (immutable by construction) | shape-exact | -| 4 | Data Manager scheduler + memory tiers | Lance version log + lance-graph-planner `AutocompleteCache` (cache/p64) | functional | -| 5 | **Apache Kafka 0.8.2.2 + ZooKeeper 3.4.6** | **`LanceVersionWatcher`** (in-proc, std::sync Condvar, `CognitiveEventRow` payload, BBB-invariant) + cluster bus for cross-instance | shape-exact in-proc | -| 6 | Titan 0.4.4 (Cassandra/ES/HBase) → JanusGraph | **lance-graph** (Lance columnar storage + indices) | functional | -| 7 | Gremlin 2.4 (Groovy) | **`lance-graph-planner`** (16 strategies) + future SurrealQL → lance-graph compiler | functional | -| 8 | Cassandra 2.1.8 (KV + NoSQL) | TiKV / surrealdb kv-lance (PR #35/#36 surrealdb merged) | functional | -| 9 | Elasticsearch 1.7 + Lucene 4.10 | Tantivy (Rust-native full-text) | functional | -| 10 | ClickHouse + Hadoop + Spark/YARN (OLAP) | DataFusion over Lance versions | functional | -| 11 | InfluxDB (TSDB via exometer_influxdb) | **Lance versions as time-series** (no separate TSDB needed) | shape-exact | -| 12 | BLOB store (S3 client) | Lance fragment storage OR external object store + Lance pointers | functional | -| 13 | swarm + libcluster + libring + locker (distributed actors) | ractor + mailbox-as-owner rotating topology + optional gRPC transport | functional | -| 14 | sbroker + pobox (backpressure) | ractor bounded mailbox + `MessagingErr::Saturated` (PR `AdaWorldAPI/ractor#1` merged) | shape-exact | -| 15 | lru_cache + con_cache (ETS hot cache) | `dn_redis` (Redis-protocol over Lance via DataFusion + OGIT class views; FalkorDB/KuzuDB shape — talk Redis without being Redis) | functional | -| 16 | rafted_value (gen_statem Raft) | openraft (Rust) | functional | -| 17 | **gen_statem** (the OTP state-machine substrate) | **ractor Actor + Lance-version-as-state-machine** (the Rubicon phase machine; see §4) | shape-exact | -| 18 | expr 0.1.0 (Elixir math rule evaluator) | `lance-graph-planner::thinking` (12 styles + NARS dispatch + sigma chain) | functional | -| 19 | Jetty WebSocket + websocket_client | substrate-b WebSocket endpoint (Layer-3 outbound, tokio per the I-2 invariant) | functional | -| 20 | Jena (Java OGIT runtime validation) | OGIT compile-time check (Rust types encode SNRA required-attrs) — **stronger than OLD** | improvement | +- **Point-in-time query** = `dataset.checkout_version(V_ref)` — pin an immutable snapshot at any version +- **Time-series** = the version log itself — every commit is a versioned event with a timestamp +- **Immutable audit** = append-only by construction — versions never disappear; the log IS the audit trail -## 4. The three load-bearing structural findings +This is the substrate-b efficiency claim: three capabilities, one primitive, no separate storage. The implications are captured in `STANDING_WAVE_ARCHITECTURE.md` §1 (in substrate-b consumer repos). -### 4.1 Three OLD components collapse to one NEW primitive +### 2.2 Per-element auth = palette256 + Hamming popcount on Binary16K -OLD **Historisation** (JG versioning + temporal query) + OLD **TSDB** (InfluxDB via exometer_influxdb) + OLD **signed audit log** all become a **single substrate-b primitive**: Lance versions. +The substrate-b hot-path auth primitive is bit-op-per-element via `Binary16K = [u64; 256]` (Hamming-compare format) with palette256 as the codebook. The per-vertex `_effectiveReaders` / `_effectiveDevices` bitmap is materialised on write; the per-read check is a Hamming popcount / bit-intersection (uncached, immediate-effect by construction — auth changes take effect at the next commit, no separate cache invalidation). -- `dataset.checkout_version(V_ref)` = point-in-time query (Historisation) -- The version log itself = time-series (TSDB) -- Append-only immutability = signed audit log +This is the substrate-b shape for fine-grained per-element authorization. Any consumer wiring auth onto lance-graph entities should use this primitive (per `vsa-switchboard-architecture.md` Layer-2 catalogue + `encoding-ecosystem.md`); do NOT introduce a separate ACL store. -This is the substrate-b efficiency win — three OLD components, one NEW primitive. It is NOT a slogan; it is the architectural consequence of choosing an immutable append-only storage as the foundation. +### 2.3 ractor Actor + Lance-version-as-state-machine = the Rubicon phase machine -### 4.2 Security Mesh bit-ops = palette256 + Hamming popcount (shape-exact) +A substrate-b actor models its lifecycle as a ractor `Actor` whose epistemic state transitions are mirrored by Lance commits. The pattern: -The OLD-stack Security Mesh Layer (r7.1 §3.1.3) uses *"extremely efficient bit operations to verify authorisation for individual data access ... always executed for each data element without impacting access performance. As authorisation changes are not cached, they take effect immediately in the graph."* +- **State enum** (typed) on the ractor Actor — one variant per epistemic state (e.g. Contemporary / Anachronistic / Spoiler for an awareness-mode dispatch) +- **State-enter side-effect** — entering the Decision state fires the Lance commit; the version bump is the state-transition record +- **Defer-until-transition** — events arriving before the Decision are held; replayed after the version bump +- **Per-state timeouts** — SLA-bounded waits per state; expiry routes through `MessagingErr::Saturated` for backpressure -The substrate-b hot-path primitive is bit-op-per-element via palette256 + Hamming popcount on `Binary16K = [u64; 256]`. Same algorithmic shape; same per-element guarantee; same uncached / immediate-effect property. The materialised `_effectiveReaders` / `_effectiveDevices` (per BGFS PR `almatoai/OGIT#773` platform-reserved attributes) are computed via these primitives. +The architectural payoff: the actor's state history is materialised in the Lance version log (no separate state-machine event store), and the determinism firewall is preserved (each actor commits to its own dataset; no cross-mailbox state coupling). Full pattern in `STANDING_WAVE_ARCHITECTURE.md` §6 in substrate-b consumer repos. -### 4.3 gen_statem is the confirmed OLD-stack precedent for the Rubicon model +## 3. Capability roadmap — built today / partial / not-yet -`ericentin/gen_state_machine 2.0.1` is in the HIRO manifest. It is the OTP state-machine substrate; `rafted_value`'s Raft consensus runs on it (follower / candidate / leader = `:gen_statem` states). Its feature set IS the Rubicon model: +Honest accounting for substrate-b consumers planning integration sequencing. -| gen_statem feature | Rubicon analogue (substrate-b) | -|---|---| -| `state_functions` callback mode | ractor ClassActor: one `handle` arm per epistemic state (Contemporary / Anachronistic / Spoiler — see `STANDING_WAVE_ARCHITECTURE.md` §1.5 in any substrate-b consumer) | -| `handle_event_function` mode | typed-enum match in `Actor::handle` | -| `postpone` (defer until next state change) | Rubicon: hold events arriving before the Decision/Rubicon commit; replay after the phase transition | -| `state_enter` callbacks | Rubicon: fire the Lance commit on entering the Decision state | -| per-state / per-event / generic timeouts | SLA-bounded cold-path waits (ractor + `MessagingErr::Saturated`) | -| internal (self-generated) events | cognitive cycle self-dispatch (encode → decode → F-check → persist) | +| Capability | Where | Status | +|---|---|---| +| Lance versions (point-in-time + time-series + audit) | `lance` / `lance-graph` | **built** | +| `LanceVersionWatcher` (in-proc event bus) | `lance-graph-callcenter::version_watcher` | **built** (std::sync Condvar, never tokio) | +| `ractor::MessagingErr::Saturated` (backpressure) | `AdaWorldAPI/ractor#1` | **built** (merged) | +| surrealdb `kv-lance` feature + Lance backend struct | `AdaWorldAPI/surrealdb#35` + `#36` | **built** (merged) | +| `lance-graph-planner` 16 strategies + 12 thinking styles + NARS | `lance-graph-planner` | **built** | +| `auth-plug` in-proc JWT validation | `auth-plug` | **built** | +| palette256 + Hamming popcount primitives | `lance-graph-contract` + `bgz17` | **built** | +| `cognitive-shader-driver` co-located dispatch | `cognitive-shader-driver` | **built** (canonical surface) | +| `EpisodicEdges64` 4-slot MRU + `DemotionSink` (Phase A) | `lance-graph-contract::episodic_edges` (#446/#447/#448) | **built** | +| OGAR `MappingProposal` → `OntologyRegistry` | `AdaWorldAPI/OGAR#5/#6/#7/#8` | **built** (Sprint 5/6 shipped; Sprint 7 muscle memory documented) | +| lance-graph traversal (consumer surface) | `lance-graph` + `lance-graph-planner` | **partial** — need a stable consumer surface for substrate-b | +| DataFusion OLAP surface (consumer endpoint) | `lance-graph` + DataFusion integration | **partial** | +| Tantivy search wiring | (not yet wired) | **not-yet** | +| OGAR `ogar-runtime` Sprint 7 (ClassActor + KanbanMailbox) | `AdaWorldAPI/OGAR` | **not-yet** (holding for protoc-build access + signal) | +| Peer-Raft consensus (openraft / surreal-cluster / TiKV) | (pick-one deferred) | **not-yet** | +| Migration endpoint contract (the dual-stack ground-truth surface) | (substrate-b consumer concern) | **not-yet** (consumer side) | +| WebSocket / gRPC actor mailbox (Layer-3 outbound) | (deferred per I-2 invariant) | **not-yet** | +| Cold-tier `DemotionSink` impl (Phase C, surreal-LIVE wingman) | `lance-graph-contract::episodic_edges::DemotionSink` (seam shipped; impl gated on OQ-11.6) | **gated** | +| `EpisodicWitness64` SoA column (Phase D) | `soa_view.rs:77 episodic_witness()` accessor | **gated** (offline; needs `cognitive-shader-driver`'s `MailboxSoA`) | -**The Rubicon model IS a gen_statem.** It is NOT an invention; it is the faithful translation of an OTP behavior HIRO already runs in production (rafted_value + the lifecycle machines). This matters for any consumer mapping the OLD-stack thinking layer onto substrate-b: the Rubicon shape is the confirmed precedent, not a hypothesis. +## 4. The migration endpoint contract — substrate-b's dual-stack ground-truth surface -## 5. The OLD data model — exact OGIT shapes (PR harvest) +A substrate-b consumer that's replacing an external system needs a uniform API surface exposed by BOTH the substrate-b binary AND the system being replaced, so the same workload can be replayed against each and compared deterministically. -The OLD stack carries 10 production workloads (confirmed by walking ~493 OGIT closed PRs, 2017-2026). Any substrate-b consumer replacing HIRO needs to handle all of them: +The contract substrate-b consumers should expose (one minimal shape; consumers extend per workload): -- **BGFS** (Bardioc Graph File System, PR #773 merged 2026-06-01) — 5 entities (File, Folder, Symlink, ShareLink, AppHandler) + 2 verbs (`refersTo`, `sharedVia`) + 17 attributes incl. capability fixed-set `{read, write, share, admin, delete}`; platform-reserved `_effectiveReaders` / `_effectiveDevices`; 16-hop symlink resolution -- **Auth/Device** (PR #775 open) — `Device` (deviceType ∈ {mobile, desktop, web, hsm, hardware-wallet}; securityLevel ∈ {0, 50, 80, 100}) + `usesDevice` + `hasVault` (Person-anchored, survives Account deactivation) + `isWorkspace` (Team marker) -- **Three-layer identity** (established 2018 in PRs #362/#376/#403) — Person (persistent) / Account (ephemeral, job-scoped) / DataScope (access perimeter; **mandatory-named** since 2018-11) -- **Documents** — `DocumentInfoRecord` with blob/status/creationTime/typ -- **Automation** — `AutomationIssue` with `savedTimeSeconds` (RPA ROI metric) -- **Knowledge Items** — with `manualProcessingTimeSeconds` (human cost metric) -- **Tickets** — `Ticket`/`ChangeRequest`/`ConfigurationItem` with `assignedTo`/`isPartOf`/`precedes`/`affects`/`subType` -- **OSINT** — Person/Organization/Address/Position/SecurityIncident relational graph + `locatedIn` -- **Org lifecycle** — Organization with `endedAt`/`precedes` -- **Trust** — Rating -- **Forms** — Form → Attachment connection -- **MARS** — survives within OGIT (`ogit.Automation:MARSNode` + `ogit/MARS/Resource` + `mars2ogit`); NOT deprecated, refactored +``` +POST /v1/entity create vertex +GET /v1/entity/:id read vertex +GET /v1/entity/:id?at=V read vertex at Lance version V (historisation) +PUT /v1/entity/:id update vertex +DELETE /v1/entity/:id soft-delete (lifecycle markers, never hard delete) +POST /v1/edge create edge +POST /v1/traverse multi-hop traversal (lance-graph-planner dispatch) +POST /v1/query point query +POST /v1/graphql tabular output (DataFusion SQL over Lance versions) +GET /v1/audit audit query (DataFusion over Lance version log) +WS /v1/stream real-time subscription (LanceVersionWatcher → WS push, Layer-3 tokio) +POST /v1/dispatch cognitive dispatch (substrate-b-specific; no comparison) +``` -## 6. Boundary collapse (the migration value) +Properties to preserve at every endpoint: +- **Version-pinnable reads** — every read can specify `?at=V` for point-in-time +- **Lifecycle markers, not hard delete** — `revokedAt` / `archivedAt` timestamps; never DROP +- **Real-time subscription via the in-proc bus** — `WS /v1/stream` proxies `LanceVersionWatcher::subscribe()` through to the WebSocket client (Layer-3 tokio outbound) +- **DataFusion is the cold-path SQL** — graphql + audit go through DataFusion over Lance versions; the hot path stays on `lance-graph-planner` strategy dispatch -The OLD-stack request path traverses **8 boundaries**: +Substrate-b consumers run dual-stack workload replay against this contract; the §14 acceptance gate (in substrate-b consumer repos' `docs/MIGRATION-COMPARISON-HARNESS.md`) produces a per-endpoint verdict (PASS / DIVERGENT-RECONCILABLE / DIVERGENT-FAULTY / INDETERMINATE). -1. Operator Query → BEAM (HTTP) -2. BEAM → JVM (HTTP, graph_conn → Java OGIT) -3. JVM → C++ (JNI, Java → Cassandra/Lucene) -4. Gremlin → Storage (TinkerPop → Titan backend) -5. App → DB (CQL serialize) -6. DB → Analytics (Cassandra → ClickHouse/Spark) -7. **Auth boundary** (Zitadel JWT validation) -8. **Message Bus produce/consume** (Kafka — every event) +## 5. Integration patterns that fall out of this shape -Plus **4 concurrency models**: BEAM (Phoenix + swarm + sbroker), JVM (Titan + Gremlin + ES), Go (Zitadel — retained), C++ (Cassandra + Lucene). - -The substrate-b shape collapses to: **0 in-binary application boundaries** + 1 retained external Go IAM (Zitadel) + 1 concurrency model (ractor) + the irreducible Raft consensus tax (honest — see `ROADMAP_RUST_PRIMARY_HEADSTONE.md` in any substrate-b consumer for the per-workload tax accounting). - -The 8 → 0 boundary collapse is the migration's measured value, not a slogan; the §14 acceptance gate proves it per-endpoint via dual-stack workload replay. +### 5.1 Three OLD components collapse to one when substrate-b is the target + +A consumer migrating from a separate Historisation layer + a separate time-series database + a separate signed-audit-log service replaces all three with Lance versions. This is the design-pattern claim; it follows from §2.1. Substrate-b consumers should NOT introduce separate stores for these three capabilities. + +### 5.2 ACL changes take effect immediately, by construction + +Because the per-element auth check is a bit-op against the per-vertex bitmap (no separate cache), an ACL change at Lance version V is in effect at every read at version >= V. There is no auth-cache invalidation step; substrate-b consumers should NOT introduce one. The materialisation of `_effectiveReaders` on write is the only side-effect. + +### 5.3 The actor's state history is the Lance version log + +A ractor Actor following the Rubicon pattern (§2.3) does NOT need a separate state-machine event store. The Lance version log on the actor's dataset IS the state history. Substrate-b consumers should NOT introduce a side-table of state transitions; queries against the version log answer "what state was this actor in at version V?" via `checkout_version(V)`. + +### 5.4 In-process events use std::sync, not tokio + +The `LanceVersionWatcher` (lance-graph-callcenter) uses `std::sync::{Arc, RwLock, Mutex, Condvar, AtomicUsize}` and never `tokio::sync` — per the I-2 invariant documented in that module. Substrate-b consumers wiring real-time event subscription must follow the same rule for in-process listeners; tokio is reserved for Layer-3 outbound sinks (PhoenixServer, PostgRestHandler, WebSocket push, gRPC remote actor transport). + +This is a `hollow-wire-failure-modes.md` failure-mode magnet: a consumer that introduces tokio for in-process subscription violates I-2 and creates the exact bug `version_watcher.rs`'s migration history note (2026-05-06) records as already-corrected upstream. + +## 6. The OGAR carrier — substrate-b's data-model entry point + +OGAR (`AdaWorldAPI/OGAR`) is the substrate-b carrier for class identity + schema + Active-Record semantics → `lance-graph-ontology::OntologyRegistry`. Substrate-b consumers feeding domain models into lance-graph go through OGAR's `MappingProposal` shape (PR `AdaWorldAPI/OGAR#5` shipped via owned-mirror workaround; Sprint 6 registry integration shipped; Sprint 7 ClassActor + KanbanMailbox muscle-memory documented and gated on the upstream symbol-layout decisions). + +Consumer integration sequence (when wiring a new domain model): + +1. Author the domain model as an OGAR `Class` (the IR; OGAR Sprint 1 vocab + Sprint 4.5 SurrealQL adapter shipping) +2. Feed `MappingProposal` into `OntologyRegistry` (OGAR Sprint 5/6 path) +3. The lance-graph-planner picks up the registered class for strategy dispatch +4. The `lance-graph-callcenter::LanceMembrane` (sole writer per session) projects domain events into Arrow-scalar `CognitiveEventRow` (BBB invariant: no VSA / RoleKey / NarsTruth crosses the membrane) +5. `LanceVersionWatcher` fans out to in-proc subscribers; the bus is the version pointer + +No new contracts are needed for steps 1-5; the existing OGAR + lance-graph-ontology + lance-graph-callcenter surfaces compose. See `OGAR_ELIXIR_HIRO_MUSCLE_MEMORY.md` and `STANDING_WAVE_ARCHITECTURE.md` §1.6 in substrate-b consumer repos for the muscle memory. ## 7. Process rule for substrate-b consumers -Before proposing a new lance-graph integration trait / contract / coordination surface to replace an OLD-stack capability: +Before proposing a new lance-graph integration trait / contract / coordination surface: -1. Check this doc — does the §3 correspondence already name the substrate-b primitive? -2. Check `.claude/knowledge/encoding-ecosystem.md` — does an existing codec serve the capability? -3. Check `.claude/knowledge/lab-vs-canonical-surface.md` — is the canonical bridge the right place? +1. Check the §3 capability roadmap — does an existing built-or-partial primitive serve the capability? +2. Check `.claude/knowledge/encoding-ecosystem.md` — does an existing codec serve the data shape? +3. Check `.claude/knowledge/lab-vs-canonical-surface.md` — is the canonical bridge the right place (vs the LAB transport)? 4. Check `.claude/knowledge/hollow-wire-failure-modes.md` — am I about to wire the lab surface without plugging the canonical bridge? -If steps 1-4 don't dissolve the proposal, then a new structure is warranted. Otherwise, the OLD-stack correspondence here already names what to wire against. +If steps 1-4 don't dissolve the proposal, then a new structure is warranted. Otherwise, the existing surfaces already name what to wire against. --- ## Cross-references -### Source documents (confirmed ground truth) -- **Almato r7.1 Product Description** (Oct 2025, 33 pages) — the 9-component OS architecture (`BARDIOC_PRODUCT_CANONICAL.md` in substrate-b consumers) -- **Almato OSS dependency manifest** (`bitbucket.org/almatoag/opensource`, project KG) — the confirmed component versions (`BARDIOC_DEPENDENCY_MANIFEST_CONFIRMED.md`) -- **OGIT closed PR harvest** (~493 PRs 2017-2026 from `github.com/almatoai/OGIT`) — the exact data model shapes (`BARDIOC_HIRO_CONTEXT_HARVEST.md` + `TARGET_STACK_REFERENCE.md`) -- **substrate-b architecture doc** — `STANDING_WAVE_ARCHITECTURE.md` (awareness-in-Lance-versioning + §1.6 OGAR Sprint 7 muscle memory) - ### Companion lance-graph knowledge docs -- `.claude/knowledge/encoding-ecosystem.md` — the full codec ledger (MANDATORY read before any codec work) -- `.claude/knowledge/lab-vs-canonical-surface.md` — the canonical surface rule (MANDATORY read before any REST/gRPC/Wire DTO work) -- `.claude/knowledge/hollow-wire-failure-modes.md` — DRAFT-INERT / sealed-but-shadowed / feature-flag mismatch (companion to lab-vs-canonical-surface) +- `.claude/knowledge/lab-vs-canonical-surface.md` — the canonical surface rule (MANDATORY before any REST/gRPC/Wire DTO work) +- `.claude/knowledge/hollow-wire-failure-modes.md` — DRAFT-INERT / sealed-but-shadowed / feature-flag mismatch (companion failure-mode catalogue) +- `.claude/knowledge/encoding-ecosystem.md` — the full codec ledger (MANDATORY before any codec work) - `.claude/knowledge/vsa-switchboard-architecture.md` — the three-layer carrier (Switchboard / Domain role catalogues / Content stores) -### Upstream PRs from this correspondence -- `AdaWorldAPI/lance-graph#452` (Lance-append-Raft dovetail), `#453` (cluster asymmetry), `#454` (post-merge corrections), `#455` (dn_redis as key-shape protocol), `#456`/`#457`/`#458` (Pearl junctions classifier + post-merge corrections) — all MERGED +### Upstream contributions in this lineage (substrate-b correspondence) +- `AdaWorldAPI/lance-graph#452` (Lance-append-Raft dovetail), `#453` (cluster asymmetry), `#454` (post-merge corrections), `#455` (dn_redis as key-shape protocol), `#456`/`#457`/`#458` (Pearl junctions classifier + post-merge corrections) — MERGED - `AdaWorldAPI/lance-graph#464` (hollow-wire failure modes catalogue) — OPEN -- `AdaWorldAPI/surrealdb#35` (kv-lance SDK feature), `#36` (Lance backend struct + endpoint helper) — both MERGED +- `AdaWorldAPI/surrealdb#35` (kv-lance SDK feature), `#36` (Lance backend struct + endpoint helper) — MERGED - `AdaWorldAPI/ractor#1` (`MessagingErr::Saturated` variant + `From` split) — MERGED +- `AdaWorldAPI/OGAR#5` (Sprint 5a owned-mirror), `#6` (cross-session coordination), `#7` (temporal time-travel + std::sync correction), `#8` (Sprint 7 muscle memory absorbed) — MERGED From 58753096249008e0725f4a3da169ce6e044b0c5d Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:28:38 +0200 Subject: [PATCH 5/6] epiphany(E-SUBSTRATE-B-CAPABILITY-ROADMAP): three load-bearing NEW-stack primitives codified; consumer integration shape documented --- .claude/board/EPIPHANIES.md | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 95c56ff48..10b2d9916 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,18 +1,20 @@ -## 2026-06-04 — E-OLD-STACK-CONFIRMED — Almato's own published OSS manifest confirms the OLD HIRO/Bardioc stack shape; three OLD components collapse to one NEW primitive +## 2026-06-04 — E-SUBSTRATE-B-CAPABILITY-ROADMAP — three load-bearing NEW-stack primitives codified; consumer integration shape documented -**Status:** FINDING (ground-truth from `bitbucket.org/almatoag/opensource` — the manifest Almato r7.1 Product Description §5.5 explicitly cites — + the OGIT closed-PR harvest, 2026-06-04; confirmed against `BARDIOC_PRODUCT_CANONICAL.md` and `BARDIOC_DEPENDENCY_MANIFEST_CONFIRMED.md` in substrate-b consumers). +**Status:** FINDING (substrate-b consumer integration pattern, codified after the OGAR / surrealdb / ractor / lance-graph correspondence work converged on three structural primitives, 2026-06-04). -**Three structural findings** that any lance-graph + ractor + surrealdb consumer replacing a HIRO-shaped OLD stack must internalize: +**Three NEW-stack primitives substrate-b consumers must internalise** (now codified in `.claude/knowledge/old-stack-capability-parity.md`): -1. **Three OLD components collapse to one NEW primitive.** OLD Historisation (JG temporal query) + OLD TSDB (InfluxDB via exometer_influxdb) + OLD signed audit log all become **Lance versions** in substrate-b. `dataset.checkout_version(V_ref)` = point-in-time; the version log itself = time-series; append-only immutability = audit. One primitive, three OLD capabilities. Concrete efficiency win, not a slogan. +1. **Lance versions are a multi-purpose primitive.** One primitive serves three capabilities a substrate-b consumer would otherwise build separately: `checkout_version(V)` = point-in-time query (Historisation); the version log = time-series; append-only immutability = signed audit. Consumers should NOT introduce separate stores for these three. -2. **Security Mesh bit-ops = palette256 + Hamming popcount (shape-exact).** The OLD-stack 4-axis bit-op per-element auth (Subject(n) × Object(n) × Implicit(4) × Explicit(x), uncached, immediate) IS the substrate-b hot-path primitive. Materialised `_effectiveReaders` / `_effectiveDevices` (per `almatoai/OGIT#773` BGFS platform-reserved attributes) compute via these primitives. The OLD-stack security model survives migration unchanged. +2. **Per-element auth = palette256 + Hamming popcount on `Binary16K`.** The hot-path auth primitive is bit-op-per-element via the per-vertex `_effectiveReaders` / `_effectiveDevices` bitmap. Materialised on write; checked on read via Hamming popcount / bit-intersection; uncached / immediate-effect by construction. ACL changes at version V are in effect at every read at version >= V; consumers should NOT introduce an auth cache. -3. **gen_statem is the confirmed OLD-stack precedent for the Rubicon model.** `ericentin/gen_state_machine 2.0.1` is in the HIRO manifest; `rafted_value`'s Raft consensus runs on it (follower/candidate/leader = `:gen_statem` states). Its feature set — `state_functions`, `handle_event_function`, `postpone` (defer-until-next-state), `state_enter` callbacks, per-state timeouts, internal self-events — IS the Rubicon phase machine. `state_enter` fires the Lance commit on entering the Decision state; `postpone` holds events arriving before Rubicon; timeouts bound SLA waits. The substrate-b actor-state-machine is the faithful translation of an OTP behavior HIRO already runs. +3. **ractor Actor + Lance-version-as-state-machine = the Rubicon phase machine.** A substrate-b actor models its lifecycle as a typed state enum on a ractor `Actor`; state-enter side-effect fires the Lance commit at the Decision state; events arriving before Decision are deferred; per-state timeouts route through `MessagingErr::Saturated`. The actor's state history IS the Lance version log on its dataset; no separate state-machine event store needed. -**Why this matters here (lance-graph):** any consumer mapping the OLD-stack thinking layer onto lance-graph + ractor needs these correspondences to avoid reinventing primitives that already exist. The new knowledge doc `.claude/knowledge/old-stack-capability-parity.md` is the reference; this entry records the three load-bearing structural findings as a single FINDING-level epiphany. +**Two consumer-side patterns** that fall out of these primitives: +- The `LanceVersionWatcher` (in-proc event bus) uses `std::sync` per the I-2 invariant — tokio is reserved for Layer-3 outbound sinks. A consumer that wires tokio for in-process subscription violates I-2 and reproduces the bug `version_watcher.rs`'s 2026-05-06 plan correction note already records as fixed upstream. This is a `hollow-wire-failure-modes.md` failure-mode magnet. +- The migration endpoint contract (`POST /v1/{entity,edge,traverse,query,graphql,audit}` + `WS /v1/stream` + `POST /v1/dispatch`) is the substrate-b dual-stack ground-truth surface — same workload replayed against substrate-b AND the system being replaced; §14 acceptance gate produces a per-endpoint verdict. -**Cross-ref:** `.claude/knowledge/old-stack-capability-parity.md` (new); `.claude/knowledge/lab-vs-canonical-surface.md` (companion); `.claude/knowledge/hollow-wire-failure-modes.md` (companion); `AdaWorldAPI/lance-graph#452/#453/#454/#455/#456/#457/#458` (the merged contributions from this correspondence work); `AdaWorldAPI/surrealdb#35/#36` (kv-lance feature + Lance backend struct); `AdaWorldAPI/ractor#1` (`MessagingErr::Saturated` for the backpressure invariant). +**Cross-ref:** `.claude/knowledge/old-stack-capability-parity.md` (new); `.claude/knowledge/lab-vs-canonical-surface.md` (companion); `.claude/knowledge/hollow-wire-failure-modes.md` (companion); `AdaWorldAPI/lance-graph#452/#453/#454/#455/#456/#457/#458` (merged contributions); `AdaWorldAPI/surrealdb#35/#36` (kv-lance feature + Lance backend struct); `AdaWorldAPI/ractor#1` (`MessagingErr::Saturated`); `AdaWorldAPI/OGAR#5/#6/#7/#8` (carrier shipping). --- From 03149d7a4ed5d855086a6fa75af5bb87e300ddb7 Mon Sep 17 00:00:00 2001 From: AdaWorldAPI Date: Thu, 4 Jun 2026 22:28:40 +0200 Subject: [PATCH 6/6] =?UTF-8?q?agent-log:=20D-SUBSTRATE-B-CONSUMER-DOC=20S?= =?UTF-8?q?HIPPED=20=E2=80=94=20substrate-b=20consumer=20integration=20sha?= =?UTF-8?q?pe=20(companion=20to=20lab-vs-canonical-surface=20+=20hollow-wi?= =?UTF-8?q?re-failure-modes)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .claude/board/AGENT_LOG.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index 8853aa860..f9297b262 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,16 +1,16 @@ -## [Main thread / Opus, autoattended] D-OLD-STACK-PARITY-DOC — `.claude/knowledge/old-stack-capability-parity.md` SHIPPED (companion to lab-vs-canonical-surface + hollow-wire-failure-modes) +## [Main thread / Opus, autoattended] D-SUBSTRATE-B-CONSUMER-DOC — `.claude/knowledge/old-stack-capability-parity.md` SHIPPED (companion to lab-vs-canonical-surface + hollow-wire-failure-modes) -**Branch:** claude/old-stack-capability-parity (this PR). New `.claude/knowledge/` doc capturing the substrate-b ↔ OLD HIRO/Bardioc stack capability correspondence, grounded in Almato's own published OSS manifest (`bitbucket.org/almatoag/opensource` — the list the r7.1 Product Description §5.5 cites) + the OGIT closed-PR harvest (~493 PRs 2017-2026, three Explore agents) + the Almato r7.1 Product Description (Oct 2025, 33 pages). +**Branch:** doc/knowledge-old-stack-capability-parity (this PR). New `.claude/knowledge/` doc capturing the substrate-b consumer integration shape: the seven-capability composition (`lance-graph` storage + `surrealdb kv-lance` KV + Tantivy search + DataFusion OLAP + ractor actors + `LanceVersionWatcher` in-proc bus + external Zitadel IAM), the three load-bearing primitives (Lance versions as multi-purpose temporal; palette256+Hamming per-element auth; ractor-Actor + Lance-version-as-state-machine = Rubicon), and the capability roadmap (built / partial / not-yet) honest accounting. -**What it captures (20-row correspondence table):** Zitadel-stays + Security-Mesh-bit-ops-= palette256+Hamming + signed-audit = Lance-version-log + Kafka 0.8.2.2+ZooKeeper 3.4.6 = LanceVersionWatcher (in-proc) + Titan 0.4.4→lance-graph + Gremlin 2.4 → lance-graph-planner + Cassandra 2.1.8 → TiKV/surrealdb-kv-lance + ES 1.7+Lucene 4.10 → Tantivy + ClickHouse+Spark → DataFusion + InfluxDB → Lance versions + S3 → Lance fragments + swarm/libcluster → ractor + sbroker/pobox → bounded mailbox + lru_cache/con_cache → dn_redis + rafted_value → openraft + **gen_statem → Rubicon-as-ractor-actor (shape-exact)** + expr → lance-graph-planner thinking + Jetty WS → substrate-b WS + Jena → OGIT compile-time check (stronger). +**What it serves:** any substrate-b consumer planning a lance-graph + ractor + surrealdb integration needs the same correspondence answers (what's built, what's partial, which primitive replaces what design pattern). Documenting it once upstream lets every consumer reuse the answer without re-deriving. -**Three load-bearing structural findings** (also recorded in EPIPHANIES as `E-OLD-STACK-CONFIRMED`): (1) three OLD components (Historisation + TSDB + audit) collapse to one NEW primitive (Lance versions); (2) Security Mesh bit-ops = palette256+Hamming (shape-exact); (3) gen_statem IS the confirmed Rubicon precedent (not invention). +**Three load-bearing structural patterns** (also recorded in EPIPHANIES as `E-SUBSTRATE-B-CAPABILITY-ROADMAP`): (1) Lance versions are multi-purpose (point-in-time + time-series + audit, one primitive); (2) per-element auth = palette256+Hamming popcount (uncached / immediate-effect by construction); (3) ractor Actor + Lance-version-as-state-machine = Rubicon phase machine (the actor's state history IS the version log). -**Boundary collapse documented:** OLD 8 boundaries (Operator → BEAM → JVM → Gremlin → JG → Cassandra → Analytics → Kafka) + 4 concurrency models (BEAM/JVM/Go/C++) → NEW 0 in-binary application boundaries + 1 retained external Go IAM + 1 concurrency model (ractor) + honest Raft consensus tax. The 8 → 0 collapse is the migration's measured value, not a slogan. +**Migration endpoint contract documented:** the substrate-b dual-stack ground-truth surface (`POST /v1/{entity,edge,traverse,query,graphql,audit}` + `WS /v1/stream` + `POST /v1/dispatch`). Same workload replayed against substrate-b AND the system being replaced; the §14 acceptance gate (consumer-side `docs/MIGRATION-COMPARISON-HARNESS.md`) produces per-endpoint verdicts. -**Why it lives in lance-graph (not the consumer repo):** any consumer integrating lance-graph + ractor + surrealdb as an OLD-HIRO replacement hits the same correspondence question. Documenting it once upstream, with confirmed sources, lets every consumer reuse the answer. Companion to `lab-vs-canonical-surface.md` (the rule) + `hollow-wire-failure-modes.md` (the failure mode). +**Capability roadmap honesty:** built today = Lance versions, LanceVersionWatcher (std::sync), `MessagingErr::Saturated`, surrealdb kv-lance, planner 16 strategies, auth-plug, palette256+Hamming, cognitive-shader-driver, `EpisodicEdges64` Phase A, OGAR Sprint 5/6. Partial = lance-graph consumer surface, DataFusion OLAP, dn_redis wiring, distributed actor topology, OGIT data-model coverage. Not-yet = Tantivy wiring, OGAR Sprint 7 (gated), peer-Raft pick, migration endpoint router, WS/gRPC Layer-3. -**Outcome:** doc-only, no code changes. No new tests (knowledge docs don't ship tests). Spot-check provenance: Kafka 0.8.2.2 is at `bitbucket.org/almatoag/opensource/src/main/third-party-java.adoc:575-578`; Titan 0.4.4 blocks at `:lines around Titan-Core/Titan-Cassandra/Titan-ElasticSearch/Titan-HBase`; Elixir manifest at `third-party-elixir.adoc` (lru_cache 0.1.3 / con_cache 0.12.1 / gen_state_machine 2.0.1 / sbroker 0.7.0 / pobox 1.0.4 / swarm 3.0.5 / libcluster 3.0.2 / libring 1.3.1 / locker 6 / exometer_influxdb 0.5.8 / expr 0.1.0). +**Outcome:** doc-only, no code changes. Spot-check provenance: every cross-reference is to lance-graph / surrealdb / ractor / OGAR PR numbers + existing knowledge docs in this repo. No consumer-internal specifications cross the upstream boundary; only the integration shape + capability roadmap. ---