# FrankenGraphDB — RULEBOOK v1.0 Assessment Packet v5

**Repository:** `Dicklesworthstone/frankengraphdb` · **Language:** Rust [Code-verified, High] · **Pinned commit:** `f077badcc4c6e201942e3b10cd20d09354afdc79` (2026-09-22 11:29:33 -0400, [Git-observed, High]) · **Last push:** 2026-09-22T15:32:39Z (GitHub API — ~3 minutes after the pin commit's timestamp; HEAD has moved past the assessment pin) [External, High] · **Scope:** the pinned commit only, not HEAD or current `main`. **Releases:** 0 (GitHub Releases API, 2026-09-22) [External, High] · **Stars:** 24 · **Forks:** 5 · **Created:** 2026-07-15 · **Open issues/PRs:** 0 [External, High] · Assessment date: 2026-09-22.

*Cold-reader glosses used in this packet:* **W10** = the plan's "Fabric + operations" workstream — the full product surface (server, protocol adapters, CLI, transactions, backup/restore, Python/system graph) [Maintainer claim, High — plan §19 workstream table]; **bead** = the repo's issue-tracker work unit [Maintainer claim, High].

**Method (analyst):** shallow clone of HEAD (recorded pin above) under `~/workspace/.scratch/frankengraphdb-verify`; full `git log` metadata read; README (tense note, six bets, performance-gates table, design philosophy, Limitations, FAQ), `IMPLEMENTATION_STATUS.md` (whole file), `CHANGELOG.md` (head ~400 lines), `docs/NEGATIVE_EVIDENCE.md` (whole, 562 lines), `docs/REALITY_CHECK_AND_BRIDGE_PLAN.md` (bridge table + Sep-08 measurement sections), `docs/LOCAL_PROOF_BUNDLE.md` (head), `AGENTS.md` (head), `COMPREHENSIVE_PLAN_FOR_THE_DESIGN_OF_FRANKENGRAPHDB.md` (thesis §0, gates §17/§19, W10 definition), root `Cargo.toml` (all 30 members enumerated), `Cargo.lock` (asupersync pin + transitive registry scan + `franken*` name scan), `deny.toml` (cargo-deny policy), `LICENSE` (verbatim), `rust-toolchain.toml`, `.github/workflows/check.yml` (whole), `rustfmt`/unsafe-attribute census over `crates/*/src`, src/test/example line census over `crates/` + `tools/` (via `cat` pipe — the round-4 recount that corrected the 1.2M double-count), per-crate top-10 distribution, `.beads/issues.jsonl` census (986 beads), `registries/invariants.toml` (20 IDs counted), `crates/fgdb-bench` directory listing, web search for independent coverage (2026-09-22), for the Kùzu/Apple archival story, and for Neo4j/FalkorDB lane facts. **Not done:** nothing was compiled, no test suite was executed, no benchmark was reproduced, no binary was run; the pin's CI page has no verdict-bearing runs after the 2026-09-03 owner ruling (see §4.5).

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read); **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green); **[Maintainer claim]** asserted in README/docs, not independently executed; **[External]** independent sources; **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low**.

---

## Hook

A 735,929-line [Counted, High], single-maintainer Rust graph database whose README is *deliberately written in present tense as the 1.0 target-state spec* — while its own status doc, a 19-row promise-vs-reality bridge table (most rows: Partial or Not integrated [Maintainer claim, High]), and a changelog entry about a test that silently skipped its Timestamp arm say what actually runs. The real asset isn't the database (server, CLI, WCOJ execution engine: all "Not integrated") but the *evidence apparatus* around it — 20 machine-checked invariants, claim registries, Lean proof lanes, a negative-evidence ledger — aimed at the lane Apple just vacated by archiving Kùzu [External, High]. The catch is in the lockfile: 204 crates.io packages, including serde itself, sit under a "No serde. Ever." badge [Counted, High], and the ≥3× Neo4j convergence gates are provisional CI targets, not measured results [Maintainer claim, High].

---

## TL;DR

- **What it is:** A from-scratch Rust property-graph database (GQL, ISO/IEC 39075:2024) being built by one human maintainer since 2026-07-15, unifying MVCC/time-travel/git-style branches/replication into a single fountain-coded commit stream ("One Version Universe"), with a WCO+factorized execution vision ("Loom"), DBSP-style incrementality ("Ripple"), and deterministic, certificate-carrying query results. 735,929 first-party `.rs` lines across 1,433 files in 30 workspace members at the pin [Counted, High].
- **Strongest evidence:** The claim-governance machinery is real and self-scrutinizing: machine-readable registries (`invariants.toml`, `laws.toml`, `claims_lint.toml`, `unsafe_boundary_ledger.toml`) enforced by a std-only `tools/registry-check` [Code-verified, High]; a `REALITY_CHECK_AND_BRIDGE_PLAN.md` whose Sep-08 verification reports 9/9 core gates, 40/40 registered gates, 3,449 test outcomes in agreement, and 9 Miri tests green on the embedded subset [Maintainer claim, Medium]; a 2026-09-04 changelog sequence documenting *two independent verifier-found overclaim residues* and the mutations that now guard them [Maintainer claim, High]; `unsafe_code = "forbid"` workspace-wide with exactly 6 `unsafe` block sites confined to three `deny`+ledgered `fgdb-unsafe-*` crates [Counted, High]; the durable path (Chronicle capsule-first, marker-last two-fsync; Strata tier-D; first-committer-wins validator with attributable aborts) is documented as executing [Maintainer claim, Medium].
- **Strongest doubts:** What ships today is an embedded Rust composition crate with a bounded GQL read slice (labeled one/two-hop patterns, integer predicates, deterministic projection — aggregation, `ORDER BY`, mutation, typed parameters explicitly unsupported); **there is no `fgdbd` server and no installable `fgdb` CLI as products** — the REALITY_CHECK bridge table marks the server, CLI, full GQL, Loom/GLA physical execution, full SSI, distributed system, and Ripple subscriptions as Partial or Not integrated [Maintainer claim, High]; zero releases, 24 stars, 5 forks [External, High]; GitHub Actions was de-automated by owner ruling on 2026-09-03 ("we do not use gh actions for any reason, ONLY /dsr"), so the pin has no CI verdict [CI-observed + Maintainer claim, High]; the "closed universe / No serde … Ever" README badge is contradicted by the repo's own lockfile [Counted, High]; one human maintainer, bus factor 1 [Git-observed, High].
- **NODUS ring: Explore** [Inference, Medium] (TRL 4 — see §4.9). Substantive-but-unproven is the textbook Explore case: the machinery is unusually rigorous, but the product surface is pre-release, the performance gates are targets not results, and the license rider is an advancement blocker for the most likely evaluators.

## Quick Links

Pin-relative links (`blob/f077badcc4c6e201942e3b10cd20d09354afdc79`); all returned HTTP 200 when fetched 2026-09-22 [Verified, High on resolution]:

1. [Repository](https://github.com/Dicklesworthstone/frankengraphdb) — 24 stars / 5 forks / 0 releases
2. [README](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/README.md) — includes the tense-note disclaimer (L23) and the six bets
3. [Implementation status (the honest map)](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/IMPLEMENTATION_STATUS.md) — "what executes now" vs "target architecture"
4. [License (MIT + OpenAI/Anthropic rider)](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/LICENSE)
5. [Changelog](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/CHANGELOG.md) — records landed, executable capability only (not plans)
6. [Negative evidence ledger](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/docs/NEGATIVE_EVIDENCE.md) — doctrine-violation memorial, 562 lines
7. [Reality check & bridge plan](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/docs/REALITY_CHECK_AND_BRIDGE_PLAN.md) — 19-row promise-vs-reality bridge table
8. [Comprehensive plan (3,273 lines)](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/COMPREHENSIVE_PLAN_FOR_THE_DESIGN_OF_FRANKENGRAPHDB.md) — §17 gates, §19 convergence milestones G1→G4
9. [CI workflow (`check.yml`)](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/.github/workflows/check.yml) — `workflow_dispatch`-only since the 2026-09-03 owner ruling
10. [AGENTS.md](https://github.com/Dicklesworthstone/frankengraphdb/blob/f077badcc4c6e201942e3b10cd20d09354afdc79/AGENTS.md) — the constitutional doctrine (Backwards Compatibility, evidence rules)

## Did You Know

The repository's negative-evidence ledger records that the doctrine clause it enforces is keyed to an event **the project has never performed**: of 705 commits measured at `e0bddd3`, exactly **1** was produced by `git revert`, **3** had revert semantics in the subject — and **0** reverted a doctrine violation, because `AGENTS.md`'s Backwards Compatibility doctrine ("Never create compatibility shims or wrappers… Just fix the code directly") forbids the mechanism the clause requires. [Maintainer claim, High — verified present verbatim in `docs/NEGATIVE_EVIDENCE.md` at the pin; the 705-commit census is the maintainer's count, not independently re-derived.] The doctrine is self-negating, the ledger caught it, and the project published the finding rather than deleting the clause.

## Franken-worthy next steps

1. **Export the claim-governance machinery as a standalone crate.** `tools/registry-check` (std-only, validates the TOML registries under `registries/`: invariants, laws, claims-lint, checker index, unsafe-boundary ledger) plus the `expected_enforced_clauses` ledger-control pattern is the most portable artifact in the repo — and unlike the database, it is nearly complete. It is the natural intake-time screen for the FrankenSuite's own assessments: require every project's claim inventory to be machine-registered and check-bound. *Done when:* `registry-check` is extracted with a README and adopted (or explicitly rejected) by one other FrankenSuite repo. [Inference, High]
2. **Run the first honest benchmark of the *shipped* subset, not the target state.** The performance section (§17 gates) is all targets; the only measured perf anywhere is a Sep-08 before/after on a certified-query path (73.8/78.1 ms → 7.59/8.04 ms median/p95) in REALITY_CHECK. Bind the bounded GQL slice (label scans, 1/2-hop patterns, integer predicates) to LDBC SNB Interactive micro-workloads at SF-1 and publish a number the disclaimers can't touch. *Done when:* a committed baseline exists under `fgdb-bench` with a committed variance budget, or a bead records why it can't be done yet. [Inference, High]
3. **Differential-test the bounded GQL slice against `fgdb-reference`.** The repo already owns a "deliberately simple, single-threaded, obviously-correct" reference implementation of the logical semantics (README, Determinism section) — the FrankenRedis-style oracle playbook waiting to happen. Fuzz the GQL binder/executor with generated 1–2 hop queries and diff `fgdb` vs `fgdb-reference` outputs; the falsifiable target is *N divergences per 10k random queries*, not zero bugs. *Done when:* a `differential` harness exists and its first corpus run has a recorded divergence count. [Inference, Medium]
4. **Replace de-automated CI with the local-proof verdict contract.** Since 2026-09-03 there is no automatic CI verdict at any pin; the workflow comment names `scripts/local_proof.sh` on the exact tree as the verdict and `/dsr` as the release path. The packet's §4.5 needs a verdict source: formalize "pin + local_proof.sh exit code + bundle verifier exit code" as the shipped-state evidence, recorded per pin the way the README's run-counts used to be. *Done when:* IMPLEMENTATION_STATUS records the local-proof exit code and pin for three consecutive weeks. [Inference, High]
5. **Write the rider's cost into the program's dependency policy — as a benchmark-blocking finding, not just a license note.** The rider forbids Restricted Parties from *benchmarking, testing, or analyzing* the code. For a database whose §17 gates are the engineering discipline, that means no independent lab can ever validate a frankengraphdb number — the honest-numbers story dies at the license, not at the lab. *Done when:* the program's intake rule is committed: any performance-claiming dependency candidate carrying a named-party benchmarking restriction is flagged as unvalidatable-by-design. [Inference, High]

## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** Every shipping graph database is a compromise fossilized around one old decision — Neo4j around pointer-chasing index-free adjacency on the JVM (good ergonomics, mediocre analytics, a query runtime that took 15 years to vectorize); TigerGraph around MPP with a proprietary language and platform-sized footprint; Memgraph/FalkorDB fast in-memory with thin durability; JanusGraph/NebulaGraph on generic KV underlays paying a permanent impedance tax. **Kùzu got the query architecture right** — columnar CSR + vectorization + factorization + worst-case-optimal joins — and then it left the commons [Maintainer claim, Medium — the Kùzu-archived fact itself is independently corroborated, see below].

**The externally verified part:** Apple acquired Kùzu Inc. (deal completed October 2025; disclosed February 2026 via Apple's EU DMA filing reporting), and the upstream `kuzudb/kuzu` repository was archived read-only on 2025-10-10; the company website was taken down. Community forks (LadybugDB, Kineviz's bighorn, ryugraph, Vela) carry the architecture forward [External, High — corroborated by AppleInsider 2026-02-11, MacRumors 2026-02-11, and an independent ADR in `qwts/cartograph` recording the same facts on 2026-07-05]. This is the strongest demand-side fact in the packet: the maintainer's "why now" is not narrative — the only open embedded engine with a comparable query architecture has been removed from the commons by an acquirer, and no community fork has yet established maintenance or a stable Rust story [External, High on the archival; Inference, Medium on the "no fork has established" judgment].

**Who feels the pain:** agent-memory and GraphRAG workloads needing transactional, time-travelable, branchable graph state with auditable results — the workloads the README's B6 ("Agent-Native by Construction": branch-per-agent isolation, semantic merge, capability-scoped subgraph authorization) is aimed at [Inference, Medium — this is the maintainer's stated bet, not measured demand].

**Why a rewrite, not a fork:** stated explicitly as "blank-slate" — a fork inherits the substrate decisions (JVM, KV underlay, C memory unsafety) the project exists to escape; only a clean room lets the maintainer re-derive storage, execution, and evidence machinery around the asupersync structured-concurrency model ("a database written in the asupersync programming model, the way FoundationDB is a database written in Flow") [Maintainer claim, Medium].

**Adjacent context:** one entry in the larger solo-maintainer FrankenSuite program. The three "owned foundations" the plan names are principally `asupersync` (structured concurrency, lab runtime, deterministic testing), `franken_networkx` (graph algorithms), and `frankensqlite` (MVCC ledger) [Maintainer claim, Medium — from the plan's §0 "Dependency target"; verified at the pin: `asupersync` 0.5.0 pinned by git rev `78b6463` and consumed by 15 of the 30 workspace members [Code-verified, High]; `fnx-classes`/`fnx-generators`/`fnx-algorithms` (franken_networkx native Rust crates) also present as pinned git deps [Code-verified, High]; `frankensqlite` was **not** found as a package in `Cargo.lock` at the pin — the plan's third foundation is not yet wired in [Counted, High]. `franken-decision`, `franken-evidence`, and `franken-kernel` *are* in the lockfile, as transitive dependencies of the pinned asupersync [Counted, High]].

## 4.2 What it is — repo TL;DR

A 30-member Cargo workspace (28 `fgdb-*` engine crates + `fgdb-bench` + the std-only `tools/registry-check`; [Counted, High]) implementing a property-graph database in Rust around six named bets (B1 One Version Universe: MVCC/time-travel/branches/replication as one fountain-coded commit stream — "Chronicle"; B2 Graph-Structured LSM — "Strata"; B3 unified factorized/WCO execution — "Loom"; B4 incremental everything — "Ripple"; B5 determinism as product feature; B6 agent-native), speaking GQL (ISO/IEC 39075:2024) with an openCypher on-ramp and a Bolt-compat subset as an adoption wedge. Development is solo and fast: repo created 2026-07-15, pushes observed through the 2026-09-22 pin date [Git-observed + External, High]. The honest one-line description comes from the maintainer's own status doc: "The live product surface is an embedded Rust composition crate over real Chronicle durability and real Strata tier-D storage, with a deliberately bounded GQL read slice and a bounded write-transaction overlay" — plus a machine-readable claim-governance layer (invariant/law/claims registries, unsafe-boundary ledger) enforced by registry tooling and CI gates [Maintainer claim, High].

One-line verdict: **the most self-scrutinizing pre-product codebase in the FrankenSuite — a machine-checked evidence apparatus wrapped around an embedded graph store whose server, CLI, execution engine, and benchmark story are still target-state spec — built in the open exactly as its strongest architectural rival was archived by Apple.** (NODUS: Explore — see §4.9.)

## 4.3 Repo facts (claim inventory)

Status is the Rulebook's required audit verdict per claim. Every claim re-verified against the pin on 2026-09-22.

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | 30 workspace members, 735,929 first-party `.rs` lines / 1,433 files | demonstrated | Root `Cargo.toml` members enumerated; line sum over `crates/` + `tools/` via `cat` pipe (avoids `wc -l`'s double-counting total line — the method that produced the earlier 1.2M figure). Split: crates tree 346,171 src / 262,464 tests / 5,299 examples (tests = 43% of the crates tree); `tools/registry-check` 84,136 src / 42,968 tests. 28 `fgdb-*` + `fgdb-bench` + `tools/registry-check` | [Counted, High] |
| 2 | `unsafe_code = "forbid"` workspace-wide; exactly 6 `unsafe` block sites, all in `fgdb-unsafe-{arena,simd,vfs}` whose roots use `deny` + ledgered narrow `allow(unsafe_code)` | demonstrated | Anchored `#![…]` scan over `crates/*/src`; `unsafe {`-site grep. 60 files merely *mention* unsafe in comments; the executable sites are 6 | [Counted, High] |
| 3 | "Closed dependency universe … No serde, no tokio, no rocksdb, no arrow, no tantivy, no hnswlib. Ever." (README badge + §Design philosophy) | **disproven as stated** | `Cargo.lock` at the pin contains **204 crates.io registry packages**, including `serde`, `serde_json`, `rmp-serde`, `thiserror`, `rayon`, `tempfile`, `tracing` — pulled transitively through the pinned `asupersync 0.5.0` (git rev `78b6463`, `default-features = false`) and `fnx-*` foundations. **True only for direct fgdb-crate deps** (15 crates declare `asupersync` by git rev; no direct crates.io dep); the *built graph* includes serde. The claim as a reader reads it — the dependency surface of the product — is false | [Counted, High] |
| 4 | README written in present tense "as if the entire design … is fully realized" — a deliberate choice, disclosed at L23, with genuine future work (horizontal sharding) labeled in Limitations | demonstrated (the disclosure exists and is prominent); the individual target-state sentences are aspirational | Tense note read at the pin; §19 gates G1→G4 as the truing mechanism; Limitations section's sharding honesty. But: *only* sharding is called out as future work there, while the bridge table marks the server, CLI, Loom, Ripple, full SSI as Partial/Not integrated — a disclosure gap | [Code-verified, High] |
| 5 | Bounded deterministic GQL slice executes: labeled node scans; directed/incoming/undirected 1-hop; bounded 2-hop; selected equality/inequality/integer-property predicates; deterministic projection, SKIP, LIMIT — aggregation, ORDER BY, mutation, typed params, property projection refused by the parser | demonstrated | `IMPLEMENTATION_STATUS.md` live-verticals list; REALITY_CHECK L158–161 "Unsupported-language consumer" test asserts eight parser refusals (exit 0) at the Sep-08 commit. Pin-currency of the refusal list not re-executed | [Maintainer claim + Code-verified, Medium] |
| 6 | Durable embedded `fgdb::Database`: Chronicle capsule-first/marker-last two-fsync open+reopen, marker-chain recovery, Strata tier-D storage, first-committer-wins commit validator with attributable aborts (`FG-LAW-FCW-01`) | demonstrated | `IMPLEMENTATION_STATUS.md` live verticals; CHANGELOG 2026-09-04 documents the bound tests (`overlapping_prepared_batches_abort_the_second_committer`) with mutation controls | [Maintainer claim, Medium] |
| 7 | Performance gates: cold bulk load ≥40M edges/s; txn ingest ≥2M edge-inserts/s; SNB Interactive SF-100 throughput ≥3× Neo4j and ≥1.5× best published embedded engine; 12 domains total (§17 `EmpiricalGate`s, reference machine specified) | **aspirational** — provisional CI targets, not results | README Performance section header, verbatim: "Numbers below are the provisional CI **gates** … **chosen from measured SOTA anchors with leapfrog margins**." Activated "only under pinned benchmark manifests." No measured number exists anywhere for these gates at the pin | [Maintainer claim, High] |
| 8 | Sep-08 local verification: 9/9 core + 40/40 registered gates; two workspace reruns agree over 3,449 test outcomes; 9 Miri tests pass; certified-query median/p95 73.832/78.093 ms → 7.591/8.039 ms after vertex patch packing; max RSS 36,752 → 36,540 KiB | demonstrated at the Sep-08 commit; **stale at the pin** | `docs/REALITY_CHECK_AND_BRIDGE_PLAN.md` (§"Continued implementation — 2026-09-08 afternoon"; commit `9adf484d`). 14 days stale at the pin; no rerun recorded since | [Maintainer claim, Medium] |
| 9 | 19-row promise→reality bridge table: embedded open partial; server (fgdbd, FGP/HTTP2/gRPC/WS/Bolt) "Not implemented as a product — no `fgdbd` target"; CLI "Not implemented as a product"; GQL partial; Chronicle one-mechanism partial; Strata partial; GLA/Loom "Not integrated"; Ripple "Not integrated"; full SSI partial; Prism "Not integrated"; Beacon/hybrid "Not integrated"; Warden "Not integrated"; agent branches "Not delivered"; replication partial; closed-deps "Working for the current workspace" | demonstrated | REALITY_CHECK bridge table rows 1–19 read at the pin. **The single most load-bearing governance document in the repo** | [Code-verified, High] |
| 10 | CI: `check.yml` is the one gate — `scripts/check.sh` exit code is the verdict; Lean proofs, UBS scanner, cargo-deny, cargo-audit, Miri lanes included | partially demonstrated | Workflow read at the pin; **397 runs exist on the Actions API, but the owner ruling of 2026-09-03 made the workflow `workflow_dispatch`-only ("we do not use gh actions for any reason, ONLY /dsr")**; latest run 2026-09-03T22:22:20Z. **No verdict-bearing run exists at or near the pin** (pin: 2026-09-22). The verdict contract is now `scripts/local_proof.sh` on the exact tree, per LOCAL_PROOF_BUNDLE.md | [CI-observed + Maintainer claim, High] |
| 11 | 24 stars, 5 forks, 0 releases, 0 tagged commits, 0 open issues; license classified NOASSERTION by GitHub (rider unrecognized) | demonstrated | GitHub API 2026-09-22; Releases API empty | [External, High] |
| 12 | Formal anchors: Lean proves MVCC visibility, block-level SSI safety, merge-ladder soundness, Z-set operator subset; TLA+/TLC models two-fsync commit + recovery, compaction publish/retire, Raft-marker interaction, branch fork/merge. Stable invariant IDs `FG-INV-01 … FG-INV-20` in a machine-readable registry, CI cross-checks live checkers | partially demonstrated | `formal/lean` exists; `registries/invariants.toml` holds exactly **20** IDs `FG-INV-01`–`FG-INV-20` [Counted, High]; Lean toolchain pinned via `formal/lean/lean-toolchain`. *What each ID's proof actually establishes* is the maintainer's assertion — no proof was executed or its statement inspected by this assessment | [Maintainer claim + Counted, Medium] |
| 13 | Bus factor 1: sole human maintainer Jeffrey Emanuel; pinned commit authored by Dicklesworthstone (Jeff Emanuel) | demonstrated | `git log -1` authorship at the pin; no second committer visible in the repo's public surface | [Git-observed, High] |
| 14 | Six `fgdb-bench` claim: "Every gate has a bench binary, a committed baseline, a variance budget, and a flamegraph artifact on regression" | partially demonstrated | `crates/fgdb-bench` exists at the pin containing `src/lib.rs`, `src/main.rs`, and `tests/shapes_witness.rs` — **no `baselines/` directory exists anywhere in the tree** [Counted, High]. "Committed baseline, variance budget, flamegraph artifact on regression" per gate is therefore unverified at the pin; the harness shape exists, the artifacts don't | [Code-verified, Medium] |
| 15 | Kùzu upstream archived read-only 2025-10-10 after Apple's October 2025 acquisition (disclosed Feb 2026 via EU DMA filing); community forks carry the architecture with gaps | demonstrated | AppleInsider + MacRumors 2026-02-11; cartograph ADR-0008 (2026-07-05); kuzu-prebuilt-wheels README | [External, High] |

| 16 | "`git`-style database branches: O(1), zero-copy, 10k+ concurrent. Fork, mutate, run analytics, merge or discard." (README "Why frankengraphdb" table) | **aspirational** | Bridge table row 15: "Agent branches, provenance and isolated GraphRAG memory (B6) — **Not delivered**. Depends on real branches, authorization, retrieval and public surfa[ce]" [Maintainer claim, High]. Pinned read views (`EmbeddedReadView`) are the delivered subset — snapshot isolation at a retained `CommitSeq`, not branches with merge | [Maintainer claim, High] |

**What the inventory says in aggregate:** claims about *process and honesty* (tense disclosure, bridge table, overclaim-residue repairs, registry enforcement) verify at High; claims about *the product as described in the README* are mostly aspirational, and the README's own Limitations section under-discloses how much is aspirational (sharding is the only future work named there; the bridge table names ~10 more). The per-crate census adds a compositional fact: 43% of the crates tree is tests, the registry-check tool alone is 84k src lines, and the largest crate (`fgdb-gql`, 105k src lines) fronts a deliberately bounded grammar — the tree's size measures the methodology as much as the engine. Two integrity events cut opposite ways: the 2026-09-04 overclaim corrections raise credibility; the lockfile-vs-"No serde. Ever." contradiction lowers it — a README-vs-lockfile drift of exactly the class the Rulebook demands be reported as a governance signal.

## 4.4 Codebase tour

**Workspace topology (30 members, [Counted, High]):** `fgdb` (composition root), `fgdb-beacon`, `fgdb-bench`, `fgdb-bigint`, `fgdb-calibrate`, `fgdb-chronicle`, `fgdb-claim`, `fgdb-cli`, `fgdb-codec`, `fgdb-collections`, `fgdb-crypto`, `fgdb-delta-types`, `fgdb-evidence`, `fgdb-gql`, `fgdb-order`, `fgdb-policy`, `fgdb-prism`, `fgdb-protocol`, `fgdb-reference`, `fgdb-repl`, `fgdb-resource`, `fgdb-sim`, `fgdb-sketch`, `fgdb-strata`, `fgdb-types`, `fgdb-unsafe-arena`, `fgdb-unsafe-simd`, `fgdb-unsafe-vfs`, `fgdb-warden`, plus `tools/registry-check`.

**Crate-size distribution (src lines / test lines, counted at the pin [Counted, High]):** the tree is evidence-heavy — 43% of the crates tree (262,464 of 608,825 lines) is tests, and several crates carry more test than source. `fgdb-gql` 105,146 src / 38,073 tests · `fgdb` 62,554 src / **117,382** tests · `fgdb-calibrate` 37,004 / 4,580 · `fgdb-codec` 20,124 / 1,096 · `fgdb-delta-types` 15,921 / 3,309 · `fgdb-sketch` 14,278 / 479 · `fgdb-sim` 13,982 / **47,691** · `fgdb-strata` 13,101 / 9,252 · `fgdb-types` 9,482 / 2,315 · `fgdb-chronicle` 8,889 / 9,658. The `fgdb` composition root's test suite (117k lines) is nearly 2× its source — and `fgdb-sim`'s tests (47.7k) are 3.4× its source. Two readings, both held: this is the strongest test-to-code investment signal in the FrankenSuite [Inference, Medium], and the tree's size measures the methodology as much as the engine. Separately, `tools/registry-check` — the claim-governance tool itself — is 84,136 src lines plus 42,968 test lines: the evidence machinery is a large codebase in its own right [Counted, High].

**The `fgdb-gql` anomaly:** 105,146 src lines of parser/binder for a grammar whose *live* surface refuses aggregation, `ORDER BY`, mutation, and typed parameters. The split the code implies: the parser is general (it must parse to refuse), the binder/executor is bounded — so the largest crate in the workspace is mostly a front door to a small room. That is either forward investment (the grammar is ready when the binder catches up) or overbuilt scaffolding; the bridge table's "GQL partial" row doesn't distinguish, and neither can this packet without binder-row coverage data [Inference, Medium].

**Dependency posture (the 30-second survey the Rulebook demands):** **direct deps are closed, the transitive graph is not.** No `fgdb-*` crate declares any crates.io dependency directly — 15 of them declare `asupersync` (git, pinned rev `78b6463`, `=0.5.0`, `default-features = false`) and 1–2 declare `fnx-classes`/`fnx-generators`/`fnx-algorithms` (franken_networkx native crates, pinned git revs) [Code-verified, High]. But the pinned `asupersync 0.5.0` itself depends on the registry: the repo's own `Cargo.lock` resolves **204 crates.io packages** — serde, serde_json, rmp-serde, rayon, tempfile, thiserror, tracing, zerocopy, blake3, ed25519-dalek — into the workspace build graph [Counted, High]. The README's "No serde … Ever" is therefore false for the *built product* and true only for *direct fgdb-crate manifests*; `deny.toml` (cargo-deny) governs the full graph and explicitly binds the FrankenSuite foundations to `LicenseRef-MIT-OpenAI-Anthropic-Rider` by license-text hash [Code-verified, High]. There is **no tokio** (asupersync is the async substrate — the "database written in the asupersync programming model" claim has a real dependency behind it), **no rocksdb**, **no arrow**, **no tantivy** [Code-verified, High] — the substantive closed-universe engineering choice is real; the absolutist badge wording is not.

**Data flow, as the plan describes it (README present-tense; the executed subset is narrower — claims 5, 6, 9):**

- **Ingest/commit — `fgdb-chronicle`:** the "One Version Universe" mechanism: an append-only, content-addressed, RaptorQ-erasure-coded commit stream; capsule-first, marker-last two-fsync commit; marker-chain recovery authenticates checkpoint-selected Strata roots [Maintainer claim, High on the design; Medium on execution — the durable open/reopen path is claimed executing].
- **Storage — `fgdb-strata`:** three temperature tiers per vertex — inline micro-adjacency → sorted delta blocks → sealed compressed CSR runs. The current memory path is flagged by the bridge table as "requires replacement" (claim 9, row 6) — the sealed-run story is target state [Maintainer claim, High].
- **Execution — `fgdb-gql` (parser/binder) + `fgdb` (`gql_exec.rs`):** live grammar is one exact-sequence execution kernel shared by live/historical/read-view reads; parsing+ binding in `parser.rs`, plan-only `BoundPlan`, owned prepared queries with redacted `Debug` [Maintainer claim, Medium]. The plan's Free-Join/WCOJ "Loom" family and vectorization are **not integrated** (claim 9, row 7).
- **Transactions — `fgdb`:** typed `WriteBatch` under a first-committer-wins validator; abort reasons name `FG-LAW-FCW-01` so checkers can't pass for the wrong reason; full serializability (acyclic dependency graphs, real-time precedence) is target state, not claimed as shipped (the changelog itself says FCW "builds no such graph") [Maintainer claim, High].
- **Incremental — `fgdb-delta-types`, `fgdb-reference`:** Z-set delta vocabulary and reference semantics exist; the Ripple engine driving recursion/views/subscriptions is **not integrated** (claim 9, row 8) [Maintainer claim, High].
- **Determinism/evidence — `fgdb-evidence`, `fgdb-claim`, `fgdb-calibrate`, `fgdb-resource`:** plan certificates (plan hash, tie-break policy, snapshot seq, per-operator observed-vs-bound counts, BLAKE3 decision-path hash), `replay(certificate, seq, seed)` byte-for-byte reproduction, complexity witnesses that fail CI on op-count regression, six standing benchmark laws (no benchmark-only semantics; distributions not averages; never hide compaction; memory is first-class; adaptive numbers disclose policy epoch; no unpriced protocol weight) [Maintainer claim, Medium — laws are stated and cited as binding; enforcement at the pin is CI-observed only up to Sep 3].
- **Simulation — `fgdb-sim` + asupersync lab runtime:** virtual time, fault-injecting virtual disk (torn writes, bit flips, ENOSPC, fsync lies), DPOR schedule exploration, crashpacks with replay commands [Maintainer claim, Medium]. `FG-INV-19.replay-grade-monotonicity` binds the replay grader's negative control [Maintainer claim, High — changelog documents the binding].
- **Governance/security — `fgdb-warden`, `fgdb-policy`, `fgdb-crypto`:** macaroon capability tokens compiling to planner-enforced predicates — **not integrated** per the bridge table (claim 9, row 14); "caller-supplied keys and crypto are real" [Maintainer claim, High].
- **Retrieval — `fgdb-beacon`, `fgdb-sketch`, `fgdb-prism`:** codecs/sketches are foundations; the hybrid ANN+BM25+graph operator is **not integrated** (claim 9, row 13); Prism's zero-copy bridge to the fnx algorithm universe is **not integrated** (row 12) [Maintainer claim, High].
- **Server/CLI — `fgdb-protocol`, `fgdb-cli`, `fgdb-repl`:** FGP wire protocol + HTTP/2, gRPC, WebSocket, Bolt-compat subset, multi-database server, human/NDJSON CLI — **no `fgdbd` product target and no installable CLI exist** (claim 9, rows 2–3) [Maintainer claim, High].
- **Reference oracle — `fgdb-reference`:** "deliberately simple, single-threaded, obviously-correct implementation of the full logical semantics, compiled for tests only" — the differential-testing anchor that exists *before* the optimized lines [Maintainer claim, Medium].

**Unsafe arithmetic, stated explicitly:** workspace `unsafe_code = "forbid"` [Code-verified, High]; exactly **6 `unsafe {}` block sites**, all inside the three `fgdb-unsafe-*` crates whose roots relax to `#![deny(unsafe_code)]` with enumerated narrow `allow(unsafe_code)` sites tracked in `registries/unsafe_boundary_ledger.toml` [Counted, High]. 60 files *mention* unsafe (comments/docs) — the executable boundary is 6 sites. The boundary-ledger pattern is the methodology artifact §4.8-style export candidate for the Suite.

## 4.5 The maintainer's stated case

**The pitch, in the maintainer's own structure:**

1. **Composition as leapfrog:** six bets (B1–B6), each "at or beyond the current frontier," feasible only because the foundation libraries (asupersync, fnx) already exist — "no shipping system has ever composed them" [Maintainer claim, Medium — the composition claim is the thesis; whether the pieces are individually frontier is uncited].
2. **Memory safety by construction:** workspace `forbid`, 6 ledgered unsafe sites with bit-identical scalar fallbacks, Miri lanes in the gate chain [Counted/Partially, High on the census; Medium on Miri — lanes exist in `check.sh` per the workflow comment; the Sep-08 reality check reports 9 Miri tests green, stale at pin].
3. **Determinism as product feature:** CGSE tie-break policies, plan certificates, byte-identical replay, seed-replayable failures under the lab runtime — "a feature no competitor ships" [Maintainer claim, Medium].
4. **Verification posture:** Lean proofs (MVCC visibility, block-level SSI safety, merge-ladder soundness), TLA+/TLC models, stable invariant IDs bound to live checkers, claim registries enforced by `registry-check`, 19-row bridge table, negative-evidence ledger, overclaim-residue repairs with mutation controls [Maintainer claim, Medium–High per claim 12/REALITY_CHECK].
5. **Performance gates as engineering discipline:** §17 `EmpiricalGate`s on a named reference machine with six standing laws and complexity-witness regression locks — the honest framing is targets, not results (claim 7) [Maintainer claim, High]. **Enforcement currency:** the six laws are stated as binding on every published figure, but their enforcement is observable only through CI runs up to 2026-09-03 and the Sep-08 local proof — whether the laws bind the pin's tree is unestablished, since no verdict-bearing gate has run on any commit after Sep 3 [Inference, Medium].

**Benchmark table — maintainer-produced:**

| Number | Methodology doc | Controls | Independent rerun | Verdict |
|---|---|---|---|---|
| ≥3× Neo4j on LDBC SNB Interactive SF-100; ≥1.5× best published embedded engine | §17 EmpiricalGates, six standing laws, named reference machine (32c/256GB/NVMe 7GB/s) | None executed — provisional gates activated "only under pinned benchmark manifests" | No | **Target, not a result. Never cite as a result.** [Maintainer claim, High] |
| 12-domain gate table (40M edges/s bulk load; 2M txn edge-inserts/s; 8M lookups/s; 500M edges/s/core sealed scans; …) | Same | None executed | No | Targets, not results [Maintainer claim, High] |
| Sep-08: certified-query median/p95 73.832/78.093 → 7.591/8.039 ms (after vertex patch packing); whole-process mean 10.336 → 8.838 s; max RSS 36,752 → 36,540 KiB | REALITY_CHECK §read-comparison: real durable two-commit fixture (8,192 vertices, 512 edges), 3 warmup + 10 measured processes × 10 repetitions, SHA-256 baseline match on all outputs incl. certificates | Warmup discipline, multi-process, baseline-digest match — genuine measurement hygiene | No | **Measured, but of the shipped embedded subset, 14 days stale at the pin, and unrelated to the §17 gates.** The one honest number set in the repo [Maintainer claim, Medium] |
| 9/9 core gates, 40/40 registered gates, 3,449 test outcomes agreeing across workspace reruns, 9 Miri green | REALITY_CHECK 2026-09-08, `scripts/local_proof.sh` chain | Cross-rerun agreement, bundle-verifier exit 0 | No | Correctness evidence for the embedded subset at Sep-08; stale at pin [Maintainer claim, Medium] |

**Independent numbers:** none exist. A 2026-09-22 web search found no third-party benchmark, review, deployment, or fork activity beyond the repo and its own docs [External, High within recall caveats].

**Reproduction cost:** checkout is small (28.9 MB GitHub size, shallow); the toolchain is pinned (`nightly-2026-08-31` + miri/clippy/rustfmt components); but the full `check.sh` chain — Lean toolchain install, Miri lanes, UBS scanner, cargo-deny/audit — historically ENOSPC'd a standard GitHub runner (~29 min into compilation; 18 red runs, zero completed verdicts per the workflow's own comment) [Maintainer claim, High]. The honest reproduction path is `scripts/local_proof.sh` on the maintainer's fleet, not CI.

## 4.6 Competitors

The incumbent wins on shipping software, managed offerings, and query breadth; frankengraphdb's only defensible edge is its evidence apparatus plus the composition thesis — neither of which has a measured benchmark behind it [Inference, Medium].

- **Neo4j (the named incumbent):** The graph-database incumbent — property-graph pioneer, native graph storage, the ergonomics and ecosystem standard the README's "≥3× Neo4j" gate is aimed at. Licensing: Community Edition is GPLv3 open source; Enterprise Edition is closed-source commercial (clustering, hot backups, fine-grained auth); AuraDB is the managed offering in four tiers (Free, Professional, Business Critical, Virtual Dedicated Cloud); openCypher is Apache 2.0 and Neo4j drove the GQL standardization effort [External, High — Wikipedia/neo4j.com]. Wins today on: 15+ years of operational knowledge, a full Cypher/GQL surface with APOC's hundreds of procedures, clustering, managed service, native drivers in five languages, and an ecosystem of tooling that a bounded 1–2-hop read slice cannot touch [Inference, High]. Neo4j's own documented weakness per the maintainer — JVM memory behavior and a runtime that took 15 years to vectorize — is the gap the composition thesis is aimed at [Maintainer claim, Medium]. Note the irony: Neo4j's Community Edition is genuinely open (GPLv3), so frankengraphdb's "open" pitch is aimed less at Neo4j's license than at its architecture.
- **FalkorDB (the agent-memory rival):** a Redis-based property-graph DBMS (fork of RedisGraph after Redis's 2023 end-of-life announcement), SSPL-licensed, speaking openCypher over the Redis protocol, using GraphBLAS sparse-matrix adjacency — and explicitly positioned as the knowledge-graph backend for GenAI/GraphRAG workloads, with vector and full-text indexes built in [External, High — dbdb.io, falkordb.com, googleapis/mcp-toolbox docs]. Active: last commit observed 2026-09-17 [External, Medium]. This is the project contesting frankengraphdb's B6 (agent-native/GraphRAG) lane *today*, with shipping software — the sharpest near-term competitive fact in the packet [Inference, Medium].
- **Kùzu (archived) and its forks:** The closest architectural rival — columnar CSR + vectorization + factorization + WCOJ — was removed from the commons by Apple's October 2025 acquisition and archived 2025-10-10; forks (LadybugDB, bighorn, ryugraph, Vela) carry the architecture with unproven maintenance and no stable Rust story [External, High]. The maintainer's claim that upstream Kùzu "left gaps" (single-writer — the Vela fork explicitly targets multi-writer agent memory; no replication, temporal, or deterministic-testing story) is the pitch's factual core [Maintainer claim, Medium]. **This is the lane frankengraphdb is actually aimed at: embedded, open, WCOJ-class graph queries.** It is the only lane where the timing argument is externally verified.
- **TigerGraph:** MPP analytics, proprietary GSQL, platform-sized footprint — owns the distributed-analytics-platform lane [Maintainer claim, Medium]. Not frankengraphdb's lane (single-node-first).
- **Memgraph / FalkorDB:** fast in-memory engines, thin durability [Maintainer claim, Medium]. Own the in-memory speed lane; no principled larger-than-memory or history story — the gap B1/B2 target [Inference, Medium].
- **JanusGraph / NebulaGraph:** generic KV underlays (Cassandra/RocksDB) with a permanent impedance tax on traversal [Maintainer claim, Medium]. Own the horizontal-scale-on-commodity-KV lane [Inference, Medium].
- **Rust peers:** the embedded-Rust graph space is thin — `redcon`-class frameworks are tooling, not databases; no Rust-native property-graph engine with transactional MVCC + WCOJ is currently shipping [Inference, Low–Medium — absence-of-coverage finding with recall caveats].
- **Unoccupied lane:** an *open*, memory-safe, embedded property-graph engine with WCOJ-class analytics, transactional MVCC, time travel, and machine-checked evidence, in the lane Kùzu vacated [Inference, Medium]. Whether anyone will pay — in adoption — for the evidence apparatus over query breadth is the unproven bet. Note the tension: Kùzu's forks are free and already run full Cypher; frankengraphdb's honest advantage is architecture-plus-evidence, not features.

## 4.7 Skeptic's take

Weaknesses, each substantive:

1. **[FATAL] The README's present-tense spec describes a product that does not exist.** The tense note (L23) is honest and prominent, but the document it heads describes protocols, servers, CLIs, operators, and 10k+ O(1) branches as *current facts* while the bridge table says "Not implemented as a product" / "Not integrated" for the server, CLI, Loom, Ripple, Warden, Beacon, Prism, and agent branches. The Limitations section names *only sharding* as future work — a reader who stops at Limitations (as readers do) gets a materially wrong picture; the true state lives in a separate doc (IMPLEMENTATION_STATUS) and a bridge table in `docs/`. The tense note is a fig leaf over a 3,273-line plan wearing a README costume [Code-verified, High].
2. **[FATAL] The lockfile contradicts the closed-universe claim.** "No serde, no tokio, no rocksdb, no arrow, no tantivy, no hnswlib. **Ever.**" — and the repo's own `Cargo.lock` resolves serde, serde_json, rmp-serde, rayon, thiserror, tempfile, tracing, zerocopy… 204 registry crates via the pinned asupersync/fnx foundations [Counted, High]. In a project whose pitch is *auditability and honest claims*, a badge-level claim falsified by its own lockfile is a structural credibility wound — and exactly the README-vs-code drift class the program flags. The defense ("direct deps are closed") requires reading the claim more narrowly than any reader will [Inference, Medium].
3. **[HIGH] No verdict-bearing CI at any recent pin.** The 2026-09-03 owner ruling removed all automatic triggers ("we do not use gh actions for any reason, ONLY /dsr"); the workflow's own comments record 166-of-200 cancelled runs, 18 red ENOSPC runs, zero completed verdicts on the hosted lane. The gate chain's authority now rests on `scripts/local_proof.sh` on the maintainer's fleet and `docs/LOCAL_PROOF_BUNDLE.md` — unobservable to any outsider [CI-observed + Maintainer claim, High]. The Sep-08 reality check is 14 days stale at the pin. For a project whose thesis is *evidence*, the evidence pipeline is currently trust-me [Inference, Medium].
4. **[HIGH] One human, no release, no users.** Bus factor 1 (Jeff Emanuel); 24 stars, 5 forks, 0 releases, 0 issues; the pinned commit is ~2 months of solo work from repo creation [Git-observed + External, High]. If the maintainer stops, the 736k-line tree freezes with no fork point anyone can evaluate as a product.
5. **[MEDIUM] The performance story is all targets and one stale micro-measurement.** The §17 gates are "provisional … chosen from measured SOTA anchors with leapfrog margins" — honest as gates, useless as results; the only measured numbers (Sep-08 certified-query 10× after patch-packing) cover the bounded embedded slice and are stale [Maintainer claim, High]. The "ultra-high-performance" badge is an aspiration with a badge [Inference, Medium].
6. **[MEDIUM] GQL conformance is a bounded slice with an honest parser but no conformance suite.** The grammar is deliberately smaller than ISO GQL (1–2 hop, no aggregation/ORDER BY/mutation/typed params); no TCK-style conformance harness or LDBC run exists at the pin [Maintainer claim + Code-verified, Medium]. The openCypher on-ramp and Bolt-compat subset are plan rows 4 and 2 ("Partial" / "Not implemented") [Maintainer claim, High].
7. **[MEDIUM] Formal anchors are claimed, not demonstrated to the analyst.** Lean proofs (MVCC visibility, SSI safety, merge-ladder, Z-set subset) and TLA+ models are asserted in the README and registered in `proof_lanes.toml`; no proof was executed or its statement inspected by this assessment [Maintainer claim, Medium]. "Scoped, honest" is the maintainer's adjective — the scoping is theirs.
8. **[LOW] The dependency story has a single-foundation fragility.** asupersync 0.5.0 (pinned git rev) is load-bearing for 15 crates — the lab runtime, structured concurrency, and the entire "deterministic testing of the whole system" thesis. If asupersync's own velocity or governance falters, frankengraphdb inherits the failure mode with no abstraction boundary [Inference, Low–Medium].

**Bear-case steelman (strongest counter-case):** frankengraphdb is a 736k-line monument to a development methodology, not a database. What runs is an embedded store with a 2-hop query slice; everything a buyer would pay for — server, CLI, full GQL, the WCOJ engine, incremental views, the hybrid retriever, the agent branches — is "Not integrated" in its own bridge table. Its benchmarks are targets; its CI is de-automated by owner fiat; its closed-universe badge is falsified by its own lockfile; its license bars OpenAI and Anthropic — the two entities most likely to stress-test an "agent-native" database — from even *analyzing* it. The strongest market event in its favor (Apple archiving Kùzu) is being contested by forks that already run full Cypher while this project's README describes a 1.0 that needs four convergence gates it hasn't crossed. The rational response is to mine the methodology (registry-check, claim ledgers, negative-evidence discipline, unsafe-boundary ledgers) and never deploy the database. Its most likely end state is maintainer context-switch abandonment, leaving a 736k-line tree whose own verdict pipeline is unobservable from the outside. [Inference, Medium — deliberately uncharitable; the counter-evidence is the overclaim-residue repair culture and the bridge table's refusal to inflate the present.]

## 4.8 License and governance (material, not boilerplate)

**License text (verbatim, read at the pin):** "MIT License (with OpenAI/Anthropic Rider)", copyright 2026 Jeffrey Emanuel. Standard MIT grant, followed by an **ADDITIONAL RIDER / RESTRICTION (OpenAI / Anthropic)** that is "part of the 'conditions' of this License" and "controls" in any conflict.

**Rider scope, quoted exactly:** *"Restricted Parties" means OpenAI, L.L.C.; Anthropic, PBC; any of their respective Affiliates; and any person or entity acting directly or indirectly on behalf of, for the benefit of, or under the direction of any of the foregoing (including any officer, director, employee, contractor, agent, consultant, service provider, or representative).* — *"Notwithstanding any other provision of this License, no rights are granted to any Restricted Party."* — *"You may not provide, disclose, distribute, sublicense, sell, lease, lend, host, make available, or otherwise permit access to the Software or any derivative work … to or for any Restricted Party."* — *"use" includes, without limitation: copying, modifying, merging, publishing, distributing, sublicensing, selling, transferring, making available, hosting, deploying, executing, **benchmarking, testing, analyzing, indexing, or incorporating the Software** … into any dataset, training corpus, evaluation harness, or pipeline for machine learning.* — *Any breach of this rider automatically and immediately terminates the permissions granted by this License.* [Code-verified (license text), High]

**OSI status: non-OSI.** The rider discriminates against named persons/groups (violates OSD #5) and restricts fields of endeavor including benchmarking and analysis (violates OSD #6). GitHub's own classifier returns NOASSERTION [External, High]. The README badge says "MIT + Rider" — accurate shorthand, not concealment [Code-verified, High].

**The rider as strategy (§6 lens):** it excludes OpenAI and Anthropic — plus affiliates and anyone acting for them — from use, benchmarking, testing, analysis, and training-data incorporation. For a project whose B6 bet is *agent-native by construction* and whose stated audience includes agent swarms running GraphRAG memory, excluding the two largest agent-model labs from even *analyzing* the code is strategically self-wounding [Inference, Medium]. The `deny.toml` exceptions show the rider propagates through the whole FrankenSuite dependency chain (asupersync, fnx-*, franken-* foundations all bound to `LicenseRef-MIT-OpenAI-Anthropic-Rider` by license hash), so the exclusion compounds across every project that adopts the stack [Code-verified, High]. What it buys: protection against training-data ingestion of a 736k-line corpus. What it costs: any AI-company evaluation, contribution, or adoption — and legal uncertainty for contributors employed anywhere near the AI supply chain via the "acting directly or indirectly for … the benefit of" prong. The mission says "open commons graph engine after Kùzu left the commons"; the rider says "open to everyone except the labs most likely to use it" [Inference, Medium].

**Governance:** bus factor 1 — sole human maintainer Jeffrey Emanuel, no succession plan, no second committer, no foundation, no contribution policy beyond the constitutional AGENTS.md doctrine (which is maintainer-written, not community-governed) [Git-observed + Inference, Medium]. Commit velocity is high and daily; review depth is unobservable (solo). The work-tracking substrate is in-repo, not on GitHub (GitHub issues = 0): `.beads/issues.jsonl` at the pin holds **986 beads — 709 closed, 264 open, 9 blocked, 4 in_progress** [Counted, High] — a high-throughput, fine-grained issue ledger consistent with the daily cadence and the changelog's bead-per-repair discipline. The constitutional machinery (beads, registries, negative-evidence ledger, overclaim residues corrected by *independent verifier* findings in the Sep-04 changelog) is the governance substitute — unusually strong for process, nonexistent for succession [Maintainer claim + Inference, Medium].

## 4.9 NODUS factsheet

| Criterion | Scale | Justification (one line) |
|---|---|---|
| Technology readiness | **TRL 4** | Durable embedded store + bounded GQL slice validated in lab (Sep-08 proof: 3,449 test outcomes, Miri green); server, execution engine, and perf gates unproven — lab-validated components, no operational environment. [Inference, Medium] |
| Strategic relevance | **3/5** | Kùzu's archival vacates the open-embedded-WCOJ lane this project targets; but the project is pre-product and its agent-native thesis is unvalidated. [Inference, Medium] |
| Impact potential | **3/5** | If the composition thesis lands, it redefines embedded graph DBs; the methodology-export path (registry-check, claim ledgers) has impact even if the DB fails. [Inference, Medium] |
| Implementation feasibility | **2/5** | One maintainer, 736k lines, no CI verdicts since Sep 3, G1–G4 gates uncrossed; the scope-to-resource ratio is the program's sharpest. [Inference, Medium] |
| Time to mainstream | **2/5** | Even the maintainer's plan stages sharding as the final workstream; no release, no 1.0 surface, no conformance suite. Years, not quarters. [Inference, Medium] |
| Collaboration potential | **2/5** | Rider bars the two largest AI labs from analyzing it; single-maintainer governance; but the methodology artifacts are collaboration-ready. [Inference, Medium] |

**Ring: Explore** [Inference, Medium]. The assignment rules: *Invest* needs independent validation plus governance (neither exists); *Pilot* needs a release artifact plus a bounded real workload fit (no release; the embedded slice is untested against any external workload); *Explore* is the default for substantive-but-unproven — the evidence machinery and the real durable embedded path are substantive; the product claims are unproven. The rider is an advancement blocker (Explore-with-a-ceiling), not a ring qualifier. When in doubt, ring down: this packet considered Monitor (pre-product, zero releases) and judged Explore correct because the *machinery* (registries, reference oracle, simulation) is real and worth tracking even before the database ships.

## 4.10 Wardley placement

- **Property-graph storage/query surface (the commodity):** GQL/Cypher semantics, Bolt wire compat, CSR adjacency — *commodity/product* stage, dominated by Neo4j; frankengraphdb's bounded slice is a partial clone of a commodity.
- **The custom reimplementation (the build):** the One-Version-Universe commit stream, Strata tiers, Loom executor, Ripple incrementality — *custom-built* stage components, novel in composition, none individually productized yet. What moves them toward product: G1 ("The Engine Lives") crossing with a real release artifact.
- **Genesis-stage novel elements:** machine-readable claim/invariant registries with live-checker binding (`registry-check`), plan certificates with replay closure, complexity-witness regression locks, the negative-evidence doctrine — *genesis* stage, no incumbent owns this. What moves them: extraction as standalone artifacts (see next step 1); they are the methodology-export candidates.

## 4.11 Trajectory (12 / 24 / 60 months) — [Inference, all of this section]

**Base case:** the maintainer continues the daily cadence; G1 ("The Engine Lives") is crossed in 2026–2027 with an embedded 0.1 release of the bounded GQL slice; the evidence machinery keeps improving and gets copied by sibling FrankenSuite repos; the database itself remains pre-product through 2027 as Loom/Ripple integration dominates the work; Kùzu forks consolidate the vacated lane's users before frankengraphdb ships anything competitive.

**Bifurcation — upside:** a second maintainer or institutional sponsor arrives (the Kùzu-archival moment is the recruiting pitch); the bounded embedded slice gets its first external workload (agent episodic memory — the one workload where time-travel + branches + auditability beat Cypher breadth); LDBC SNB SF-1 numbers land and survive scrutiny; the rider is narrowed or dropped and OpenAI/Anthropic can evaluate it. Any two of these move the ring to Pilot.

**Bifurcation — decay:** maintainer context-switch (the program's known failure mode — one coordinator already died quietly this week); the lockfile contradiction and present-tense README erode the credibility the bridge table earned; Kùzu's forks (Vela's multi-writer agent memory in particular) occupy the agent-memory lane first; the project becomes a 736k-line methodology museum.

**Revisit triggers (concrete, observable):** (1) first tagged release or installable artifact; (2) G1 gate crossed per §19 with the pinned evidence; (3) an independent benchmark or third-party deployment published; (4) a second human committer with merge rights; (5) the rider narrowed, dropped, or upheld in a dispute; (6) CI verdicts restored to automatic (or the local-proof pin-record contract from next step 4 operating for a month).

## 4.12 Limitations and open questions

**Not done:** the workspace was never compiled; no test suite was executed; no benchmark was reproduced; the pin's CI pages carry no verdict-bearing runs (workflow is manual-only since 2026-09-03); the Lean proofs and TLA+ models were asserted but not inspected or executed; the 705-commit negative-evidence census was not re-derived; author/line-level agent co-authorship was not measured; the Kùzu-fork maintenance state was assessed from secondary sources only.

**Open questions that would most change the verdict:**
1. Does `scripts/local_proof.sh` exit 0 at the pin? (The whole correctness claim rests on an unobservable fleet run.)
2. Does the pinned workspace compile? The analyst never compiled it, CI was de-automated on 2026-09-03, and no verdict-bearing run exists at any recent pin — so the pin's buildability is unobservable from outside. If the pin doesn't build, the Explore ring's lab-validation premise belongs to the Sep-08 commit, not the pin, and the claim-governance machinery is asserting over a tree nobody outside the maintainer's fleet can verify as a whole. (Round 4 already answered the scaffolding-fraction sub-question: 43% of the crates tree is tests; a related unknown is how much of the 736k lines is generated or template-expanded versus hand-authored — relevant to the bus-factor reading.)
3. Is `fgdb-reference` actually used in differential testing today, or is it an aspiration with a crate name?
4. Would the maintainer narrow the rider if a credible institutional adopter asked? (The rider is the advancement blocker; its negotiability is unknown.)
5. Which Kùzu fork, if any, has shipped multi-writer — and does that close the agent-memory window before B6 lands?

---

## Deepening questions (one paragraph each)

1. **Provenance.** Every claim lives in a machine-readable registry (`claims_lint.toml`, `invariants.toml`, `laws.toml`, `checker_index.toml`) with a named owner crate, a status (`live` vs `stub`), and a bound checker symbol; the `claims_enforcement_ledger_control` test asserts the exact key set of enforced clauses so demoting a live clause fails loudly. Provenance of *code artifacts* is weaker: commits are single-author (Jeff Emanuel) with no signed-release chain — nothing is signed at all (0 releases) — so artifact attestation today is "the git hash the maintainer pushed." Portability would require what the project hasn't built: signed tags or a release artifact with a checksum manifest, plus the ledger's clause-key assertions surviving into the release bundle. The machinery for *claim* provenance is the best in the Suite; the machinery for *artifact* provenance doesn't exist yet. [Maintainer claim + Code-verified, Medium]

2. **The embeddable unit.** `fgdb-types` (canonical scalar value model: equality/hashing/ordering/encoding coherence laws, mutation-guarded per the Sep-04 changelog) and `tools/registry-check` (std-only claim-registry validator) are the smallest adoptable pieces. Cost: `fgdb-types` drags the workspace's nightly pin and (transitively) the asupersync graph; `registry-check` is genuinely std-only and the cheapest export — a weekend to extract, since its inputs are just TOML registries. The honest unit the maintainer would name is the whole `fgdb` embedded composition crate; its cost is the full dependency story of §4.4 including the 204-crate lockfile. [Inference, Medium]

3. **Unexercised option value.** The architecture holds: (a) the asupersync lab runtime (virtual time, DPOR, fault-injecting VFS) — currently used for simulation lanes, not yet the substrate of a shipped server; (b) `fgdb-reference` as a differential oracle — exists, underused; (c) the plan-certificate/replay machinery — built for auditability, one step from becoming a compliance artifact for regulated pipelines; (d) branch-per-agent isolation — designed, not delivered, and the highest-leverage option if agent-memory demand materializes. Unlock: G1 crossing plus a release artifact; each option is currently gated on productization, not on invention. [Inference, Medium]

4. **Benchmark honesty.** The §17 gates would *not* survive an independent rerun today — they are provisional targets with no measured instance, and citing them as results would be fabrication. The Sep-08 certified-query before/after (73.8→7.6 ms median) is a genuine measurement with real hygiene (warmup, multi-process, digest-matched outputs) but covers a micro-slice of the embedded subset and is stale. The load-bearing number for the thesis — the SNB SF-100 ≥3× Neo4j gate — is the one with zero measurements behind it, which is exactly backwards from where a leapfrog claim needs its evidence. [Maintainer claim + Inference, Medium]

5. **The governance path.** The credible route is maintainer → second committer → foundation/consortium, and the recruiting asset is the Kùzu-archival moment plus the evidence machinery. What breaks first if velocity decays: the gate chain — `check.sh` already takes ~29+ minutes to ENOSPC a hosted runner, Lean/Miri/UBS lanes need a maintained fleet, and the registry assertions only bind if someone runs them; a quiet maintainer means the registries go stale exactly the way the README's crate-count once did, converting the project's core differentiator into its core liability. The solo-maintainer + heavy-machinery combination is the governance risk: the machinery's maintenance cost exceeds one person's slack. [Inference, Medium]

6. **The license as strategy.** The rider excludes OpenAI, Anthropic, their affiliates, and anyone acting for them from use, benchmarking, testing, analysis, indexing, and training-data incorporation, with automatic termination on breach. For the stated mission — an open commons graph engine in Kùzu's vacated lane, agent-native by construction — the exclusion sabotages more than it serves: the two labs most likely to evaluate, adopt, or contribute to an *agent-memory* database may not even benchmark it, while the protection it buys (training-data exclusion for a 736k-line corpus) is speculative. It serves exactly one mission: preventing the corpus from becoming training data. Against every other reading of the mission — adoption, validation, contribution — it is a tax with no revenue. [Inference, Medium]

7. **Agent-era fit.** The concrete workload is *agent episodic memory*: an agent swarm appending timestamped facts needs time-travel queries ("what did we know at seq N"), branch-per-agent isolation with semantic merge, and auditable replay — the B1/B6 composition no incumbent offers. What has to become true first: the bounded GQL slice must support writes-with-history queries at a documented latency, the branch mechanism must actually exist (currently "Not delivered"), and an agent framework must be able to *depend* on it — which the rider currently forbids for the two largest agent labs. The workload fit is the project's best idea and its least-built surface. [Inference, Medium]

8. **The kill test.** Publish the bounded embedded slice's LDBC SNB Interactive SF-1 numbers with the six standing laws enforced (distributions, no hidden compaction, memory first-class). If the slice can't beat or match a Kùzu fork on its home workload — or if the measurement apparatus can't produce a number at all — the composition thesis is untestable and the project is methodology, not a database. A cheaper kill test: run the pin through `scripts/local_proof.sh` on an independent machine; a red or un-runnable chain at the pin falsifies the "evidence-first" claim the whole packet's Explore ring rests on. [Inference, Medium]